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