ring_buffer.h 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214
  1. /* SPDX-License-Identifier: GPL-2.0 */
  2. #ifndef _LINUX_RING_BUFFER_H
  3. #define _LINUX_RING_BUFFER_H
  4. #include <linux/mm.h>
  5. #include <linux/seq_file.h>
  6. #include <linux/poll.h>
  7. struct trace_buffer;
  8. struct ring_buffer_iter;
  9. /*
  10. * Don't refer to this struct directly, use functions below.
  11. */
  12. struct ring_buffer_event {
  13. u32 type_len:5, time_delta:27;
  14. u32 array[];
  15. };
  16. /**
  17. * enum ring_buffer_type - internal ring buffer types
  18. *
  19. * @RINGBUF_TYPE_PADDING: Left over page padding or discarded event
  20. * If time_delta is 0:
  21. * array is ignored
  22. * size is variable depending on how much
  23. * padding is needed
  24. * If time_delta is non zero:
  25. * array[0] holds the actual length
  26. * size = 4 + length (bytes)
  27. *
  28. * @RINGBUF_TYPE_TIME_EXTEND: Extend the time delta
  29. * array[0] = time delta (28 .. 59)
  30. * size = 8 bytes
  31. *
  32. * @RINGBUF_TYPE_TIME_STAMP: Absolute timestamp
  33. * Same format as TIME_EXTEND except that the
  34. * value is an absolute timestamp, not a delta
  35. * event.time_delta contains bottom 27 bits
  36. * array[0] = top (28 .. 59) bits
  37. * size = 8 bytes
  38. *
  39. * <= @RINGBUF_TYPE_DATA_TYPE_LEN_MAX:
  40. * Data record
  41. * If type_len is zero:
  42. * array[0] holds the actual length
  43. * array[1..(length+3)/4] holds data
  44. * size = 4 + length (bytes)
  45. * else
  46. * length = type_len << 2
  47. * array[0..(length+3)/4-1] holds data
  48. * size = 4 + length (bytes)
  49. */
  50. enum ring_buffer_type {
  51. RINGBUF_TYPE_DATA_TYPE_LEN_MAX = 28,
  52. RINGBUF_TYPE_PADDING,
  53. RINGBUF_TYPE_TIME_EXTEND,
  54. RINGBUF_TYPE_TIME_STAMP,
  55. };
  56. unsigned ring_buffer_event_length(struct ring_buffer_event *event);
  57. void *ring_buffer_event_data(struct ring_buffer_event *event);
  58. u64 ring_buffer_event_time_stamp(struct ring_buffer_event *event);
  59. /*
  60. * ring_buffer_discard_commit will remove an event that has not
  61. * been committed yet. If this is used, then ring_buffer_unlock_commit
  62. * must not be called on the discarded event. This function
  63. * will try to remove the event from the ring buffer completely
  64. * if another event has not been written after it.
  65. *
  66. * Example use:
  67. *
  68. * if (some_condition)
  69. * ring_buffer_discard_commit(buffer, event);
  70. * else
  71. * ring_buffer_unlock_commit(buffer, event);
  72. */
  73. void ring_buffer_discard_commit(struct trace_buffer *buffer,
  74. struct ring_buffer_event *event);
  75. /*
  76. * size is in bytes for each per CPU buffer.
  77. */
  78. struct trace_buffer *
  79. __ring_buffer_alloc(unsigned long size, unsigned flags, struct lock_class_key *key);
  80. /*
  81. * Because the ring buffer is generic, if other users of the ring buffer get
  82. * traced by ftrace, it can produce lockdep warnings. We need to keep each
  83. * ring buffer's lock class separate.
  84. */
  85. #define ring_buffer_alloc(size, flags) \
  86. ({ \
  87. static struct lock_class_key __key; \
  88. __ring_buffer_alloc((size), (flags), &__key); \
  89. })
  90. int ring_buffer_wait(struct trace_buffer *buffer, int cpu, int full);
  91. __poll_t ring_buffer_poll_wait(struct trace_buffer *buffer, int cpu,
  92. struct file *filp, poll_table *poll_table);
  93. #define RING_BUFFER_ALL_CPUS -1
  94. void ring_buffer_free(struct trace_buffer *buffer);
  95. int ring_buffer_resize(struct trace_buffer *buffer, unsigned long size, int cpu);
  96. void ring_buffer_change_overwrite(struct trace_buffer *buffer, int val);
  97. struct ring_buffer_event *ring_buffer_lock_reserve(struct trace_buffer *buffer,
  98. unsigned long length);
  99. int ring_buffer_unlock_commit(struct trace_buffer *buffer,
  100. struct ring_buffer_event *event);
  101. int ring_buffer_write(struct trace_buffer *buffer,
  102. unsigned long length, void *data);
  103. void ring_buffer_nest_start(struct trace_buffer *buffer);
  104. void ring_buffer_nest_end(struct trace_buffer *buffer);
  105. struct ring_buffer_event *
  106. ring_buffer_peek(struct trace_buffer *buffer, int cpu, u64 *ts,
  107. unsigned long *lost_events);
  108. struct ring_buffer_event *
  109. ring_buffer_consume(struct trace_buffer *buffer, int cpu, u64 *ts,
  110. unsigned long *lost_events);
  111. struct ring_buffer_iter *
  112. ring_buffer_read_prepare(struct trace_buffer *buffer, int cpu, gfp_t flags);
  113. void ring_buffer_read_prepare_sync(void);
  114. void ring_buffer_read_start(struct ring_buffer_iter *iter);
  115. void ring_buffer_read_finish(struct ring_buffer_iter *iter);
  116. struct ring_buffer_event *
  117. ring_buffer_iter_peek(struct ring_buffer_iter *iter, u64 *ts);
  118. void ring_buffer_iter_advance(struct ring_buffer_iter *iter);
  119. void ring_buffer_iter_reset(struct ring_buffer_iter *iter);
  120. int ring_buffer_iter_empty(struct ring_buffer_iter *iter);
  121. bool ring_buffer_iter_dropped(struct ring_buffer_iter *iter);
  122. unsigned long ring_buffer_size(struct trace_buffer *buffer, int cpu);
  123. void ring_buffer_reset_cpu(struct trace_buffer *buffer, int cpu);
  124. void ring_buffer_reset_online_cpus(struct trace_buffer *buffer);
  125. void ring_buffer_reset(struct trace_buffer *buffer);
  126. #ifdef CONFIG_RING_BUFFER_ALLOW_SWAP
  127. int ring_buffer_swap_cpu(struct trace_buffer *buffer_a,
  128. struct trace_buffer *buffer_b, int cpu);
  129. #else
  130. static inline int
  131. ring_buffer_swap_cpu(struct trace_buffer *buffer_a,
  132. struct trace_buffer *buffer_b, int cpu)
  133. {
  134. return -ENODEV;
  135. }
  136. #endif
  137. bool ring_buffer_empty(struct trace_buffer *buffer);
  138. bool ring_buffer_empty_cpu(struct trace_buffer *buffer, int cpu);
  139. void ring_buffer_record_disable(struct trace_buffer *buffer);
  140. void ring_buffer_record_enable(struct trace_buffer *buffer);
  141. void ring_buffer_record_off(struct trace_buffer *buffer);
  142. void ring_buffer_record_on(struct trace_buffer *buffer);
  143. bool ring_buffer_record_is_on(struct trace_buffer *buffer);
  144. bool ring_buffer_record_is_set_on(struct trace_buffer *buffer);
  145. void ring_buffer_record_disable_cpu(struct trace_buffer *buffer, int cpu);
  146. void ring_buffer_record_enable_cpu(struct trace_buffer *buffer, int cpu);
  147. u64 ring_buffer_oldest_event_ts(struct trace_buffer *buffer, int cpu);
  148. unsigned long ring_buffer_bytes_cpu(struct trace_buffer *buffer, int cpu);
  149. unsigned long ring_buffer_entries(struct trace_buffer *buffer);
  150. unsigned long ring_buffer_overruns(struct trace_buffer *buffer);
  151. unsigned long ring_buffer_entries_cpu(struct trace_buffer *buffer, int cpu);
  152. unsigned long ring_buffer_overrun_cpu(struct trace_buffer *buffer, int cpu);
  153. unsigned long ring_buffer_commit_overrun_cpu(struct trace_buffer *buffer, int cpu);
  154. unsigned long ring_buffer_dropped_events_cpu(struct trace_buffer *buffer, int cpu);
  155. unsigned long ring_buffer_read_events_cpu(struct trace_buffer *buffer, int cpu);
  156. u64 ring_buffer_time_stamp(struct trace_buffer *buffer, int cpu);
  157. void ring_buffer_normalize_time_stamp(struct trace_buffer *buffer,
  158. int cpu, u64 *ts);
  159. void ring_buffer_set_clock(struct trace_buffer *buffer,
  160. u64 (*clock)(void));
  161. void ring_buffer_set_time_stamp_abs(struct trace_buffer *buffer, bool abs);
  162. bool ring_buffer_time_stamp_abs(struct trace_buffer *buffer);
  163. size_t ring_buffer_nr_pages(struct trace_buffer *buffer, int cpu);
  164. size_t ring_buffer_nr_dirty_pages(struct trace_buffer *buffer, int cpu);
  165. void *ring_buffer_alloc_read_page(struct trace_buffer *buffer, int cpu);
  166. void ring_buffer_free_read_page(struct trace_buffer *buffer, int cpu, void *data);
  167. int ring_buffer_read_page(struct trace_buffer *buffer, void **data_page,
  168. size_t len, int cpu, int full);
  169. struct trace_seq;
  170. int ring_buffer_print_entry_header(struct trace_seq *s);
  171. int ring_buffer_print_page_header(struct trace_seq *s);
  172. enum ring_buffer_flags {
  173. RB_FL_OVERWRITE = 1 << 0,
  174. };
  175. #ifdef CONFIG_RING_BUFFER
  176. int trace_rb_cpu_prepare(unsigned int cpu, struct hlist_node *node);
  177. #else
  178. #define trace_rb_cpu_prepare NULL
  179. #endif
  180. #endif /* _LINUX_RING_BUFFER_H */