Branch data Line data Source code
1 : : /*
2 : : * Public API and common code for kernel->userspace relay file support.
3 : : *
4 : : * See Documentation/filesystems/relay.txt for an overview.
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 : : * Moved to kernel/relay.c by Paul Mundt, 2006.
10 : : * November 2006 - CPU hotplug support by Mathieu Desnoyers
11 : : * (mathieu.desnoyers@polymtl.ca)
12 : : *
13 : : * This file is released under the GPL.
14 : : */
15 : : #include <linux/errno.h>
16 : : #include <linux/stddef.h>
17 : : #include <linux/slab.h>
18 : : #include <linux/export.h>
19 : : #include <linux/string.h>
20 : : #include <linux/relay.h>
21 : : #include <linux/vmalloc.h>
22 : : #include <linux/mm.h>
23 : : #include <linux/cpu.h>
24 : : #include <linux/splice.h>
25 : :
26 : : /* list of open channels, for cpu hotplug */
27 : : static DEFINE_MUTEX(relay_channels_mutex);
28 : : static LIST_HEAD(relay_channels);
29 : :
30 : : /*
31 : : * close() vm_op implementation for relay file mapping.
32 : : */
33 : 0 : static void relay_file_mmap_close(struct vm_area_struct *vma)
34 : : {
35 : 0 : struct rchan_buf *buf = vma->vm_private_data;
36 : 0 : buf->chan->cb->buf_unmapped(buf, vma->vm_file);
37 : 0 : }
38 : :
39 : : /*
40 : : * fault() vm_op implementation for relay file mapping.
41 : : */
42 : 0 : static vm_fault_t relay_buf_fault(struct vm_fault *vmf)
43 : : {
44 : 0 : struct page *page;
45 : 0 : struct rchan_buf *buf = vmf->vma->vm_private_data;
46 : 0 : pgoff_t pgoff = vmf->pgoff;
47 : :
48 [ # # ]: 0 : if (!buf)
49 : : return VM_FAULT_OOM;
50 : :
51 : 0 : page = vmalloc_to_page(buf->start + (pgoff << PAGE_SHIFT));
52 [ # # ]: 0 : if (!page)
53 : : return VM_FAULT_SIGBUS;
54 [ # # ]: 0 : get_page(page);
55 : 0 : vmf->page = page;
56 : :
57 : 0 : return 0;
58 : : }
59 : :
60 : : /*
61 : : * vm_ops for relay file mappings.
62 : : */
63 : : static const struct vm_operations_struct relay_file_mmap_ops = {
64 : : .fault = relay_buf_fault,
65 : : .close = relay_file_mmap_close,
66 : : };
67 : :
68 : : /*
69 : : * allocate an array of pointers of struct page
70 : : */
71 : 0 : static struct page **relay_alloc_page_array(unsigned int n_pages)
72 : : {
73 : 0 : const size_t pa_size = n_pages * sizeof(struct page *);
74 [ # # ]: 0 : if (pa_size > PAGE_SIZE)
75 : 0 : return vzalloc(pa_size);
76 : 0 : return kzalloc(pa_size, GFP_KERNEL);
77 : : }
78 : :
79 : : /*
80 : : * free an array of pointers of struct page
81 : : */
82 : 0 : static void relay_free_page_array(struct page **array)
83 : : {
84 : 0 : kvfree(array);
85 : 0 : }
86 : :
87 : : /**
88 : : * relay_mmap_buf: - mmap channel buffer to process address space
89 : : * @buf: relay channel buffer
90 : : * @vma: vm_area_struct describing memory to be mapped
91 : : *
92 : : * Returns 0 if ok, negative on error
93 : : *
94 : : * Caller should already have grabbed mmap_sem.
95 : : */
96 : 0 : static int relay_mmap_buf(struct rchan_buf *buf, struct vm_area_struct *vma)
97 : : {
98 : 0 : unsigned long length = vma->vm_end - vma->vm_start;
99 : 0 : struct file *filp = vma->vm_file;
100 : :
101 [ # # ]: 0 : if (!buf)
102 : : return -EBADF;
103 : :
104 [ # # ]: 0 : if (length != (unsigned long)buf->chan->alloc_size)
105 : : return -EINVAL;
106 : :
107 : 0 : vma->vm_ops = &relay_file_mmap_ops;
108 : 0 : vma->vm_flags |= VM_DONTEXPAND;
109 : 0 : vma->vm_private_data = buf;
110 : 0 : buf->chan->cb->buf_mapped(buf, filp);
111 : :
112 : 0 : return 0;
113 : : }
114 : :
115 : : /**
116 : : * relay_alloc_buf - allocate a channel buffer
117 : : * @buf: the buffer struct
118 : : * @size: total size of the buffer
119 : : *
120 : : * Returns a pointer to the resulting buffer, %NULL if unsuccessful. The
121 : : * passed in size will get page aligned, if it isn't already.
122 : : */
123 : 0 : static void *relay_alloc_buf(struct rchan_buf *buf, size_t *size)
124 : : {
125 : 0 : void *mem;
126 : 0 : unsigned int i, j, n_pages;
127 : :
128 : 0 : *size = PAGE_ALIGN(*size);
129 : 0 : n_pages = *size >> PAGE_SHIFT;
130 : :
131 : 0 : buf->page_array = relay_alloc_page_array(n_pages);
132 [ # # ]: 0 : if (!buf->page_array)
133 : : return NULL;
134 : :
135 [ # # ]: 0 : for (i = 0; i < n_pages; i++) {
136 : 0 : buf->page_array[i] = alloc_page(GFP_KERNEL);
137 [ # # ]: 0 : if (unlikely(!buf->page_array[i]))
138 : 0 : goto depopulate;
139 : 0 : set_page_private(buf->page_array[i], (unsigned long)buf);
140 : : }
141 : 0 : mem = vmap(buf->page_array, n_pages, VM_MAP, PAGE_KERNEL);
142 [ # # ]: 0 : if (!mem)
143 : 0 : goto depopulate;
144 : :
145 : 0 : memset(mem, 0, *size);
146 : 0 : buf->page_count = n_pages;
147 : 0 : return mem;
148 : :
149 : 0 : depopulate:
150 [ # # ]: 0 : for (j = 0; j < i; j++)
151 : 0 : __free_page(buf->page_array[j]);
152 : 0 : relay_free_page_array(buf->page_array);
153 : 0 : return NULL;
154 : : }
155 : :
156 : : /**
157 : : * relay_create_buf - allocate and initialize a channel buffer
158 : : * @chan: the relay channel
159 : : *
160 : : * Returns channel buffer if successful, %NULL otherwise.
161 : : */
162 : 0 : static struct rchan_buf *relay_create_buf(struct rchan *chan)
163 : : {
164 : 0 : struct rchan_buf *buf;
165 : :
166 [ # # ]: 0 : if (chan->n_subbufs > KMALLOC_MAX_SIZE / sizeof(size_t *))
167 : : return NULL;
168 : :
169 : 0 : buf = kzalloc(sizeof(struct rchan_buf), GFP_KERNEL);
170 [ # # ]: 0 : if (!buf)
171 : : return NULL;
172 : 0 : buf->padding = kmalloc_array(chan->n_subbufs, sizeof(size_t *),
173 : : GFP_KERNEL);
174 [ # # ]: 0 : if (!buf->padding)
175 : 0 : goto free_buf;
176 : :
177 : 0 : buf->start = relay_alloc_buf(buf, &chan->alloc_size);
178 [ # # ]: 0 : if (!buf->start)
179 : 0 : goto free_buf;
180 : :
181 : 0 : buf->chan = chan;
182 : 0 : kref_get(&buf->chan->kref);
183 : 0 : return buf;
184 : :
185 : 0 : free_buf:
186 : 0 : kfree(buf->padding);
187 : 0 : kfree(buf);
188 : 0 : return NULL;
189 : : }
190 : :
191 : : /**
192 : : * relay_destroy_channel - free the channel struct
193 : : * @kref: target kernel reference that contains the relay channel
194 : : *
195 : : * Should only be called from kref_put().
196 : : */
197 : 0 : static void relay_destroy_channel(struct kref *kref)
198 : : {
199 : 0 : struct rchan *chan = container_of(kref, struct rchan, kref);
200 : 0 : kfree(chan);
201 : 0 : }
202 : :
203 : : /**
204 : : * relay_destroy_buf - destroy an rchan_buf struct and associated buffer
205 : : * @buf: the buffer struct
206 : : */
207 : 0 : static void relay_destroy_buf(struct rchan_buf *buf)
208 : : {
209 : 0 : struct rchan *chan = buf->chan;
210 : 0 : unsigned int i;
211 : :
212 [ # # ]: 0 : if (likely(buf->start)) {
213 : 0 : vunmap(buf->start);
214 [ # # ]: 0 : for (i = 0; i < buf->page_count; i++)
215 : 0 : __free_page(buf->page_array[i]);
216 : 0 : relay_free_page_array(buf->page_array);
217 : : }
218 : 0 : *per_cpu_ptr(chan->buf, buf->cpu) = NULL;
219 : 0 : kfree(buf->padding);
220 : 0 : kfree(buf);
221 : 0 : kref_put(&chan->kref, relay_destroy_channel);
222 : 0 : }
223 : :
224 : : /**
225 : : * relay_remove_buf - remove a channel buffer
226 : : * @kref: target kernel reference that contains the relay buffer
227 : : *
228 : : * Removes the file from the filesystem, which also frees the
229 : : * rchan_buf_struct and the channel buffer. Should only be called from
230 : : * kref_put().
231 : : */
232 : 0 : static void relay_remove_buf(struct kref *kref)
233 : : {
234 : 0 : struct rchan_buf *buf = container_of(kref, struct rchan_buf, kref);
235 : 0 : relay_destroy_buf(buf);
236 : 0 : }
237 : :
238 : : /**
239 : : * relay_buf_empty - boolean, is the channel buffer empty?
240 : : * @buf: channel buffer
241 : : *
242 : : * Returns 1 if the buffer is empty, 0 otherwise.
243 : : */
244 : 0 : static int relay_buf_empty(struct rchan_buf *buf)
245 : : {
246 : 0 : return (buf->subbufs_produced - buf->subbufs_consumed) ? 0 : 1;
247 : : }
248 : :
249 : : /**
250 : : * relay_buf_full - boolean, is the channel buffer full?
251 : : * @buf: channel buffer
252 : : *
253 : : * Returns 1 if the buffer is full, 0 otherwise.
254 : : */
255 : 0 : int relay_buf_full(struct rchan_buf *buf)
256 : : {
257 : 0 : size_t ready = buf->subbufs_produced - buf->subbufs_consumed;
258 : 0 : return (ready >= buf->chan->n_subbufs) ? 1 : 0;
259 : : }
260 : : EXPORT_SYMBOL_GPL(relay_buf_full);
261 : :
262 : : /*
263 : : * High-level relay kernel API and associated functions.
264 : : */
265 : :
266 : : /*
267 : : * rchan_callback implementations defining default channel behavior. Used
268 : : * in place of corresponding NULL values in client callback struct.
269 : : */
270 : :
271 : : /*
272 : : * subbuf_start() default callback. Does nothing.
273 : : */
274 : 0 : static int subbuf_start_default_callback (struct rchan_buf *buf,
275 : : void *subbuf,
276 : : void *prev_subbuf,
277 : : size_t prev_padding)
278 : : {
279 [ # # ]: 0 : if (relay_buf_full(buf))
280 : 0 : return 0;
281 : :
282 : : return 1;
283 : : }
284 : :
285 : : /*
286 : : * buf_mapped() default callback. Does nothing.
287 : : */
288 : 0 : static void buf_mapped_default_callback(struct rchan_buf *buf,
289 : : struct file *filp)
290 : : {
291 : 0 : }
292 : :
293 : : /*
294 : : * buf_unmapped() default callback. Does nothing.
295 : : */
296 : 0 : static void buf_unmapped_default_callback(struct rchan_buf *buf,
297 : : struct file *filp)
298 : : {
299 : 0 : }
300 : :
301 : : /*
302 : : * create_buf_file_create() default callback. Does nothing.
303 : : */
304 : 0 : static struct dentry *create_buf_file_default_callback(const char *filename,
305 : : struct dentry *parent,
306 : : umode_t mode,
307 : : struct rchan_buf *buf,
308 : : int *is_global)
309 : : {
310 : 0 : return NULL;
311 : : }
312 : :
313 : : /*
314 : : * remove_buf_file() default callback. Does nothing.
315 : : */
316 : 0 : static int remove_buf_file_default_callback(struct dentry *dentry)
317 : : {
318 : 0 : return -EINVAL;
319 : : }
320 : :
321 : : /* relay channel default callbacks */
322 : : static struct rchan_callbacks default_channel_callbacks = {
323 : : .subbuf_start = subbuf_start_default_callback,
324 : : .buf_mapped = buf_mapped_default_callback,
325 : : .buf_unmapped = buf_unmapped_default_callback,
326 : : .create_buf_file = create_buf_file_default_callback,
327 : : .remove_buf_file = remove_buf_file_default_callback,
328 : : };
329 : :
330 : : /**
331 : : * wakeup_readers - wake up readers waiting on a channel
332 : : * @work: contains the channel buffer
333 : : *
334 : : * This is the function used to defer reader waking
335 : : */
336 : 0 : static void wakeup_readers(struct irq_work *work)
337 : : {
338 : 0 : struct rchan_buf *buf;
339 : :
340 : 0 : buf = container_of(work, struct rchan_buf, wakeup_work);
341 : 0 : wake_up_interruptible(&buf->read_wait);
342 : 0 : }
343 : :
344 : : /**
345 : : * __relay_reset - reset a channel buffer
346 : : * @buf: the channel buffer
347 : : * @init: 1 if this is a first-time initialization
348 : : *
349 : : * See relay_reset() for description of effect.
350 : : */
351 : 0 : static void __relay_reset(struct rchan_buf *buf, unsigned int init)
352 : : {
353 : 0 : size_t i;
354 : :
355 [ # # ]: 0 : if (init) {
356 : 0 : init_waitqueue_head(&buf->read_wait);
357 : 0 : kref_init(&buf->kref);
358 : 0 : init_irq_work(&buf->wakeup_work, wakeup_readers);
359 : : } else {
360 : 0 : irq_work_sync(&buf->wakeup_work);
361 : : }
362 : :
363 : 0 : buf->subbufs_produced = 0;
364 : 0 : buf->subbufs_consumed = 0;
365 : 0 : buf->bytes_consumed = 0;
366 : 0 : buf->finalized = 0;
367 : 0 : buf->data = buf->start;
368 : 0 : buf->offset = 0;
369 : :
370 [ # # ]: 0 : for (i = 0; i < buf->chan->n_subbufs; i++)
371 : 0 : buf->padding[i] = 0;
372 : :
373 : 0 : buf->chan->cb->subbuf_start(buf, buf->data, NULL, 0);
374 : 0 : }
375 : :
376 : : /**
377 : : * relay_reset - reset the channel
378 : : * @chan: the channel
379 : : *
380 : : * This has the effect of erasing all data from all channel buffers
381 : : * and restarting the channel in its initial state. The buffers
382 : : * are not freed, so any mappings are still in effect.
383 : : *
384 : : * NOTE. Care should be taken that the channel isn't actually
385 : : * being used by anything when this call is made.
386 : : */
387 : 0 : void relay_reset(struct rchan *chan)
388 : : {
389 : 0 : struct rchan_buf *buf;
390 : 0 : unsigned int i;
391 : :
392 [ # # ]: 0 : if (!chan)
393 : : return;
394 : :
395 [ # # # # ]: 0 : if (chan->is_global && (buf = *per_cpu_ptr(chan->buf, 0))) {
396 : 0 : __relay_reset(buf, 0);
397 : 0 : return;
398 : : }
399 : :
400 : 0 : mutex_lock(&relay_channels_mutex);
401 [ # # ]: 0 : for_each_possible_cpu(i)
402 [ # # ]: 0 : if ((buf = *per_cpu_ptr(chan->buf, i)))
403 : 0 : __relay_reset(buf, 0);
404 : 0 : mutex_unlock(&relay_channels_mutex);
405 : : }
406 : : EXPORT_SYMBOL_GPL(relay_reset);
407 : :
408 : 0 : static inline void relay_set_buf_dentry(struct rchan_buf *buf,
409 : : struct dentry *dentry)
410 : : {
411 : 0 : buf->dentry = dentry;
412 : 0 : d_inode(buf->dentry)->i_size = buf->early_bytes;
413 : 0 : }
414 : :
415 : 0 : static struct dentry *relay_create_buf_file(struct rchan *chan,
416 : : struct rchan_buf *buf,
417 : : unsigned int cpu)
418 : : {
419 : 0 : struct dentry *dentry;
420 : 0 : char *tmpname;
421 : :
422 : 0 : tmpname = kzalloc(NAME_MAX + 1, GFP_KERNEL);
423 [ # # ]: 0 : if (!tmpname)
424 : : return NULL;
425 : 0 : snprintf(tmpname, NAME_MAX, "%s%d", chan->base_filename, cpu);
426 : :
427 : : /* Create file in fs */
428 : 0 : dentry = chan->cb->create_buf_file(tmpname, chan->parent,
429 : : S_IRUSR, buf,
430 : : &chan->is_global);
431 [ # # ]: 0 : if (IS_ERR(dentry))
432 : 0 : dentry = NULL;
433 : :
434 : 0 : kfree(tmpname);
435 : :
436 : 0 : return dentry;
437 : : }
438 : :
439 : : /*
440 : : * relay_open_buf - create a new relay channel buffer
441 : : *
442 : : * used by relay_open() and CPU hotplug.
443 : : */
444 : 0 : static struct rchan_buf *relay_open_buf(struct rchan *chan, unsigned int cpu)
445 : : {
446 : 0 : struct rchan_buf *buf = NULL;
447 : 0 : struct dentry *dentry;
448 : :
449 [ # # ]: 0 : if (chan->is_global)
450 : 0 : return *per_cpu_ptr(chan->buf, 0);
451 : :
452 : 0 : buf = relay_create_buf(chan);
453 [ # # ]: 0 : if (!buf)
454 : : return NULL;
455 : :
456 [ # # ]: 0 : if (chan->has_base_filename) {
457 : 0 : dentry = relay_create_buf_file(chan, buf, cpu);
458 [ # # ]: 0 : if (!dentry)
459 : 0 : goto free_buf;
460 : 0 : relay_set_buf_dentry(buf, dentry);
461 : : } else {
462 : : /* Only retrieve global info, nothing more, nothing less */
463 : 0 : dentry = chan->cb->create_buf_file(NULL, NULL,
464 : : S_IRUSR, buf,
465 : : &chan->is_global);
466 [ # # # # ]: 0 : if (IS_ERR_OR_NULL(dentry))
467 : 0 : goto free_buf;
468 : : }
469 : :
470 : 0 : buf->cpu = cpu;
471 : 0 : __relay_reset(buf, 1);
472 : :
473 [ # # ]: 0 : if(chan->is_global) {
474 : 0 : *per_cpu_ptr(chan->buf, 0) = buf;
475 : 0 : buf->cpu = 0;
476 : : }
477 : :
478 : : return buf;
479 : :
480 : 0 : free_buf:
481 : 0 : relay_destroy_buf(buf);
482 : 0 : return NULL;
483 : : }
484 : :
485 : : /**
486 : : * relay_close_buf - close a channel buffer
487 : : * @buf: channel buffer
488 : : *
489 : : * Marks the buffer finalized and restores the default callbacks.
490 : : * The channel buffer and channel buffer data structure are then freed
491 : : * automatically when the last reference is given up.
492 : : */
493 : 0 : static void relay_close_buf(struct rchan_buf *buf)
494 : : {
495 : 0 : buf->finalized = 1;
496 : 0 : irq_work_sync(&buf->wakeup_work);
497 : 0 : buf->chan->cb->remove_buf_file(buf->dentry);
498 : 0 : kref_put(&buf->kref, relay_remove_buf);
499 : 0 : }
500 : :
501 : : static void setup_callbacks(struct rchan *chan,
502 : : struct rchan_callbacks *cb)
503 : : {
504 : : if (!cb) {
505 : : chan->cb = &default_channel_callbacks;
506 : : return;
507 : : }
508 : :
509 : : if (!cb->subbuf_start)
510 : : cb->subbuf_start = subbuf_start_default_callback;
511 : : if (!cb->buf_mapped)
512 : : cb->buf_mapped = buf_mapped_default_callback;
513 : : if (!cb->buf_unmapped)
514 : : cb->buf_unmapped = buf_unmapped_default_callback;
515 : : if (!cb->create_buf_file)
516 : : cb->create_buf_file = create_buf_file_default_callback;
517 : : if (!cb->remove_buf_file)
518 : : cb->remove_buf_file = remove_buf_file_default_callback;
519 : : chan->cb = cb;
520 : : }
521 : :
522 : 0 : int relay_prepare_cpu(unsigned int cpu)
523 : : {
524 : 0 : struct rchan *chan;
525 : 0 : struct rchan_buf *buf;
526 : :
527 : 0 : mutex_lock(&relay_channels_mutex);
528 [ # # ]: 0 : list_for_each_entry(chan, &relay_channels, list) {
529 [ # # ]: 0 : if ((buf = *per_cpu_ptr(chan->buf, cpu)))
530 : 0 : continue;
531 : 0 : buf = relay_open_buf(chan, cpu);
532 [ # # ]: 0 : if (!buf) {
533 : 0 : pr_err("relay: cpu %d buffer creation failed\n", cpu);
534 : 0 : mutex_unlock(&relay_channels_mutex);
535 : 0 : return -ENOMEM;
536 : : }
537 : 0 : *per_cpu_ptr(chan->buf, cpu) = buf;
538 : : }
539 : 0 : mutex_unlock(&relay_channels_mutex);
540 : 0 : return 0;
541 : : }
542 : :
543 : : /**
544 : : * relay_open - create a new relay channel
545 : : * @base_filename: base name of files to create, %NULL for buffering only
546 : : * @parent: dentry of parent directory, %NULL for root directory or buffer
547 : : * @subbuf_size: size of sub-buffers
548 : : * @n_subbufs: number of sub-buffers
549 : : * @cb: client callback functions
550 : : * @private_data: user-defined data
551 : : *
552 : : * Returns channel pointer if successful, %NULL otherwise.
553 : : *
554 : : * Creates a channel buffer for each cpu using the sizes and
555 : : * attributes specified. The created channel buffer files
556 : : * will be named base_filename0...base_filenameN-1. File
557 : : * permissions will be %S_IRUSR.
558 : : *
559 : : * If opening a buffer (@parent = NULL) that you later wish to register
560 : : * in a filesystem, call relay_late_setup_files() once the @parent dentry
561 : : * is available.
562 : : */
563 : 0 : struct rchan *relay_open(const char *base_filename,
564 : : struct dentry *parent,
565 : : size_t subbuf_size,
566 : : size_t n_subbufs,
567 : : struct rchan_callbacks *cb,
568 : : void *private_data)
569 : : {
570 : 0 : unsigned int i;
571 : 0 : struct rchan *chan;
572 : 0 : struct rchan_buf *buf;
573 : :
574 [ # # ]: 0 : if (!(subbuf_size && n_subbufs))
575 : : return NULL;
576 [ # # ]: 0 : if (subbuf_size > UINT_MAX / n_subbufs)
577 : : return NULL;
578 : :
579 : 0 : chan = kzalloc(sizeof(struct rchan), GFP_KERNEL);
580 [ # # ]: 0 : if (!chan)
581 : : return NULL;
582 : :
583 : 0 : chan->buf = alloc_percpu(struct rchan_buf *);
584 : 0 : chan->version = RELAYFS_CHANNEL_VERSION;
585 : 0 : chan->n_subbufs = n_subbufs;
586 : 0 : chan->subbuf_size = subbuf_size;
587 : 0 : chan->alloc_size = PAGE_ALIGN(subbuf_size * n_subbufs);
588 : 0 : chan->parent = parent;
589 : 0 : chan->private_data = private_data;
590 [ # # ]: 0 : if (base_filename) {
591 : 0 : chan->has_base_filename = 1;
592 : 0 : strlcpy(chan->base_filename, base_filename, NAME_MAX);
593 : : }
594 : 0 : setup_callbacks(chan, cb);
595 : 0 : kref_init(&chan->kref);
596 : :
597 : 0 : mutex_lock(&relay_channels_mutex);
598 [ # # ]: 0 : for_each_online_cpu(i) {
599 : 0 : buf = relay_open_buf(chan, i);
600 [ # # ]: 0 : if (!buf)
601 : 0 : goto free_bufs;
602 : 0 : *per_cpu_ptr(chan->buf, i) = buf;
603 : : }
604 : 0 : list_add(&chan->list, &relay_channels);
605 : 0 : mutex_unlock(&relay_channels_mutex);
606 : :
607 : 0 : return chan;
608 : :
609 : : free_bufs:
610 [ # # ]: 0 : for_each_possible_cpu(i) {
611 [ # # ]: 0 : if ((buf = *per_cpu_ptr(chan->buf, i)))
612 : 0 : relay_close_buf(buf);
613 : : }
614 : :
615 : 0 : kref_put(&chan->kref, relay_destroy_channel);
616 : 0 : mutex_unlock(&relay_channels_mutex);
617 : 0 : return NULL;
618 : : }
619 : : EXPORT_SYMBOL_GPL(relay_open);
620 : :
621 : : struct rchan_percpu_buf_dispatcher {
622 : : struct rchan_buf *buf;
623 : : struct dentry *dentry;
624 : : };
625 : :
626 : : /* Called in atomic context. */
627 : 0 : static void __relay_set_buf_dentry(void *info)
628 : : {
629 : 0 : struct rchan_percpu_buf_dispatcher *p = info;
630 : :
631 : 0 : relay_set_buf_dentry(p->buf, p->dentry);
632 : 0 : }
633 : :
634 : : /**
635 : : * relay_late_setup_files - triggers file creation
636 : : * @chan: channel to operate on
637 : : * @base_filename: base name of files to create
638 : : * @parent: dentry of parent directory, %NULL for root directory
639 : : *
640 : : * Returns 0 if successful, non-zero otherwise.
641 : : *
642 : : * Use to setup files for a previously buffer-only channel created
643 : : * by relay_open() with a NULL parent dentry.
644 : : *
645 : : * For example, this is useful for perfomring early tracing in kernel,
646 : : * before VFS is up and then exposing the early results once the dentry
647 : : * is available.
648 : : */
649 : 0 : int relay_late_setup_files(struct rchan *chan,
650 : : const char *base_filename,
651 : : struct dentry *parent)
652 : : {
653 : 0 : int err = 0;
654 : 0 : unsigned int i, curr_cpu;
655 : 0 : unsigned long flags;
656 : 0 : struct dentry *dentry;
657 : 0 : struct rchan_buf *buf;
658 : 0 : struct rchan_percpu_buf_dispatcher disp;
659 : :
660 [ # # ]: 0 : if (!chan || !base_filename)
661 : : return -EINVAL;
662 : :
663 : 0 : strlcpy(chan->base_filename, base_filename, NAME_MAX);
664 : :
665 : 0 : mutex_lock(&relay_channels_mutex);
666 : : /* Is chan already set up? */
667 [ # # ]: 0 : if (unlikely(chan->has_base_filename)) {
668 : 0 : mutex_unlock(&relay_channels_mutex);
669 : 0 : return -EEXIST;
670 : : }
671 : 0 : chan->has_base_filename = 1;
672 : 0 : chan->parent = parent;
673 : :
674 [ # # ]: 0 : if (chan->is_global) {
675 : 0 : err = -EINVAL;
676 : 0 : buf = *per_cpu_ptr(chan->buf, 0);
677 [ # # # # ]: 0 : if (!WARN_ON_ONCE(!buf)) {
678 : 0 : dentry = relay_create_buf_file(chan, buf, 0);
679 [ # # # # : 0 : if (dentry && !WARN_ON_ONCE(!chan->is_global)) {
# # ]
680 : 0 : relay_set_buf_dentry(buf, dentry);
681 : 0 : err = 0;
682 : : }
683 : : }
684 : 0 : mutex_unlock(&relay_channels_mutex);
685 : 0 : return err;
686 : : }
687 : :
688 : 0 : curr_cpu = get_cpu();
689 : : /*
690 : : * The CPU hotplug notifier ran before us and created buffers with
691 : : * no files associated. So it's safe to call relay_setup_buf_file()
692 : : * on all currently online CPUs.
693 : : */
694 [ # # ]: 0 : for_each_online_cpu(i) {
695 : 0 : buf = *per_cpu_ptr(chan->buf, i);
696 [ # # ]: 0 : if (unlikely(!buf)) {
697 [ # # ]: 0 : WARN_ONCE(1, KERN_ERR "CPU has no buffer!\n");
698 : : err = -EINVAL;
699 : : break;
700 : : }
701 : :
702 : 0 : dentry = relay_create_buf_file(chan, buf, i);
703 [ # # ]: 0 : if (unlikely(!dentry)) {
704 : : err = -EINVAL;
705 : : break;
706 : : }
707 : :
708 [ # # ]: 0 : if (curr_cpu == i) {
709 : 0 : local_irq_save(flags);
710 : 0 : relay_set_buf_dentry(buf, dentry);
711 : 0 : local_irq_restore(flags);
712 : : } else {
713 : 0 : disp.buf = buf;
714 : 0 : disp.dentry = dentry;
715 : 0 : smp_mb();
716 : : /* relay_channels_mutex must be held, so wait. */
717 : 0 : err = smp_call_function_single(i,
718 : : __relay_set_buf_dentry,
719 : : &disp, 1);
720 : : }
721 [ # # ]: 0 : if (unlikely(err))
722 : : break;
723 : : }
724 : 0 : put_cpu();
725 : 0 : mutex_unlock(&relay_channels_mutex);
726 : :
727 : 0 : return err;
728 : : }
729 : : EXPORT_SYMBOL_GPL(relay_late_setup_files);
730 : :
731 : : /**
732 : : * relay_switch_subbuf - switch to a new sub-buffer
733 : : * @buf: channel buffer
734 : : * @length: size of current event
735 : : *
736 : : * Returns either the length passed in or 0 if full.
737 : : *
738 : : * Performs sub-buffer-switch tasks such as invoking callbacks,
739 : : * updating padding counts, waking up readers, etc.
740 : : */
741 : 0 : size_t relay_switch_subbuf(struct rchan_buf *buf, size_t length)
742 : : {
743 : 0 : void *old, *new;
744 : 0 : size_t old_subbuf, new_subbuf;
745 : :
746 [ # # ]: 0 : if (unlikely(length > buf->chan->subbuf_size))
747 : 0 : goto toobig;
748 : :
749 [ # # ]: 0 : if (buf->offset != buf->chan->subbuf_size + 1) {
750 : 0 : buf->prev_padding = buf->chan->subbuf_size - buf->offset;
751 : 0 : old_subbuf = buf->subbufs_produced % buf->chan->n_subbufs;
752 : 0 : buf->padding[old_subbuf] = buf->prev_padding;
753 : 0 : buf->subbufs_produced++;
754 [ # # ]: 0 : if (buf->dentry)
755 : 0 : d_inode(buf->dentry)->i_size +=
756 : 0 : buf->chan->subbuf_size -
757 : 0 : buf->padding[old_subbuf];
758 : : else
759 : 0 : buf->early_bytes += buf->chan->subbuf_size -
760 : 0 : buf->padding[old_subbuf];
761 : 0 : smp_mb();
762 [ # # ]: 0 : if (waitqueue_active(&buf->read_wait)) {
763 : : /*
764 : : * Calling wake_up_interruptible() from here
765 : : * will deadlock if we happen to be logging
766 : : * from the scheduler (trying to re-grab
767 : : * rq->lock), so defer it.
768 : : */
769 : 0 : irq_work_queue(&buf->wakeup_work);
770 : : }
771 : : }
772 : :
773 : 0 : old = buf->data;
774 : 0 : new_subbuf = buf->subbufs_produced % buf->chan->n_subbufs;
775 : 0 : new = buf->start + new_subbuf * buf->chan->subbuf_size;
776 : 0 : buf->offset = 0;
777 [ # # ]: 0 : if (!buf->chan->cb->subbuf_start(buf, new, old, buf->prev_padding)) {
778 : 0 : buf->offset = buf->chan->subbuf_size + 1;
779 : 0 : return 0;
780 : : }
781 : 0 : buf->data = new;
782 : 0 : buf->padding[new_subbuf] = 0;
783 : :
784 [ # # ]: 0 : if (unlikely(length + buf->offset > buf->chan->subbuf_size))
785 : 0 : goto toobig;
786 : :
787 : : return length;
788 : :
789 : 0 : toobig:
790 : 0 : buf->chan->last_toobig = length;
791 : 0 : return 0;
792 : : }
793 : : EXPORT_SYMBOL_GPL(relay_switch_subbuf);
794 : :
795 : : /**
796 : : * relay_subbufs_consumed - update the buffer's sub-buffers-consumed count
797 : : * @chan: the channel
798 : : * @cpu: the cpu associated with the channel buffer to update
799 : : * @subbufs_consumed: number of sub-buffers to add to current buf's count
800 : : *
801 : : * Adds to the channel buffer's consumed sub-buffer count.
802 : : * subbufs_consumed should be the number of sub-buffers newly consumed,
803 : : * not the total consumed.
804 : : *
805 : : * NOTE. Kernel clients don't need to call this function if the channel
806 : : * mode is 'overwrite'.
807 : : */
808 : 0 : void relay_subbufs_consumed(struct rchan *chan,
809 : : unsigned int cpu,
810 : : size_t subbufs_consumed)
811 : : {
812 : 0 : struct rchan_buf *buf;
813 : :
814 [ # # ]: 0 : if (!chan || cpu >= NR_CPUS)
815 : : return;
816 : :
817 : 0 : buf = *per_cpu_ptr(chan->buf, cpu);
818 [ # # # # ]: 0 : if (!buf || subbufs_consumed > chan->n_subbufs)
819 : : return;
820 : :
821 [ # # ]: 0 : if (subbufs_consumed > buf->subbufs_produced - buf->subbufs_consumed)
822 : 0 : buf->subbufs_consumed = buf->subbufs_produced;
823 : : else
824 : 0 : buf->subbufs_consumed += subbufs_consumed;
825 : : }
826 : : EXPORT_SYMBOL_GPL(relay_subbufs_consumed);
827 : :
828 : : /**
829 : : * relay_close - close the channel
830 : : * @chan: the channel
831 : : *
832 : : * Closes all channel buffers and frees the channel.
833 : : */
834 : 0 : void relay_close(struct rchan *chan)
835 : : {
836 : 0 : struct rchan_buf *buf;
837 : 0 : unsigned int i;
838 : :
839 [ # # ]: 0 : if (!chan)
840 : : return;
841 : :
842 : 0 : mutex_lock(&relay_channels_mutex);
843 [ # # # # ]: 0 : if (chan->is_global && (buf = *per_cpu_ptr(chan->buf, 0)))
844 : 0 : relay_close_buf(buf);
845 : : else
846 [ # # ]: 0 : for_each_possible_cpu(i)
847 [ # # ]: 0 : if ((buf = *per_cpu_ptr(chan->buf, i)))
848 : 0 : relay_close_buf(buf);
849 : :
850 [ # # ]: 0 : if (chan->last_toobig)
851 : 0 : printk(KERN_WARNING "relay: one or more items not logged "
852 : : "[item size (%zd) > sub-buffer size (%zd)]\n",
853 : : chan->last_toobig, chan->subbuf_size);
854 : :
855 : 0 : list_del(&chan->list);
856 : 0 : kref_put(&chan->kref, relay_destroy_channel);
857 : 0 : mutex_unlock(&relay_channels_mutex);
858 : : }
859 : : EXPORT_SYMBOL_GPL(relay_close);
860 : :
861 : : /**
862 : : * relay_flush - close the channel
863 : : * @chan: the channel
864 : : *
865 : : * Flushes all channel buffers, i.e. forces buffer switch.
866 : : */
867 : 0 : void relay_flush(struct rchan *chan)
868 : : {
869 : 0 : struct rchan_buf *buf;
870 : 0 : unsigned int i;
871 : :
872 [ # # ]: 0 : if (!chan)
873 : : return;
874 : :
875 [ # # # # ]: 0 : if (chan->is_global && (buf = *per_cpu_ptr(chan->buf, 0))) {
876 : 0 : relay_switch_subbuf(buf, 0);
877 : 0 : return;
878 : : }
879 : :
880 : 0 : mutex_lock(&relay_channels_mutex);
881 [ # # ]: 0 : for_each_possible_cpu(i)
882 [ # # ]: 0 : if ((buf = *per_cpu_ptr(chan->buf, i)))
883 : 0 : relay_switch_subbuf(buf, 0);
884 : 0 : mutex_unlock(&relay_channels_mutex);
885 : : }
886 : : EXPORT_SYMBOL_GPL(relay_flush);
887 : :
888 : : /**
889 : : * relay_file_open - open file op for relay files
890 : : * @inode: the inode
891 : : * @filp: the file
892 : : *
893 : : * Increments the channel buffer refcount.
894 : : */
895 : 0 : static int relay_file_open(struct inode *inode, struct file *filp)
896 : : {
897 : 0 : struct rchan_buf *buf = inode->i_private;
898 : 0 : kref_get(&buf->kref);
899 : 0 : filp->private_data = buf;
900 : :
901 : 0 : return nonseekable_open(inode, filp);
902 : : }
903 : :
904 : : /**
905 : : * relay_file_mmap - mmap file op for relay files
906 : : * @filp: the file
907 : : * @vma: the vma describing what to map
908 : : *
909 : : * Calls upon relay_mmap_buf() to map the file into user space.
910 : : */
911 : 0 : static int relay_file_mmap(struct file *filp, struct vm_area_struct *vma)
912 : : {
913 : 0 : struct rchan_buf *buf = filp->private_data;
914 : 0 : return relay_mmap_buf(buf, vma);
915 : : }
916 : :
917 : : /**
918 : : * relay_file_poll - poll file op for relay files
919 : : * @filp: the file
920 : : * @wait: poll table
921 : : *
922 : : * Poll implemention.
923 : : */
924 : 0 : static __poll_t relay_file_poll(struct file *filp, poll_table *wait)
925 : : {
926 : 0 : __poll_t mask = 0;
927 : 0 : struct rchan_buf *buf = filp->private_data;
928 : :
929 [ # # ]: 0 : if (buf->finalized)
930 : : return EPOLLERR;
931 : :
932 [ # # ]: 0 : if (filp->f_mode & FMODE_READ) {
933 [ # # ]: 0 : poll_wait(filp, &buf->read_wait, wait);
934 [ # # ]: 0 : if (!relay_buf_empty(buf))
935 : 0 : mask |= EPOLLIN | EPOLLRDNORM;
936 : : }
937 : :
938 : : return mask;
939 : : }
940 : :
941 : : /**
942 : : * relay_file_release - release file op for relay files
943 : : * @inode: the inode
944 : : * @filp: the file
945 : : *
946 : : * Decrements the channel refcount, as the filesystem is
947 : : * no longer using it.
948 : : */
949 : 0 : static int relay_file_release(struct inode *inode, struct file *filp)
950 : : {
951 : 0 : struct rchan_buf *buf = filp->private_data;
952 : 0 : kref_put(&buf->kref, relay_remove_buf);
953 : :
954 : 0 : return 0;
955 : : }
956 : :
957 : : /*
958 : : * relay_file_read_consume - update the consumed count for the buffer
959 : : */
960 : 0 : static void relay_file_read_consume(struct rchan_buf *buf,
961 : : size_t read_pos,
962 : : size_t bytes_consumed)
963 : : {
964 : 0 : size_t subbuf_size = buf->chan->subbuf_size;
965 : 0 : size_t n_subbufs = buf->chan->n_subbufs;
966 : 0 : size_t read_subbuf;
967 : :
968 [ # # ]: 0 : if (buf->subbufs_produced == buf->subbufs_consumed &&
969 [ # # ]: 0 : buf->offset == buf->bytes_consumed)
970 : : return;
971 : :
972 [ # # ]: 0 : if (buf->bytes_consumed + bytes_consumed > subbuf_size) {
973 : 0 : relay_subbufs_consumed(buf->chan, buf->cpu, 1);
974 : 0 : buf->bytes_consumed = 0;
975 : : }
976 : :
977 : 0 : buf->bytes_consumed += bytes_consumed;
978 [ # # ]: 0 : if (!read_pos)
979 : 0 : read_subbuf = buf->subbufs_consumed % n_subbufs;
980 : : else
981 : 0 : read_subbuf = read_pos / buf->chan->subbuf_size;
982 [ # # ]: 0 : if (buf->bytes_consumed + buf->padding[read_subbuf] == subbuf_size) {
983 [ # # ]: 0 : if ((read_subbuf == buf->subbufs_produced % n_subbufs) &&
984 [ # # ]: 0 : (buf->offset == subbuf_size))
985 : : return;
986 : 0 : relay_subbufs_consumed(buf->chan, buf->cpu, 1);
987 : 0 : buf->bytes_consumed = 0;
988 : : }
989 : : }
990 : :
991 : : /*
992 : : * relay_file_read_avail - boolean, are there unconsumed bytes available?
993 : : */
994 : 0 : static int relay_file_read_avail(struct rchan_buf *buf, size_t read_pos)
995 : : {
996 : 0 : size_t subbuf_size = buf->chan->subbuf_size;
997 : 0 : size_t n_subbufs = buf->chan->n_subbufs;
998 : 0 : size_t produced = buf->subbufs_produced;
999 : 0 : size_t consumed = buf->subbufs_consumed;
1000 : :
1001 : 0 : relay_file_read_consume(buf, read_pos, 0);
1002 : :
1003 : 0 : consumed = buf->subbufs_consumed;
1004 : :
1005 [ # # ]: 0 : if (unlikely(buf->offset > subbuf_size)) {
1006 [ # # ]: 0 : if (produced == consumed)
1007 : : return 0;
1008 : 0 : return 1;
1009 : : }
1010 : :
1011 [ # # ]: 0 : if (unlikely(produced - consumed >= n_subbufs)) {
1012 : 0 : consumed = produced - n_subbufs + 1;
1013 : 0 : buf->subbufs_consumed = consumed;
1014 : 0 : buf->bytes_consumed = 0;
1015 : : }
1016 : :
1017 : 0 : produced = (produced % n_subbufs) * subbuf_size + buf->offset;
1018 : 0 : consumed = (consumed % n_subbufs) * subbuf_size + buf->bytes_consumed;
1019 : :
1020 [ # # ]: 0 : if (consumed > produced)
1021 : 0 : produced += n_subbufs * subbuf_size;
1022 : :
1023 [ # # ]: 0 : if (consumed == produced) {
1024 [ # # ]: 0 : if (buf->offset == subbuf_size &&
1025 [ # # ]: 0 : buf->subbufs_produced > buf->subbufs_consumed)
1026 : : return 1;
1027 : 0 : return 0;
1028 : : }
1029 : :
1030 : : return 1;
1031 : : }
1032 : :
1033 : : /**
1034 : : * relay_file_read_subbuf_avail - return bytes available in sub-buffer
1035 : : * @read_pos: file read position
1036 : : * @buf: relay channel buffer
1037 : : */
1038 : 0 : static size_t relay_file_read_subbuf_avail(size_t read_pos,
1039 : : struct rchan_buf *buf)
1040 : : {
1041 : 0 : size_t padding, avail = 0;
1042 : 0 : size_t read_subbuf, read_offset, write_subbuf, write_offset;
1043 : 0 : size_t subbuf_size = buf->chan->subbuf_size;
1044 : :
1045 : 0 : write_subbuf = (buf->data - buf->start) / subbuf_size;
1046 : 0 : write_offset = buf->offset > subbuf_size ? subbuf_size : buf->offset;
1047 : 0 : read_subbuf = read_pos / subbuf_size;
1048 : 0 : read_offset = read_pos % subbuf_size;
1049 : 0 : padding = buf->padding[read_subbuf];
1050 : :
1051 [ # # ]: 0 : if (read_subbuf == write_subbuf) {
1052 [ # # ]: 0 : if (read_offset + padding < write_offset)
1053 : 0 : avail = write_offset - (read_offset + padding);
1054 : : } else
1055 : 0 : avail = (subbuf_size - padding) - read_offset;
1056 : :
1057 : 0 : return avail;
1058 : : }
1059 : :
1060 : : /**
1061 : : * relay_file_read_start_pos - find the first available byte to read
1062 : : * @read_pos: file read position
1063 : : * @buf: relay channel buffer
1064 : : *
1065 : : * If the @read_pos is in the middle of padding, return the
1066 : : * position of the first actually available byte, otherwise
1067 : : * return the original value.
1068 : : */
1069 : 0 : static size_t relay_file_read_start_pos(size_t read_pos,
1070 : : struct rchan_buf *buf)
1071 : : {
1072 : 0 : size_t read_subbuf, padding, padding_start, padding_end;
1073 : 0 : size_t subbuf_size = buf->chan->subbuf_size;
1074 : 0 : size_t n_subbufs = buf->chan->n_subbufs;
1075 : 0 : size_t consumed = buf->subbufs_consumed % n_subbufs;
1076 : :
1077 [ # # ]: 0 : if (!read_pos)
1078 : 0 : read_pos = consumed * subbuf_size + buf->bytes_consumed;
1079 : 0 : read_subbuf = read_pos / subbuf_size;
1080 : 0 : padding = buf->padding[read_subbuf];
1081 : 0 : padding_start = (read_subbuf + 1) * subbuf_size - padding;
1082 : 0 : padding_end = (read_subbuf + 1) * subbuf_size;
1083 [ # # ]: 0 : if (read_pos >= padding_start && read_pos < padding_end) {
1084 : 0 : read_subbuf = (read_subbuf + 1) % n_subbufs;
1085 : 0 : read_pos = read_subbuf * subbuf_size;
1086 : : }
1087 : :
1088 : 0 : return read_pos;
1089 : : }
1090 : :
1091 : : /**
1092 : : * relay_file_read_end_pos - return the new read position
1093 : : * @read_pos: file read position
1094 : : * @buf: relay channel buffer
1095 : : * @count: number of bytes to be read
1096 : : */
1097 : 0 : static size_t relay_file_read_end_pos(struct rchan_buf *buf,
1098 : : size_t read_pos,
1099 : : size_t count)
1100 : : {
1101 : 0 : size_t read_subbuf, padding, end_pos;
1102 : 0 : size_t subbuf_size = buf->chan->subbuf_size;
1103 : 0 : size_t n_subbufs = buf->chan->n_subbufs;
1104 : :
1105 : 0 : read_subbuf = read_pos / subbuf_size;
1106 : 0 : padding = buf->padding[read_subbuf];
1107 : 0 : if (read_pos % subbuf_size + count + padding == subbuf_size)
1108 : 0 : end_pos = (read_subbuf + 1) * subbuf_size;
1109 : : else
1110 : 0 : end_pos = read_pos + count;
1111 [ # # ]: 0 : if (end_pos >= subbuf_size * n_subbufs)
1112 : 0 : end_pos = 0;
1113 : :
1114 : 0 : return end_pos;
1115 : : }
1116 : :
1117 : 0 : static ssize_t relay_file_read(struct file *filp,
1118 : : char __user *buffer,
1119 : : size_t count,
1120 : : loff_t *ppos)
1121 : : {
1122 : 0 : struct rchan_buf *buf = filp->private_data;
1123 : 0 : size_t read_start, avail;
1124 : 0 : size_t written = 0;
1125 : 0 : int ret;
1126 : :
1127 [ # # ]: 0 : if (!count)
1128 : : return 0;
1129 : :
1130 : 0 : inode_lock(file_inode(filp));
1131 : 0 : do {
1132 : 0 : void *from;
1133 : :
1134 [ # # ]: 0 : if (!relay_file_read_avail(buf, *ppos))
1135 : : break;
1136 : :
1137 : 0 : read_start = relay_file_read_start_pos(*ppos, buf);
1138 : 0 : avail = relay_file_read_subbuf_avail(read_start, buf);
1139 [ # # ]: 0 : if (!avail)
1140 : : break;
1141 : :
1142 : 0 : avail = min(count, avail);
1143 : 0 : from = buf->start + read_start;
1144 : 0 : ret = avail;
1145 [ # # # # ]: 0 : if (copy_to_user(buffer, from, avail))
1146 : : break;
1147 : :
1148 : 0 : buffer += ret;
1149 : 0 : written += ret;
1150 : 0 : count -= ret;
1151 : :
1152 : 0 : relay_file_read_consume(buf, read_start, ret);
1153 [ # # ]: 0 : *ppos = relay_file_read_end_pos(buf, read_start, ret);
1154 [ # # ]: 0 : } while (count);
1155 : 0 : inode_unlock(file_inode(filp));
1156 : :
1157 : 0 : return written;
1158 : : }
1159 : :
1160 : 0 : static void relay_consume_bytes(struct rchan_buf *rbuf, int bytes_consumed)
1161 : : {
1162 : 0 : rbuf->bytes_consumed += bytes_consumed;
1163 : :
1164 [ # # ]: 0 : if (rbuf->bytes_consumed >= rbuf->chan->subbuf_size) {
1165 : 0 : relay_subbufs_consumed(rbuf->chan, rbuf->cpu, 1);
1166 : 0 : rbuf->bytes_consumed %= rbuf->chan->subbuf_size;
1167 : : }
1168 : 0 : }
1169 : :
1170 : 0 : static void relay_pipe_buf_release(struct pipe_inode_info *pipe,
1171 : : struct pipe_buffer *buf)
1172 : : {
1173 : 0 : struct rchan_buf *rbuf;
1174 : :
1175 : 0 : rbuf = (struct rchan_buf *)page_private(buf->page);
1176 : 0 : relay_consume_bytes(rbuf, buf->private);
1177 : 0 : }
1178 : :
1179 : : static const struct pipe_buf_operations relay_pipe_buf_ops = {
1180 : : .confirm = generic_pipe_buf_confirm,
1181 : : .release = relay_pipe_buf_release,
1182 : : .steal = generic_pipe_buf_steal,
1183 : : .get = generic_pipe_buf_get,
1184 : : };
1185 : :
1186 : 0 : static void relay_page_release(struct splice_pipe_desc *spd, unsigned int i)
1187 : : {
1188 : 0 : }
1189 : :
1190 : : /*
1191 : : * subbuf_splice_actor - splice up to one subbuf's worth of data
1192 : : */
1193 : : static ssize_t subbuf_splice_actor(struct file *in,
1194 : : loff_t *ppos,
1195 : : struct pipe_inode_info *pipe,
1196 : : size_t len,
1197 : : unsigned int flags,
1198 : : int *nonpad_ret)
1199 : : {
1200 : : unsigned int pidx, poff, total_len, subbuf_pages, nr_pages;
1201 : : struct rchan_buf *rbuf = in->private_data;
1202 : : unsigned int subbuf_size = rbuf->chan->subbuf_size;
1203 : : uint64_t pos = (uint64_t) *ppos;
1204 : : uint32_t alloc_size = (uint32_t) rbuf->chan->alloc_size;
1205 : : size_t read_start = (size_t) do_div(pos, alloc_size);
1206 : : size_t read_subbuf = read_start / subbuf_size;
1207 : : size_t padding = rbuf->padding[read_subbuf];
1208 : : size_t nonpad_end = read_subbuf * subbuf_size + subbuf_size - padding;
1209 : : struct page *pages[PIPE_DEF_BUFFERS];
1210 : : struct partial_page partial[PIPE_DEF_BUFFERS];
1211 : : struct splice_pipe_desc spd = {
1212 : : .pages = pages,
1213 : : .nr_pages = 0,
1214 : : .nr_pages_max = PIPE_DEF_BUFFERS,
1215 : : .partial = partial,
1216 : : .ops = &relay_pipe_buf_ops,
1217 : : .spd_release = relay_page_release,
1218 : : };
1219 : : ssize_t ret;
1220 : :
1221 : : if (rbuf->subbufs_produced == rbuf->subbufs_consumed)
1222 : : return 0;
1223 : : if (splice_grow_spd(pipe, &spd))
1224 : : return -ENOMEM;
1225 : :
1226 : : /*
1227 : : * Adjust read len, if longer than what is available
1228 : : */
1229 : : if (len > (subbuf_size - read_start % subbuf_size))
1230 : : len = subbuf_size - read_start % subbuf_size;
1231 : :
1232 : : subbuf_pages = rbuf->chan->alloc_size >> PAGE_SHIFT;
1233 : : pidx = (read_start / PAGE_SIZE) % subbuf_pages;
1234 : : poff = read_start & ~PAGE_MASK;
1235 : : nr_pages = min_t(unsigned int, subbuf_pages, spd.nr_pages_max);
1236 : :
1237 : : for (total_len = 0; spd.nr_pages < nr_pages; spd.nr_pages++) {
1238 : : unsigned int this_len, this_end, private;
1239 : : unsigned int cur_pos = read_start + total_len;
1240 : :
1241 : : if (!len)
1242 : : break;
1243 : :
1244 : : this_len = min_t(unsigned long, len, PAGE_SIZE - poff);
1245 : : private = this_len;
1246 : :
1247 : : spd.pages[spd.nr_pages] = rbuf->page_array[pidx];
1248 : : spd.partial[spd.nr_pages].offset = poff;
1249 : :
1250 : : this_end = cur_pos + this_len;
1251 : : if (this_end >= nonpad_end) {
1252 : : this_len = nonpad_end - cur_pos;
1253 : : private = this_len + padding;
1254 : : }
1255 : : spd.partial[spd.nr_pages].len = this_len;
1256 : : spd.partial[spd.nr_pages].private = private;
1257 : :
1258 : : len -= this_len;
1259 : : total_len += this_len;
1260 : : poff = 0;
1261 : : pidx = (pidx + 1) % subbuf_pages;
1262 : :
1263 : : if (this_end >= nonpad_end) {
1264 : : spd.nr_pages++;
1265 : : break;
1266 : : }
1267 : : }
1268 : :
1269 : : ret = 0;
1270 : : if (!spd.nr_pages)
1271 : : goto out;
1272 : :
1273 : : ret = *nonpad_ret = splice_to_pipe(pipe, &spd);
1274 : : if (ret < 0 || ret < total_len)
1275 : : goto out;
1276 : :
1277 : : if (read_start + ret == nonpad_end)
1278 : : ret += padding;
1279 : :
1280 : : out:
1281 : : splice_shrink_spd(&spd);
1282 : : return ret;
1283 : : }
1284 : :
1285 : 0 : static ssize_t relay_file_splice_read(struct file *in,
1286 : : loff_t *ppos,
1287 : : struct pipe_inode_info *pipe,
1288 : : size_t len,
1289 : : unsigned int flags)
1290 : : {
1291 : 0 : ssize_t spliced;
1292 : 0 : int ret;
1293 : 0 : int nonpad_ret = 0;
1294 : :
1295 : 0 : ret = 0;
1296 : 0 : spliced = 0;
1297 : :
1298 [ # # ]: 0 : while (len && !spliced) {
1299 : 0 : ret = subbuf_splice_actor(in, ppos, pipe, len, flags, &nonpad_ret);
1300 [ # # ]: 0 : if (ret < 0)
1301 : : break;
1302 [ # # ]: 0 : else if (!ret) {
1303 [ # # ]: 0 : if (flags & SPLICE_F_NONBLOCK)
1304 : 0 : ret = -EAGAIN;
1305 : : break;
1306 : : }
1307 : :
1308 : 0 : *ppos += ret;
1309 [ # # ]: 0 : if (ret > len)
1310 : : len = 0;
1311 : : else
1312 : 0 : len -= ret;
1313 : 0 : spliced += nonpad_ret;
1314 : 0 : nonpad_ret = 0;
1315 : : }
1316 : :
1317 [ # # ]: 0 : if (spliced)
1318 : : return spliced;
1319 : :
1320 : 0 : return ret;
1321 : : }
1322 : :
1323 : : const struct file_operations relay_file_operations = {
1324 : : .open = relay_file_open,
1325 : : .poll = relay_file_poll,
1326 : : .mmap = relay_file_mmap,
1327 : : .read = relay_file_read,
1328 : : .llseek = no_llseek,
1329 : : .release = relay_file_release,
1330 : : .splice_read = relay_file_splice_read,
1331 : : };
1332 : : EXPORT_SYMBOL_GPL(relay_file_operations);
|
