Merge tag 'trace-v6.1-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace

+1 -1

include/linux/ring_buffer.h

··· 100 100 101 101 int ring_buffer_wait(struct trace_buffer *buffer, int cpu, int full); 102 102 __poll_t ring_buffer_poll_wait(struct trace_buffer *buffer, int cpu, 103 - struct file *filp, poll_table *poll_table); 103 + struct file *filp, poll_table *poll_table, int full); 104 104 void ring_buffer_wake_waiters(struct trace_buffer *buffer, int cpu); 105 105 106 106 #define RING_BUFFER_ALL_CPUS -1

+2 -2

include/linux/trace.h

··· 26 26 int flags; 27 27 }; 28 28 29 + struct trace_array; 30 + 29 31 #ifdef CONFIG_TRACING 30 32 31 33 int register_ftrace_export(struct trace_export *export); 32 34 int unregister_ftrace_export(struct trace_export *export); 33 - 34 - struct trace_array; 35 35 36 36 void trace_printk_init_buffers(void); 37 37 __printf(3, 4)

+3 -2

kernel/trace/ftrace.c

··· 1289 1289 if (!ftrace_mod) 1290 1290 return -ENOMEM; 1291 1291 1292 + INIT_LIST_HEAD(&ftrace_mod->list); 1292 1293 ftrace_mod->func = kstrdup(func, GFP_KERNEL); 1293 1294 ftrace_mod->module = kstrdup(module, GFP_KERNEL); 1294 1295 ftrace_mod->enable = enable; ··· 3191 3190 /* if we can't allocate this size, try something smaller */ 3192 3191 if (!order) 3193 3192 return -ENOMEM; 3194 - order >>= 1; 3193 + order--; 3195 3194 goto again; 3196 3195 } 3197 3196 ··· 7392 7391 } 7393 7392 7394 7393 pr_info("ftrace: allocating %ld entries in %ld pages\n", 7395 - count, count / ENTRIES_PER_PAGE + 1); 7394 + count, DIV_ROUND_UP(count, ENTRIES_PER_PAGE)); 7396 7395 7397 7396 ret = ftrace_process_locs(NULL, 7398 7397 __start_mcount_loc,

+50 -21

kernel/trace/ring_buffer.c

··· 519 519 local_t committing; 520 520 local_t commits; 521 521 local_t pages_touched; 522 + local_t pages_lost; 522 523 local_t pages_read; 523 524 long last_pages_touch; 524 525 size_t shortest_full; ··· 895 894 size_t ring_buffer_nr_dirty_pages(struct trace_buffer *buffer, int cpu) 896 895 { 897 896 size_t read; 897 + size_t lost; 898 898 size_t cnt; 899 899 900 900 read = local_read(&buffer->buffers[cpu]->pages_read); 901 + lost = local_read(&buffer->buffers[cpu]->pages_lost); 901 902 cnt = local_read(&buffer->buffers[cpu]->pages_touched); 903 + 904 + if (WARN_ON_ONCE(cnt < lost)) 905 + return 0; 906 + 907 + cnt -= lost; 908 + 902 909 /* The reader can read an empty page, but not more than that */ 903 910 if (cnt < read) { 904 911 WARN_ON_ONCE(read > cnt + 1); ··· 914 905 } 915 906 916 907 return cnt - read; 908 + } 909 + 910 + static __always_inline bool full_hit(struct trace_buffer *buffer, int cpu, int full) 911 + { 912 + struct ring_buffer_per_cpu *cpu_buffer = buffer->buffers[cpu]; 913 + size_t nr_pages; 914 + size_t dirty; 915 + 916 + nr_pages = cpu_buffer->nr_pages; 917 + if (!nr_pages || !full) 918 + return true; 919 + 920 + dirty = ring_buffer_nr_dirty_pages(buffer, cpu); 921 + 922 + return (dirty * 100) > (full * nr_pages); 917 923 } 918 924 919 925 /* ··· 1070 1046 !ring_buffer_empty_cpu(buffer, cpu)) { 1071 1047 unsigned long flags; 1072 1048 bool pagebusy; 1073 - size_t nr_pages; 1074 - size_t dirty; 1049 + bool done; 1075 1050 1076 1051 if (!full) 1077 1052 break; 1078 1053 1079 1054 raw_spin_lock_irqsave(&cpu_buffer->reader_lock, flags); 1080 1055 pagebusy = cpu_buffer->reader_page == cpu_buffer->commit_page; 1081 - nr_pages = cpu_buffer->nr_pages; 1082 - dirty = ring_buffer_nr_dirty_pages(buffer, cpu); 1056 + done = !pagebusy && full_hit(buffer, cpu, full); 1057 + 1083 1058 if (!cpu_buffer->shortest_full || 1084 1059 cpu_buffer->shortest_full > full) 1085 1060 cpu_buffer->shortest_full = full; 1086 1061 raw_spin_unlock_irqrestore(&cpu_buffer->reader_lock, flags); 1087 - if (!pagebusy && 1088 - (!nr_pages || (dirty * 100) > full * nr_pages)) 1062 + if (done) 1089 1063 break; 1090 1064 } 1091 1065 ··· 1109 1087 * @cpu: the cpu buffer to wait on 1110 1088 * @filp: the file descriptor 1111 1089 * @poll_table: The poll descriptor 1090 + * @full: wait until the percentage of pages are available, if @cpu != RING_BUFFER_ALL_CPUS 1112 1091 * 1113 1092 * If @cpu == RING_BUFFER_ALL_CPUS then the task will wake up as soon 1114 1093 * as data is added to any of the @buffer's cpu buffers. Otherwise ··· 1119 1096 * zero otherwise. 1120 1097 */ 1121 1098 __poll_t ring_buffer_poll_wait(struct trace_buffer *buffer, int cpu, 1122 - struct file *filp, poll_table *poll_table) 1099 + struct file *filp, poll_table *poll_table, int full) 1123 1100 { 1124 1101 struct ring_buffer_per_cpu *cpu_buffer; 1125 1102 struct rb_irq_work *work; 1126 1103 1127 - if (cpu == RING_BUFFER_ALL_CPUS) 1104 + if (cpu == RING_BUFFER_ALL_CPUS) { 1128 1105 work = &buffer->irq_work; 1129 - else { 1106 + full = 0; 1107 + } else { 1130 1108 if (!cpumask_test_cpu(cpu, buffer->cpumask)) 1131 1109 return -EINVAL; 1132 1110 ··· 1135 1111 work = &cpu_buffer->irq_work; 1136 1112 } 1137 1113 1138 - poll_wait(filp, &work->waiters, poll_table); 1139 - work->waiters_pending = true; 1114 + if (full) { 1115 + poll_wait(filp, &work->full_waiters, poll_table); 1116 + work->full_waiters_pending = true; 1117 + } else { 1118 + poll_wait(filp, &work->waiters, poll_table); 1119 + work->waiters_pending = true; 1120 + } 1121 + 1140 1122 /* 1141 1123 * There's a tight race between setting the waiters_pending and 1142 1124 * checking if the ring buffer is empty. Once the waiters_pending bit ··· 1157 1127 * will fix it later. 1158 1128 */ 1159 1129 smp_mb(); 1130 + 1131 + if (full) 1132 + return full_hit(buffer, cpu, full) ? EPOLLIN | EPOLLRDNORM : 0; 1160 1133 1161 1134 if ((cpu == RING_BUFFER_ALL_CPUS && !ring_buffer_empty(buffer)) || 1162 1135 (cpu != RING_BUFFER_ALL_CPUS && !ring_buffer_empty_cpu(buffer, cpu))) ··· 1802 1769 1803 1770 free_buffer_page(cpu_buffer->reader_page); 1804 1771 1805 - rb_head_page_deactivate(cpu_buffer); 1806 - 1807 1772 if (head) { 1773 + rb_head_page_deactivate(cpu_buffer); 1774 + 1808 1775 list_for_each_entry_safe(bpage, tmp, head, list) { 1809 1776 list_del_init(&bpage->list); 1810 1777 free_buffer_page(bpage); ··· 2040 2007 */ 2041 2008 local_add(page_entries, &cpu_buffer->overrun); 2042 2009 local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes); 2010 + local_inc(&cpu_buffer->pages_lost); 2043 2011 } 2044 2012 2045 2013 /* ··· 2525 2491 */ 2526 2492 local_add(entries, &cpu_buffer->overrun); 2527 2493 local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes); 2494 + local_inc(&cpu_buffer->pages_lost); 2528 2495 2529 2496 /* 2530 2497 * The entries will be zeroed out when we move the ··· 3190 3155 static __always_inline void 3191 3156 rb_wakeups(struct trace_buffer *buffer, struct ring_buffer_per_cpu *cpu_buffer) 3192 3157 { 3193 - size_t nr_pages; 3194 - size_t dirty; 3195 - size_t full; 3196 - 3197 3158 if (buffer->irq_work.waiters_pending) { 3198 3159 buffer->irq_work.waiters_pending = false; 3199 3160 /* irq_work_queue() supplies it's own memory barriers */ ··· 3213 3182 3214 3183 cpu_buffer->last_pages_touch = local_read(&cpu_buffer->pages_touched); 3215 3184 3216 - full = cpu_buffer->shortest_full; 3217 - nr_pages = cpu_buffer->nr_pages; 3218 - dirty = ring_buffer_nr_dirty_pages(buffer, cpu_buffer->cpu); 3219 - if (full && nr_pages && (dirty * 100) <= full * nr_pages) 3185 + if (!full_hit(buffer, cpu_buffer->cpu, cpu_buffer->shortest_full)) 3220 3186 return; 3221 3187 3222 3188 cpu_buffer->irq_work.wakeup_full = true; ··· 5276 5248 local_set(&cpu_buffer->committing, 0); 5277 5249 local_set(&cpu_buffer->commits, 0); 5278 5250 local_set(&cpu_buffer->pages_touched, 0); 5251 + local_set(&cpu_buffer->pages_lost, 0); 5279 5252 local_set(&cpu_buffer->pages_read, 0); 5280 5253 cpu_buffer->last_pages_touch = 0; 5281 5254 cpu_buffer->shortest_full = 0;

+6 -10

kernel/trace/synth_event_gen_test.c

··· 120 120 121 121 /* Now generate a gen_synth_test event */ 122 122 ret = synth_event_trace_array(gen_synth_test, vals, ARRAY_SIZE(vals)); 123 - out: 123 + free: 124 + kfree(buf); 124 125 return ret; 125 126 delete: 126 127 /* We got an error after creating the event, delete it */ 127 128 synth_event_delete("gen_synth_test"); 128 - free: 129 - kfree(buf); 130 - 131 - goto out; 129 + goto free; 132 130 } 133 131 134 132 /* ··· 225 227 226 228 /* Now trace an empty_synth_test event */ 227 229 ret = synth_event_trace_array(empty_synth_test, vals, ARRAY_SIZE(vals)); 228 - out: 230 + free: 231 + kfree(buf); 229 232 return ret; 230 233 delete: 231 234 /* We got an error after creating the event, delete it */ 232 235 synth_event_delete("empty_synth_test"); 233 - free: 234 - kfree(buf); 235 - 236 - goto out; 236 + goto free; 237 237 } 238 238 239 239 static struct synth_field_desc create_synth_test_fields[] = {

+7 -5

kernel/trace/trace.c

··· 6657 6657 mutex_unlock(&trace_types_lock); 6658 6658 6659 6659 free_cpumask_var(iter->started); 6660 + kfree(iter->fmt); 6660 6661 mutex_destroy(&iter->mutex); 6661 6662 kfree(iter); 6662 6663 ··· 6682 6681 return EPOLLIN | EPOLLRDNORM; 6683 6682 else 6684 6683 return ring_buffer_poll_wait(iter->array_buffer->buffer, iter->cpu_file, 6685 - filp, poll_table); 6684 + filp, poll_table, iter->tr->buffer_percent); 6686 6685 } 6687 6686 6688 6687 static __poll_t ··· 7803 7802 int len) 7804 7803 { 7805 7804 struct tracing_log_err *err; 7805 + char *cmd; 7806 7806 7807 7807 if (tr->n_err_log_entries < TRACING_LOG_ERRS_MAX) { 7808 7808 err = alloc_tracing_log_err(len); ··· 7812 7810 7813 7811 return err; 7814 7812 } 7815 - 7813 + cmd = kzalloc(len, GFP_KERNEL); 7814 + if (!cmd) 7815 + return ERR_PTR(-ENOMEM); 7816 7816 err = list_first_entry(&tr->err_log, struct tracing_log_err, list); 7817 7817 kfree(err->cmd); 7818 - err->cmd = kzalloc(len, GFP_KERNEL); 7819 - if (!err->cmd) 7820 - return ERR_PTR(-ENOMEM); 7818 + err->cmd = cmd; 7821 7819 list_del(&err->list); 7822 7820 7823 7821 return err;

+3

kernel/trace/trace_eprobe.c

··· 563 563 { 564 564 struct eprobe_data *edata = data->private_data; 565 565 566 + if (unlikely(!rec)) 567 + return; 568 + 566 569 __eprobe_trace_func(edata, rec); 567 570 } 568 571

+2 -3

kernel/trace/trace_events_synth.c

··· 828 828 } 829 829 830 830 ret = set_synth_event_print_fmt(call); 831 - if (ret < 0) { 831 + /* unregister_trace_event() will be called inside */ 832 + if (ret < 0) 832 833 trace_remove_event_call(call); 833 - goto err; 834 - } 835 834 out: 836 835 return ret; 837 836 err:

-2

kernel/trace/trace_syscalls.c

··· 201 201 return trace_handle_return(s); 202 202 } 203 203 204 - extern char *__bad_type_size(void); 205 - 206 204 #define SYSCALL_FIELD(_type, _name) { \ 207 205 .type = #_type, .name = #_name, \ 208 206 .size = sizeof(_type), .align = __alignof__(_type), \

Configure Feed

Configure Feed