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

Pull tracing fixes from Steven Rostedt: - Fix the "bytes" output of the per_cpu stat file The tracefs/per_cpu/cpu*/stats "bytes" was giving bogus values as the accounting was not accurate. It is suppose to show how many used bytes are still in the ring buffer, but even when the ring buffer was empty it would still show there were bytes used. - Fix a bug in eventfs where reading a dynamic event directory (open) and then creating a dynamic event that goes into that diretory screws up the accounting. On close, the newly created event dentry will get a "dput" without ever having a "dget" done for it. The fix is to allocate an array on dir open to save what dentries were actually "dget" on, and what ones to "dput" on close. * tag 'trace-v6.6-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace: eventfs: Remember what dentries were created on dir open ring-buffer: Fix bytes info in per_cpu buffer stats

Linus Torvalds committed 3 years ago

Commit 5edc6bb2 parents 2ad78f8 ef36b4f2 files · +85 −30Browse files

Unified · Split

2 files

fs/tracefs/event_inode.c +70 −17
kernel/trace/ring_buffer.c +15 −13

fs/tracefs/event_inode.c+70−17

@@ -70,6 +70,7 @@ static struct dentry eventfs_root_lookup(struct inode dir, · 69 unmodified lines
70	struct dentry *dentry,	70	struct dentry *dentry,
71	unsigned int flags);	71	unsigned int flags);
72	static int dcache_dir_open_wrapper(struct inode inode, struct file file);	72	static int dcache_dir_open_wrapper(struct inode inode, struct file file);
		73	static int dcache_readdir_wrapper(struct file file, struct dir_context ctx);
73	static int eventfs_release(struct inode inode, struct file file);	74	static int eventfs_release(struct inode inode, struct file file);
74		75
75	static const struct inode_operations eventfs_root_dir_inode_operations = {	76	static const struct inode_operations eventfs_root_dir_inode_operations = {
@@ -79,7 +80,7 @@ static const struct inode_operations eventfs_root_dir_inode_operations = { · 3 unmodified lines
79	static const struct file_operations eventfs_file_operations = {	80	static const struct file_operations eventfs_file_operations = {
80	.open = dcache_dir_open_wrapper,	81	.open = dcache_dir_open_wrapper,
81	.read = generic_read_dir,	82	.read = generic_read_dir,
82	.iterate_shared = dcache_readdir,	83	.iterate_shared = dcache_readdir_wrapper,
83	.llseek = generic_file_llseek,	84	.llseek = generic_file_llseek,
84	.release = eventfs_release,	85	.release = eventfs_release,
85	};	86	};
@@ -396,6 +397,11 @@ static struct dentry eventfs_root_lookup(struct inode dir, · 310 unmodified lines
396	return ret;	397	return ret;
397	}	398	}
398		399
		400	struct dentry_list {
		401	void *cursor;
		402	struct dentry **dentries;
		403	};
		404
399	/**	405	/**
400	* eventfs_release - called to release eventfs file/dir	406	* eventfs_release - called to release eventfs file/dir
401	* @inode: inode to be released	407	* @inode: inode to be released
@@ -404,26 +410,25 @@ static struct dentry eventfs_root_lookup(struct inode dir, · 2 unmodified lines
404	static int eventfs_release(struct inode inode, struct file file)	410	static int eventfs_release(struct inode inode, struct file file)
405	{	411	{
406	struct tracefs_inode *ti;	412	struct tracefs_inode *ti;
407	struct eventfs_inode *ei;	413	struct dentry_list *dlist = file->private_data;
408	struct eventfs_file *ef;	414	void *cursor;
409	struct dentry *dentry;	415	int i;
410	int idx;
411		416
412	ti = get_tracefs(inode);	417	ti = get_tracefs(inode);
413	if (!(ti->flags & TRACEFS_EVENT_INODE))	418	if (!(ti->flags & TRACEFS_EVENT_INODE))
414	return -EINVAL;	419	return -EINVAL;
415		420
416	ei = ti->private;	421	if (WARN_ON_ONCE(!dlist))
417	idx = srcu_read_lock(&eventfs_srcu);	422	return -EINVAL;
418	list_for_each_entry_srcu(ef, &ei->e_top_files, list,	423
419	srcu_read_lock_held(&eventfs_srcu)) {	424	for (i = 0; dlist->dentries[i]; i++) {
420	mutex_lock(&eventfs_mutex);	425	dput(dlist->dentries[i]);
421	dentry = ef->dentry;
422	mutex_unlock(&eventfs_mutex);
423	if (dentry)
424	dput(dentry);
425	}	426	}
426	srcu_read_unlock(&eventfs_srcu, idx);	427
		428	cursor = dlist->cursor;
		429	kfree(dlist->dentries);
		430	kfree(dlist);
		431	file->private_data = cursor;
427	return dcache_dir_close(inode, file);	432	return dcache_dir_close(inode, file);
428	}	433	}
429		434
@@ -442,22 +447,70 @@ static int dcache_dir_open_wrapper(struct inode inode, struct file file) · 12 unmodified lines
442	struct tracefs_inode *ti;	447	struct tracefs_inode *ti;
443	struct eventfs_inode *ei;	448	struct eventfs_inode *ei;
444	struct eventfs_file *ef;	449	struct eventfs_file *ef;
		450	struct dentry_list *dlist;
		451	struct dentry **dentries = NULL;
445	struct dentry *dentry = file_dentry(file);	452	struct dentry *dentry = file_dentry(file);
		453	struct dentry *d;
446	struct inode *f_inode = file_inode(file);	454	struct inode *f_inode = file_inode(file);
		455	int cnt = 0;
447	int idx;	456	int idx;
		457	int ret;
448		458
449	ti = get_tracefs(f_inode);	459	ti = get_tracefs(f_inode);
450	if (!(ti->flags & TRACEFS_EVENT_INODE))	460	if (!(ti->flags & TRACEFS_EVENT_INODE))
451	return -EINVAL;	461	return -EINVAL;
452		462
		463	if (WARN_ON_ONCE(file->private_data))
		464	return -EINVAL;
		465
		466	dlist = kmalloc(sizeof(*dlist), GFP_KERNEL);
		467	if (!dlist)
		468	return -ENOMEM;
		469
453	ei = ti->private;	470	ei = ti->private;
454	idx = srcu_read_lock(&eventfs_srcu);	471	idx = srcu_read_lock(&eventfs_srcu);
455	list_for_each_entry_srcu(ef, &ei->e_top_files, list,	472	list_for_each_entry_srcu(ef, &ei->e_top_files, list,
456	srcu_read_lock_held(&eventfs_srcu)) {	473	srcu_read_lock_held(&eventfs_srcu)) {
457	create_dentry(ef, dentry, false);	474	d = create_dentry(ef, dentry, false);
		475	if (d) {
		476	struct dentry **tmp;
		477
		478	tmp = krealloc(dentries, sizeof(d) * (cnt + 2), GFP_KERNEL);
		479	if (!tmp)
		480	break;
		481	tmp[cnt] = d;
		482	tmp[cnt + 1] = NULL;
		483	cnt++;
		484	dentries = tmp;
		485	}
458	}	486	}
459	srcu_read_unlock(&eventfs_srcu, idx);	487	srcu_read_unlock(&eventfs_srcu, idx);
460	return dcache_dir_open(inode, file);	488	ret = dcache_dir_open(inode, file);
		489
		490	/*
		491	* dcache_dir_open() sets file->private_data to a dentry cursor.
		492	* Need to save that but also save all the dentries that were
		493	* opened by this function.
		494	*/
		495	dlist->cursor = file->private_data;
		496	dlist->dentries = dentries;
		497	file->private_data = dlist;
		498	return ret;
		499	}
		500
		501	/*
		502	* This just sets the file->private_data back to the cursor and back.
		503	*/
		504	static int dcache_readdir_wrapper(struct file file, struct dir_context ctx)
		505	{
		506	struct dentry_list *dlist = file->private_data;
		507	int ret;
		508
		509	file->private_data = dlist->cursor;
		510	ret = dcache_readdir(file, ctx);
		511	dlist->cursor = file->private_data;
		512	file->private_data = dlist;
		513	return ret;
461	}	514	}
462		515
463	/**	516	/**

kernel/trace/ring_buffer.c+15−13

 	local_set(&bpage->commit, 0);
 }
+static __always_inline unsigned int rb_page_commit(struct buffer_page *bpage)
+{
+	return local_read(&bpage->page->commit);
+}
 static void free_buffer_page(struct buffer_page *bpage)
 {
 	free_page((unsigned long)bpage->page);
 			 * Increment overrun to account for the lost events.
 			 */
 			local_add(page_entries, &cpu_buffer->overrun);
