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