History

tracing: Save off entry when peeking at next entry

In order to have the iterator read the buffer even when it's still updating, it requires that the ring buffer iterator saves each event in a separate location outside the ring buffer such that its use is immutable. There's one use case that saves off the event returned from the ring buffer interator and calls it again to look at the next event, before going back to use the first event. As the ring buffer iterator will only have a single copy, this use case will no longer be supported. Instead, have the one use case create its own buffer to store the first event when looking at the next event. This way, when looking at the first event again, it wont be corrupted by the second read. Link: http://lkml.kernel.org/r/20200317213415.722539921@goodmis.org

Steven Rostedt (VMware) committed 6 years ago

Commit ff895101 parent 8c77f0b3 files · +47 −10Browse files

Unified · Split

3 files
  1. include/linux/trace_events.h +2 −0
  2. kernel/trace/trace.c +39 −1
  3. kernel/trace/trace_output.c +6 −9
include/linux/trace_events.h+2−0
@@ -85,6 +85,8 @@ struct trace_iterator { · 84 unmodified lines
85 struct mutex mutex;85 struct mutex mutex;
86 struct ring_buffer_iter **buffer_iter;86 struct ring_buffer_iter **buffer_iter;
87 unsigned long iter_flags;87 unsigned long iter_flags;
88 void *temp; /* temp holder */
89 unsigned int temp_size;
88 90
89 /* trace_seq for __print_flags() and __print_symbolic() etc. */91 /* trace_seq for __print_flags() and __print_symbolic() etc. */
90 struct trace_seq tmp_seq;92 struct trace_seq tmp_seq;
kernel/trace/trace.c+39−1
@@ -3466,7 +3466,31 @@ __find_next_entry(struct trace_iterator *iter, int *ent_cpu, · 3465 unmodified lines
3466struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,3466struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
3467 int *ent_cpu, u64 *ent_ts)3467 int *ent_cpu, u64 *ent_ts)
3468{3468{
3469 return __find_next_entry(iter, ent_cpu, NULL, ent_ts);3469 /* __find_next_entry will reset ent_size */
3470 int ent_size = iter->ent_size;
3471 struct trace_entry *entry;
3472
3473 /*
3474 * The __find_next_entry() may call peek_next_entry(), which may
3475 * call ring_buffer_peek() that may make the contents of iter->ent
3476 * undefined. Need to copy iter->ent now.
3477 */
3478 if (iter->ent && iter->ent != iter->temp) {
3479 if (!iter->temp || iter->temp_size < iter->ent_size) {
3480 kfree(iter->temp);
3481 iter->temp = kmalloc(iter->ent_size, GFP_KERNEL);
3482 if (!iter->temp)
3483 return NULL;
3484 }
3485 memcpy(iter->temp, iter->ent, iter->ent_size);
3486 iter->temp_size = iter->ent_size;
3487 iter->ent = iter->temp;
3488 }
3489 entry = __find_next_entry(iter, ent_cpu, NULL, ent_ts);
3490 /* Put back the original ent_size */
3491 iter->ent_size = ent_size;
3492
3493 return entry;
3470}3494}
3471 3495
3472/* Find the next real entry, and increment the iterator to the next entry */3496/* Find the next real entry, and increment the iterator to the next entry */
@@ -4197,6 +4221,18 @@ __tracing_open(struct inode *inode, struct file *file, bool snapshot) · 724 unmodified lines
4197 if (!iter->buffer_iter)4221 if (!iter->buffer_iter)
4198 goto release;4222 goto release;
4199 4223
4224 /*
4225 * trace_find_next_entry() may need to save off iter->ent.
4226 * It will place it into the iter->temp buffer. As most
4227 * events are less than 128, allocate a buffer of that size.
4228 * If one is greater, then trace_find_next_entry() will
4229 * allocate a new buffer to adjust for the bigger iter->ent.
4230 * It's not critical if it fails to get allocated here.
4231 */
4232 iter->temp = kmalloc(128, GFP_KERNEL);
4233 if (iter->temp)
4234 iter->temp_size = 128;
4235
4200 /*4236 /*
4201 * We make a copy of the current tracer to avoid concurrent4237 * We make a copy of the current tracer to avoid concurrent
4202 * changes on it while we are reading.4238 * changes on it while we are reading.
@@ -4269,6 +4305,7 @@ __tracing_open(struct inode *inode, struct file *file, bool snapshot) · 66 unmodified lines
4269 fail:4305 fail:
4270 mutex_unlock(&trace_types_lock);4306 mutex_unlock(&trace_types_lock);
4271 kfree(iter->trace);4307 kfree(iter->trace);
4308 kfree(iter->temp);
4272 kfree(iter->buffer_iter);4309 kfree(iter->buffer_iter);
4273release:4310release:
4274 seq_release_private(inode, file);4311 seq_release_private(inode, file);
@@ -4344,6 +4381,7 @@ static int tracing_release(struct inode *inode, struct file *file) · 69 unmodified lines
4344 4381
4345 mutex_destroy(&iter->mutex);4382 mutex_destroy(&iter->mutex);
4346 free_cpumask_var(iter->started);4383 free_cpumask_var(iter->started);
4384 kfree(iter->temp);
4347 kfree(iter->trace);4385 kfree(iter->trace);
4348 kfree(iter->buffer_iter);4386 kfree(iter->buffer_iter);
4349 seq_release_private(inode, file);4387 seq_release_private(inode, file);
kernel/trace/trace_output.c+6−9
@@ -617,22 +617,19 @@ int trace_print_context(struct trace_iterator *iter) · 616 unmodified lines
617 617
618int trace_print_lat_context(struct trace_iterator *iter)618int trace_print_lat_context(struct trace_iterator *iter)
619{619{
620 struct trace_entry *entry, *next_entry;
620 struct trace_array *tr = iter->tr;621 struct trace_array *tr = iter->tr;
621 /* trace_find_next_entry will reset ent_size */
622 int ent_size = iter->ent_size;
623 struct trace_seq *s = &iter->seq;622 struct trace_seq *s = &iter->seq;
624 u64 next_ts;
625 struct trace_entry *entry = iter->ent,
626 *next_entry = trace_find_next_entry(iter, NULL,
627 &next_ts);
628 unsigned long verbose = (tr->trace_flags & TRACE_ITER_VERBOSE);623 unsigned long verbose = (tr->trace_flags & TRACE_ITER_VERBOSE);
624 u64 next_ts;
629 625
630 /* Restore the original ent_size */626 next_entry = trace_find_next_entry(iter, NULL, &next_ts);
631 iter->ent_size = ent_size;
632
633 if (!next_entry)627 if (!next_entry)
634 next_ts = iter->ts;628 next_ts = iter->ts;
635 629
630 /* trace_find_next_entry() may change iter->ent */
631 entry = iter->ent;
632
636 if (verbose) {633 if (verbose) {
637 char comm[TASK_COMM_LEN];634 char comm[TASK_COMM_LEN];
638 635

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t