-			local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);
+			local_sub(rb_page_commit(to_remove_page), &cpu_buffer->entries_bytes);
 			local_inc(&cpu_buffer->pages_lost);
 		}
 			       cpu_buffer->reader_page->read);
 }
-static __always_inline unsigned rb_page_commit(struct buffer_page *bpage)
-{
-	return local_read(&bpage->page->commit);
-}
 static struct ring_buffer_event *
 rb_iter_head_event(struct ring_buffer_iter *iter)
 {
 		 * the counters.
 		 */
 		local_add(entries, &cpu_buffer->overrun);
-		local_sub(BUF_PAGE_SIZE, &cpu_buffer->entries_bytes);
+		local_sub(rb_page_commit(next_page), &cpu_buffer->entries_bytes);
 		local_inc(&cpu_buffer->pages_lost);
 		/*
 	event = __rb_page_index(tail_page, tail);
-	/* account for padding bytes */
-	local_add(BUF_PAGE_SIZE - tail, &cpu_buffer->entries_bytes);
 	/*
 	 * Save the original length to the meta data.
 	 * This will be used by the reader to add lost event
 	 * write counter enough to allow another writer to slip
 	 * in on this page.
 	 * We put in a discarded commit instead, to make sure
-	 * that this space is not used again.
+	 * that this space is not used again, and this space will
+	 * not be accounted into 'entries_bytes'.
 	 *
 	 * If we are less than the minimum size, we don't need to
 	 * worry about it.
 	/* time delta must be non zero */
 	event->time_delta = 1;
+	/* account for padding bytes */
+	local_add(BUF_PAGE_SIZE - tail, &cpu_buffer->entries_bytes);
 	/* Make sure the padding is visible before the tail_page->write update */
 	smp_wmb();
 EXPORT_SYMBOL_GPL(ring_buffer_oldest_event_ts);
 /**
- * ring_buffer_bytes_cpu - get the number of bytes consumed in a cpu buffer
+ * ring_buffer_bytes_cpu - get the number of bytes unconsumed in a cpu buffer
  * @buffer: The ring buffer
  * @cpu: The per CPU buffer to read from.
  */
 	length = rb_event_length(event);
 	cpu_buffer->reader_page->read += length;
+	cpu_buffer->read_bytes += length;
 }
 static void rb_advance_iter(struct ring_buffer_iter *iter)
 	} else {
 		/* update the entry counter */
 		cpu_buffer->read += rb_page_entries(reader);
-		cpu_buffer->read_bytes += BUF_PAGE_SIZE;
+		cpu_buffer->read_bytes += rb_page_commit(reader);
 		/* swap the pages */
 		rb_init_page(bpage);