1
2
3
4
5
6#include <linux/trace_events.h>
7#include <linux/ring_buffer.h>
8#include <linux/trace_clock.h>
9#include <linux/trace_seq.h>
10#include <linux/spinlock.h>
11#include <linux/irq_work.h>
12#include <linux/uaccess.h>
13#include <linux/hardirq.h>
14#include <linux/kthread.h>
15#include <linux/kmemcheck.h>
16#include <linux/module.h>
17#include <linux/percpu.h>
18#include <linux/mutex.h>
19#include <linux/delay.h>
20#include <linux/slab.h>
21#include <linux/init.h>
22#include <linux/hash.h>
23#include <linux/list.h>
24#include <linux/cpu.h>
25
26#include <asm/local.h>
27
28static void update_pages_handler(struct work_struct *work);
29
30
31
32
33int ring_buffer_print_entry_header(struct trace_seq *s)
34{
35 trace_seq_puts(s, "# compressed entry header\n");
36 trace_seq_puts(s, "\ttype_len : 5 bits\n");
37 trace_seq_puts(s, "\ttime_delta : 27 bits\n");
38 trace_seq_puts(s, "\tarray : 32 bits\n");
39 trace_seq_putc(s, '\n');
40 trace_seq_printf(s, "\tpadding : type == %d\n",
41 RINGBUF_TYPE_PADDING);
42 trace_seq_printf(s, "\ttime_extend : type == %d\n",
43 RINGBUF_TYPE_TIME_EXTEND);
44 trace_seq_printf(s, "\tdata max type_len == %d\n",
45 RINGBUF_TYPE_DATA_TYPE_LEN_MAX);
46
47 return !trace_seq_has_overflowed(s);
48}
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119#define RB_BUFFER_OFF (1 << 20)
120
121#define BUF_PAGE_HDR_SIZE offsetof(struct buffer_data_page, data)
122
123#define RB_EVNT_HDR_SIZE (offsetof(struct ring_buffer_event, array))
124#define RB_ALIGNMENT 4U
125#define RB_MAX_SMALL_DATA (RB_ALIGNMENT * RINGBUF_TYPE_DATA_TYPE_LEN_MAX)
126#define RB_EVNT_MIN_SIZE 8U
127
128#ifndef CONFIG_HAVE_64BIT_ALIGNED_ACCESS
129# define RB_FORCE_8BYTE_ALIGNMENT 0
130# define RB_ARCH_ALIGNMENT RB_ALIGNMENT
131#else
132# define RB_FORCE_8BYTE_ALIGNMENT 1
133# define RB_ARCH_ALIGNMENT 8U
134#endif
135
136#define RB_ALIGN_DATA __aligned(RB_ARCH_ALIGNMENT)
137
138
139#define RINGBUF_TYPE_DATA 0 ... RINGBUF_TYPE_DATA_TYPE_LEN_MAX
140
141enum {
142 RB_LEN_TIME_EXTEND = 8,
143 RB_LEN_TIME_STAMP = 16,
144};
145
146#define skip_time_extend(event) \
147 ((struct ring_buffer_event *)((char *)event + RB_LEN_TIME_EXTEND))
148
149static inline int rb_null_event(struct ring_buffer_event *event)
150{
151 return event->type_len == RINGBUF_TYPE_PADDING && !event->time_delta;
152}
153
154static void rb_event_set_padding(struct ring_buffer_event *event)
155{
156
157 event->type_len = RINGBUF_TYPE_PADDING;
158 event->time_delta = 0;
159}
160
161static unsigned
162rb_event_data_length(struct ring_buffer_event *event)
163{
164 unsigned length;
165
166 if (event->type_len)
167 length = event->type_len * RB_ALIGNMENT;
168 else
169 length = event->array[0];
170 return length + RB_EVNT_HDR_SIZE;
171}
172
173
174
175
176
177
178static inline unsigned
179rb_event_length(struct ring_buffer_event *event)
180{
181 switch (event->type_len) {
182 case RINGBUF_TYPE_PADDING:
183 if (rb_null_event(event))
184
185 return -1;
186 return event->array[0] + RB_EVNT_HDR_SIZE;
187
188 case RINGBUF_TYPE_TIME_EXTEND:
189 return RB_LEN_TIME_EXTEND;
190
191 case RINGBUF_TYPE_TIME_STAMP:
192 return RB_LEN_TIME_STAMP;
193
194 case RINGBUF_TYPE_DATA:
195 return rb_event_data_length(event);
196 default:
197 BUG();
198 }
199
200 return 0;
201}
202
203
204
205
206
207static inline unsigned
208rb_event_ts_length(struct ring_buffer_event *event)
209{
210 unsigned len = 0;
211
212 if (event->type_len == RINGBUF_TYPE_TIME_EXTEND) {
213
214 len = RB_LEN_TIME_EXTEND;
215 event = skip_time_extend(event);
216 }
217 return len + rb_event_length(event);
218}
219
220
221
222
223
224
225
226
227
228
229
230unsigned ring_buffer_event_length(struct ring_buffer_event *event)
231{
232 unsigned length;
233
234 if (event->type_len == RINGBUF_TYPE_TIME_EXTEND)
235 event = skip_time_extend(event);
236
237 length = rb_event_length(event);
238 if (event->type_len > RINGBUF_TYPE_DATA_TYPE_LEN_MAX)
239 return length;
240 length -= RB_EVNT_HDR_SIZE;
241 if (length > RB_MAX_SMALL_DATA + sizeof(event->array[0]))
242 length -= sizeof(event->array[0]);
243 return length;
244}
245EXPORT_SYMBOL_GPL(ring_buffer_event_length);
246
247
248static void *
249rb_event_data(struct ring_buffer_event *event)
250{
251 if (event->type_len == RINGBUF_TYPE_TIME_EXTEND)
252 event = skip_time_extend(event);
253 BUG_ON(event->type_len > RINGBUF_TYPE_DATA_TYPE_LEN_MAX);
254
255 if (event->type_len)
256 return (void *)&event->array[0];
257
258 return (void *)&event->array[1];
259}
260
261
262
263
264
265void *ring_buffer_event_data(struct ring_buffer_event *event)
266{
267 return rb_event_data(event);
268}
269EXPORT_SYMBOL_GPL(ring_buffer_event_data);
270
271#define for_each_buffer_cpu(buffer, cpu) \
272 for_each_cpu(cpu, buffer->cpumask)
273
274#define TS_SHIFT 27
275#define TS_MASK ((1ULL << TS_SHIFT) - 1)
276#define TS_DELTA_TEST (~TS_MASK)
277
278
279#define RB_MISSED_EVENTS (1 << 31)
280
281#define RB_MISSED_STORED (1 << 30)
282
283struct buffer_data_page {
284 u64 time_stamp;
285 local_t commit;
286 unsigned char data[] RB_ALIGN_DATA;
287};
288
289
290
291
292
293
294
295
296
297struct buffer_page {
298 struct list_head list;
299 local_t write;
300 unsigned read;
301 local_t entries;
302 unsigned long real_end;
303 struct buffer_data_page *page;
304};
305
306
307
308
309
310
311
312
313
314
315
316
317
318#define RB_WRITE_MASK 0xfffff
319#define RB_WRITE_INTCNT (1 << 20)
320
321static void rb_init_page(struct buffer_data_page *bpage)
322{
323 local_set(&bpage->commit, 0);
324}
325
326
327
328
329
330
331
332size_t ring_buffer_page_len(void *page)
333{
334 return local_read(&((struct buffer_data_page *)page)->commit)
335 + BUF_PAGE_HDR_SIZE;
336}
337
338
339
340
341
342static void free_buffer_page(struct buffer_page *bpage)
343{
344 free_page((unsigned long)bpage->page);
345 kfree(bpage);
346}
347
348
349
350
351static inline int test_time_stamp(u64 delta)
352{
353 if (delta & TS_DELTA_TEST)
354 return 1;
355 return 0;
356}
357
358#define BUF_PAGE_SIZE (PAGE_SIZE - BUF_PAGE_HDR_SIZE)
359
360
361#define BUF_MAX_DATA_SIZE (BUF_PAGE_SIZE - (sizeof(u32) * 2))
362
363int ring_buffer_print_page_header(struct trace_seq *s)
364{
365 struct buffer_data_page field;
366
367 trace_seq_printf(s, "\tfield: u64 timestamp;\t"
368 "offset:0;\tsize:%u;\tsigned:%u;\n",
369 (unsigned int)sizeof(field.time_stamp),
370 (unsigned int)is_signed_type(u64));
371
372 trace_seq_printf(s, "\tfield: local_t commit;\t"
373 "offset:%u;\tsize:%u;\tsigned:%u;\n",
374 (unsigned int)offsetof(typeof(field), commit),
375 (unsigned int)sizeof(field.commit),
376 (unsigned int)is_signed_type(long));
377
378 trace_seq_printf(s, "\tfield: int overwrite;\t"
379 "offset:%u;\tsize:%u;\tsigned:%u;\n",
380 (unsigned int)offsetof(typeof(field), commit),
381 1,
382 (unsigned int)is_signed_type(long));
383
384 trace_seq_printf(s, "\tfield: char data;\t"
385 "offset:%u;\tsize:%u;\tsigned:%u;\n",
386 (unsigned int)offsetof(typeof(field), data),
387 (unsigned int)BUF_PAGE_SIZE,
388 (unsigned int)is_signed_type(char));
389
390 return !trace_seq_has_overflowed(s);
391}
392
393struct rb_irq_work {
394 struct irq_work work;
395 wait_queue_head_t waiters;
396 wait_queue_head_t full_waiters;
397 bool waiters_pending;
398 bool full_waiters_pending;
399 bool wakeup_full;
400};
401
402
403
404
405struct rb_event_info {
406 u64 ts;
407 u64 delta;
408 unsigned long length;
409 struct buffer_page *tail_page;
410 int add_timestamp;
411};
412
413
414
415
416
417
418
419
420
421
422enum {
423 RB_CTX_NMI,
424 RB_CTX_IRQ,
425 RB_CTX_SOFTIRQ,
426 RB_CTX_NORMAL,
427 RB_CTX_MAX
428};
429
430
431
432
433struct ring_buffer_per_cpu {
434 int cpu;
435 atomic_t record_disabled;
436 struct ring_buffer *buffer;
437 raw_spinlock_t reader_lock;
438 arch_spinlock_t lock;
439 struct lock_class_key lock_key;
440 unsigned int nr_pages;
441 unsigned int current_context;
442 struct list_head *pages;
443 struct buffer_page *head_page;
444 struct buffer_page *tail_page;
445 struct buffer_page *commit_page;
446 struct buffer_page *reader_page;
447 unsigned long lost_events;
448 unsigned long last_overrun;
449 local_t entries_bytes;
450 local_t entries;
451 local_t overrun;
452 local_t commit_overrun;
453 local_t dropped_events;
454 local_t committing;
455 local_t commits;
456 unsigned long read;
457 unsigned long read_bytes;
458 u64 write_stamp;
459 u64 read_stamp;
460
461 int nr_pages_to_update;
462 struct list_head new_pages;
463 struct work_struct update_pages_work;
464 struct completion update_done;
465
466 struct rb_irq_work irq_work;
467};
468
469struct ring_buffer {
470 unsigned flags;
471 int cpus;
472 atomic_t record_disabled;
473 atomic_t resize_disabled;
474 cpumask_var_t cpumask;
475
476 struct lock_class_key *reader_lock_key;
477
478 struct mutex mutex;
479
480 struct ring_buffer_per_cpu **buffers;
481
482#ifdef CONFIG_HOTPLUG_CPU
483 struct notifier_block cpu_notify;
484#endif
485 u64 (*clock)(void);
486
487 struct rb_irq_work irq_work;
488};
489
490struct ring_buffer_iter {
491 struct ring_buffer_per_cpu *cpu_buffer;
492 unsigned long head;
493 struct buffer_page *head_page;
494 struct buffer_page *cache_reader_page;
495 unsigned long cache_read;
496 u64 read_stamp;
497};
498
499
500
501
502
503
504
505static void rb_wake_up_waiters(struct irq_work *work)
506{
507 struct rb_irq_work *rbwork = container_of(work, struct rb_irq_work, work);
508
509 wake_up_all(&rbwork->waiters);
510 if (rbwork->wakeup_full) {
511 rbwork->wakeup_full = false;
512 wake_up_all(&rbwork->full_waiters);
513 }
514}
515
516
517
518
519
520
521
522
523
524
525
526int ring_buffer_wait(struct ring_buffer *buffer, int cpu, bool full)
527{
528 struct ring_buffer_per_cpu *uninitialized_var(cpu_buffer);
529 DEFINE_WAIT(wait);
530 struct rb_irq_work *work;
531 int ret = 0;
532
533
534
535
536
537
538 if (cpu == RING_BUFFER_ALL_CPUS) {
539 work = &buffer->irq_work;
540
541 full = false;
542 } else {
543 if (!cpumask_test_cpu(cpu, buffer->cpumask))
544 return -ENODEV;
545 cpu_buffer = buffer->buffers[cpu];
546 work = &cpu_buffer->irq_work;
547 }
548
549
550 while (true) {
551 if (full)
552 prepare_to_wait(&work->full_waiters, &wait, TASK_INTERRUPTIBLE);
553 else
554 prepare_to_wait(&work->waiters, &wait, TASK_INTERRUPTIBLE);
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576 if (full)
577 work->full_waiters_pending = true;
578 else
579 work->waiters_pending = true;
580
581 if (signal_pending(current)) {
582 ret = -EINTR;
583 break;
584 }
585
586 if (cpu == RING_BUFFER_ALL_CPUS && !ring_buffer_empty(buffer))
587 break;
588
589 if (cpu != RING_BUFFER_ALL_CPUS &&
590 !ring_buffer_empty_cpu(buffer, cpu)) {
591 unsigned long flags;
592 bool pagebusy;
593
594 if (!full)
595 break;
596
597 raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
598 pagebusy = cpu_buffer->reader_page == cpu_buffer->commit_page;
599 raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
600
601 if (!pagebusy)
602 break;
603 }
604
605 schedule();
606 }
607
608 if (full)
609 finish_wait(&work->full_waiters, &wait);
610 else
611 finish_wait(&work->waiters, &wait);
612
613 return ret;
614}
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630int ring_buffer_poll_wait(struct ring_buffer *buffer, int cpu,
631 struct file *filp, poll_table *poll_table)
632{
633 struct ring_buffer_per_cpu *cpu_buffer;
634 struct rb_irq_work *work;
635
636 if (cpu == RING_BUFFER_ALL_CPUS)
637 work = &buffer->irq_work;
638 else {
639 if (!cpumask_test_cpu(cpu, buffer->cpumask))
640 return -EINVAL;
641
642 cpu_buffer = buffer->buffers[cpu];
643 work = &cpu_buffer->irq_work;
644 }
645
646 poll_wait(filp, &work->waiters, poll_table);
647 work->waiters_pending = true;
648
649
650
651
652
653
654
655
656
657
658
659
660
661 smp_mb();
662
663 if ((cpu == RING_BUFFER_ALL_CPUS && !ring_buffer_empty(buffer)) ||
664 (cpu != RING_BUFFER_ALL_CPUS && !ring_buffer_empty_cpu(buffer, cpu)))
665 return POLLIN | POLLRDNORM;
666 return 0;
667}
668
669
670#define RB_WARN_ON(b, cond) \
671 ({ \
672 int _____ret = unlikely(cond); \
673 if (_____ret) { \
674 if (__same_type(*(b), struct ring_buffer_per_cpu)) { \
675 struct ring_buffer_per_cpu *__b = \
676 (void *)b; \
677 atomic_inc(&__b->buffer->record_disabled); \
678 } else \
679 atomic_inc(&b->record_disabled); \
680 WARN_ON(1); \
681 } \
682 _____ret; \
683 })
684
685
686#define DEBUG_SHIFT 0
687
688static inline u64 rb_time_stamp(struct ring_buffer *buffer)
689{
690
691 return buffer->clock() << DEBUG_SHIFT;
692}
693
694u64 ring_buffer_time_stamp(struct ring_buffer *buffer, int cpu)
695{
696 u64 time;
697
698 preempt_disable_notrace();
699 time = rb_time_stamp(buffer);
700 preempt_enable_no_resched_notrace();
701
702 return time;
703}
704EXPORT_SYMBOL_GPL(ring_buffer_time_stamp);
705
706void ring_buffer_normalize_time_stamp(struct ring_buffer *buffer,
707 int cpu, u64 *ts)
708{
709
710 *ts >>= DEBUG_SHIFT;
711}
712EXPORT_SYMBOL_GPL(ring_buffer_normalize_time_stamp);
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783#define RB_PAGE_NORMAL 0UL
784#define RB_PAGE_HEAD 1UL
785#define RB_PAGE_UPDATE 2UL
786
787
788#define RB_FLAG_MASK 3UL
789
790
791#define RB_PAGE_MOVED 4UL
792
793
794
795
796static struct list_head *rb_list_head(struct list_head *list)
797{
798 unsigned long val = (unsigned long)list;
799
800 return (struct list_head *)(val & ~RB_FLAG_MASK);
801}
802
803
804
805
806
807
808
809
810
811static inline int
812rb_is_head_page(struct ring_buffer_per_cpu *cpu_buffer,
813 struct buffer_page *page, struct list_head *list)
814{
815 unsigned long val;
816
817 val = (unsigned long)list->next;
818
819 if ((val & ~RB_FLAG_MASK) != (unsigned long)&page->list)
820 return RB_PAGE_MOVED;
821
822 return val & RB_FLAG_MASK;
823}
824
825
826
827
828
829
830
831
832static bool rb_is_reader_page(struct buffer_page *page)
833{
834 struct list_head *list = page->list.prev;
835
836 return rb_list_head(list->next) != &page->list;
837}
838
839
840
841
842static void rb_set_list_to_head(struct ring_buffer_per_cpu *cpu_buffer,
843 struct list_head *list)
844{
845 unsigned long *ptr;
846
847 ptr = (unsigned long *)&list->next;
848 *ptr |= RB_PAGE_HEAD;
849 *ptr &= ~RB_PAGE_UPDATE;
850}
851
852
853
854
855static void rb_head_page_activate(struct ring_buffer_per_cpu *cpu_buffer)
856{
857 struct buffer_page *head;
858
859 head = cpu_buffer->head_page;
860 if (!head)
861 return;
862
863
864
865
866 rb_set_list_to_head(cpu_buffer, head->list.prev);
867}
868
869static void rb_list_head_clear(struct list_head *list)
870{
871 unsigned long *ptr = (unsigned long *)&list->next;
872
873 *ptr &= ~RB_FLAG_MASK;
874}
875
876
877
878
879static void
880rb_head_page_deactivate(struct ring_buffer_per_cpu *cpu_buffer)
881{
882 struct list_head *hd;
883
884
885 rb_list_head_clear(cpu_buffer->pages);
886
887 list_for_each(hd, cpu_buffer->pages)
888 rb_list_head_clear(hd);
889}
890
891static int rb_head_page_set(struct ring_buffer_per_cpu *cpu_buffer,
892 struct buffer_page *head,
893 struct buffer_page *prev,
894 int old_flag, int new_flag)
895{
896 struct list_head *list;
897 unsigned long val = (unsigned long)&head->list;
898 unsigned long ret;
899
900 list = &prev->list;
901
902 val &= ~RB_FLAG_MASK;
903
904 ret = cmpxchg((unsigned long *)&list->next,
905 val | old_flag, val | new_flag);
906
907
908 if ((ret & ~RB_FLAG_MASK) != val)
909 return RB_PAGE_MOVED;
910
911 return ret & RB_FLAG_MASK;
912}
913
914static int rb_head_page_set_update(struct ring_buffer_per_cpu *cpu_buffer,
915 struct buffer_page *head,
916 struct buffer_page *prev,
917 int old_flag)
918{
919 return rb_head_page_set(cpu_buffer, head, prev,
920 old_flag, RB_PAGE_UPDATE);
921}
922
923static int rb_head_page_set_head(struct ring_buffer_per_cpu *cpu_buffer,
924 struct buffer_page *head,
925 struct buffer_page *prev,
926 int old_flag)
927{
928 return rb_head_page_set(cpu_buffer, head, prev,
929 old_flag, RB_PAGE_HEAD);
930}
931
932static int rb_head_page_set_normal(struct ring_buffer_per_cpu *cpu_buffer,
933 struct buffer_page *head,
934 struct buffer_page *prev,
935 int old_flag)
936{
937 return rb_head_page_set(cpu_buffer, head, prev,
938 old_flag, RB_PAGE_NORMAL);
939}
940
941static inline void rb_inc_page(struct ring_buffer_per_cpu *cpu_buffer,
942 struct buffer_page **bpage)
943{
944 struct list_head *p = rb_list_head((*bpage)->list.next);
945
946 *bpage = list_entry(p, struct buffer_page, list);
947}
948
949static struct buffer_page *
950rb_set_head_page(struct ring_buffer_per_cpu *cpu_buffer)
951{
952 struct buffer_page *head;
953 struct buffer_page *page;
954 struct list_head *list;
955 int i;
956
957 if (RB_WARN_ON(cpu_buffer, !cpu_buffer->head_page))
958 return NULL;
959
960
961 list = cpu_buffer->pages;
962 if (RB_WARN_ON(cpu_buffer, rb_list_head(list->prev->next) != list))
963 return NULL;
964
965 page = head = cpu_buffer->head_page;
966
967
968
969
970
971
972 for (i = 0; i < 3; i++) {
973 do {
974 if (rb_is_head_page(cpu_buffer, page, page->list.prev)) {
975 cpu_buffer->head_page = page;
976 return page;
977 }
978 rb_inc_page(cpu_buffer, &page);
979 } while (page != head);
980 }
981
982 RB_WARN_ON(cpu_buffer, 1);
983
984 return NULL;
985}
986
987static int rb_head_page_replace(struct buffer_page *old,
988 struct buffer_page *new)
989{
990 unsigned long *ptr = (unsigned long *)&old->list.prev->next;
991 unsigned long val;
992 unsigned long ret;
993
994 val = *ptr & ~RB_FLAG_MASK;
995 val |= RB_PAGE_HEAD;
996
997 ret = cmpxchg(ptr, val, (unsigned long)&new->list);
998
999 return ret == val;
1000}
1001
1002
1003
1004
1005static void rb_tail_page_update(struct ring_buffer_per_cpu *cpu_buffer,
1006 struct buffer_page *tail_page,
1007 struct buffer_page *next_page)
1008{
1009 unsigned long old_entries;
1010 unsigned long old_write;
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021 old_write = local_add_return(RB_WRITE_INTCNT, &next_page->write);
1022 old_entries = local_add_return(RB_WRITE_INTCNT, &next_page->entries);
1023
1024
1025
1026
1027
1028 barrier();
1029
1030
1031
1032
1033
1034
1035 if (tail_page == READ_ONCE(cpu_buffer->tail_page)) {
1036
1037 unsigned long val = old_write & ~RB_WRITE_MASK;
1038 unsigned long eval = old_entries & ~RB_WRITE_MASK;
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050 (void)local_cmpxchg(&next_page->write, old_write, val);
1051 (void)local_cmpxchg(&next_page->entries, old_entries, eval);
1052
1053
1054
1055
1056
1057
1058 local_set(&next_page->page->commit, 0);
1059
1060
1061 (void)cmpxchg(&cpu_buffer->tail_page, tail_page, next_page);
1062 }
1063}
1064
1065static int rb_check_bpage(struct ring_buffer_per_cpu *cpu_buffer,
1066 struct buffer_page *bpage)
1067{
1068 unsigned long val = (unsigned long)bpage;
1069
1070 if (RB_WARN_ON(cpu_buffer, val & RB_FLAG_MASK))
1071 return 1;
1072
1073 return 0;
1074}
1075
1076
1077
1078
1079static int rb_check_list(struct ring_buffer_per_cpu *cpu_buffer,
1080 struct list_head *list)
1081{
1082 if (RB_WARN_ON(cpu_buffer, rb_list_head(list->prev) != list->prev))
1083 return 1;
1084 if (RB_WARN_ON(cpu_buffer, rb_list_head(list->next) != list->next))
1085 return 1;
1086 return 0;
1087}
1088
1089
1090
1091
1092
1093
1094
1095
1096static int rb_check_pages(struct ring_buffer_per_cpu *cpu_buffer)
1097{
1098 struct list_head *head = cpu_buffer->pages;
1099 struct buffer_page *bpage, *tmp;
1100
1101
1102 if (cpu_buffer->head_page)
1103 rb_set_head_page(cpu_buffer);
1104
1105 rb_head_page_deactivate(cpu_buffer);
1106
1107 if (RB_WARN_ON(cpu_buffer, head->next->prev != head))
1108 return -1;
1109 if (RB_WARN_ON(cpu_buffer, head->prev->next != head))
1110 return -1;
1111
1112 if (rb_check_list(cpu_buffer, head))
1113 return -1;
1114
1115 list_for_each_entry_safe(bpage, tmp, head, list) {
1116 if (RB_WARN_ON(cpu_buffer,
1117 bpage->list.next->prev != &bpage->list))
1118 return -1;
1119 if (RB_WARN_ON(cpu_buffer,
1120 bpage->list.prev->next != &bpage->list))
1121 return -1;
1122 if (rb_check_list(cpu_buffer, &bpage->list))
1123 return -1;
1124 }
1125
1126 rb_head_page_activate(cpu_buffer);
1127
1128 return 0;
1129}
1130
1131static int __rb_allocate_pages(int nr_pages, struct list_head *pages, int cpu)
1132{
1133 int i;
1134 struct buffer_page *bpage, *tmp;
1135
1136 for (i = 0; i < nr_pages; i++) {
1137 struct page *page;
1138
1139
1140
1141
1142
1143 bpage = kzalloc_node(ALIGN(sizeof(*bpage), cache_line_size()),
1144 GFP_KERNEL | __GFP_NORETRY,
1145 cpu_to_node(cpu));
1146 if (!bpage)
1147 goto free_pages;
1148
1149 list_add(&bpage->list, pages);
1150
1151 page = alloc_pages_node(cpu_to_node(cpu),
1152 GFP_KERNEL | __GFP_NORETRY, 0);
1153 if (!page)
1154 goto free_pages;
1155 bpage->page = page_address(page);
1156 rb_init_page(bpage->page);
1157 }
1158
1159 return 0;
1160
1161free_pages:
1162 list_for_each_entry_safe(bpage, tmp, pages, list) {
1163 list_del_init(&bpage->list);
1164 free_buffer_page(bpage);
1165 }
1166
1167 return -ENOMEM;
1168}
1169
1170static int rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,
1171 unsigned nr_pages)
1172{
1173 LIST_HEAD(pages);
1174
1175 WARN_ON(!nr_pages);
1176
1177 if (__rb_allocate_pages(nr_pages, &pages, cpu_buffer->cpu))
1178 return -ENOMEM;
1179
1180
1181
1182
1183
1184
1185 cpu_buffer->pages = pages.next;
1186 list_del(&pages);
1187
1188 cpu_buffer->nr_pages = nr_pages;
1189
1190 rb_check_pages(cpu_buffer);
1191
1192 return 0;
1193}
1194
1195static struct ring_buffer_per_cpu *
1196rb_allocate_cpu_buffer(struct ring_buffer *buffer, int nr_pages, int cpu)
1197{
1198 struct ring_buffer_per_cpu *cpu_buffer;
1199 struct buffer_page *bpage;
1200 struct page *page;
1201 int ret;
1202
1203 cpu_buffer = kzalloc_node(ALIGN(sizeof(*cpu_buffer), cache_line_size()),
1204 GFP_KERNEL, cpu_to_node(cpu));
1205 if (!cpu_buffer)
1206 return NULL;
1207
1208 cpu_buffer->cpu = cpu;
1209 cpu_buffer->buffer = buffer;
1210 raw_spin_lock_init(&cpu_buffer->reader_lock);
1211 lockdep_set_class(&cpu_buffer->reader_lock, buffer->reader_lock_key);
1212 cpu_buffer->lock = (arch_spinlock_t)__ARCH_SPIN_LOCK_UNLOCKED;
1213 INIT_WORK(&cpu_buffer->update_pages_work, update_pages_handler);
1214 init_completion(&cpu_buffer->update_done);
1215 init_irq_work(&cpu_buffer->irq_work.work, rb_wake_up_waiters);
1216 init_waitqueue_head(&cpu_buffer->irq_work.waiters);
1217 init_waitqueue_head(&cpu_buffer->irq_work.full_waiters);
1218
1219 bpage = kzalloc_node(ALIGN(sizeof(*bpage), cache_line_size()),
1220 GFP_KERNEL, cpu_to_node(cpu));
1221 if (!bpage)
1222 goto fail_free_buffer;
1223
1224 rb_check_bpage(cpu_buffer, bpage);
1225
1226 cpu_buffer->reader_page = bpage;
1227 page = alloc_pages_node(cpu_to_node(cpu), GFP_KERNEL, 0);
1228 if (!page)
1229 goto fail_free_reader;
1230 bpage->page = page_address(page);
1231 rb_init_page(bpage->page);
1232
1233 INIT_LIST_HEAD(&cpu_buffer->reader_page->list);
1234 INIT_LIST_HEAD(&cpu_buffer->new_pages);
1235
1236 ret = rb_allocate_pages(cpu_buffer, nr_pages);
1237 if (ret < 0)
1238 goto fail_free_reader;
1239
1240 cpu_buffer->head_page
1241 = list_entry(cpu_buffer->pages, struct buffer_page, list);
1242 cpu_buffer->tail_page = cpu_buffer->commit_page = cpu_buffer->head_page;
1243
1244 rb_head_page_activate(cpu_buffer);
1245
1246 return cpu_buffer;
1247
1248 fail_free_reader:
1249 free_buffer_page(cpu_buffer->reader_page);
1250
1251 fail_free_buffer:
1252 kfree(cpu_buffer);
1253 return NULL;
1254}
1255
1256static void rb_free_cpu_buffer(struct ring_buffer_per_cpu *cpu_buffer)
1257{
1258 struct list_head *head = cpu_buffer->pages;
1259 struct buffer_page *bpage, *tmp;
1260
1261 free_buffer_page(cpu_buffer->reader_page);
1262
1263 rb_head_page_deactivate(cpu_buffer);
1264
1265 if (head) {
1266 list_for_each_entry_safe(bpage, tmp, head, list) {
1267 list_del_init(&bpage->list);
1268 free_buffer_page(bpage);
1269 }
1270 bpage = list_entry(head, struct buffer_page, list);
1271 free_buffer_page(bpage);
1272 }
1273
1274 kfree(cpu_buffer);
1275}
1276
1277#ifdef CONFIG_HOTPLUG_CPU
1278static int rb_cpu_notify(struct notifier_block *self,
1279 unsigned long action, void *hcpu);
1280#endif
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292struct ring_buffer *__ring_buffer_alloc(unsigned long size, unsigned flags,
1293 struct lock_class_key *key)
1294{
1295 struct ring_buffer *buffer;
1296 int bsize;
1297 int cpu, nr_pages;
1298
1299
1300 buffer = kzalloc(ALIGN(sizeof(*buffer), cache_line_size()),
1301 GFP_KERNEL);
1302 if (!buffer)
1303 return NULL;
1304
1305 if (!alloc_cpumask_var(&buffer->cpumask, GFP_KERNEL))
1306 goto fail_free_buffer;
1307
1308 nr_pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
1309 buffer->flags = flags;
1310 buffer->clock = trace_clock_local;
1311 buffer->reader_lock_key = key;
1312
1313 init_irq_work(&buffer->irq_work.work, rb_wake_up_waiters);
1314 init_waitqueue_head(&buffer->irq_work.waiters);
1315
1316
1317 if (nr_pages < 2)
1318 nr_pages = 2;
1319
1320
1321
1322
1323
1324
1325#ifdef CONFIG_HOTPLUG_CPU
1326 cpu_notifier_register_begin();
1327 cpumask_copy(buffer->cpumask, cpu_online_mask);
1328#else
1329 cpumask_copy(buffer->cpumask, cpu_possible_mask);
1330#endif
1331 buffer->cpus = nr_cpu_ids;
1332
1333 bsize = sizeof(void *) * nr_cpu_ids;
1334 buffer->buffers = kzalloc(ALIGN(bsize, cache_line_size()),
1335 GFP_KERNEL);
1336 if (!buffer->buffers)
1337 goto fail_free_cpumask;
1338
1339 for_each_buffer_cpu(buffer, cpu) {
1340 buffer->buffers[cpu] =
1341 rb_allocate_cpu_buffer(buffer, nr_pages, cpu);
1342 if (!buffer->buffers[cpu])
1343 goto fail_free_buffers;
1344 }
1345
1346#ifdef CONFIG_HOTPLUG_CPU
1347 buffer->cpu_notify.notifier_call = rb_cpu_notify;
1348 buffer->cpu_notify.priority = 0;
1349 __register_cpu_notifier(&buffer->cpu_notify);
1350 cpu_notifier_register_done();
1351#endif
1352
1353 mutex_init(&buffer->mutex);
1354
1355 return buffer;
1356
1357 fail_free_buffers:
1358 for_each_buffer_cpu(buffer, cpu) {
1359 if (buffer->buffers[cpu])
1360 rb_free_cpu_buffer(buffer->buffers[cpu]);
1361 }
1362 kfree(buffer->buffers);
1363
1364 fail_free_cpumask:
1365 free_cpumask_var(buffer->cpumask);
1366#ifdef CONFIG_HOTPLUG_CPU
1367 cpu_notifier_register_done();
1368#endif
1369
1370 fail_free_buffer:
1371 kfree(buffer);
1372 return NULL;
1373}
1374EXPORT_SYMBOL_GPL(__ring_buffer_alloc);
1375
1376
1377
1378
1379
1380void
1381ring_buffer_free(struct ring_buffer *buffer)
1382{
1383 int cpu;
1384
1385#ifdef CONFIG_HOTPLUG_CPU
1386 cpu_notifier_register_begin();
1387 __unregister_cpu_notifier(&buffer->cpu_notify);
1388#endif
1389
1390 for_each_buffer_cpu(buffer, cpu)
1391 rb_free_cpu_buffer(buffer->buffers[cpu]);
1392
1393#ifdef CONFIG_HOTPLUG_CPU
1394 cpu_notifier_register_done();
1395#endif
1396
1397 kfree(buffer->buffers);
1398 free_cpumask_var(buffer->cpumask);
1399
1400 kfree(buffer);
1401}
1402EXPORT_SYMBOL_GPL(ring_buffer_free);
1403
1404void ring_buffer_set_clock(struct ring_buffer *buffer,
1405 u64 (*clock)(void))
1406{
1407 buffer->clock = clock;
1408}
1409
1410static void rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer);
1411
1412static inline unsigned long rb_page_entries(struct buffer_page *bpage)
1413{
1414 return local_read(&bpage->entries) & RB_WRITE_MASK;
1415}
1416
1417static inline unsigned long rb_page_write(struct buffer_page *bpage)
1418{
1419 return local_read(&bpage->write) & RB_WRITE_MASK;
1420}
1421
1422static int
1423rb_remove_pages(struct ring_buffer_per_cpu *cpu_buffer, unsigned int nr_pages)
1424{
1425 struct list_head *tail_page, *to_remove, *next_page;
1426 struct buffer_page *to_remove_page, *tmp_iter_page;
1427 struct buffer_page *last_page, *first_page;
1428 unsigned int nr_removed;
1429 unsigned long head_bit;
1430 int page_entries;
1431
1432 head_bit = 0;
1433
1434 raw_spin_lock_irq(&cpu_buffer->reader_lock);
1435 atomic_inc(&cpu_buffer->record_disabled);
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445 tail_page = &cpu_buffer->tail_page->list;
1446
1447
1448
1449
1450
1451 if (cpu_buffer->tail_page == cpu_buffer->reader_page)
1452 tail_page = rb_list_head(tail_page->next);
1453 to_remove = tail_page;
1454
1455
1456 first_page = list_entry(rb_list_head(to_remove->next),
1457 struct buffer_page, list);
1458
1459 for (nr_removed = 0; nr_removed < nr_pages; nr_removed++) {
1460 to_remove = rb_list_head(to_remove)->next;
1461 head_bit |= (unsigned long)to_remove & RB_PAGE_HEAD;
1462 }
1463
1464 next_page = rb_list_head(to_remove)->next;
1465
1466
1467
1468
1469
1470
1471 tail_page->next = (struct list_head *)((unsigned long)next_page |
1472 head_bit);
1473 next_page = rb_list_head(next_page);
1474 next_page->prev = tail_page;
1475
1476
1477 cpu_buffer->pages = next_page;
1478
1479
1480 if (head_bit)
1481 cpu_buffer->head_page = list_entry(next_page,
1482 struct buffer_page, list);
1483
1484
1485
1486
1487
1488 cpu_buffer->read = 0;
1489
1490
1491 atomic_dec(&cpu_buffer->record_disabled);
1492 raw_spin_unlock_irq(&cpu_buffer->reader_lock);
1493
1494 RB_WARN_ON(cpu_buffer, list_empty(cpu_buffer->pages));
1495
1496
1497 last_page = list_entry(rb_list_head(to_remove), struct buffer_page,
1498 list);
1499 tmp_iter_page = first_page;
1500
1501 do {
1502 to_remove_page = tmp_iter_page;
1503 rb_inc_page(cpu_buffer, &tmp_iter_page);
1504
1505
1506 page_entries = rb_page_entries(to_remove_page);
1507 if (page_entries) {
1508
1509
1510
1511
1512
1513
1514 local_add(page_entries, &cpu_buffer->overrun);
1515 local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);
1516 }
1517
1518
1519
1520
1521
1522 free_buffer_page(to_remove_page);
1523 nr_removed--;
1524
1525 } while (to_remove_page != last_page);
1526
1527 RB_WARN_ON(cpu_buffer, nr_removed);
1528
1529 return nr_removed == 0;
1530}
1531
1532static int
1533rb_insert_pages(struct ring_buffer_per_cpu *cpu_buffer)
1534{
1535 struct list_head *pages = &cpu_buffer->new_pages;
1536 int retries, success;
1537
1538 raw_spin_lock_irq(&cpu_buffer->reader_lock);
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553 retries = 10;
1554 success = 0;
1555 while (retries--) {
1556 struct list_head *head_page, *prev_page, *r;
1557 struct list_head *last_page, *first_page;
1558 struct list_head *head_page_with_bit;
1559
1560 head_page = &rb_set_head_page(cpu_buffer)->list;
1561 if (!head_page)
1562 break;
1563 prev_page = head_page->prev;
1564
1565 first_page = pages->next;
1566 last_page = pages->prev;
1567
1568 head_page_with_bit = (struct list_head *)
1569 ((unsigned long)head_page | RB_PAGE_HEAD);
1570
1571 last_page->next = head_page_with_bit;
1572 first_page->prev = prev_page;
1573
1574 r = cmpxchg(&prev_page->next, head_page_with_bit, first_page);
1575
1576 if (r == head_page_with_bit) {
1577
1578
1579
1580
1581
1582 head_page->prev = last_page;
1583 success = 1;
1584 break;
1585 }
1586 }
1587
1588 if (success)
1589 INIT_LIST_HEAD(pages);
1590
1591
1592
1593
1594 RB_WARN_ON(cpu_buffer, !success);
1595 raw_spin_unlock_irq(&cpu_buffer->reader_lock);
1596
1597
1598 if (!success) {
1599 struct buffer_page *bpage, *tmp;
1600 list_for_each_entry_safe(bpage, tmp, &cpu_buffer->new_pages,
1601 list) {
1602 list_del_init(&bpage->list);
1603 free_buffer_page(bpage);
1604 }
1605 }
1606 return success;
1607}
1608
1609static void rb_update_pages(struct ring_buffer_per_cpu *cpu_buffer)
1610{
1611 int success;
1612
1613 if (cpu_buffer->nr_pages_to_update > 0)
1614 success = rb_insert_pages(cpu_buffer);
1615 else
1616 success = rb_remove_pages(cpu_buffer,
1617 -cpu_buffer->nr_pages_to_update);
1618
1619 if (success)
1620 cpu_buffer->nr_pages += cpu_buffer->nr_pages_to_update;
1621}
1622
1623static void update_pages_handler(struct work_struct *work)
1624{
1625 struct ring_buffer_per_cpu *cpu_buffer = container_of(work,
1626 struct ring_buffer_per_cpu, update_pages_work);
1627 rb_update_pages(cpu_buffer);
1628 complete(&cpu_buffer->update_done);
1629}
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641int ring_buffer_resize(struct ring_buffer *buffer, unsigned long size,
1642 int cpu_id)
1643{
1644 struct ring_buffer_per_cpu *cpu_buffer;
1645 unsigned nr_pages;
1646 int cpu, err = 0;
1647
1648
1649
1650
1651 if (!buffer)
1652 return size;
1653
1654
1655 if (cpu_id != RING_BUFFER_ALL_CPUS &&
1656 !cpumask_test_cpu(cpu_id, buffer->cpumask))
1657 return size;
1658
1659 size = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
1660 size *= BUF_PAGE_SIZE;
1661
1662
1663 if (size < BUF_PAGE_SIZE * 2)
1664 size = BUF_PAGE_SIZE * 2;
1665
1666 nr_pages = DIV_ROUND_UP(size, BUF_PAGE_SIZE);
1667
1668
1669
1670
1671
1672
1673 if (atomic_read(&buffer->resize_disabled))
1674 return -EBUSY;
1675
1676
1677 mutex_lock(&buffer->mutex);
1678
1679 if (cpu_id == RING_BUFFER_ALL_CPUS) {
1680
1681 for_each_buffer_cpu(buffer, cpu) {
1682 cpu_buffer = buffer->buffers[cpu];
1683
1684 cpu_buffer->nr_pages_to_update = nr_pages -
1685 cpu_buffer->nr_pages;
1686
1687
1688
1689 if (cpu_buffer->nr_pages_to_update <= 0)
1690 continue;
1691
1692
1693
1694
1695 INIT_LIST_HEAD(&cpu_buffer->new_pages);
1696 if (__rb_allocate_pages(cpu_buffer->nr_pages_to_update,
1697 &cpu_buffer->new_pages, cpu)) {
1698
1699 err = -ENOMEM;
1700 goto out_err;
1701 }
1702 }
1703
1704 get_online_cpus();
1705
1706
1707
1708
1709
1710 for_each_buffer_cpu(buffer, cpu) {
1711 cpu_buffer = buffer->buffers[cpu];
1712 if (!cpu_buffer->nr_pages_to_update)
1713 continue;
1714
1715
1716 if (!cpu_online(cpu)) {
1717 rb_update_pages(cpu_buffer);
1718 cpu_buffer->nr_pages_to_update = 0;
1719 } else {
1720 schedule_work_on(cpu,
1721 &cpu_buffer->update_pages_work);
1722 }
1723 }
1724
1725
1726 for_each_buffer_cpu(buffer, cpu) {
1727 cpu_buffer = buffer->buffers[cpu];
1728 if (!cpu_buffer->nr_pages_to_update)
1729 continue;
1730
1731 if (cpu_online(cpu))
1732 wait_for_completion(&cpu_buffer->update_done);
1733 cpu_buffer->nr_pages_to_update = 0;
1734 }
1735
1736 put_online_cpus();
1737 } else {
1738
1739 if (!cpumask_test_cpu(cpu_id, buffer->cpumask))
1740 goto out;
1741
1742 cpu_buffer = buffer->buffers[cpu_id];
1743
1744 if (nr_pages == cpu_buffer->nr_pages)
1745 goto out;
1746
1747 cpu_buffer->nr_pages_to_update = nr_pages -
1748 cpu_buffer->nr_pages;
1749
1750 INIT_LIST_HEAD(&cpu_buffer->new_pages);
1751 if (cpu_buffer->nr_pages_to_update > 0 &&
1752 __rb_allocate_pages(cpu_buffer->nr_pages_to_update,
1753 &cpu_buffer->new_pages, cpu_id)) {
1754 err = -ENOMEM;
1755 goto out_err;
1756 }
1757
1758 get_online_cpus();
1759
1760
1761 if (!cpu_online(cpu_id))
1762 rb_update_pages(cpu_buffer);
1763 else {
1764 schedule_work_on(cpu_id,
1765 &cpu_buffer->update_pages_work);
1766 wait_for_completion(&cpu_buffer->update_done);
1767 }
1768
1769 cpu_buffer->nr_pages_to_update = 0;
1770 put_online_cpus();
1771 }
1772
1773 out:
1774
1775
1776
1777
1778
1779
1780
1781 if (atomic_read(&buffer->record_disabled)) {
1782 atomic_inc(&buffer->record_disabled);
1783
1784
1785
1786
1787
1788
1789 synchronize_sched();
1790 for_each_buffer_cpu(buffer, cpu) {
1791 cpu_buffer = buffer->buffers[cpu];
1792 rb_check_pages(cpu_buffer);
1793 }
1794 atomic_dec(&buffer->record_disabled);
1795 }
1796
1797 mutex_unlock(&buffer->mutex);
1798 return size;
1799
1800 out_err:
1801 for_each_buffer_cpu(buffer, cpu) {
1802 struct buffer_page *bpage, *tmp;
1803
1804 cpu_buffer = buffer->buffers[cpu];
1805 cpu_buffer->nr_pages_to_update = 0;
1806
1807 if (list_empty(&cpu_buffer->new_pages))
1808 continue;
1809
1810 list_for_each_entry_safe(bpage, tmp, &cpu_buffer->new_pages,
1811 list) {
1812 list_del_init(&bpage->list);
1813 free_buffer_page(bpage);
1814 }
1815 }
1816 mutex_unlock(&buffer->mutex);
1817 return err;
1818}
1819EXPORT_SYMBOL_GPL(ring_buffer_resize);
1820
1821void ring_buffer_change_overwrite(struct ring_buffer *buffer, int val)
1822{
1823 mutex_lock(&buffer->mutex);
1824 if (val)
1825 buffer->flags |= RB_FL_OVERWRITE;
1826 else
1827 buffer->flags &= ~RB_FL_OVERWRITE;
1828 mutex_unlock(&buffer->mutex);
1829}
1830EXPORT_SYMBOL_GPL(ring_buffer_change_overwrite);
1831
1832static inline void *
1833__rb_data_page_index(struct buffer_data_page *bpage, unsigned index)
1834{
1835 return bpage->data + index;
1836}
1837
1838static inline void *__rb_page_index(struct buffer_page *bpage, unsigned index)
1839{
1840 return bpage->page->data + index;
1841}
1842
1843static inline struct ring_buffer_event *
1844rb_reader_event(struct ring_buffer_per_cpu *cpu_buffer)
1845{
1846 return __rb_page_index(cpu_buffer->reader_page,
1847 cpu_buffer->reader_page->read);
1848}
1849
1850static inline struct ring_buffer_event *
1851rb_iter_head_event(struct ring_buffer_iter *iter)
1852{
1853 return __rb_page_index(iter->head_page, iter->head);
1854}
1855
1856static inline unsigned rb_page_commit(struct buffer_page *bpage)
1857{
1858 return local_read(&bpage->page->commit);
1859}
1860
1861
1862static inline unsigned rb_page_size(struct buffer_page *bpage)
1863{
1864 return rb_page_commit(bpage);
1865}
1866
1867static inline unsigned
1868rb_commit_index(struct ring_buffer_per_cpu *cpu_buffer)
1869{
1870 return rb_page_commit(cpu_buffer->commit_page);
1871}
1872
1873static inline unsigned
1874rb_event_index(struct ring_buffer_event *event)
1875{
1876 unsigned long addr = (unsigned long)event;
1877
1878 return (addr & ~PAGE_MASK) - BUF_PAGE_HDR_SIZE;
1879}
1880
1881static void rb_inc_iter(struct ring_buffer_iter *iter)
1882{
1883 struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
1884
1885
1886
1887
1888
1889
1890
1891 if (iter->head_page == cpu_buffer->reader_page)
1892 iter->head_page = rb_set_head_page(cpu_buffer);
1893 else
1894 rb_inc_page(cpu_buffer, &iter->head_page);
1895
1896 iter->read_stamp = iter->head_page->page->time_stamp;
1897 iter->head = 0;
1898}
1899
1900
1901
1902
1903
1904
1905
1906
1907static int
1908rb_handle_head_page(struct ring_buffer_per_cpu *cpu_buffer,
1909 struct buffer_page *tail_page,
1910 struct buffer_page *next_page)
1911{
1912 struct buffer_page *new_head;
1913 int entries;
1914 int type;
1915 int ret;
1916
1917 entries = rb_page_entries(next_page);
1918
1919
1920
1921
1922
1923
1924 type = rb_head_page_set_update(cpu_buffer, next_page, tail_page,
1925 RB_PAGE_HEAD);
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938 switch (type) {
1939 case RB_PAGE_HEAD:
1940
1941
1942
1943
1944
1945 local_add(entries, &cpu_buffer->overrun);
1946 local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);
1947
1948
1949
1950
1951
1952
1953
1954 break;
1955
1956 case RB_PAGE_UPDATE:
1957
1958
1959
1960
1961 break;
1962 case RB_PAGE_NORMAL:
1963
1964
1965
1966
1967
1968 return 1;
1969 case RB_PAGE_MOVED:
1970
1971
1972
1973
1974
1975 return 1;
1976 default:
1977 RB_WARN_ON(cpu_buffer, 1);
1978 return -1;
1979 }
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995 new_head = next_page;
1996 rb_inc_page(cpu_buffer, &new_head);
1997
1998 ret = rb_head_page_set_head(cpu_buffer, new_head, next_page,
1999 RB_PAGE_NORMAL);
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009 switch (ret) {
2010 case RB_PAGE_HEAD:
2011 case RB_PAGE_NORMAL:
2012
2013 break;
2014 default:
2015 RB_WARN_ON(cpu_buffer, 1);
2016 return -1;
2017 }
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029 if (ret == RB_PAGE_NORMAL) {
2030 struct buffer_page *buffer_tail_page;
2031
2032 buffer_tail_page = READ_ONCE(cpu_buffer->tail_page);
2033
2034
2035
2036
2037 if (buffer_tail_page != tail_page &&
2038 buffer_tail_page != next_page)
2039 rb_head_page_set_normal(cpu_buffer, new_head,
2040 next_page,
2041 RB_PAGE_HEAD);
2042 }
2043
2044
2045
2046
2047
2048
2049 if (type == RB_PAGE_HEAD) {
2050 ret = rb_head_page_set_normal(cpu_buffer, next_page,
2051 tail_page,
2052 RB_PAGE_UPDATE);
2053 if (RB_WARN_ON(cpu_buffer,
2054 ret != RB_PAGE_UPDATE))
2055 return -1;
2056 }
2057
2058 return 0;
2059}
2060
2061static inline void
2062rb_reset_tail(struct ring_buffer_per_cpu *cpu_buffer,
2063 unsigned long tail, struct rb_event_info *info)
2064{
2065 struct buffer_page *tail_page = info->tail_page;
2066 struct ring_buffer_event *event;
2067 unsigned long length = info->length;
2068
2069
2070
2071
2072
2073 if (tail >= BUF_PAGE_SIZE) {
2074
2075
2076
2077
2078
2079 if (tail == BUF_PAGE_SIZE)
2080 tail_page->real_end = 0;
2081
2082 local_sub(length, &tail_page->write);
2083 return;
2084 }
2085
2086 event = __rb_page_index(tail_page, tail);
2087 kmemcheck_annotate_bitfield(event, bitfield);
2088
2089
2090 local_add(BUF_PAGE_SIZE - tail, &cpu_buffer->entries_bytes);
2091
2092
2093
2094
2095
2096
2097 tail_page->real_end = tail;
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110 if (tail > (BUF_PAGE_SIZE - RB_EVNT_MIN_SIZE)) {
2111
2112
2113
2114 rb_event_set_padding(event);
2115
2116
2117 local_sub(length, &tail_page->write);
2118 return;
2119 }
2120
2121
2122 event->array[0] = (BUF_PAGE_SIZE - tail) - RB_EVNT_HDR_SIZE;
2123 event->type_len = RINGBUF_TYPE_PADDING;
2124
2125 event->time_delta = 1;
2126
2127
2128 length = (tail + length) - BUF_PAGE_SIZE;
2129 local_sub(length, &tail_page->write);
2130}
2131
2132static inline void rb_end_commit(struct ring_buffer_per_cpu *cpu_buffer);
2133
2134
2135
2136
2137static noinline struct ring_buffer_event *
2138rb_move_tail(struct ring_buffer_per_cpu *cpu_buffer,
2139 unsigned long tail, struct rb_event_info *info)
2140{
2141 struct buffer_page *tail_page = info->tail_page;
2142 struct buffer_page *commit_page = cpu_buffer->commit_page;
2143 struct ring_buffer *buffer = cpu_buffer->buffer;
2144 struct buffer_page *next_page;
2145 int ret;
2146
2147 next_page = tail_page;
2148
2149 rb_inc_page(cpu_buffer, &next_page);
2150
2151
2152
2153
2154
2155
2156 if (unlikely(next_page == commit_page)) {
2157 local_inc(&cpu_buffer->commit_overrun);
2158 goto out_reset;
2159 }
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175 if (rb_is_head_page(cpu_buffer, next_page, &tail_page->list)) {
2176
2177
2178
2179
2180
2181 if (!rb_is_reader_page(cpu_buffer->commit_page)) {
2182
2183
2184
2185
2186 if (!(buffer->flags & RB_FL_OVERWRITE)) {
2187 local_inc(&cpu_buffer->dropped_events);
2188 goto out_reset;
2189 }
2190
2191 ret = rb_handle_head_page(cpu_buffer,
2192 tail_page,
2193 next_page);
2194 if (ret < 0)
2195 goto out_reset;
2196 if (ret)
2197 goto out_again;
2198 } else {
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209 if (unlikely((cpu_buffer->commit_page !=
2210 cpu_buffer->tail_page) &&
2211 (cpu_buffer->commit_page ==
2212 cpu_buffer->reader_page))) {
2213 local_inc(&cpu_buffer->commit_overrun);
2214 goto out_reset;
2215 }
2216 }
2217 }
2218
2219 rb_tail_page_update(cpu_buffer, tail_page, next_page);
2220
2221 out_again:
2222
2223 rb_reset_tail(cpu_buffer, tail, info);
2224
2225
2226 rb_end_commit(cpu_buffer);
2227
2228 local_inc(&cpu_buffer->committing);
2229
2230
2231 return ERR_PTR(-EAGAIN);
2232
2233 out_reset:
2234
2235 rb_reset_tail(cpu_buffer, tail, info);
2236
2237 return NULL;
2238}
2239
2240
2241static noinline struct ring_buffer_event *
2242rb_add_time_stamp(struct ring_buffer_event *event, u64 delta)
2243{
2244 event->type_len = RINGBUF_TYPE_TIME_EXTEND;
2245
2246
2247 if (rb_event_index(event)) {
2248 event->time_delta = delta & TS_MASK;
2249 event->array[0] = delta >> TS_SHIFT;
2250 } else {
2251
2252 event->time_delta = 0;
2253 event->array[0] = 0;
2254 }
2255
2256 return skip_time_extend(event);
2257}
2258
2259static inline bool rb_event_is_commit(struct ring_buffer_per_cpu *cpu_buffer,
2260 struct ring_buffer_event *event);
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273static void
2274rb_update_event(struct ring_buffer_per_cpu *cpu_buffer,
2275 struct ring_buffer_event *event,
2276 struct rb_event_info *info)
2277{
2278 unsigned length = info->length;
2279 u64 delta = info->delta;
2280
2281
2282 if (unlikely(!rb_event_is_commit(cpu_buffer, event)))
2283 delta = 0;
2284
2285
2286
2287
2288
2289 if (unlikely(info->add_timestamp)) {
2290 event = rb_add_time_stamp(event, delta);
2291 length -= RB_LEN_TIME_EXTEND;
2292 delta = 0;
2293 }
2294
2295 event->time_delta = delta;
2296 length -= RB_EVNT_HDR_SIZE;
2297 if (length > RB_MAX_SMALL_DATA || RB_FORCE_8BYTE_ALIGNMENT) {
2298 event->type_len = 0;
2299 event->array[0] = length;
2300 } else
2301 event->type_len = DIV_ROUND_UP(length, RB_ALIGNMENT);
2302}
2303
2304static unsigned rb_calculate_event_length(unsigned length)
2305{
2306 struct ring_buffer_event event;
2307
2308
2309 if (!length)
2310 length++;
2311
2312 if (length > RB_MAX_SMALL_DATA || RB_FORCE_8BYTE_ALIGNMENT)
2313 length += sizeof(event.array[0]);
2314
2315 length += RB_EVNT_HDR_SIZE;
2316 length = ALIGN(length, RB_ARCH_ALIGNMENT);
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330 if (length == RB_LEN_TIME_EXTEND + RB_ALIGNMENT)
2331 length += RB_ALIGNMENT;
2332
2333 return length;
2334}
2335
2336#ifndef CONFIG_HAVE_UNSTABLE_SCHED_CLOCK
2337static inline bool sched_clock_stable(void)
2338{
2339 return true;
2340}
2341#endif
2342
2343static inline int
2344rb_try_to_discard(struct ring_buffer_per_cpu *cpu_buffer,
2345 struct ring_buffer_event *event)
2346{
2347 unsigned long new_index, old_index;
2348 struct buffer_page *bpage;
2349 unsigned long index;
2350 unsigned long addr;
2351
2352 new_index = rb_event_index(event);
2353 old_index = new_index + rb_event_ts_length(event);
2354 addr = (unsigned long)event;
2355 addr &= PAGE_MASK;
2356
2357 bpage = READ_ONCE(cpu_buffer->tail_page);
2358
2359 if (bpage->page == (void *)addr && rb_page_write(bpage) == old_index) {
2360 unsigned long write_mask =
2361 local_read(&bpage->write) & ~RB_WRITE_MASK;
2362 unsigned long event_length = rb_event_length(event);
2363
2364
2365
2366
2367
2368
2369 old_index += write_mask;
2370 new_index += write_mask;
2371 index = local_cmpxchg(&bpage->write, old_index, new_index);
2372 if (index == old_index) {
2373
2374 local_sub(event_length, &cpu_buffer->entries_bytes);
2375 return 1;
2376 }
2377 }
2378
2379
2380 return 0;
2381}
2382
2383static void rb_start_commit(struct ring_buffer_per_cpu *cpu_buffer)
2384{
2385 local_inc(&cpu_buffer->committing);
2386 local_inc(&cpu_buffer->commits);
2387}
2388
2389static void
2390rb_set_commit_to_write(struct ring_buffer_per_cpu *cpu_buffer)
2391{
2392 unsigned long max_count;
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402 again:
2403 max_count = cpu_buffer->nr_pages * 100;
2404
2405 while (cpu_buffer->commit_page != READ_ONCE(cpu_buffer->tail_page)) {
2406 if (RB_WARN_ON(cpu_buffer, !(--max_count)))
2407 return;
2408 if (RB_WARN_ON(cpu_buffer,
2409 rb_is_reader_page(cpu_buffer->tail_page)))
2410 return;
2411 local_set(&cpu_buffer->commit_page->page->commit,
2412 rb_page_write(cpu_buffer->commit_page));
2413 rb_inc_page(cpu_buffer, &cpu_buffer->commit_page);
2414
2415 if (rb_page_write(cpu_buffer->commit_page))
2416 cpu_buffer->write_stamp =
2417 cpu_buffer->commit_page->page->time_stamp;
2418
2419 barrier();
2420 }
2421 while (rb_commit_index(cpu_buffer) !=
2422 rb_page_write(cpu_buffer->commit_page)) {
2423
2424 local_set(&cpu_buffer->commit_page->page->commit,
2425 rb_page_write(cpu_buffer->commit_page));
2426 RB_WARN_ON(cpu_buffer,
2427 local_read(&cpu_buffer->commit_page->page->commit) &
2428 ~RB_WRITE_MASK);
2429 barrier();
2430 }
2431
2432
2433 barrier();
2434
2435
2436
2437
2438
2439
2440 if (unlikely(cpu_buffer->commit_page != READ_ONCE(cpu_buffer->tail_page)))
2441 goto again;
2442}
2443
2444static inline void rb_end_commit(struct ring_buffer_per_cpu *cpu_buffer)
2445{
2446 unsigned long commits;
2447
2448 if (RB_WARN_ON(cpu_buffer,
2449 !local_read(&cpu_buffer->committing)))
2450 return;
2451
2452 again:
2453 commits = local_read(&cpu_buffer->commits);
2454
2455 barrier();
2456 if (local_read(&cpu_buffer->committing) == 1)
2457 rb_set_commit_to_write(cpu_buffer);
2458
2459 local_dec(&cpu_buffer->committing);
2460
2461
2462 barrier();
2463
2464
2465
2466
2467
2468
2469 if (unlikely(local_read(&cpu_buffer->commits) != commits) &&
2470 !local_read(&cpu_buffer->committing)) {
2471 local_inc(&cpu_buffer->committing);
2472 goto again;
2473 }
2474}
2475
2476static inline void rb_event_discard(struct ring_buffer_event *event)
2477{
2478 if (event->type_len == RINGBUF_TYPE_TIME_EXTEND)
2479 event = skip_time_extend(event);
2480
2481
2482 event->array[0] = rb_event_data_length(event) - RB_EVNT_HDR_SIZE;
2483 event->type_len = RINGBUF_TYPE_PADDING;
2484
2485 if (!event->time_delta)
2486 event->time_delta = 1;
2487}
2488
2489static inline bool
2490rb_event_is_commit(struct ring_buffer_per_cpu *cpu_buffer,
2491 struct ring_buffer_event *event)
2492{
2493 unsigned long addr = (unsigned long)event;
2494 unsigned long index;
2495
2496 index = rb_event_index(event);
2497 addr &= PAGE_MASK;
2498
2499 return cpu_buffer->commit_page->page == (void *)addr &&
2500 rb_commit_index(cpu_buffer) == index;
2501}
2502
2503static void
2504rb_update_write_stamp(struct ring_buffer_per_cpu *cpu_buffer,
2505 struct ring_buffer_event *event)
2506{
2507 u64 delta;
2508
2509
2510
2511
2512
2513 if (rb_event_is_commit(cpu_buffer, event)) {
2514
2515
2516
2517
2518 if (!rb_event_index(event))
2519 cpu_buffer->write_stamp =
2520 cpu_buffer->commit_page->page->time_stamp;
2521 else if (event->type_len == RINGBUF_TYPE_TIME_EXTEND) {
2522 delta = event->array[0];
2523 delta <<= TS_SHIFT;
2524 delta += event->time_delta;
2525 cpu_buffer->write_stamp += delta;
2526 } else
2527 cpu_buffer->write_stamp += event->time_delta;
2528 }
2529}
2530
2531static void rb_commit(struct ring_buffer_per_cpu *cpu_buffer,
2532 struct ring_buffer_event *event)
2533{
2534 local_inc(&cpu_buffer->entries);
2535 rb_update_write_stamp(cpu_buffer, event);
2536 rb_end_commit(cpu_buffer);
2537}
2538
2539static __always_inline void
2540rb_wakeups(struct ring_buffer *buffer, struct ring_buffer_per_cpu *cpu_buffer)
2541{
2542 bool pagebusy;
2543
2544 if (buffer->irq_work.waiters_pending) {
2545 buffer->irq_work.waiters_pending = false;
2546
2547 irq_work_queue(&buffer->irq_work.work);
2548 }
2549
2550 if (cpu_buffer->irq_work.waiters_pending) {
2551 cpu_buffer->irq_work.waiters_pending = false;
2552
2553 irq_work_queue(&cpu_buffer->irq_work.work);
2554 }
2555
2556 pagebusy = cpu_buffer->reader_page == cpu_buffer->commit_page;
2557
2558 if (!pagebusy && cpu_buffer->irq_work.full_waiters_pending) {
2559 cpu_buffer->irq_work.wakeup_full = true;
2560 cpu_buffer->irq_work.full_waiters_pending = false;
2561
2562 irq_work_queue(&cpu_buffer->irq_work.work);
2563 }
2564}
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604static __always_inline int
2605trace_recursive_lock(struct ring_buffer_per_cpu *cpu_buffer)
2606{
2607 unsigned int val = cpu_buffer->current_context;
2608 int bit;
2609
2610 if (in_interrupt()) {
2611 if (in_nmi())
2612 bit = RB_CTX_NMI;
2613 else if (in_irq())
2614 bit = RB_CTX_IRQ;
2615 else
2616 bit = RB_CTX_SOFTIRQ;
2617 } else
2618 bit = RB_CTX_NORMAL;
2619
2620 if (unlikely(val & (1 << bit)))
2621 return 1;
2622
2623 val |= (1 << bit);
2624 cpu_buffer->current_context = val;
2625
2626 return 0;
2627}
2628
2629static __always_inline void
2630trace_recursive_unlock(struct ring_buffer_per_cpu *cpu_buffer)
2631{
2632 cpu_buffer->current_context &= cpu_buffer->current_context - 1;
2633}
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644int ring_buffer_unlock_commit(struct ring_buffer *buffer,
2645 struct ring_buffer_event *event)
2646{
2647 struct ring_buffer_per_cpu *cpu_buffer;
2648 int cpu = raw_smp_processor_id();
2649
2650 cpu_buffer = buffer->buffers[cpu];
2651
2652 rb_commit(cpu_buffer, event);
2653
2654 rb_wakeups(buffer, cpu_buffer);
2655
2656 trace_recursive_unlock(cpu_buffer);
2657
2658 preempt_enable_notrace();
2659
2660 return 0;
2661}
2662EXPORT_SYMBOL_GPL(ring_buffer_unlock_commit);
2663
2664static noinline void
2665rb_handle_timestamp(struct ring_buffer_per_cpu *cpu_buffer,
2666 struct rb_event_info *info)
2667{
2668 WARN_ONCE(info->delta > (1ULL << 59),
2669 KERN_WARNING "Delta way too big! %llu ts=%llu write stamp = %llu\n%s",
2670 (unsigned long long)info->delta,
2671 (unsigned long long)info->ts,
2672 (unsigned long long)cpu_buffer->write_stamp,
2673 sched_clock_stable() ? "" :
2674 "If you just came from a suspend/resume,\n"
2675 "please switch to the trace global clock:\n"
2676 " echo global > /sys/kernel/debug/tracing/trace_clock\n");
2677 info->add_timestamp = 1;
2678}
2679
2680static struct ring_buffer_event *
2681__rb_reserve_next(struct ring_buffer_per_cpu *cpu_buffer,
2682 struct rb_event_info *info)
2683{
2684 struct ring_buffer_event *event;
2685 struct buffer_page *tail_page;
2686 unsigned long tail, write;
2687
2688
2689
2690
2691
2692
2693 if (unlikely(info->add_timestamp))
2694 info->length += RB_LEN_TIME_EXTEND;
2695
2696
2697 tail_page = info->tail_page = READ_ONCE(cpu_buffer->tail_page);
2698 write = local_add_return(info->length, &tail_page->write);
2699
2700
2701 write &= RB_WRITE_MASK;
2702 tail = write - info->length;
2703
2704
2705
2706
2707
2708 if (!tail)
2709 info->delta = 0;
2710
2711
2712 if (unlikely(write > BUF_PAGE_SIZE))
2713 return rb_move_tail(cpu_buffer, tail, info);
2714
2715
2716
2717 event = __rb_page_index(tail_page, tail);
2718 kmemcheck_annotate_bitfield(event, bitfield);
2719 rb_update_event(cpu_buffer, event, info);
2720
2721 local_inc(&tail_page->entries);
2722
2723
2724
2725
2726
2727 if (!tail)
2728 tail_page->page->time_stamp = info->ts;
2729
2730
2731 local_add(info->length, &cpu_buffer->entries_bytes);
2732
2733 return event;
2734}
2735
2736static struct ring_buffer_event *
2737rb_reserve_next_event(struct ring_buffer *buffer,
2738 struct ring_buffer_per_cpu *cpu_buffer,
2739 unsigned long length)
2740{
2741 struct ring_buffer_event *event;
2742 struct rb_event_info info;
2743 int nr_loops = 0;
2744 u64 diff;
2745
2746 rb_start_commit(cpu_buffer);
2747
2748#ifdef CONFIG_RING_BUFFER_ALLOW_SWAP
2749
2750
2751
2752
2753
2754
2755 barrier();
2756 if (unlikely(ACCESS_ONCE(cpu_buffer->buffer) != buffer)) {
2757 local_dec(&cpu_buffer->committing);
2758 local_dec(&cpu_buffer->commits);
2759 return NULL;
2760 }
2761#endif
2762
2763 info.length = rb_calculate_event_length(length);
2764 again:
2765 info.add_timestamp = 0;
2766 info.delta = 0;
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777 if (RB_WARN_ON(cpu_buffer, ++nr_loops > 1000))
2778 goto out_fail;
2779
2780 info.ts = rb_time_stamp(cpu_buffer->buffer);
2781 diff = info.ts - cpu_buffer->write_stamp;
2782
2783
2784 barrier();
2785
2786
2787 if (likely(info.ts >= cpu_buffer->write_stamp)) {
2788 info.delta = diff;
2789 if (unlikely(test_time_stamp(info.delta)))
2790 rb_handle_timestamp(cpu_buffer, &info);
2791 }
2792
2793 event = __rb_reserve_next(cpu_buffer, &info);
2794
2795 if (unlikely(PTR_ERR(event) == -EAGAIN)) {
2796 if (info.add_timestamp)
2797 info.length -= RB_LEN_TIME_EXTEND;
2798 goto again;
2799 }
2800
2801 if (!event)
2802 goto out_fail;
2803
2804 return event;
2805
2806 out_fail:
2807 rb_end_commit(cpu_buffer);
2808 return NULL;
2809}
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826struct ring_buffer_event *
2827ring_buffer_lock_reserve(struct ring_buffer *buffer, unsigned long length)
2828{
2829 struct ring_buffer_per_cpu *cpu_buffer;
2830 struct ring_buffer_event *event;
2831 int cpu;
2832
2833
2834 preempt_disable_notrace();
2835
2836 if (unlikely(atomic_read(&buffer->record_disabled)))
2837 goto out;
2838
2839 cpu = raw_smp_processor_id();
2840
2841 if (unlikely(!cpumask_test_cpu(cpu, buffer->cpumask)))
2842 goto out;
2843
2844 cpu_buffer = buffer->buffers[cpu];
2845
2846 if (unlikely(atomic_read(&cpu_buffer->record_disabled)))
2847 goto out;
2848
2849 if (unlikely(length > BUF_MAX_DATA_SIZE))
2850 goto out;
2851
2852 if (unlikely(trace_recursive_lock(cpu_buffer)))
2853 goto out;
2854
2855 event = rb_reserve_next_event(buffer, cpu_buffer, length);
2856 if (!event)
2857 goto out_unlock;
2858
2859 return event;
2860
2861 out_unlock:
2862 trace_recursive_unlock(cpu_buffer);
2863 out:
2864 preempt_enable_notrace();
2865 return NULL;
2866}
2867EXPORT_SYMBOL_GPL(ring_buffer_lock_reserve);
2868
2869
2870
2871
2872
2873
2874
2875static inline void
2876rb_decrement_entry(struct ring_buffer_per_cpu *cpu_buffer,
2877 struct ring_buffer_event *event)
2878{
2879 unsigned long addr = (unsigned long)event;
2880 struct buffer_page *bpage = cpu_buffer->commit_page;
2881 struct buffer_page *start;
2882
2883 addr &= PAGE_MASK;
2884
2885
2886 if (likely(bpage->page == (void *)addr)) {
2887 local_dec(&bpage->entries);
2888 return;
2889 }
2890
2891
2892
2893
2894
2895 rb_inc_page(cpu_buffer, &bpage);
2896 start = bpage;
2897 do {
2898 if (bpage->page == (void *)addr) {
2899 local_dec(&bpage->entries);
2900 return;
2901 }
2902 rb_inc_page(cpu_buffer, &bpage);
2903 } while (bpage != start);
2904
2905
2906 RB_WARN_ON(cpu_buffer, 1);
2907}
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928void ring_buffer_discard_commit(struct ring_buffer *buffer,
2929 struct ring_buffer_event *event)
2930{
2931 struct ring_buffer_per_cpu *cpu_buffer;
2932 int cpu;
2933
2934
2935 rb_event_discard(event);
2936
2937 cpu = smp_processor_id();
2938 cpu_buffer = buffer->buffers[cpu];
2939
2940
2941
2942
2943
2944
2945 RB_WARN_ON(buffer, !local_read(&cpu_buffer->committing));
2946
2947 rb_decrement_entry(cpu_buffer, event);
2948 if (rb_try_to_discard(cpu_buffer, event))
2949 goto out;
2950
2951
2952
2953
2954
2955 rb_update_write_stamp(cpu_buffer, event);
2956 out:
2957 rb_end_commit(cpu_buffer);
2958
2959 trace_recursive_unlock(cpu_buffer);
2960
2961 preempt_enable_notrace();
2962
2963}
2964EXPORT_SYMBOL_GPL(ring_buffer_discard_commit);
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979int ring_buffer_write(struct ring_buffer *buffer,
2980 unsigned long length,
2981 void *data)
2982{
2983 struct ring_buffer_per_cpu *cpu_buffer;
2984 struct ring_buffer_event *event;
2985 void *body;
2986 int ret = -EBUSY;
2987 int cpu;
2988
2989 preempt_disable_notrace();
2990
2991 if (atomic_read(&buffer->record_disabled))
2992 goto out;
2993
2994 cpu = raw_smp_processor_id();
2995
2996 if (!cpumask_test_cpu(cpu, buffer->cpumask))
2997 goto out;
2998
2999 cpu_buffer = buffer->buffers[cpu];
3000
3001 if (atomic_read(&cpu_buffer->record_disabled))
3002 goto out;
3003
3004 if (length > BUF_MAX_DATA_SIZE)
3005 goto out;
3006
3007 if (unlikely(trace_recursive_lock(cpu_buffer)))
3008 goto out;
3009
3010 event = rb_reserve_next_event(buffer, cpu_buffer, length);
3011 if (!event)
3012 goto out_unlock;
3013
3014 body = rb_event_data(event);
3015
3016 memcpy(body, data, length);
3017
3018 rb_commit(cpu_buffer, event);
3019
3020 rb_wakeups(buffer, cpu_buffer);
3021
3022 ret = 0;
3023
3024 out_unlock:
3025 trace_recursive_unlock(cpu_buffer);
3026
3027 out:
3028 preempt_enable_notrace();
3029
3030 return ret;
3031}
3032EXPORT_SYMBOL_GPL(ring_buffer_write);
3033
3034static bool rb_per_cpu_empty(struct ring_buffer_per_cpu *cpu_buffer)
3035{
3036 struct buffer_page *reader = cpu_buffer->reader_page;
3037 struct buffer_page *head = rb_set_head_page(cpu_buffer);
3038 struct buffer_page *commit = cpu_buffer->commit_page;
3039
3040
3041 if (unlikely(!head))
3042 return true;
3043
3044 return reader->read == rb_page_commit(reader) &&
3045 (commit == reader ||
3046 (commit == head &&
3047 head->read == rb_page_commit(commit)));
3048}
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058
3059void ring_buffer_record_disable(struct ring_buffer *buffer)
3060{
3061 atomic_inc(&buffer->record_disabled);
3062}
3063EXPORT_SYMBOL_GPL(ring_buffer_record_disable);
3064
3065
3066
3067
3068
3069
3070
3071
3072void ring_buffer_record_enable(struct ring_buffer *buffer)
3073{
3074 atomic_dec(&buffer->record_disabled);
3075}
3076EXPORT_SYMBOL_GPL(ring_buffer_record_enable);
3077
3078
3079
3080
3081
3082
3083
3084
3085
3086
3087
3088
3089void ring_buffer_record_off(struct ring_buffer *buffer)
3090{
3091 unsigned int rd;
3092 unsigned int new_rd;
3093
3094 do {
3095 rd = atomic_read(&buffer->record_disabled);
3096 new_rd = rd | RB_BUFFER_OFF;
3097 } while (atomic_cmpxchg(&buffer->record_disabled, rd, new_rd) != rd);
3098}
3099EXPORT_SYMBOL_GPL(ring_buffer_record_off);
3100
3101
3102
3103
3104
3105
3106
3107
3108
3109
3110
3111
3112void ring_buffer_record_on(struct ring_buffer *buffer)
3113{
3114 unsigned int rd;
3115 unsigned int new_rd;
3116
3117 do {
3118 rd = atomic_read(&buffer->record_disabled);
3119 new_rd = rd & ~RB_BUFFER_OFF;
3120 } while (atomic_cmpxchg(&buffer->record_disabled, rd, new_rd) != rd);
3121}
3122EXPORT_SYMBOL_GPL(ring_buffer_record_on);
3123
3124
3125
3126
3127
3128
3129
3130int ring_buffer_record_is_on(struct ring_buffer *buffer)
3131{
3132 return !atomic_read(&buffer->record_disabled);
3133}
3134
3135
3136
3137
3138
3139
3140
3141
3142
3143
3144
3145void ring_buffer_record_disable_cpu(struct ring_buffer *buffer, int cpu)
3146{
3147 struct ring_buffer_per_cpu *cpu_buffer;
3148
3149 if (!cpumask_test_cpu(cpu, buffer->cpumask))
3150 return;
3151
3152 cpu_buffer = buffer->buffers[cpu];
3153 atomic_inc(&cpu_buffer->record_disabled);
3154}
3155EXPORT_SYMBOL_GPL(ring_buffer_record_disable_cpu);
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165void ring_buffer_record_enable_cpu(struct ring_buffer *buffer, int cpu)
3166{
3167 struct ring_buffer_per_cpu *cpu_buffer;
3168
3169 if (!cpumask_test_cpu(cpu, buffer->cpumask))
3170 return;
3171
3172 cpu_buffer = buffer->buffers[cpu];
3173 atomic_dec(&cpu_buffer->record_disabled);
3174}
3175EXPORT_SYMBOL_GPL(ring_buffer_record_enable_cpu);
3176
3177
3178
3179
3180
3181
3182
3183static inline unsigned long
3184rb_num_of_entries(struct ring_buffer_per_cpu *cpu_buffer)
3185{
3186 return local_read(&cpu_buffer->entries) -
3187 (local_read(&cpu_buffer->overrun) + cpu_buffer->read);
3188}
3189
3190
3191
3192
3193
3194
3195u64 ring_buffer_oldest_event_ts(struct ring_buffer *buffer, int cpu)
3196{
3197 unsigned long flags;
3198 struct ring_buffer_per_cpu *cpu_buffer;
3199 struct buffer_page *bpage;
3200 u64 ret = 0;
3201
3202 if (!cpumask_test_cpu(cpu, buffer->cpumask))
3203 return 0;
3204
3205 cpu_buffer = buffer->buffers[cpu];
3206 raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
3207
3208
3209
3210
3211 if (cpu_buffer->tail_page == cpu_buffer->reader_page)
3212 bpage = cpu_buffer->reader_page;
3213 else
3214 bpage = rb_set_head_page(cpu_buffer);
3215 if (bpage)
3216 ret = bpage->page->time_stamp;
3217 raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
3218
3219 return ret;
3220}
3221EXPORT_SYMBOL_GPL(ring_buffer_oldest_event_ts);
3222
3223
3224
3225
3226
3227
3228unsigned long ring_buffer_bytes_cpu(struct ring_buffer *buffer, int cpu)
3229{
3230 struct ring_buffer_per_cpu *cpu_buffer;
3231 unsigned long ret;
3232
3233 if (!cpumask_test_cpu(cpu, buffer->cpumask))
3234 return 0;
3235
3236 cpu_buffer = buffer->buffers[cpu];
3237 ret = local_read(&cpu_buffer->entries_bytes) - cpu_buffer->read_bytes;
3238
3239 return ret;
3240}
3241EXPORT_SYMBOL_GPL(ring_buffer_bytes_cpu);
3242
3243
3244
3245
3246
3247
3248unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu)
3249{
3250 struct ring_buffer_per_cpu *cpu_buffer;
3251
3252 if (!cpumask_test_cpu(cpu, buffer->cpumask))
3253 return 0;
3254
3255 cpu_buffer = buffer->buffers[cpu];
3256
3257 return rb_num_of_entries(cpu_buffer);
3258}
3259EXPORT_SYMBOL_GPL(ring_buffer_entries_cpu);
3260
3261
3262
3263
3264
3265
3266
3267unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu)
3268{
3269 struct ring_buffer_per_cpu *cpu_buffer;
3270 unsigned long ret;
3271
3272 if (!cpumask_test_cpu(cpu, buffer->cpumask))
3273 return 0;
3274
3275 cpu_buffer = buffer->buffers[cpu];
3276 ret = local_read(&cpu_buffer->overrun);
3277
3278 return ret;
3279}
3280EXPORT_SYMBOL_GPL(ring_buffer_overrun_cpu);
3281
3282
3283
3284
3285
3286
3287
3288
3289unsigned long
3290ring_buffer_commit_overrun_cpu(struct ring_buffer *buffer, int cpu)
3291{
3292 struct ring_buffer_per_cpu *cpu_buffer;
3293 unsigned long ret;
3294
3295 if (!cpumask_test_cpu(cpu, buffer->cpumask))
3296 return 0;
3297
3298 cpu_buffer = buffer->buffers[cpu];
3299 ret = local_read(&cpu_buffer->commit_overrun);
3300
3301 return ret;
3302}
3303EXPORT_SYMBOL_GPL(ring_buffer_commit_overrun_cpu);
3304
3305
3306
3307
3308
3309
3310
3311unsigned long
3312ring_buffer_dropped_events_cpu(struct ring_buffer *buffer, int cpu)
3313{
3314 struct ring_buffer_per_cpu *cpu_buffer;
3315 unsigned long ret;
3316
3317 if (!cpumask_test_cpu(cpu, buffer->cpumask))
3318 return 0;
3319
3320 cpu_buffer = buffer->buffers[cpu];
3321 ret = local_read(&cpu_buffer->dropped_events);
3322
3323 return ret;
3324}
3325EXPORT_SYMBOL_GPL(ring_buffer_dropped_events_cpu);
3326
3327
3328
3329
3330
3331
3332unsigned long
3333ring_buffer_read_events_cpu(struct ring_buffer *buffer, int cpu)
3334{
3335 struct ring_buffer_per_cpu *cpu_buffer;
3336
3337 if (!cpumask_test_cpu(cpu, buffer->cpumask))
3338 return 0;
3339
3340 cpu_buffer = buffer->buffers[cpu];
3341 return cpu_buffer->read;
3342}
3343EXPORT_SYMBOL_GPL(ring_buffer_read_events_cpu);
3344
3345
3346
3347
3348
3349
3350
3351
3352unsigned long ring_buffer_entries(struct ring_buffer *buffer)
3353{
3354 struct ring_buffer_per_cpu *cpu_buffer;
3355 unsigned long entries = 0;
3356 int cpu;
3357
3358
3359 for_each_buffer_cpu(buffer, cpu) {
3360 cpu_buffer = buffer->buffers[cpu];
3361 entries += rb_num_of_entries(cpu_buffer);
3362 }
3363
3364 return entries;
3365}
3366EXPORT_SYMBOL_GPL(ring_buffer_entries);
3367
3368
3369
3370
3371
3372
3373
3374
3375unsigned long ring_buffer_overruns(struct ring_buffer *buffer)
3376{
3377 struct ring_buffer_per_cpu *cpu_buffer;
3378 unsigned long overruns = 0;
3379 int cpu;
3380
3381
3382 for_each_buffer_cpu(buffer, cpu) {
3383 cpu_buffer = buffer->buffers[cpu];
3384 overruns += local_read(&cpu_buffer->overrun);
3385 }
3386
3387 return overruns;
3388}
3389EXPORT_SYMBOL_GPL(ring_buffer_overruns);
3390
3391static void rb_iter_reset(struct ring_buffer_iter *iter)
3392{
3393 struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
3394
3395
3396 iter->head_page = cpu_buffer->reader_page;
3397 iter->head = cpu_buffer->reader_page->read;
3398
3399 iter->cache_reader_page = iter->head_page;
3400 iter->cache_read = cpu_buffer->read;
3401
3402 if (iter->head)
3403 iter->read_stamp = cpu_buffer->read_stamp;
3404 else
3405 iter->read_stamp = iter->head_page->page->time_stamp;
3406}
3407
3408
3409
3410
3411
3412
3413
3414
3415void ring_buffer_iter_reset(struct ring_buffer_iter *iter)
3416{
3417 struct ring_buffer_per_cpu *cpu_buffer;
3418 unsigned long flags;
3419
3420 if (!iter)
3421 return;
3422
3423 cpu_buffer = iter->cpu_buffer;
3424
3425 raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
3426 rb_iter_reset(iter);
3427 raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
3428}
3429EXPORT_SYMBOL_GPL(ring_buffer_iter_reset);
3430
3431
3432
3433
3434
3435int ring_buffer_iter_empty(struct ring_buffer_iter *iter)
3436{
3437 struct ring_buffer_per_cpu *cpu_buffer;
3438
3439 cpu_buffer = iter->cpu_buffer;
3440
3441 return iter->head_page == cpu_buffer->commit_page &&
3442 iter->head == rb_commit_index(cpu_buffer);
3443}
3444EXPORT_SYMBOL_GPL(ring_buffer_iter_empty);
3445
3446static void
3447rb_update_read_stamp(struct ring_buffer_per_cpu *cpu_buffer,
3448 struct ring_buffer_event *event)
3449{
3450 u64 delta;
3451
3452 switch (event->type_len) {
3453 case RINGBUF_TYPE_PADDING:
3454 return;
3455
3456 case RINGBUF_TYPE_TIME_EXTEND:
3457 delta = event->array[0];
3458 delta <<= TS_SHIFT;
3459 delta += event->time_delta;
3460 cpu_buffer->read_stamp += delta;
3461 return;
3462
3463 case RINGBUF_TYPE_TIME_STAMP:
3464
3465 return;
3466
3467 case RINGBUF_TYPE_DATA:
3468 cpu_buffer->read_stamp += event->time_delta;
3469 return;
3470
3471 default:
3472 BUG();
3473 }
3474 return;
3475}
3476
3477static void
3478rb_update_iter_read_stamp(struct ring_buffer_iter *iter,
3479 struct ring_buffer_event *event)
3480{
3481 u64 delta;
3482
3483 switch (event->type_len) {
3484 case RINGBUF_TYPE_PADDING:
3485 return;
3486
3487 case RINGBUF_TYPE_TIME_EXTEND:
3488 delta = event->array[0];
3489 delta <<= TS_SHIFT;
3490 delta += event->time_delta;
3491 iter->read_stamp += delta;
3492 return;
3493
3494 case RINGBUF_TYPE_TIME_STAMP:
3495
3496 return;
3497
3498 case RINGBUF_TYPE_DATA:
3499 iter->read_stamp += event->time_delta;
3500 return;
3501
3502 default:
3503 BUG();
3504 }
3505 return;
3506}
3507
3508static struct buffer_page *
3509rb_get_reader_page(struct ring_buffer_per_cpu *cpu_buffer)
3510{
3511 struct buffer_page *reader = NULL;
3512 unsigned long overwrite;
3513 unsigned long flags;
3514 int nr_loops = 0;
3515 int ret;
3516
3517 local_irq_save(flags);
3518 arch_spin_lock(&cpu_buffer->lock);
3519
3520 again:
3521
3522
3523
3524
3525
3526
3527 if (RB_WARN_ON(cpu_buffer, ++nr_loops > 3)) {
3528 reader = NULL;
3529 goto out;
3530 }
3531
3532 reader = cpu_buffer->reader_page;
3533
3534
3535 if (cpu_buffer->reader_page->read < rb_page_size(reader))
3536 goto out;
3537
3538
3539 if (RB_WARN_ON(cpu_buffer,
3540 cpu_buffer->reader_page->read > rb_page_size(reader)))
3541 goto out;
3542
3543
3544 reader = NULL;
3545 if (cpu_buffer->commit_page == cpu_buffer->reader_page)
3546 goto out;
3547
3548
3549 if (rb_num_of_entries(cpu_buffer) == 0)
3550 goto out;
3551
3552
3553
3554
3555 local_set(&cpu_buffer->reader_page->write, 0);
3556 local_set(&cpu_buffer->reader_page->entries, 0);
3557 local_set(&cpu_buffer->reader_page->page->commit, 0);
3558 cpu_buffer->reader_page->real_end = 0;
3559
3560 spin:
3561
3562
3563
3564 reader = rb_set_head_page(cpu_buffer);
3565 if (!reader)
3566 goto out;
3567 cpu_buffer->reader_page->list.next = rb_list_head(reader->list.next);
3568 cpu_buffer->reader_page->list.prev = reader->list.prev;
3569
3570
3571
3572
3573
3574
3575 cpu_buffer->pages = reader->list.prev;
3576
3577
3578 rb_set_list_to_head(cpu_buffer, &cpu_buffer->reader_page->list);
3579
3580
3581
3582
3583
3584
3585
3586
3587
3588
3589 smp_mb();
3590 overwrite = local_read(&(cpu_buffer->overrun));
3591
3592
3593
3594
3595
3596
3597
3598
3599
3600
3601
3602
3603 ret = rb_head_page_replace(reader, cpu_buffer->reader_page);
3604
3605
3606
3607
3608 if (!ret)
3609 goto spin;
3610
3611
3612
3613
3614
3615
3616 rb_list_head(reader->list.next)->prev = &cpu_buffer->reader_page->list;
3617 rb_inc_page(cpu_buffer, &cpu_buffer->head_page);
3618
3619
3620 cpu_buffer->reader_page = reader;
3621 cpu_buffer->reader_page->read = 0;
3622
3623 if (overwrite != cpu_buffer->last_overrun) {
3624 cpu_buffer->lost_events = overwrite - cpu_buffer->last_overrun;
3625 cpu_buffer->last_overrun = overwrite;
3626 }
3627
3628 goto again;
3629
3630 out:
3631
3632 if (reader && reader->read == 0)
3633 cpu_buffer->read_stamp = reader->page->time_stamp;
3634
3635 arch_spin_unlock(&cpu_buffer->lock);
3636 local_irq_restore(flags);
3637
3638 return reader;
3639}
3640
3641static void rb_advance_reader(struct ring_buffer_per_cpu *cpu_buffer)
3642{
3643 struct ring_buffer_event *event;
3644 struct buffer_page *reader;
3645 unsigned length;
3646
3647 reader = rb_get_reader_page(cpu_buffer);
3648
3649
3650 if (RB_WARN_ON(cpu_buffer, !reader))
3651 return;
3652
3653 event = rb_reader_event(cpu_buffer);
3654
3655 if (event->type_len <= RINGBUF_TYPE_DATA_TYPE_LEN_MAX)
3656 cpu_buffer->read++;
3657
3658 rb_update_read_stamp(cpu_buffer, event);
3659
3660 length = rb_event_length(event);
3661 cpu_buffer->reader_page->read += length;
3662}
3663
3664static void rb_advance_iter(struct ring_buffer_iter *iter)
3665{
3666 struct ring_buffer_per_cpu *cpu_buffer;
3667 struct ring_buffer_event *event;
3668 unsigned length;
3669
3670 cpu_buffer = iter->cpu_buffer;
3671
3672
3673
3674
3675 if (iter->head >= rb_page_size(iter->head_page)) {
3676
3677 if (iter->head_page == cpu_buffer->commit_page)
3678 return;
3679 rb_inc_iter(iter);
3680 return;
3681 }
3682
3683 event = rb_iter_head_event(iter);
3684
3685 length = rb_event_length(event);
3686
3687
3688
3689
3690
3691 if (RB_WARN_ON(cpu_buffer,
3692 (iter->head_page == cpu_buffer->commit_page) &&
3693 (iter->head + length > rb_commit_index(cpu_buffer))))
3694 return;
3695
3696 rb_update_iter_read_stamp(iter, event);
3697
3698 iter->head += length;
3699
3700
3701 if ((iter->head >= rb_page_size(iter->head_page)) &&
3702 (iter->head_page != cpu_buffer->commit_page))
3703 rb_inc_iter(iter);
3704}
3705
3706static int rb_lost_events(struct ring_buffer_per_cpu *cpu_buffer)
3707{
3708 return cpu_buffer->lost_events;
3709}
3710
3711static struct ring_buffer_event *
3712rb_buffer_peek(struct ring_buffer_per_cpu *cpu_buffer, u64 *ts,
3713 unsigned long *lost_events)
3714{
3715 struct ring_buffer_event *event;
3716 struct buffer_page *reader;
3717 int nr_loops = 0;
3718
3719 again:
3720
3721
3722
3723
3724
3725
3726 if (RB_WARN_ON(cpu_buffer, ++nr_loops > 2))
3727 return NULL;
3728
3729 reader = rb_get_reader_page(cpu_buffer);
3730 if (!reader)
3731 return NULL;
3732
3733 event = rb_reader_event(cpu_buffer);
3734
3735 switch (event->type_len) {
3736 case RINGBUF_TYPE_PADDING:
3737 if (rb_null_event(event))
3738 RB_WARN_ON(cpu_buffer, 1);
3739
3740
3741
3742
3743
3744
3745
3746
3747 return event;
3748
3749 case RINGBUF_TYPE_TIME_EXTEND:
3750
3751 rb_advance_reader(cpu_buffer);
3752 goto again;
3753
3754 case RINGBUF_TYPE_TIME_STAMP:
3755
3756 rb_advance_reader(cpu_buffer);
3757 goto again;
3758
3759 case RINGBUF_TYPE_DATA:
3760 if (ts) {
3761 *ts = cpu_buffer->read_stamp + event->time_delta;
3762 ring_buffer_normalize_time_stamp(cpu_buffer->buffer,
3763 cpu_buffer->cpu, ts);
3764 }
3765 if (lost_events)
3766 *lost_events = rb_lost_events(cpu_buffer);
3767 return event;
3768
3769 default:
3770 BUG();
3771 }
3772
3773 return NULL;
3774}
3775EXPORT_SYMBOL_GPL(ring_buffer_peek);
3776
3777static struct ring_buffer_event *
3778rb_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
3779{
3780 struct ring_buffer *buffer;
3781 struct ring_buffer_per_cpu *cpu_buffer;
3782 struct ring_buffer_event *event;
3783 int nr_loops = 0;
3784
3785 cpu_buffer = iter->cpu_buffer;
3786 buffer = cpu_buffer->buffer;
3787
3788
3789
3790
3791
3792
3793 if (unlikely(iter->cache_read != cpu_buffer->read ||
3794 iter->cache_reader_page != cpu_buffer->reader_page))
3795 rb_iter_reset(iter);
3796
3797 again:
3798 if (ring_buffer_iter_empty(iter))
3799 return NULL;
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809 if (RB_WARN_ON(cpu_buffer, ++nr_loops > 3))
3810 return NULL;
3811
3812 if (rb_per_cpu_empty(cpu_buffer))
3813 return NULL;
3814
3815 if (iter->head >= rb_page_size(iter->head_page)) {
3816 rb_inc_iter(iter);
3817 goto again;
3818 }
3819
3820 event = rb_iter_head_event(iter);
3821
3822 switch (event->type_len) {
3823 case RINGBUF_TYPE_PADDING:
3824 if (rb_null_event(event)) {
3825 rb_inc_iter(iter);
3826 goto again;
3827 }
3828 rb_advance_iter(iter);
3829 return event;
3830
3831 case RINGBUF_TYPE_TIME_EXTEND:
3832
3833 rb_advance_iter(iter);
3834 goto again;
3835
3836 case RINGBUF_TYPE_TIME_STAMP:
3837
3838 rb_advance_iter(iter);
3839 goto again;
3840
3841 case RINGBUF_TYPE_DATA:
3842 if (ts) {
3843 *ts = iter->read_stamp + event->time_delta;
3844 ring_buffer_normalize_time_stamp(buffer,
3845 cpu_buffer->cpu, ts);
3846 }
3847 return event;
3848
3849 default:
3850 BUG();
3851 }
3852
3853 return NULL;
3854}
3855EXPORT_SYMBOL_GPL(ring_buffer_iter_peek);
3856
3857static inline bool rb_reader_lock(struct ring_buffer_per_cpu *cpu_buffer)
3858{
3859 if (likely(!in_nmi())) {
3860 raw_spin_lock(&cpu_buffer->reader_lock);
3861 return true;
3862 }
3863
3864
3865
3866
3867
3868
3869
3870
3871
3872
3873 if (raw_spin_trylock(&cpu_buffer->reader_lock))
3874 return true;
3875
3876
3877 atomic_inc(&cpu_buffer->record_disabled);
3878 return false;
3879}
3880
3881static inline void
3882rb_reader_unlock(struct ring_buffer_per_cpu *cpu_buffer, bool locked)
3883{
3884 if (likely(locked))
3885 raw_spin_unlock(&cpu_buffer->reader_lock);
3886 return;
3887}
3888
3889
3890
3891
3892
3893
3894
3895
3896
3897
3898
3899struct ring_buffer_event *
3900ring_buffer_peek(struct ring_buffer *buffer, int cpu, u64 *ts,
3901 unsigned long *lost_events)
3902{
3903 struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
3904 struct ring_buffer_event *event;
3905 unsigned long flags;
3906 bool dolock;
3907
3908 if (!cpumask_test_cpu(cpu, buffer->cpumask))
3909 return NULL;
3910
3911 again:
3912 local_irq_save(flags);
3913 dolock = rb_reader_lock(cpu_buffer);
3914 event = rb_buffer_peek(cpu_buffer, ts, lost_events);
3915 if (event && event->type_len == RINGBUF_TYPE_PADDING)
3916 rb_advance_reader(cpu_buffer);
3917 rb_reader_unlock(cpu_buffer, dolock);
3918 local_irq_restore(flags);
3919
3920 if (event && event->type_len == RINGBUF_TYPE_PADDING)
3921 goto again;
3922
3923 return event;
3924}
3925
3926
3927
3928
3929
3930
3931
3932
3933
3934struct ring_buffer_event *
3935ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts)
3936{
3937 struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
3938 struct ring_buffer_event *event;
3939 unsigned long flags;
3940
3941 again:
3942 raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
3943 event = rb_iter_peek(iter, ts);
3944 raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
3945
3946 if (event && event->type_len == RINGBUF_TYPE_PADDING)
3947 goto again;
3948
3949 return event;
3950}
3951
3952
3953
3954
3955
3956
3957
3958
3959
3960
3961
3962
3963struct ring_buffer_event *
3964ring_buffer_consume(struct ring_buffer *buffer, int cpu, u64 *ts,
3965 unsigned long *lost_events)
3966{
3967 struct ring_buffer_per_cpu *cpu_buffer;
3968 struct ring_buffer_event *event = NULL;
3969 unsigned long flags;
3970 bool dolock;
3971
3972 again:
3973
3974 preempt_disable();
3975
3976 if (!cpumask_test_cpu(cpu, buffer->cpumask))
3977 goto out;
3978
3979 cpu_buffer = buffer->buffers[cpu];
3980 local_irq_save(flags);
3981 dolock = rb_reader_lock(cpu_buffer);
3982
3983 event = rb_buffer_peek(cpu_buffer, ts, lost_events);
3984 if (event) {
3985 cpu_buffer->lost_events = 0;
3986 rb_advance_reader(cpu_buffer);
3987 }
3988
3989 rb_reader_unlock(cpu_buffer, dolock);
3990 local_irq_restore(flags);
3991
3992 out:
3993 preempt_enable();
3994
3995 if (event && event->type_len == RINGBUF_TYPE_PADDING)
3996 goto again;
3997
3998 return event;
3999}
4000EXPORT_SYMBOL_GPL(ring_buffer_consume);
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010
4011
4012
4013
4014
4015
4016
4017
4018
4019
4020
4021
4022struct ring_buffer_iter *
4023ring_buffer_read_prepare(struct ring_buffer *buffer, int cpu)
4024{
4025 struct ring_buffer_per_cpu *cpu_buffer;
4026 struct ring_buffer_iter *iter;
4027
4028 if (!cpumask_test_cpu(cpu, buffer->cpumask))
4029 return NULL;
4030
4031 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
4032 if (!iter)
4033 return NULL;
4034
4035 cpu_buffer = buffer->buffers[cpu];
4036
4037 iter->cpu_buffer = cpu_buffer;
4038
4039 atomic_inc(&buffer->resize_disabled);
4040 atomic_inc(&cpu_buffer->record_disabled);
4041
4042 return iter;
4043}
4044EXPORT_SYMBOL_GPL(ring_buffer_read_prepare);
4045
4046
4047
4048
4049
4050
4051
4052
4053void
4054ring_buffer_read_prepare_sync(void)
4055{
4056 synchronize_sched();
4057}
4058EXPORT_SYMBOL_GPL(ring_buffer_read_prepare_sync);
4059
4060
4061
4062
4063
4064
4065
4066
4067
4068
4069
4070
4071void
4072ring_buffer_read_start(struct ring_buffer_iter *iter)
4073{
4074 struct ring_buffer_per_cpu *cpu_buffer;
4075 unsigned long flags;
4076
4077 if (!iter)
4078 return;
4079
4080 cpu_buffer = iter->cpu_buffer;
4081
4082 raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
4083 arch_spin_lock(&cpu_buffer->lock);
4084 rb_iter_reset(iter);
4085 arch_spin_unlock(&cpu_buffer->lock);
4086 raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
4087}
4088EXPORT_SYMBOL_GPL(ring_buffer_read_start);
4089
4090
4091
4092
4093
4094
4095
4096
4097void
4098ring_buffer_read_finish(struct ring_buffer_iter *iter)
4099{
4100 struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
4101 unsigned long flags;
4102
4103
4104
4105
4106
4107
4108
4109 raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
4110 rb_check_pages(cpu_buffer);
4111 raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
4112
4113 atomic_dec(&cpu_buffer->record_disabled);
4114 atomic_dec(&cpu_buffer->buffer->resize_disabled);
4115 kfree(iter);
4116}
4117EXPORT_SYMBOL_GPL(ring_buffer_read_finish);
4118
4119
4120
4121
4122
4123
4124
4125
4126struct ring_buffer_event *
4127ring_buffer_read(struct ring_buffer_iter *iter, u64 *ts)
4128{
4129 struct ring_buffer_event *event;
4130 struct ring_buffer_per_cpu *cpu_buffer = iter->cpu_buffer;
4131 unsigned long flags;
4132
4133 raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
4134 again:
4135 event = rb_iter_peek(iter, ts);
4136 if (!event)
4137 goto out;
4138
4139 if (event->type_len == RINGBUF_TYPE_PADDING)
4140 goto again;
4141
4142 rb_advance_iter(iter);
4143 out:
4144 raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
4145
4146 return event;
4147}
4148EXPORT_SYMBOL_GPL(ring_buffer_read);
4149
4150
4151
4152
4153
4154unsigned long ring_buffer_size(struct ring_buffer *buffer, int cpu)
4155{
4156
4157
4158
4159
4160
4161
4162 if (!cpumask_test_cpu(cpu, buffer->cpumask))
4163 return 0;
4164
4165 return BUF_PAGE_SIZE * buffer->buffers[cpu]->nr_pages;
4166}
4167EXPORT_SYMBOL_GPL(ring_buffer_size);
4168
4169static void
4170rb_reset_cpu(struct ring_buffer_per_cpu *cpu_buffer)
4171{
4172 rb_head_page_deactivate(cpu_buffer);
4173
4174 cpu_buffer->head_page
4175 = list_entry(cpu_buffer->pages, struct buffer_page, list);
4176 local_set(&cpu_buffer->head_page->write, 0);
4177 local_set(&cpu_buffer->head_page->entries, 0);
4178 local_set(&cpu_buffer->head_page->page->commit, 0);
4179
4180 cpu_buffer->head_page->read = 0;
4181
4182 cpu_buffer->tail_page = cpu_buffer->head_page;
4183 cpu_buffer->commit_page = cpu_buffer->head_page;
4184
4185 INIT_LIST_HEAD(&cpu_buffer->reader_page->list);
4186 INIT_LIST_HEAD(&cpu_buffer->new_pages);
4187 local_set(&cpu_buffer->reader_page->write, 0);
4188 local_set(&cpu_buffer->reader_page->entries, 0);
4189 local_set(&cpu_buffer->reader_page->page->commit, 0);
4190 cpu_buffer->reader_page->read = 0;
4191
4192 local_set(&cpu_buffer->entries_bytes, 0);
4193 local_set(&cpu_buffer->overrun, 0);
4194 local_set(&cpu_buffer->commit_overrun, 0);
4195 local_set(&cpu_buffer->dropped_events, 0);
4196 local_set(&cpu_buffer->entries, 0);
4197 local_set(&cpu_buffer->committing, 0);
4198 local_set(&cpu_buffer->commits, 0);
4199 cpu_buffer->read = 0;
4200 cpu_buffer->read_bytes = 0;
4201
4202 cpu_buffer->write_stamp = 0;
4203 cpu_buffer->read_stamp = 0;
4204
4205 cpu_buffer->lost_events = 0;
4206 cpu_buffer->last_overrun = 0;
4207
4208 rb_head_page_activate(cpu_buffer);
4209}
4210
4211
4212
4213
4214
4215
4216void ring_buffer_reset_cpu(struct ring_buffer *buffer, int cpu)
4217{
4218 struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
4219 unsigned long flags;
4220
4221 if (!cpumask_test_cpu(cpu, buffer->cpumask))
4222 return;
4223
4224 atomic_inc(&buffer->resize_disabled);
4225 atomic_inc(&cpu_buffer->record_disabled);
4226
4227
4228 synchronize_sched();
4229
4230 raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
4231
4232 if (RB_WARN_ON(cpu_buffer, local_read(&cpu_buffer->committing)))
4233 goto out;
4234
4235 arch_spin_lock(&cpu_buffer->lock);
4236
4237 rb_reset_cpu(cpu_buffer);
4238
4239 arch_spin_unlock(&cpu_buffer->lock);
4240
4241 out:
4242 raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
4243
4244 atomic_dec(&cpu_buffer->record_disabled);
4245 atomic_dec(&buffer->resize_disabled);
4246}
4247EXPORT_SYMBOL_GPL(ring_buffer_reset_cpu);
4248
4249
4250
4251
4252
4253void ring_buffer_reset(struct ring_buffer *buffer)
4254{
4255 int cpu;
4256
4257 for_each_buffer_cpu(buffer, cpu)
4258 ring_buffer_reset_cpu(buffer, cpu);
4259}
4260EXPORT_SYMBOL_GPL(ring_buffer_reset);
4261
4262
4263
4264
4265
4266bool ring_buffer_empty(struct ring_buffer *buffer)
4267{
4268 struct ring_buffer_per_cpu *cpu_buffer;
4269 unsigned long flags;
4270 bool dolock;
4271 int cpu;
4272 int ret;
4273
4274
4275 for_each_buffer_cpu(buffer, cpu) {
4276 cpu_buffer = buffer->buffers[cpu];
4277 local_irq_save(flags);
4278 dolock = rb_reader_lock(cpu_buffer);
4279 ret = rb_per_cpu_empty(cpu_buffer);
4280 rb_reader_unlock(cpu_buffer, dolock);
4281 local_irq_restore(flags);
4282
4283 if (!ret)
4284 return false;
4285 }
4286
4287 return true;
4288}
4289EXPORT_SYMBOL_GPL(ring_buffer_empty);
4290
4291
4292
4293
4294
4295
4296bool ring_buffer_empty_cpu(struct ring_buffer *buffer, int cpu)
4297{
4298 struct ring_buffer_per_cpu *cpu_buffer;
4299 unsigned long flags;
4300 bool dolock;
4301 int ret;
4302
4303 if (!cpumask_test_cpu(cpu, buffer->cpumask))
4304 return true;
4305
4306 cpu_buffer = buffer->buffers[cpu];
4307 local_irq_save(flags);
4308 dolock = rb_reader_lock(cpu_buffer);
4309 ret = rb_per_cpu_empty(cpu_buffer);
4310 rb_reader_unlock(cpu_buffer, dolock);
4311 local_irq_restore(flags);
4312
4313 return ret;
4314}
4315EXPORT_SYMBOL_GPL(ring_buffer_empty_cpu);
4316
4317#ifdef CONFIG_RING_BUFFER_ALLOW_SWAP
4318
4319
4320
4321
4322
4323
4324
4325
4326
4327
4328int ring_buffer_swap_cpu(struct ring_buffer *buffer_a,
4329 struct ring_buffer *buffer_b, int cpu)
4330{
4331 struct ring_buffer_per_cpu *cpu_buffer_a;
4332 struct ring_buffer_per_cpu *cpu_buffer_b;
4333 int ret = -EINVAL;
4334
4335 if (!cpumask_test_cpu(cpu, buffer_a->cpumask) ||
4336 !cpumask_test_cpu(cpu, buffer_b->cpumask))
4337 goto out;
4338
4339 cpu_buffer_a = buffer_a->buffers[cpu];
4340 cpu_buffer_b = buffer_b->buffers[cpu];
4341
4342
4343 if (cpu_buffer_a->nr_pages != cpu_buffer_b->nr_pages)
4344 goto out;
4345
4346 ret = -EAGAIN;
4347
4348 if (atomic_read(&buffer_a->record_disabled))
4349 goto out;
4350
4351 if (atomic_read(&buffer_b->record_disabled))
4352 goto out;
4353
4354 if (atomic_read(&cpu_buffer_a->record_disabled))
4355 goto out;
4356
4357 if (atomic_read(&cpu_buffer_b->record_disabled))
4358 goto out;
4359
4360
4361
4362
4363
4364
4365
4366 atomic_inc(&cpu_buffer_a->record_disabled);
4367 atomic_inc(&cpu_buffer_b->record_disabled);
4368
4369 ret = -EBUSY;
4370 if (local_read(&cpu_buffer_a->committing))
4371 goto out_dec;
4372 if (local_read(&cpu_buffer_b->committing))
4373 goto out_dec;
4374
4375 buffer_a->buffers[cpu] = cpu_buffer_b;
4376 buffer_b->buffers[cpu] = cpu_buffer_a;
4377
4378 cpu_buffer_b->buffer = buffer_a;
4379 cpu_buffer_a->buffer = buffer_b;
4380
4381 ret = 0;
4382
4383out_dec:
4384 atomic_dec(&cpu_buffer_a->record_disabled);
4385 atomic_dec(&cpu_buffer_b->record_disabled);
4386out:
4387 return ret;
4388}
4389EXPORT_SYMBOL_GPL(ring_buffer_swap_cpu);
4390#endif
4391
4392
4393
4394
4395
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
4406
4407
4408void *ring_buffer_alloc_read_page(struct ring_buffer *buffer, int cpu)
4409{
4410 struct buffer_data_page *bpage;
4411 struct page *page;
4412
4413 page = alloc_pages_node(cpu_to_node(cpu),
4414 GFP_KERNEL | __GFP_NORETRY, 0);
4415 if (!page)
4416 return NULL;
4417
4418 bpage = page_address(page);
4419
4420 rb_init_page(bpage);
4421
4422 return bpage;
4423}
4424EXPORT_SYMBOL_GPL(ring_buffer_alloc_read_page);
4425
4426
4427
4428
4429
4430
4431
4432
4433void ring_buffer_free_read_page(struct ring_buffer *buffer, void *data)
4434{
4435 free_page((unsigned long)data);
4436}
4437EXPORT_SYMBOL_GPL(ring_buffer_free_read_page);
4438
4439
4440
4441
4442
4443
4444
4445
4446
4447
4448
4449
4450
4451
4452
4453
4454
4455
4456
4457
4458
4459
4460
4461
4462
4463
4464
4465
4466
4467
4468
4469
4470
4471
4472int ring_buffer_read_page(struct ring_buffer *buffer,
4473 void **data_page, size_t len, int cpu, int full)
4474{
4475 struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu];
4476 struct ring_buffer_event *event;
4477 struct buffer_data_page *bpage;
4478 struct buffer_page *reader;
4479 unsigned long missed_events;
4480 unsigned long flags;
4481 unsigned int commit;
4482 unsigned int read;
4483 u64 save_timestamp;
4484 int ret = -1;
4485
4486 if (!cpumask_test_cpu(cpu, buffer->cpumask))
4487 goto out;
4488
4489
4490
4491
4492
4493 if (len <= BUF_PAGE_HDR_SIZE)
4494 goto out;
4495
4496 len -= BUF_PAGE_HDR_SIZE;
4497
4498 if (!data_page)
4499 goto out;
4500
4501 bpage = *data_page;
4502 if (!bpage)
4503 goto out;
4504
4505 raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags);
4506
4507 reader = rb_get_reader_page(cpu_buffer);
4508 if (!reader)
4509 goto out_unlock;
4510
4511 event = rb_reader_event(cpu_buffer);
4512
4513 read = reader->read;
4514 commit = rb_page_commit(reader);
4515
4516
4517 missed_events = cpu_buffer->lost_events;
4518
4519
4520
4521
4522
4523
4524
4525
4526 if (read || (len < (commit - read)) ||
4527 cpu_buffer->reader_page == cpu_buffer->commit_page) {
4528 struct buffer_data_page *rpage = cpu_buffer->reader_page->page;
4529 unsigned int rpos = read;
4530 unsigned int pos = 0;
4531 unsigned int size;
4532
4533 if (full)
4534 goto out_unlock;
4535
4536 if (len > (commit - read))
4537 len = (commit - read);
4538
4539
4540 size = rb_event_ts_length(event);
4541
4542 if (len < size)
4543 goto out_unlock;
4544
4545
4546 save_timestamp = cpu_buffer->read_stamp;
4547
4548
4549 do {
4550
4551
4552
4553
4554
4555
4556 size = rb_event_length(event);
4557 memcpy(bpage->data + pos, rpage->data + rpos, size);
4558
4559 len -= size;
4560
4561 rb_advance_reader(cpu_buffer);
4562 rpos = reader->read;
4563 pos += size;
4564
4565 if (rpos >= commit)
4566 break;
4567
4568 event = rb_reader_event(cpu_buffer);
4569
4570 size = rb_event_ts_length(event);
4571 } while (len >= size);
4572
4573
4574 local_set(&bpage->commit, pos);
4575 bpage->time_stamp = save_timestamp;
4576
4577
4578 read = 0;
4579 } else {
4580
4581 cpu_buffer->read += rb_page_entries(reader);
4582 cpu_buffer->read_bytes += BUF_PAGE_SIZE;
4583
4584
4585 rb_init_page(bpage);
4586 bpage = reader->page;
4587 reader->page = *data_page;
4588 local_set(&reader->write, 0);
4589 local_set(&reader->entries, 0);
4590 reader->read = 0;
4591 *data_page = bpage;
4592
4593
4594
4595
4596
4597
4598 if (reader->real_end)
4599 local_set(&bpage->commit, reader->real_end);
4600 }
4601 ret = read;
4602
4603 cpu_buffer->lost_events = 0;
4604
4605 commit = local_read(&bpage->commit);
4606
4607
4608
4609 if (missed_events) {
4610
4611
4612
4613 if (BUF_PAGE_SIZE - commit >= sizeof(missed_events)) {
4614 memcpy(&bpage->data[commit], &missed_events,
4615 sizeof(missed_events));
4616 local_add(RB_MISSED_STORED, &bpage->commit);
4617 commit += sizeof(missed_events);
4618 }
4619 local_add(RB_MISSED_EVENTS, &bpage->commit);
4620 }
4621
4622
4623
4624
4625 if (commit < BUF_PAGE_SIZE)
4626 memset(&bpage->data[commit], 0, BUF_PAGE_SIZE - commit);
4627
4628 out_unlock:
4629 raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags);
4630
4631 out:
4632 return ret;
4633}
4634EXPORT_SYMBOL_GPL(ring_buffer_read_page);
4635
4636#ifdef CONFIG_HOTPLUG_CPU
4637static int rb_cpu_notify(struct notifier_block *self,
4638 unsigned long action, void *hcpu)
4639{
4640 struct ring_buffer *buffer =
4641 container_of(self, struct ring_buffer, cpu_notify);
4642 long cpu = (long)hcpu;
4643 int cpu_i, nr_pages_same;
4644 unsigned int nr_pages;
4645
4646 switch (action) {
4647 case CPU_UP_PREPARE:
4648 case CPU_UP_PREPARE_FROZEN:
4649 if (cpumask_test_cpu(cpu, buffer->cpumask))
4650 return NOTIFY_OK;
4651
4652 nr_pages = 0;
4653 nr_pages_same = 1;
4654
4655 for_each_buffer_cpu(buffer, cpu_i) {
4656
4657 if (nr_pages == 0)
4658 nr_pages = buffer->buffers[cpu_i]->nr_pages;
4659 if (nr_pages != buffer->buffers[cpu_i]->nr_pages) {
4660 nr_pages_same = 0;
4661 break;
4662 }
4663 }
4664
4665 if (!nr_pages_same)
4666 nr_pages = 2;
4667 buffer->buffers[cpu] =
4668 rb_allocate_cpu_buffer(buffer, nr_pages, cpu);
4669 if (!buffer->buffers[cpu]) {
4670 WARN(1, "failed to allocate ring buffer on CPU %ld\n",
4671 cpu);
4672 return NOTIFY_OK;
4673 }
4674 smp_wmb();
4675 cpumask_set_cpu(cpu, buffer->cpumask);
4676 break;
4677 case CPU_DOWN_PREPARE:
4678 case CPU_DOWN_PREPARE_FROZEN:
4679
4680
4681
4682
4683
4684 break;
4685 default:
4686 break;
4687 }
4688 return NOTIFY_OK;
4689}
4690#endif
4691
4692#ifdef CONFIG_RING_BUFFER_STARTUP_TEST
4693
4694
4695
4696
4697
4698
4699
4700
4701
4702
4703
4704
4705
4706
4707
4708static struct task_struct *rb_threads[NR_CPUS] __initdata;
4709
4710struct rb_test_data {
4711 struct ring_buffer *buffer;
4712 unsigned long events;
4713 unsigned long bytes_written;
4714 unsigned long bytes_alloc;
4715 unsigned long bytes_dropped;
4716 unsigned long events_nested;
4717 unsigned long bytes_written_nested;
4718 unsigned long bytes_alloc_nested;
4719 unsigned long bytes_dropped_nested;
4720 int min_size_nested;
4721 int max_size_nested;
4722 int max_size;
4723 int min_size;
4724 int cpu;
4725 int cnt;
4726};
4727
4728static struct rb_test_data rb_data[NR_CPUS] __initdata;
4729
4730
4731#define RB_TEST_BUFFER_SIZE 1048576
4732
4733static char rb_string[] __initdata =
4734 "abcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()?+\\"
4735 "?+|:';\",.<>/?abcdefghijklmnopqrstuvwxyz1234567890"
4736 "!@#$%^&*()?+\\?+|:';\",.<>/?abcdefghijklmnopqrstuv";
4737
4738static bool rb_test_started __initdata;
4739
4740struct rb_item {
4741 int size;
4742 char str[];
4743};
4744
4745static __init int rb_write_something(struct rb_test_data *data, bool nested)
4746{
4747 struct ring_buffer_event *event;
4748 struct rb_item *item;
4749 bool started;
4750 int event_len;
4751 int size;
4752 int len;
4753 int cnt;
4754
4755
4756 cnt = data->cnt + (nested ? 27 : 0);
4757
4758
4759 size = (data->cnt * 68 / 25) % (sizeof(rb_string) - 1);
4760
4761 len = size + sizeof(struct rb_item);
4762
4763 started = rb_test_started;
4764
4765 smp_rmb();
4766
4767 event = ring_buffer_lock_reserve(data->buffer, len);
4768 if (!event) {
4769
4770 if (started) {
4771 if (nested)
4772 data->bytes_dropped += len;
4773 else
4774 data->bytes_dropped_nested += len;
4775 }
4776 return len;
4777 }
4778
4779 event_len = ring_buffer_event_length(event);
4780
4781 if (RB_WARN_ON(data->buffer, event_len < len))
4782 goto out;
4783
4784 item = ring_buffer_event_data(event);
4785 item->size = size;
4786 memcpy(item->str, rb_string, size);
4787
4788 if (nested) {
4789 data->bytes_alloc_nested += event_len;
4790 data->bytes_written_nested += len;
4791 data->events_nested++;
4792 if (!data->min_size_nested || len < data->min_size_nested)
4793 data->min_size_nested = len;
4794 if (len > data->max_size_nested)
4795 data->max_size_nested = len;
4796 } else {
4797 data->bytes_alloc += event_len;
4798 data->bytes_written += len;
4799 data->events++;
4800 if (!data->min_size || len < data->min_size)
4801 data->max_size = len;
4802 if (len > data->max_size)
4803 data->max_size = len;
4804 }
4805
4806 out:
4807 ring_buffer_unlock_commit(data->buffer, event);
4808
4809 return 0;
4810}
4811
4812static __init int rb_test(void *arg)
4813{
4814 struct rb_test_data *data = arg;
4815
4816 while (!kthread_should_stop()) {
4817 rb_write_something(data, false);
4818 data->cnt++;
4819
4820 set_current_state(TASK_INTERRUPTIBLE);
4821
4822 usleep_range(((data->cnt % 3) + 1) * 100, 1000);
4823 }
4824
4825 return 0;
4826}
4827
4828static __init void rb_ipi(void *ignore)
4829{
4830 struct rb_test_data *data;
4831 int cpu = smp_processor_id();
4832
4833 data = &rb_data[cpu];
4834 rb_write_something(data, true);
4835}
4836
4837static __init int rb_hammer_test(void *arg)
4838{
4839 while (!kthread_should_stop()) {
4840
4841
4842 smp_call_function(rb_ipi, NULL, 1);
4843
4844 schedule();
4845 }
4846
4847 return 0;
4848}
4849
4850static __init int test_ringbuffer(void)
4851{
4852 struct task_struct *rb_hammer;
4853 struct ring_buffer *buffer;
4854 int cpu;
4855 int ret = 0;
4856
4857 pr_info("Running ring buffer tests...\n");
4858
4859 buffer = ring_buffer_alloc(RB_TEST_BUFFER_SIZE, RB_FL_OVERWRITE);
4860 if (WARN_ON(!buffer))
4861 return 0;
4862
4863
4864 ring_buffer_record_off(buffer);
4865
4866 for_each_online_cpu(cpu) {
4867 rb_data[cpu].buffer = buffer;
4868 rb_data[cpu].cpu = cpu;
4869 rb_data[cpu].cnt = cpu;
4870 rb_threads[cpu] = kthread_create(rb_test, &rb_data[cpu],
4871 "rbtester/%d", cpu);
4872 if (WARN_ON(!rb_threads[cpu])) {
4873 pr_cont("FAILED\n");
4874 ret = -1;
4875 goto out_free;
4876 }
4877
4878 kthread_bind(rb_threads[cpu], cpu);
4879 wake_up_process(rb_threads[cpu]);
4880 }
4881
4882
4883 rb_hammer = kthread_run(rb_hammer_test, NULL, "rbhammer");
4884 if (WARN_ON(!rb_hammer)) {
4885 pr_cont("FAILED\n");
4886 ret = -1;
4887 goto out_free;
4888 }
4889
4890 ring_buffer_record_on(buffer);
4891
4892
4893
4894
4895
4896
4897
4898
4899
4900 smp_wmb();
4901 rb_test_started = true;
4902
4903 set_current_state(TASK_INTERRUPTIBLE);
4904 ;
4905 schedule_timeout(10 * HZ);
4906
4907 kthread_stop(rb_hammer);
4908
4909 out_free:
4910 for_each_online_cpu(cpu) {
4911 if (!rb_threads[cpu])
4912 break;
4913 kthread_stop(rb_threads[cpu]);
4914 }
4915 if (ret) {
4916 ring_buffer_free(buffer);
4917 return ret;
4918 }
4919
4920
4921 pr_info("finished\n");
4922 for_each_online_cpu(cpu) {
4923 struct ring_buffer_event *event;
4924 struct rb_test_data *data = &rb_data[cpu];
4925 struct rb_item *item;
4926 unsigned long total_events;
4927 unsigned long total_dropped;
4928 unsigned long total_written;
4929 unsigned long total_alloc;
4930 unsigned long total_read = 0;
4931 unsigned long total_size = 0;
4932 unsigned long total_len = 0;
4933 unsigned long total_lost = 0;
4934 unsigned long lost;
4935 int big_event_size;
4936 int small_event_size;
4937
4938 ret = -1;
4939
4940 total_events = data->events + data->events_nested;
4941 total_written = data->bytes_written + data->bytes_written_nested;
4942 total_alloc = data->bytes_alloc + data->bytes_alloc_nested;
4943 total_dropped = data->bytes_dropped + data->bytes_dropped_nested;
4944
4945 big_event_size = data->max_size + data->max_size_nested;
4946 small_event_size = data->min_size + data->min_size_nested;
4947
4948 pr_info("CPU %d:\n", cpu);
4949 pr_info(" events: %ld\n", total_events);
4950 pr_info(" dropped bytes: %ld\n", total_dropped);
4951 pr_info(" alloced bytes: %ld\n", total_alloc);
4952 pr_info(" written bytes: %ld\n", total_written);
4953 pr_info(" biggest event: %d\n", big_event_size);
4954 pr_info(" smallest event: %d\n", small_event_size);
4955
4956 if (RB_WARN_ON(buffer, total_dropped))
4957 break;
4958
4959 ret = 0;
4960
4961 while ((event = ring_buffer_consume(buffer, cpu, NULL, &lost))) {
4962 total_lost += lost;
4963 item = ring_buffer_event_data(event);
4964 total_len += ring_buffer_event_length(event);
4965 total_size += item->size + sizeof(struct rb_item);
4966 if (memcmp(&item->str[0], rb_string, item->size) != 0) {
4967 pr_info("FAILED!\n");
4968 pr_info("buffer had: %.*s\n", item->size, item->str);
4969 pr_info("expected: %.*s\n", item->size, rb_string);
4970 RB_WARN_ON(buffer, 1);
4971 ret = -1;
4972 break;
4973 }
4974 total_read++;
4975 }
4976 if (ret)
4977 break;
4978
4979 ret = -1;
4980
4981 pr_info(" read events: %ld\n", total_read);
4982 pr_info(" lost events: %ld\n", total_lost);
4983 pr_info(" total events: %ld\n", total_lost + total_read);
4984 pr_info(" recorded len bytes: %ld\n", total_len);
4985 pr_info(" recorded size bytes: %ld\n", total_size);
4986 if (total_lost)
4987 pr_info(" With dropped events, record len and size may not match\n"
4988 " alloced and written from above\n");
4989 if (!total_lost) {
4990 if (RB_WARN_ON(buffer, total_len != total_alloc ||
4991 total_size != total_written))
4992 break;
4993 }
4994 if (RB_WARN_ON(buffer, total_lost + total_read != total_events))
4995 break;
4996
4997 ret = 0;
4998 }
4999 if (!ret)
5000 pr_info("Ring buffer PASSED!\n");
5001
5002 ring_buffer_free(buffer);
5003 return 0;
5004}
5005
5006late_initcall(test_ringbuffer);
5007#endif
5008