git.oblomov.eu Git - linux-2.6/blob - fs/relayfs/relay.c

   1 /*
   2  * Public API and common code for RelayFS.
   3  *
   4  * See Documentation/filesystems/relayfs.txt for an overview of relayfs.
   5  *
   6  * Copyright (C) 2002-2005 - Tom Zanussi (zanussi@us.ibm.com), IBM Corp
   7  * Copyright (C) 1999-2005 - Karim Yaghmour (karim@opersys.com)
   8  *
   9  * This file is released under the GPL.
  10  */
  11
  12 #include <linux/errno.h>
  13 #include <linux/stddef.h>
  14 #include <linux/slab.h>
  15 #include <linux/module.h>
  16 #include <linux/string.h>
  17 #include <linux/relayfs_fs.h>
  18 #include "relay.h"
  19 #include "buffers.h"
  20
  21 /**
  22  *      relay_buf_empty - boolean, is the channel buffer empty?
  23  *      @buf: channel buffer
  24  *
  25  *      Returns 1 if the buffer is empty, 0 otherwise.
  26  */
  27 int relay_buf_empty(struct rchan_buf *buf)
  28 {
  29         return (buf->subbufs_produced - buf->subbufs_consumed) ? 0 : 1;
  30 }
  31
  32 /**
  33  *      relay_buf_full - boolean, is the channel buffer full?
  34  *      @buf: channel buffer
  35  *
  36  *      Returns 1 if the buffer is full, 0 otherwise.
  37  */
  38 int relay_buf_full(struct rchan_buf *buf)
  39 {
  40         size_t ready = buf->subbufs_produced - buf->subbufs_consumed;
  41         return (ready >= buf->chan->n_subbufs) ? 1 : 0;
  42 }
  43
  44 /*
  45  * High-level relayfs kernel API and associated functions.
  46  */
  47
  48 /*
  49  * rchan_callback implementations defining default channel behavior.  Used
  50  * in place of corresponding NULL values in client callback struct.
  51  */
  52
  53 /*
  54  * subbuf_start() default callback.  Does nothing.
  55  */
  56 static int subbuf_start_default_callback (struct rchan_buf *buf,
  57                                           void *subbuf,
  58                                           void *prev_subbuf,
  59                                           size_t prev_padding)
  60 {
  61         if (relay_buf_full(buf))
  62                 return 0;
  63
  64         return 1;
  65 }
  66
  67 /*
  68  * buf_mapped() default callback.  Does nothing.
  69  */
  70 static void buf_mapped_default_callback(struct rchan_buf *buf,
  71                                         struct file *filp)
  72 {
  73 }
  74
  75 /*
  76  * buf_unmapped() default callback.  Does nothing.
  77  */
  78 static void buf_unmapped_default_callback(struct rchan_buf *buf,
  79                                           struct file *filp)
  80 {
  81 }
  82
  83 /* relay channel default callbacks */
  84 static struct rchan_callbacks default_channel_callbacks = {
  85         .subbuf_start = subbuf_start_default_callback,
  86         .buf_mapped = buf_mapped_default_callback,
  87         .buf_unmapped = buf_unmapped_default_callback,
  88 };
  89
  90 /**
  91  *      wakeup_readers - wake up readers waiting on a channel
  92  *      @private: the channel buffer
  93  *
  94  *      This is the work function used to defer reader waking.  The
  95  *      reason waking is deferred is that calling directly from write
  96  *      causes problems if you're writing from say the scheduler.
  97  */
  98 static void wakeup_readers(void *private)
  99 {
 100         struct rchan_buf *buf = private;
 101         wake_up_interruptible(&buf->read_wait);
 102 }
 103
 104 /**
 105  *      __relay_reset - reset a channel buffer
 106  *      @buf: the channel buffer
 107  *      @init: 1 if this is a first-time initialization
 108  *
 109  *      See relay_reset for description of effect.
 110  */
 111 static inline void __relay_reset(struct rchan_buf *buf, unsigned int init)
 112 {
 113         size_t i;
 114
 115         if (init) {
 116                 init_waitqueue_head(&buf->read_wait);
 117                 kref_init(&buf->kref);
 118                 INIT_WORK(&buf->wake_readers, NULL, NULL);
 119         } else {
 120                 cancel_delayed_work(&buf->wake_readers);
 121                 flush_scheduled_work();
 122         }
 123
 124         buf->subbufs_produced = 0;
 125         buf->subbufs_consumed = 0;
 126         buf->bytes_consumed = 0;
 127         buf->finalized = 0;
 128         buf->data = buf->start;
 129         buf->offset = 0;
 130
 131         for (i = 0; i < buf->chan->n_subbufs; i++)
 132                 buf->padding[i] = 0;
 133
 134         buf->chan->cb->subbuf_start(buf, buf->data, NULL, 0);
 135 }
 136
 137 /**
 138  *      relay_reset - reset the channel
 139  *      @chan: the channel
 140  *
 141  *      This has the effect of erasing all data from all channel buffers
 142  *      and restarting the channel in its initial state.  The buffers
 143  *      are not freed, so any mappings are still in effect.
 144  *
 145  *      NOTE: Care should be taken that the channel isn't actually
 146  *      being used by anything when this call is made.
 147  */
 148 void relay_reset(struct rchan *chan)
 149 {
 150         unsigned int i;
 151
 152         if (!chan)
 153                 return;
 154
 155         for (i = 0; i < NR_CPUS; i++) {
 156                 if (!chan->buf[i])
 157                         continue;
 158                 __relay_reset(chan->buf[i], 0);
 159         }
 160 }
 161
 162 /**
 163  *      relay_open_buf - create a new channel buffer in relayfs
 164  *
 165  *      Internal - used by relay_open().
 166  */
 167 static struct rchan_buf *relay_open_buf(struct rchan *chan,
 168                                         const char *filename,
 169                                         struct dentry *parent)
 170 {
 171         struct rchan_buf *buf;
 172         struct dentry *dentry;
 173
 174         /* Create file in fs */
 175         dentry = relayfs_create_file(filename, parent, S_IRUSR, chan);
 176         if (!dentry)
 177                 return NULL;
 178
 179         buf = RELAYFS_I(dentry->d_inode)->buf;
 180         buf->dentry = dentry;
 181         __relay_reset(buf, 1);
 182
 183         return buf;
 184 }
 185
 186 /**
 187  *      relay_close_buf - close a channel buffer
 188  *      @buf: channel buffer
 189  *
 190  *      Marks the buffer finalized and restores the default callbacks.
 191  *      The channel buffer and channel buffer data structure are then freed
 192  *      automatically when the last reference is given up.
 193  */
 194 static inline void relay_close_buf(struct rchan_buf *buf)
 195 {
 196         buf->finalized = 1;
 197         buf->chan->cb = &default_channel_callbacks;
 198         cancel_delayed_work(&buf->wake_readers);
 199         flush_scheduled_work();
 200         kref_put(&buf->kref, relay_remove_buf);
 201 }
 202
 203 static inline void setup_callbacks(struct rchan *chan,
 204                                    struct rchan_callbacks *cb)
 205 {
 206         if (!cb) {
 207                 chan->cb = &default_channel_callbacks;
 208                 return;
 209         }
 210
 211         if (!cb->subbuf_start)
 212                 cb->subbuf_start = subbuf_start_default_callback;
 213         if (!cb->buf_mapped)
 214                 cb->buf_mapped = buf_mapped_default_callback;
 215         if (!cb->buf_unmapped)
 216                 cb->buf_unmapped = buf_unmapped_default_callback;
 217         chan->cb = cb;
 218 }
 219
 220 /**
 221  *      relay_open - create a new relayfs channel
 222  *      @base_filename: base name of files to create
 223  *      @parent: dentry of parent directory, NULL for root directory
 224  *      @subbuf_size: size of sub-buffers
 225  *      @n_subbufs: number of sub-buffers
 226  *      @cb: client callback functions
 227  *
 228  *      Returns channel pointer if successful, NULL otherwise.
 229  *
 230  *      Creates a channel buffer for each cpu using the sizes and
 231  *      attributes specified.  The created channel buffer files
 232  *      will be named base_filename0...base_filenameN-1.  File
 233  *      permissions will be S_IRUSR.
 234  */
 235 struct rchan *relay_open(const char *base_filename,
 236                          struct dentry *parent,
 237                          size_t subbuf_size,
 238                          size_t n_subbufs,
 239                          struct rchan_callbacks *cb)
 240 {
 241         unsigned int i;
 242         struct rchan *chan;
 243         char *tmpname;
 244
 245         if (!base_filename)
 246                 return NULL;
 247
 248         if (!(subbuf_size && n_subbufs))
 249                 return NULL;
 250
 251         chan = kcalloc(1, sizeof(struct rchan), GFP_KERNEL);
 252         if (!chan)
 253                 return NULL;
 254
 255         chan->version = RELAYFS_CHANNEL_VERSION;
 256         chan->n_subbufs = n_subbufs;
 257         chan->subbuf_size = subbuf_size;
 258         chan->alloc_size = FIX_SIZE(subbuf_size * n_subbufs);
 259         setup_callbacks(chan, cb);
 260         kref_init(&chan->kref);
 261
 262         tmpname = kmalloc(NAME_MAX + 1, GFP_KERNEL);
 263         if (!tmpname)
 264                 goto free_chan;
 265
 266         for_each_online_cpu(i) {
 267                 sprintf(tmpname, "%s%d", base_filename, i);
 268                 chan->buf[i] = relay_open_buf(chan, tmpname, parent);
 269                 chan->buf[i]->cpu = i;
 270                 if (!chan->buf[i])
 271                         goto free_bufs;
 272         }
 273
 274         kfree(tmpname);
 275         return chan;
 276
 277 free_bufs:
 278         for (i = 0; i < NR_CPUS; i++) {
 279                 if (!chan->buf[i])
 280                         break;
 281                 relay_close_buf(chan->buf[i]);
 282         }
 283         kfree(tmpname);
 284
 285 free_chan:
 286         kref_put(&chan->kref, relay_destroy_channel);
 287         return NULL;
 288 }
 289
 290 /**
 291  *      relay_switch_subbuf - switch to a new sub-buffer
 292  *      @buf: channel buffer
 293  *      @length: size of current event
 294  *
 295  *      Returns either the length passed in or 0 if full.
 296
 297  *      Performs sub-buffer-switch tasks such as invoking callbacks,
 298  *      updating padding counts, waking up readers, etc.
 299  */
 300 size_t relay_switch_subbuf(struct rchan_buf *buf, size_t length)
 301 {
 302         void *old, *new;
 303         size_t old_subbuf, new_subbuf;
 304
 305         if (unlikely(length > buf->chan->subbuf_size))
 306                 goto toobig;
 307
 308         if (buf->offset != buf->chan->subbuf_size + 1) {
 309                 buf->prev_padding = buf->chan->subbuf_size - buf->offset;
 310                 old_subbuf = buf->subbufs_produced % buf->chan->n_subbufs;
 311                 buf->padding[old_subbuf] = buf->prev_padding;
 312                 buf->subbufs_produced++;
 313                 if (waitqueue_active(&buf->read_wait)) {
 314                         PREPARE_WORK(&buf->wake_readers, wakeup_readers, buf);
 315                         schedule_delayed_work(&buf->wake_readers, 1);
 316                 }
 317         }
 318
 319         old = buf->data;
 320         new_subbuf = buf->subbufs_produced % buf->chan->n_subbufs;
 321         new = buf->start + new_subbuf * buf->chan->subbuf_size;
 322         buf->offset = 0;
 323         if (!buf->chan->cb->subbuf_start(buf, new, old, buf->prev_padding)) {
 324                 buf->offset = buf->chan->subbuf_size + 1;
 325                 return 0;
 326         }
 327         buf->data = new;
 328         buf->padding[new_subbuf] = 0;
 329
 330         if (unlikely(length + buf->offset > buf->chan->subbuf_size))
 331                 goto toobig;
 332
 333         return length;
 334
 335 toobig:
 336         printk(KERN_WARNING "relayfs: event too large (%Zd)\n", length);
 337         WARN_ON(1);
 338         return 0;
 339 }
 340
 341 /**
 342  *      relay_subbufs_consumed - update the buffer's sub-buffers-consumed count
 343  *      @chan: the channel
 344  *      @cpu: the cpu associated with the channel buffer to update
 345  *      @subbufs_consumed: number of sub-buffers to add to current buf's count
 346  *
 347  *      Adds to the channel buffer's consumed sub-buffer count.
 348  *      subbufs_consumed should be the number of sub-buffers newly consumed,
 349  *      not the total consumed.
 350  *
 351  *      NOTE: kernel clients don't need to call this function if the channel
 352  *      mode is 'overwrite'.
 353  */
 354 void relay_subbufs_consumed(struct rchan *chan,
 355                             unsigned int cpu,
 356                             size_t subbufs_consumed)
 357 {
 358         struct rchan_buf *buf;
 359
 360         if (!chan)
 361                 return;
 362
 363         if (cpu >= NR_CPUS || !chan->buf[cpu])
 364                 return;
 365
 366         buf = chan->buf[cpu];
 367         buf->subbufs_consumed += subbufs_consumed;
 368         if (buf->subbufs_consumed > buf->subbufs_produced)
 369                 buf->subbufs_consumed = buf->subbufs_produced;
 370 }
 371
 372 /**
 373  *      relay_destroy_channel - free the channel struct
 374  *
 375  *      Should only be called from kref_put().
 376  */
 377 void relay_destroy_channel(struct kref *kref)
 378 {
 379         struct rchan *chan = container_of(kref, struct rchan, kref);
 380         kfree(chan);
 381 }
 382
 383 /**
 384  *      relay_close - close the channel
 385  *      @chan: the channel
 386  *
 387  *      Closes all channel buffers and frees the channel.
 388  */
 389 void relay_close(struct rchan *chan)
 390 {
 391         unsigned int i;
 392
 393         if (!chan)
 394                 return;
 395
 396         for (i = 0; i < NR_CPUS; i++) {
 397                 if (!chan->buf[i])
 398                         continue;
 399                 relay_close_buf(chan->buf[i]);
 400         }
 401
 402         kref_put(&chan->kref, relay_destroy_channel);
 403 }
 404
 405 /**
 406  *      relay_flush - close the channel
 407  *      @chan: the channel
 408  *
 409  *      Flushes all channel buffers i.e. forces buffer switch.
 410  */
 411 void relay_flush(struct rchan *chan)
 412 {
 413         unsigned int i;
 414
 415         if (!chan)
 416                 return;
 417
 418         for (i = 0; i < NR_CPUS; i++) {
 419                 if (!chan->buf[i])
 420                         continue;
 421                 relay_switch_subbuf(chan->buf[i], 0);
 422         }
 423 }
 424
 425 EXPORT_SYMBOL_GPL(relay_open);
 426 EXPORT_SYMBOL_GPL(relay_close);
 427 EXPORT_SYMBOL_GPL(relay_flush);
 428 EXPORT_SYMBOL_GPL(relay_reset);
 429 EXPORT_SYMBOL_GPL(relay_subbufs_consumed);
 430 EXPORT_SYMBOL_GPL(relay_switch_subbuf);
 431 EXPORT_SYMBOL_GPL(relay_buf_full);