// SPDX-License-Identifier: GPL-2.0/* * Copyright (C) 2006 Jens Axboe <axboe@kernel.dk> * */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/kernel.h>#include <linux/blkdev.h>#include <linux/blktrace_api.h>#include <linux/percpu.h>#include <linux/init.h>#include <linux/mutex.h>#include <linux/slab.h>#include <linux/debugfs.h>#include <linux/export.h>#include <linux/time.h>#include <linux/uaccess.h>#include <linux/list.h>#include <linux/blk-cgroup.h> #include "../../block/blk.h" #include <trace/events/block.h> #include "trace_output.h" #ifdef CONFIG_BLK_DEV_IO_TRACE static unsigned int blktrace_seq __read_mostly = 1; static struct trace_array *blk_tr;static bool blk_tracer_enabled __read_mostly; static LIST_HEAD(running_trace_list);static __cacheline_aligned_in_smp DEFINE_SPINLOCK(running_trace_lock); /* Select an alternative, minimalistic output than the original one */#define TRACE_BLK_OPT_CLASSIC	0x1#define TRACE_BLK_OPT_CGROUP	0x2#define TRACE_BLK_OPT_CGNAME	0x4 static struct tracer_opt blk_tracer_opts[] = {	/* Default disable the minimalistic output */	{ TRACER_OPT(blk_classic, TRACE_BLK_OPT_CLASSIC) },#ifdef CONFIG_BLK_CGROUP	{ TRACER_OPT(blk_cgroup, TRACE_BLK_OPT_CGROUP) },	{ TRACER_OPT(blk_cgname, TRACE_BLK_OPT_CGNAME) },#endif	{ }}; static struct tracer_flags blk_tracer_flags = {	.val  = 0,	.opts = blk_tracer_opts,}; /* Global reference count of probes */static DEFINE_MUTEX(blk_probe_mutex);static int blk_probes_ref; static void blk_register_tracepoints(void);static void blk_unregister_tracepoints(void); /* * Send out a notify message. */static void trace_note(struct blk_trace *bt, pid_t pid, int action,		       const void *data, size_t len, u64 cgid){	struct blk_io_trace *t;	struct ring_buffer_event *event = NULL;	struct trace_buffer *buffer = NULL;	unsigned int trace_ctx = 0;	int cpu = smp_processor_id();	bool blk_tracer = blk_tracer_enabled;	ssize_t cgid_len = cgid ? sizeof(cgid) : 0; 	if (blk_tracer) {		buffer = blk_tr->array_buffer.buffer;		trace_ctx = tracing_gen_ctx_flags(0);		event = trace_buffer_lock_reserve(buffer, TRACE_BLK,						  sizeof(*t) + len + cgid_len,						  trace_ctx);		if (!event)			return;		t = ring_buffer_event_data(event);		goto record_it;	} 	if (!bt->rchan)		return; 	t = relay_reserve(bt->rchan, sizeof(*t) + len + cgid_len);	if (t) {		t->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION;		t->time = ktime_to_ns(ktime_get());record_it:		t->device = bt->dev;		t->action = action | (cgid ? __BLK_TN_CGROUP : 0);		t->pid = pid;		t->cpu = cpu;		t->pdu_len = len + cgid_len;		if (cgid_len)			memcpy((void *)t + sizeof(*t), &cgid, cgid_len);		memcpy((void *) t + sizeof(*t) + cgid_len, data, len); 		if (blk_tracer)			trace_buffer_unlock_commit(blk_tr, buffer, event, trace_ctx);	}} /* * Send out a notify for this process, if we haven't done so since a trace * started */static void trace_note_tsk(struct task_struct *tsk){	unsigned long flags;	struct blk_trace *bt; 	tsk->btrace_seq = blktrace_seq;	spin_lock_irqsave(&running_trace_lock, flags);	list_for_each_entry(bt, &running_trace_list, running_list) {		trace_note(bt, tsk->pid, BLK_TN_PROCESS, tsk->comm,			   sizeof(tsk->comm), 0);	}	spin_unlock_irqrestore(&running_trace_lock, flags);} static void trace_note_time(struct blk_trace *bt){	struct timespec64 now;	unsigned long flags;	u32 words[2]; 	/* need to check user space to see if this breaks in y2038 or y2106 */	ktime_get_real_ts64(&now);	words[0] = (u32)now.tv_sec;	words[1] = now.tv_nsec; 	local_irq_save(flags);	trace_note(bt, 0, BLK_TN_TIMESTAMP, words, sizeof(words), 0);	local_irq_restore(flags);} void __trace_note_message(struct blk_trace *bt, struct blkcg *blkcg,	const char *fmt, ...){	int n;	va_list args;	unsigned long flags;	char *buf; 	if (unlikely(bt->trace_state != Blktrace_running &&		     !blk_tracer_enabled))		return; 	/*	 * If the BLK_TC_NOTIFY action mask isn't set, don't send any note	 * message to the trace.	 */	if (!(bt->act_mask & BLK_TC_NOTIFY))		return; 	local_irq_save(flags);	buf = this_cpu_ptr(bt->msg_data);	va_start(args, fmt);	n = vscnprintf(buf, BLK_TN_MAX_MSG, fmt, args);	va_end(args); 	if (!(blk_tracer_flags.val & TRACE_BLK_OPT_CGROUP))		blkcg = NULL;#ifdef CONFIG_BLK_CGROUP	trace_note(bt, current->pid, BLK_TN_MESSAGE, buf, n,		   blkcg ? cgroup_id(blkcg->css.cgroup) : 1);#else	trace_note(bt, current->pid, BLK_TN_MESSAGE, buf, n, 0);#endif	local_irq_restore(flags);}EXPORT_SYMBOL_GPL(__trace_note_message); static int act_log_check(struct blk_trace *bt, u32 what, sector_t sector,			 pid_t pid){	if (((bt->act_mask << BLK_TC_SHIFT) & what) == 0)		return 1;	if (sector && (sector < bt->start_lba || sector > bt->end_lba))		return 1;	if (bt->pid && pid != bt->pid)		return 1; 	return 0;} /* * Data direction bit lookup */static const u32 ddir_act[2] = { BLK_TC_ACT(BLK_TC_READ),				 BLK_TC_ACT(BLK_TC_WRITE) }; #define BLK_TC_RAHEAD		BLK_TC_AHEAD#define BLK_TC_PREFLUSH		BLK_TC_FLUSH /* The ilog2() calls fall out because they're constant */#define MASK_TC_BIT(rw, __name) ((rw & REQ_ ## __name) << \	  (ilog2(BLK_TC_ ## __name) + BLK_TC_SHIFT - __REQ_ ## __name)) /* * The worker for the various blk_add_trace*() types. Fills out a * blk_io_trace structure and places it in a per-cpu subbuffer. */static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes,		     int op, int op_flags, u32 what, int error, int pdu_len,		     void *pdu_data, u64 cgid){	struct task_struct *tsk = current;	struct ring_buffer_event *event = NULL;	struct trace_buffer *buffer = NULL;	struct blk_io_trace *t;	unsigned long flags = 0;	unsigned long *sequence;	unsigned int trace_ctx = 0;	pid_t pid;	int cpu;	bool blk_tracer = blk_tracer_enabled;	ssize_t cgid_len = cgid ? sizeof(cgid) : 0; 	if (unlikely(bt->trace_state != Blktrace_running && !blk_tracer))		return; 	what |= ddir_act[op_is_write(op) ? WRITE : READ];	what |= MASK_TC_BIT(op_flags, SYNC);	what |= MASK_TC_BIT(op_flags, RAHEAD);	what |= MASK_TC_BIT(op_flags, META);	what |= MASK_TC_BIT(op_flags, PREFLUSH);	what |= MASK_TC_BIT(op_flags, FUA);	if (op == REQ_OP_DISCARD || op == REQ_OP_SECURE_ERASE)		what |= BLK_TC_ACT(BLK_TC_DISCARD);	if (op == REQ_OP_FLUSH)		what |= BLK_TC_ACT(BLK_TC_FLUSH);	if (cgid)		what |= __BLK_TA_CGROUP; 	pid = tsk->pid;	if (act_log_check(bt, what, sector, pid))		return;	cpu = raw_smp_processor_id(); 	if (blk_tracer) {		tracing_record_cmdline(current); 		buffer = blk_tr->array_buffer.buffer;		trace_ctx = tracing_gen_ctx_flags(0);		event = trace_buffer_lock_reserve(buffer, TRACE_BLK,						  sizeof(*t) + pdu_len + cgid_len,						  trace_ctx);		if (!event)			return;		t = ring_buffer_event_data(event);		goto record_it;	} 	if (unlikely(tsk->btrace_seq != blktrace_seq))		trace_note_tsk(tsk); 	/*	 * A word about the locking here - we disable interrupts to reserve	 * some space in the relay per-cpu buffer, to prevent an irq	 * from coming in and stepping on our toes.	 */	local_irq_save(flags);	t = relay_reserve(bt->rchan, sizeof(*t) + pdu_len + cgid_len);	if (t) {		sequence = per_cpu_ptr(bt->sequence, cpu); 		t->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION;		t->sequence = ++(*sequence);		t->time = ktime_to_ns(ktime_get());record_it:		/*		 * These two are not needed in ftrace as they are in the		 * generic trace_entry, filled by tracing_generic_entry_update,		 * but for the trace_event->bin() synthesizer benefit we do it		 * here too.		 */		t->cpu = cpu;		t->pid = pid; 		t->sector = sector;		t->bytes = bytes;		t->action = what;		t->device = bt->dev;		t->error = error;		t->pdu_len = pdu_len + cgid_len; 		if (cgid_len)			memcpy((void *)t + sizeof(*t), &cgid, cgid_len);		if (pdu_len)			memcpy((void *)t + sizeof(*t) + cgid_len, pdu_data, pdu_len); 		if (blk_tracer) {			trace_buffer_unlock_commit(blk_tr, buffer, event, trace_ctx);			return;		}	} 	local_irq_restore(flags);} static void blk_trace_free(struct blk_trace *bt){	relay_close(bt->rchan);	debugfs_remove(bt->dir);	free_percpu(bt->sequence);	free_percpu(bt->msg_data);	kfree(bt);} static void get_probe_ref(void){	mutex_lock(&blk_probe_mutex);	if (++blk_probes_ref == 1)		blk_register_tracepoints();	mutex_unlock(&blk_probe_mutex);} static void put_probe_ref(void){	mutex_lock(&blk_probe_mutex);	if (!--blk_probes_ref)		blk_unregister_tracepoints();	mutex_unlock(&blk_probe_mutex);} static void blk_trace_cleanup(struct blk_trace *bt){	synchronize_rcu();	blk_trace_free(bt);	put_probe_ref();} static int __blk_trace_remove(struct request_queue *q){	struct blk_trace *bt; 	bt = rcu_replace_pointer(q->blk_trace, NULL,				 lockdep_is_held(&q->debugfs_mutex));	if (!bt)		return -EINVAL; 	if (bt->trace_state != Blktrace_running)		blk_trace_cleanup(bt); 	return 0;} int blk_trace_remove(struct request_queue *q){	int ret; 	mutex_lock(&q->debugfs_mutex);	ret = __blk_trace_remove(q);	mutex_unlock(&q->debugfs_mutex); 	return ret;}EXPORT_SYMBOL_GPL(blk_trace_remove); static ssize_t blk_dropped_read(struct file *filp, char __user *buffer,				size_t count, loff_t *ppos){	struct blk_trace *bt = filp->private_data;	char buf[16]; 	snprintf(buf, sizeof(buf), "%u\n", atomic_read(&bt->dropped)); 	return simple_read_from_buffer(buffer, count, ppos, buf, strlen(buf));} static const struct file_operations blk_dropped_fops = {	.owner =	THIS_MODULE,	.open =		simple_open,	.read =		blk_dropped_read,	.llseek =	default_llseek,}; static ssize_t blk_msg_write(struct file *filp, const char __user *buffer,				size_t count, loff_t *ppos){	char *msg;	struct blk_trace *bt; 	if (count >= BLK_TN_MAX_MSG)		return -EINVAL; 	msg = memdup_user_nul(buffer, count);	if (IS_ERR(msg))		return PTR_ERR(msg); 	bt = filp->private_data;	__trace_note_message(bt, NULL, "%s", msg);	kfree(msg); 	return count;} static const struct file_operations blk_msg_fops = {	.owner =	THIS_MODULE,	.open =		simple_open,	.write =	blk_msg_write,	.llseek =	noop_llseek,}; /* * Keep track of how many times we encountered a full subbuffer, to aid * the user space app in telling how many lost events there were. */static int blk_subbuf_start_callback(struct rchan_buf *buf, void *subbuf,				     void *prev_subbuf, size_t prev_padding){	struct blk_trace *bt; 	if (!relay_buf_full(buf))		return 1; 	bt = buf->chan->private_data;	atomic_inc(&bt->dropped);	return 0;} static int blk_remove_buf_file_callback(struct dentry *dentry){	debugfs_remove(dentry); 	return 0;} static struct dentry *blk_create_buf_file_callback(const char *filename,						   struct dentry *parent,						   umode_t mode,						   struct rchan_buf *buf,						   int *is_global){	return debugfs_create_file(filename, mode, parent, buf,					&relay_file_operations);} static const struct rchan_callbacks blk_relay_callbacks = {	.subbuf_start		= blk_subbuf_start_callback,	.create_buf_file	= blk_create_buf_file_callback,	.remove_buf_file	= blk_remove_buf_file_callback,}; static void blk_trace_setup_lba(struct blk_trace *bt,				struct block_device *bdev){	if (bdev) {		bt->start_lba = bdev->bd_start_sect;		bt->end_lba = bdev->bd_start_sect + bdev_nr_sectors(bdev);	} else {		bt->start_lba = 0;		bt->end_lba = -1ULL;	}} /* * Setup everything required to start tracing */static int do_blk_trace_setup(struct request_queue *q, char *name, dev_t dev,			      struct block_device *bdev,			      struct blk_user_trace_setup *buts){	struct blk_trace *bt = NULL;	struct dentry *dir = NULL;	int ret; 	lockdep_assert_held(&q->debugfs_mutex); 	if (!buts->buf_size || !buts->buf_nr)		return -EINVAL; 	strncpy(buts->name, name, BLKTRACE_BDEV_SIZE);	buts->name[BLKTRACE_BDEV_SIZE - 1] = '\0'; 	/*	 * some device names have larger paths - convert the slashes	 * to underscores for this to work as expected	 */	strreplace(buts->name, '/', '_'); 	/*	 * bdev can be NULL, as with scsi-generic, this is a helpful as	 * we can be.	 */	if (rcu_dereference_protected(q->blk_trace,				      lockdep_is_held(&q->debugfs_mutex))) {		pr_warn("Concurrent blktraces are not allowed on %s\n",

Lines 1–500 of 1928. Load more