diff options
author | Andrew Morton <akpm@osdl.org> | 2006-03-28 04:56:27 -0500 |
---|---|---|
committer | Linus Torvalds <torvalds@g5.osdl.org> | 2006-03-28 12:16:03 -0500 |
commit | e51236092d2f7e40e87e88804b5b42e5f8025415 (patch) | |
tree | 9ac887d944107d86dad6a534bb0399b7cd60c15e | |
parent | 3ca1da4a82b169417b738a35783008c35da26466 (diff) |
[PATCH] remove relayfs_fs.h
This is obsolete.
Cc: Tom Zanussi <zanussi@us.ibm.com>
Cc: Jens Axboe <axboe@suse.de>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
-rw-r--r-- | include/linux/relayfs_fs.h | 287 |
1 files changed, 0 insertions, 287 deletions
diff --git a/include/linux/relayfs_fs.h b/include/linux/relayfs_fs.h deleted file mode 100644 index 7342e66247fb..000000000000 --- a/include/linux/relayfs_fs.h +++ /dev/null | |||
@@ -1,287 +0,0 @@ | |||
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 | * create_buf_file - create file to represent a relayfs channel buffer | ||
115 | * @filename: the name of the file to create | ||
116 | * @parent: the parent of the file to create | ||
117 | * @mode: the mode of the file to create | ||
118 | * @buf: the channel buffer | ||
119 | * @is_global: outparam - set non-zero if the buffer should be global | ||
120 | * | ||
121 | * Called during relay_open(), once for each per-cpu buffer, | ||
122 | * to allow the client to create a file to be used to | ||
123 | * represent the corresponding channel buffer. If the file is | ||
124 | * created outside of relayfs, the parent must also exist in | ||
125 | * that filesystem. | ||
126 | * | ||
127 | * The callback should return the dentry of the file created | ||
128 | * to represent the relay buffer. | ||
129 | * | ||
130 | * Setting the is_global outparam to a non-zero value will | ||
131 | * cause relay_open() to create a single global buffer rather | ||
132 | * than the default set of per-cpu buffers. | ||
133 | * | ||
134 | * See Documentation/filesystems/relayfs.txt for more info. | ||
135 | */ | ||
136 | struct dentry *(*create_buf_file)(const char *filename, | ||
137 | struct dentry *parent, | ||
138 | int mode, | ||
139 | struct rchan_buf *buf, | ||
140 | int *is_global); | ||
141 | |||
142 | /* | ||
143 | * remove_buf_file - remove file representing a relayfs channel buffer | ||
144 | * @dentry: the dentry of the file to remove | ||
145 | * | ||
146 | * Called during relay_close(), once for each per-cpu buffer, | ||
147 | * to allow the client to remove a file used to represent a | ||
148 | * channel buffer. | ||
149 | * | ||
150 | * The callback should return 0 if successful, negative if not. | ||
151 | */ | ||
152 | int (*remove_buf_file)(struct dentry *dentry); | ||
153 | }; | ||
154 | |||
155 | /* | ||
156 | * relayfs kernel API, fs/relayfs/relay.c | ||
157 | */ | ||
158 | |||
159 | struct rchan *relay_open(const char *base_filename, | ||
160 | struct dentry *parent, | ||
161 | size_t subbuf_size, | ||
162 | size_t n_subbufs, | ||
163 | struct rchan_callbacks *cb); | ||
164 | extern void relay_close(struct rchan *chan); | ||
165 | extern void relay_flush(struct rchan *chan); | ||
166 | extern void relay_subbufs_consumed(struct rchan *chan, | ||
167 | unsigned int cpu, | ||
168 | size_t consumed); | ||
169 | extern void relay_reset(struct rchan *chan); | ||
170 | extern int relay_buf_full(struct rchan_buf *buf); | ||
171 | |||
172 | extern size_t relay_switch_subbuf(struct rchan_buf *buf, | ||
173 | size_t length); | ||
174 | extern struct dentry *relayfs_create_dir(const char *name, | ||
175 | struct dentry *parent); | ||
176 | extern int relayfs_remove_dir(struct dentry *dentry); | ||
177 | extern struct dentry *relayfs_create_file(const char *name, | ||
178 | struct dentry *parent, | ||
179 | int mode, | ||
180 | struct file_operations *fops, | ||
181 | void *data); | ||
182 | extern int relayfs_remove_file(struct dentry *dentry); | ||
183 | |||
184 | /** | ||
185 | * relay_write - write data into the channel | ||
186 | * @chan: relay channel | ||
187 | * @data: data to be written | ||
188 | * @length: number of bytes to write | ||
189 | * | ||
190 | * Writes data into the current cpu's channel buffer. | ||
191 | * | ||
192 | * Protects the buffer by disabling interrupts. Use this | ||
193 | * if you might be logging from interrupt context. Try | ||
194 | * __relay_write() if you know you won't be logging from | ||
195 | * interrupt context. | ||
196 | */ | ||
197 | static inline void relay_write(struct rchan *chan, | ||
198 | const void *data, | ||
199 | size_t length) | ||
200 | { | ||
201 | unsigned long flags; | ||
202 | struct rchan_buf *buf; | ||
203 | |||
204 | local_irq_save(flags); | ||
205 | buf = chan->buf[smp_processor_id()]; | ||
206 | if (unlikely(buf->offset + length > chan->subbuf_size)) | ||
207 | length = relay_switch_subbuf(buf, length); | ||
208 | memcpy(buf->data + buf->offset, data, length); | ||
209 | buf->offset += length; | ||
210 | local_irq_restore(flags); | ||
211 | } | ||
212 | |||
213 | /** | ||
214 | * __relay_write - write data into the channel | ||
215 | * @chan: relay channel | ||
216 | * @data: data to be written | ||
217 | * @length: number of bytes to write | ||
218 | * | ||
219 | * Writes data into the current cpu's channel buffer. | ||
220 | * | ||
221 | * Protects the buffer by disabling preemption. Use | ||
222 | * relay_write() if you might be logging from interrupt | ||
223 | * context. | ||
224 | */ | ||
225 | static inline void __relay_write(struct rchan *chan, | ||
226 | const void *data, | ||
227 | size_t length) | ||
228 | { | ||
229 | struct rchan_buf *buf; | ||
230 | |||
231 | buf = chan->buf[get_cpu()]; | ||
232 | if (unlikely(buf->offset + length > buf->chan->subbuf_size)) | ||
233 | length = relay_switch_subbuf(buf, length); | ||
234 | memcpy(buf->data + buf->offset, data, length); | ||
235 | buf->offset += length; | ||
236 | put_cpu(); | ||
237 | } | ||
238 | |||
239 | /** | ||
240 | * relay_reserve - reserve slot in channel buffer | ||
241 | * @chan: relay channel | ||
242 | * @length: number of bytes to reserve | ||
243 | * | ||
244 | * Returns pointer to reserved slot, NULL if full. | ||
245 | * | ||
246 | * Reserves a slot in the current cpu's channel buffer. | ||
247 | * Does not protect the buffer at all - caller must provide | ||
248 | * appropriate synchronization. | ||
249 | */ | ||
250 | static inline void *relay_reserve(struct rchan *chan, size_t length) | ||
251 | { | ||
252 | void *reserved; | ||
253 | struct rchan_buf *buf = chan->buf[smp_processor_id()]; | ||
254 | |||
255 | if (unlikely(buf->offset + length > buf->chan->subbuf_size)) { | ||
256 | length = relay_switch_subbuf(buf, length); | ||
257 | if (!length) | ||
258 | return NULL; | ||
259 | } | ||
260 | reserved = buf->data + buf->offset; | ||
261 | buf->offset += length; | ||
262 | |||
263 | return reserved; | ||
264 | } | ||
265 | |||
266 | /** | ||
267 | * subbuf_start_reserve - reserve bytes at the start of a sub-buffer | ||
268 | * @buf: relay channel buffer | ||
269 | * @length: number of bytes to reserve | ||
270 | * | ||
271 | * Helper function used to reserve bytes at the beginning of | ||
272 | * a sub-buffer in the subbuf_start() callback. | ||
273 | */ | ||
274 | static inline void subbuf_start_reserve(struct rchan_buf *buf, | ||
275 | size_t length) | ||
276 | { | ||
277 | BUG_ON(length >= buf->chan->subbuf_size - 1); | ||
278 | buf->offset = length; | ||
279 | } | ||
280 | |||
281 | /* | ||
282 | * exported relay file operations, fs/relayfs/inode.c | ||
283 | */ | ||
284 | extern struct file_operations relay_file_operations; | ||
285 | |||
286 | #endif /* _LINUX_RELAYFS_FS_H */ | ||
287 | |||