home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / relay.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  8.7 KB  |  292 lines
  1. /*
  2.  * linux/include/linux/relay.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.  * CONFIG_RELAY definitions and declarations
  8.  */
  9.  
  10. #ifndef _LINUX_RELAY_H
  11. #define _LINUX_RELAY_H
  12.  
  13. #include <linux/types.h>
  14. #include <linux/sched.h>
  15. #include <linux/timer.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. /* Needs a _much_ better name... */
  23. #define FIX_SIZE(x) ((((x) - 1) & PAGE_MASK) + PAGE_SIZE)
  24.  
  25. /*
  26.  * Tracks changes to rchan/rchan_buf structs
  27.  */
  28. #define RELAYFS_CHANNEL_VERSION        7
  29.  
  30. /*
  31.  * Per-cpu relay channel buffer
  32.  */
  33. struct rchan_buf
  34. {
  35.     void *start;            /* start of channel buffer */
  36.     void *data;            /* start of current sub-buffer */
  37.     size_t offset;            /* current offset into sub-buffer */
  38.     size_t subbufs_produced;    /* count of sub-buffers produced */
  39.     size_t subbufs_consumed;    /* count of sub-buffers consumed */
  40.     struct rchan *chan;        /* associated channel */
  41.     wait_queue_head_t read_wait;    /* reader wait queue */
  42.     struct timer_list timer;     /* reader wake-up timer */
  43.     struct dentry *dentry;        /* channel file dentry */
  44.     struct kref kref;        /* channel buffer refcount */
  45.     struct page **page_array;    /* array of current buffer pages */
  46.     unsigned int page_count;    /* number of current buffer pages */
  47.     unsigned int finalized;        /* buffer has been finalized */
  48.     size_t *padding;        /* padding counts per sub-buffer */
  49.     size_t prev_padding;        /* temporary variable */
  50.     size_t bytes_consumed;        /* bytes consumed in cur read subbuf */
  51.     size_t early_bytes;        /* bytes consumed before VFS inited */
  52.     unsigned int cpu;        /* this buf's cpu */
  53. } ____cacheline_aligned;
  54.  
  55. /*
  56.  * Relay channel data structure
  57.  */
  58. struct rchan
  59. {
  60.     u32 version;            /* the version of this struct */
  61.     size_t subbuf_size;        /* sub-buffer size */
  62.     size_t n_subbufs;        /* number of sub-buffers per buffer */
  63.     size_t alloc_size;        /* total buffer size allocated */
  64.     struct rchan_callbacks *cb;    /* client callbacks */
  65.     struct kref kref;        /* channel refcount */
  66.     void *private_data;        /* for user-defined data */
  67.     size_t last_toobig;        /* tried to log event > subbuf size */
  68.     struct rchan_buf *buf[NR_CPUS]; /* per-cpu channel buffers */
  69.     int is_global;            /* One global buffer ? */
  70.     struct list_head list;        /* for channel list */
  71.     struct dentry *parent;        /* parent dentry passed to open */
  72.     int has_base_filename;        /* has a filename associated? */
  73.     char base_filename[NAME_MAX];    /* saved base filename */
  74. };
  75.  
  76. /*
  77.  * Relay channel client callbacks
  78.  */
  79. struct rchan_callbacks
  80. {
  81.     /*
  82.      * subbuf_start - called on buffer-switch to a new sub-buffer
  83.      * @buf: the channel buffer containing the new sub-buffer
  84.      * @subbuf: the start of the new sub-buffer
  85.      * @prev_subbuf: the start of the previous sub-buffer
  86.      * @prev_padding: unused space at the end of previous sub-buffer
  87.      *
  88.      * The client should return 1 to continue logging, 0 to stop
  89.      * logging.
  90.      *
  91.      * NOTE: subbuf_start will also be invoked when the buffer is
  92.      *       created, so that the first sub-buffer can be initialized
  93.      *       if necessary.  In this case, prev_subbuf will be NULL.
  94.      *
  95.      * NOTE: the client can reserve bytes at the beginning of the new
  96.      *       sub-buffer by calling subbuf_start_reserve() in this callback.
  97.      */
  98.     int (*subbuf_start) (struct rchan_buf *buf,
  99.                  void *subbuf,
  100.                  void *prev_subbuf,
  101.                  size_t prev_padding);
  102.  
  103.     /*
  104.      * buf_mapped - relay buffer mmap notification
  105.      * @buf: the channel buffer
  106.      * @filp: relay file pointer
  107.      *
  108.      * Called when a relay file is successfully mmapped
  109.      */
  110.         void (*buf_mapped)(struct rchan_buf *buf,
  111.                struct file *filp);
  112.  
  113.     /*
  114.      * buf_unmapped - relay buffer unmap notification
  115.      * @buf: the channel buffer
  116.      * @filp: relay file pointer
  117.      *
  118.      * Called when a relay file is successfully unmapped
  119.      */
  120.         void (*buf_unmapped)(struct rchan_buf *buf,
  121.                  struct file *filp);
  122.     /*
  123.      * create_buf_file - create file to represent a relay channel buffer
  124.      * @filename: the name of the file to create
  125.      * @parent: the parent of the file to create
  126.      * @mode: the mode of the file to create
  127.      * @buf: the channel buffer
  128.      * @is_global: outparam - set non-zero if the buffer should be global
  129.      *
  130.      * Called during relay_open(), once for each per-cpu buffer,
  131.      * to allow the client to create a file to be used to
  132.      * represent the corresponding channel buffer.  If the file is
  133.      * created outside of relay, the parent must also exist in
  134.      * that filesystem.
  135.      *
  136.      * The callback should return the dentry of the file created
  137.      * to represent the relay buffer.
  138.      *
  139.      * Setting the is_global outparam to a non-zero value will
  140.      * cause relay_open() to create a single global buffer rather
  141.      * than the default set of per-cpu buffers.
  142.      *
  143.      * See Documentation/filesystems/relayfs.txt for more info.
  144.      */
  145.     struct dentry *(*create_buf_file)(const char *filename,
  146.                       struct dentry *parent,
  147.                       int mode,
  148.                       struct rchan_buf *buf,
  149.                       int *is_global);
  150.  
  151.     /*
  152.      * remove_buf_file - remove file representing a relay channel buffer
  153.      * @dentry: the dentry of the file to remove
  154.      *
  155.      * Called during relay_close(), once for each per-cpu buffer,
  156.      * to allow the client to remove a file used to represent a
  157.      * channel buffer.
  158.      *
  159.      * The callback should return 0 if successful, negative if not.
  160.      */
  161.     int (*remove_buf_file)(struct dentry *dentry);
  162. };
  163.  
  164. /*
  165.  * CONFIG_RELAY kernel API, kernel/relay.c
  166.  */
  167.  
  168. struct rchan *relay_open(const char *base_filename,
  169.              struct dentry *parent,
  170.              size_t subbuf_size,
  171.              size_t n_subbufs,
  172.              struct rchan_callbacks *cb,
  173.              void *private_data);
  174. extern int relay_late_setup_files(struct rchan *chan,
  175.                   const char *base_filename,
  176.                   struct dentry *parent);
  177. extern void relay_close(struct rchan *chan);
  178. extern void relay_flush(struct rchan *chan);
  179. extern void relay_subbufs_consumed(struct rchan *chan,
  180.                    unsigned int cpu,
  181.                    size_t consumed);
  182. extern void relay_reset(struct rchan *chan);
  183. extern int relay_buf_full(struct rchan_buf *buf);
  184.  
  185. extern size_t relay_switch_subbuf(struct rchan_buf *buf,
  186.                   size_t length);
  187.  
  188. /**
  189.  *    relay_write - write data into the channel
  190.  *    @chan: relay channel
  191.  *    @data: data to be written
  192.  *    @length: number of bytes to write
  193.  *
  194.  *    Writes data into the current cpu's channel buffer.
  195.  *
  196.  *    Protects the buffer by disabling interrupts.  Use this
  197.  *    if you might be logging from interrupt context.  Try
  198.  *    __relay_write() if you know you    won't be logging from
  199.  *    interrupt context.
  200.  */
  201. static inline void relay_write(struct rchan *chan,
  202.                    const void *data,
  203.                    size_t length)
  204. {
  205.     unsigned long flags;
  206.     struct rchan_buf *buf;
  207.  
  208.     local_irq_save(flags);
  209.     buf = chan->buf[smp_processor_id()];
  210.     if (unlikely(buf->offset + length > chan->subbuf_size))
  211.         length = relay_switch_subbuf(buf, length);
  212.     memcpy(buf->data + buf->offset, data, length);
  213.     buf->offset += length;
  214.     local_irq_restore(flags);
  215. }
  216.  
  217. /**
  218.  *    __relay_write - write data into the channel
  219.  *    @chan: relay channel
  220.  *    @data: data to be written
  221.  *    @length: number of bytes to write
  222.  *
  223.  *    Writes data into the current cpu's channel buffer.
  224.  *
  225.  *    Protects the buffer by disabling preemption.  Use
  226.  *    relay_write() if you might be logging from interrupt
  227.  *    context.
  228.  */
  229. static inline void __relay_write(struct rchan *chan,
  230.                  const void *data,
  231.                  size_t length)
  232. {
  233.     struct rchan_buf *buf;
  234.  
  235.     buf = chan->buf[get_cpu()];
  236.     if (unlikely(buf->offset + length > buf->chan->subbuf_size))
  237.         length = relay_switch_subbuf(buf, length);
  238.     memcpy(buf->data + buf->offset, data, length);
  239.     buf->offset += length;
  240.     put_cpu();
  241. }
  242.  
  243. /**
  244.  *    relay_reserve - reserve slot in channel buffer
  245.  *    @chan: relay channel
  246.  *    @length: number of bytes to reserve
  247.  *
  248.  *    Returns pointer to reserved slot, NULL if full.
  249.  *
  250.  *    Reserves a slot in the current cpu's channel buffer.
  251.  *    Does not protect the buffer at all - caller must provide
  252.  *    appropriate synchronization.
  253.  */
  254. static inline void *relay_reserve(struct rchan *chan, size_t length)
  255. {
  256.     void *reserved;
  257.     struct rchan_buf *buf = chan->buf[smp_processor_id()];
  258.  
  259.     if (unlikely(buf->offset + length > buf->chan->subbuf_size)) {
  260.         length = relay_switch_subbuf(buf, length);
  261.         if (!length)
  262.             return NULL;
  263.     }
  264.     reserved = buf->data + buf->offset;
  265.     buf->offset += length;
  266.  
  267.     return reserved;
  268. }
  269.  
  270. /**
  271.  *    subbuf_start_reserve - reserve bytes at the start of a sub-buffer
  272.  *    @buf: relay channel buffer
  273.  *    @length: number of bytes to reserve
  274.  *
  275.  *    Helper function used to reserve bytes at the beginning of
  276.  *    a sub-buffer in the subbuf_start() callback.
  277.  */
  278. static inline void subbuf_start_reserve(struct rchan_buf *buf,
  279.                     size_t length)
  280. {
  281.     BUG_ON(length >= buf->chan->subbuf_size - 1);
  282.     buf->offset = length;
  283. }
  284.  
  285. /*
  286.  * exported relay file operations, kernel/relay.c
  287.  */
  288. extern const struct file_operations relay_file_operations;
  289.  
  290. #endif /* _LINUX_RELAY_H */
  291.  
  292.