err.no Git - linux-2.6/blob - include/linux/relayfs_fs.h

   1 /*
   2  * linux/include/linux/relayfs_fs.h
   3  *
   4  * Copyright (C) 2002, 2003 - Tom Zanussi (zanussi@us.ibm.com), IBM Corp
   5  * Copyright (C) 1999, 2000, 2001, 2002 - Karim Yaghmour (karim@opersys.com)
   6  *
   7  * RelayFS definitions and declarations
   8  */
   9
  10 #ifndef _LINUX_RELAYFS_FS_H
  11 #define _LINUX_RELAYFS_FS_H
  12
  13 #include <linux/config.h>
  14 #include <linux/types.h>
  15 #include <linux/sched.h>
  16 #include <linux/wait.h>
  17 #include <linux/list.h>
  18 #include <linux/fs.h>
  19 #include <linux/poll.h>
  20 #include <linux/kref.h>
  21
  22 /*
  23  * Tracks changes to rchan/rchan_buf structs
  24  */
  25 #define RELAYFS_CHANNEL_VERSION         6
  26
  27 /*
  28  * Per-cpu relay channel buffer
  29  */
  30 struct rchan_buf
  31 {
  32         void *start;                    /* start of channel buffer */
  33         void *data;                     /* start of current sub-buffer */
  34         size_t offset;                  /* current offset into sub-buffer */
  35         size_t subbufs_produced;        /* count of sub-buffers produced */
  36         size_t subbufs_consumed;        /* count of sub-buffers consumed */
  37         struct rchan *chan;             /* associated channel */
  38         wait_queue_head_t read_wait;    /* reader wait queue */
  39         struct work_struct wake_readers; /* reader wake-up work struct */
  40         struct dentry *dentry;          /* channel file dentry */
  41         struct kref kref;               /* channel buffer refcount */
  42         struct page **page_array;       /* array of current buffer pages */
  43         unsigned int page_count;        /* number of current buffer pages */
  44         unsigned int finalized;         /* buffer has been finalized */
  45         size_t *padding;                /* padding counts per sub-buffer */
  46         size_t prev_padding;            /* temporary variable */
  47         size_t bytes_consumed;          /* bytes consumed in cur read subbuf */
  48         unsigned int cpu;               /* this buf's cpu */
  49 } ____cacheline_aligned;
  50
  51 /*
  52  * Relay channel data structure
  53  */
  54 struct rchan
  55 {
  56         u32 version;                    /* the version of this struct */
  57         size_t subbuf_size;             /* sub-buffer size */
  58         size_t n_subbufs;               /* number of sub-buffers per buffer */
  59         size_t alloc_size;              /* total buffer size allocated */
  60         struct rchan_callbacks *cb;     /* client callbacks */
  61         struct kref kref;               /* channel refcount */
  62         void *private_data;             /* for user-defined data */
  63         size_t last_toobig;             /* tried to log event > subbuf size */
  64         struct rchan_buf *buf[NR_CPUS]; /* per-cpu channel buffers */
  65 };
  66
  67 /*
  68  * Relay channel client callbacks
  69  */
  70 struct rchan_callbacks
  71 {
  72         /*
  73          * subbuf_start - called on buffer-switch to a new sub-buffer
  74          * @buf: the channel buffer containing the new sub-buffer
  75          * @subbuf: the start of the new sub-buffer
  76          * @prev_subbuf: the start of the previous sub-buffer
  77          * @prev_padding: unused space at the end of previous sub-buffer
  78          *
  79          * The client should return 1 to continue logging, 0 to stop
  80          * logging.
  81          *
  82          * NOTE: subbuf_start will also be invoked when the buffer is
  83          *       created, so that the first sub-buffer can be initialized
  84          *       if necessary.  In this case, prev_subbuf will be NULL.
  85          *
  86          * NOTE: the client can reserve bytes at the beginning of the new
  87          *       sub-buffer by calling subbuf_start_reserve() in this callback.
  88          */
  89         int (*subbuf_start) (struct rchan_buf *buf,
  90                              void *subbuf,
  91                              void *prev_subbuf,
  92                              size_t prev_padding);
  93
  94         /*
  95          * buf_mapped - relayfs buffer mmap notification
  96          * @buf: the channel buffer
  97          * @filp: relayfs file pointer
  98          *
  99          * Called when a relayfs file is successfully mmapped
 100          */
 101         void (*buf_mapped)(struct rchan_buf *buf,
 102                            struct file *filp);
 103
 104         /*
 105          * buf_unmapped - relayfs buffer unmap notification
 106          * @buf: the channel buffer
 107          * @filp: relayfs file pointer
 108          *
 109          * Called when a relayfs file is successfully unmapped
 110          */
 111         void (*buf_unmapped)(struct rchan_buf *buf,
 112                              struct file *filp);
 113 };
 114
 115 /*
 116  * relayfs kernel API, fs/relayfs/relay.c
 117  */
 118
 119 struct rchan *relay_open(const char *base_filename,
 120                          struct dentry *parent,
 121                          size_t subbuf_size,
 122                          size_t n_subbufs,
 123                          struct rchan_callbacks *cb);
 124 extern void relay_close(struct rchan *chan);
 125 extern void relay_flush(struct rchan *chan);
 126 extern void relay_subbufs_consumed(struct rchan *chan,
 127                                    unsigned int cpu,
 128                                    size_t consumed);
 129 extern void relay_reset(struct rchan *chan);
 130 extern int relay_buf_full(struct rchan_buf *buf);
 131
 132 extern size_t relay_switch_subbuf(struct rchan_buf *buf,
 133                                   size_t length);
 134 extern struct dentry *relayfs_create_dir(const char *name,
 135                                          struct dentry *parent);
 136 extern int relayfs_remove_dir(struct dentry *dentry);
 137 extern struct dentry *relayfs_create_file(const char *name,
 138                                           struct dentry *parent,
 139                                           int mode,
 140                                           struct file_operations *fops,
 141                                           void *data);
 142 extern int relayfs_remove_file(struct dentry *dentry);
 143
 144 /**
 145  *      relay_write - write data into the channel
 146  *      @chan: relay channel
 147  *      @data: data to be written
 148  *      @length: number of bytes to write
 149  *
 150  *      Writes data into the current cpu's channel buffer.
 151  *
 152  *      Protects the buffer by disabling interrupts.  Use this
 153  *      if you might be logging from interrupt context.  Try
 154  *      __relay_write() if you know you won't be logging from
 155  *      interrupt context.
 156  */
 157 static inline void relay_write(struct rchan *chan,
 158                                const void *data,
 159                                size_t length)
 160 {
 161         unsigned long flags;
 162         struct rchan_buf *buf;
 163
 164         local_irq_save(flags);
 165         buf = chan->buf[smp_processor_id()];
 166         if (unlikely(buf->offset + length > chan->subbuf_size))
 167                 length = relay_switch_subbuf(buf, length);
 168         memcpy(buf->data + buf->offset, data, length);
 169         buf->offset += length;
 170         local_irq_restore(flags);
 171 }
 172
 173 /**
 174  *      __relay_write - write data into the channel
 175  *      @chan: relay channel
 176  *      @data: data to be written
 177  *      @length: number of bytes to write
 178  *
 179  *      Writes data into the current cpu's channel buffer.
 180  *
 181  *      Protects the buffer by disabling preemption.  Use
 182  *      relay_write() if you might be logging from interrupt
 183  *      context.
 184  */
 185 static inline void __relay_write(struct rchan *chan,
 186                                  const void *data,
 187                                  size_t length)
 188 {
 189         struct rchan_buf *buf;
 190
 191         buf = chan->buf[get_cpu()];
 192         if (unlikely(buf->offset + length > buf->chan->subbuf_size))
 193                 length = relay_switch_subbuf(buf, length);
 194         memcpy(buf->data + buf->offset, data, length);
 195         buf->offset += length;
 196         put_cpu();
 197 }
 198
 199 /**
 200  *      relay_reserve - reserve slot in channel buffer
 201  *      @chan: relay channel
 202  *      @length: number of bytes to reserve
 203  *
 204  *      Returns pointer to reserved slot, NULL if full.
 205  *
 206  *      Reserves a slot in the current cpu's channel buffer.
 207  *      Does not protect the buffer at all - caller must provide
 208  *      appropriate synchronization.
 209  */
 210 static inline void *relay_reserve(struct rchan *chan, size_t length)
 211 {
 212         void *reserved;
 213         struct rchan_buf *buf = chan->buf[smp_processor_id()];
 214
 215         if (unlikely(buf->offset + length > buf->chan->subbuf_size)) {
 216                 length = relay_switch_subbuf(buf, length);
 217                 if (!length)
 218                         return NULL;
 219         }
 220         reserved = buf->data + buf->offset;
 221         buf->offset += length;
 222
 223         return reserved;
 224 }
 225
 226 /**
 227  *      subbuf_start_reserve - reserve bytes at the start of a sub-buffer
 228  *      @buf: relay channel buffer
 229  *      @length: number of bytes to reserve
 230  *
 231  *      Helper function used to reserve bytes at the beginning of
 232  *      a sub-buffer in the subbuf_start() callback.
 233  */
 234 static inline void subbuf_start_reserve(struct rchan_buf *buf,
 235                                         size_t length)
 236 {
 237         BUG_ON(length >= buf->chan->subbuf_size - 1);
 238         buf->offset = length;
 239 }
 240
 241 /*
 242  * exported relayfs file operations, fs/relayfs/inode.c
 243  */
 244
 245 extern struct file_operations relayfs_file_operations;
 246
 247 #endif /* _LINUX_RELAYFS_FS_H */
 248