// 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_RAW_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); static void record_blktrace_event(struct blk_io_trace *t, pid_t pid, int cpu,				  sector_t sector, int bytes, u64 what,				  dev_t dev, int error, u64 cgid,				  ssize_t cgid_len, void *pdu_data, int pdu_len) {	/*	 * 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 = lower_32_bits(what);	t->device = 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);} static void record_blktrace_event2(struct blk_io_trace2 *t2, pid_t pid, int cpu,				   sector_t sector, int bytes, u64 what,				   dev_t dev, int error, u64 cgid,				   ssize_t cgid_len, void *pdu_data,				   int pdu_len){	t2->pid = pid;	t2->cpu = cpu; 	t2->sector = sector;	t2->bytes = bytes;	t2->action = what;	t2->device = dev;	t2->error = error;	t2->pdu_len = pdu_len + cgid_len; 	if (cgid_len)		memcpy((void *)t2 + sizeof(*t2), &cgid, cgid_len);	if (pdu_len)		memcpy((void *)t2 + sizeof(*t2) + cgid_len, pdu_data, pdu_len);} static void relay_blktrace_event1(struct blk_trace *bt, unsigned long sequence,				 pid_t pid, int cpu, sector_t sector, int bytes,				 u64 what, int error, u64 cgid,				 ssize_t cgid_len, void *pdu_data, int pdu_len){	struct blk_io_trace *t;	size_t trace_len = sizeof(*t) + pdu_len + cgid_len; 	t = relay_reserve(bt->rchan, trace_len);	if (!t)		return; 	t->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION;	t->sequence = sequence;	t->time = ktime_to_ns(ktime_get()); 	record_blktrace_event(t, pid, cpu, sector, bytes, what, bt->dev, error,			      cgid, cgid_len, pdu_data, pdu_len);} static void relay_blktrace_event2(struct blk_trace *bt, unsigned long sequence,				  pid_t pid, int cpu, sector_t sector,				  int bytes, u64 what, int error, u64 cgid,				  ssize_t cgid_len, void *pdu_data, int pdu_len){	struct blk_io_trace2 *t;	size_t trace_len = sizeof(struct blk_io_trace2) + pdu_len + cgid_len; 	t = relay_reserve(bt->rchan, trace_len);	if (!t)		return; 	t->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE2_VERSION;	t->sequence = sequence;	t->time = ktime_to_ns(ktime_get()); 	record_blktrace_event2(t, pid, cpu, sector, bytes, what, bt->dev, error,			       cgid, cgid_len, pdu_data, pdu_len);} static void relay_blktrace_event(struct blk_trace *bt, unsigned long sequence,				 pid_t pid, int cpu, sector_t sector, int bytes,				 u64 what, int error, u64 cgid,				 ssize_t cgid_len, void *pdu_data, int pdu_len){	if (bt->version == 2)		return relay_blktrace_event2(bt, sequence, pid, cpu, sector,					     bytes, what, error, cgid, cgid_len,					     pdu_data, pdu_len);	return relay_blktrace_event1(bt, sequence, pid, cpu, sector, bytes,				     what, error, cgid, cgid_len, pdu_data,				     pdu_len);} /* * Send out a notify message. */static void trace_note(struct blk_trace *bt, pid_t pid, u64 action,		       const void *data, size_t len, u64 cgid){	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; 	action = lower_32_bits(action | (cgid ? __BLK_TN_CGROUP : 0));	if (blk_tracer) {		struct blk_io_trace2 *t;		size_t trace_len = sizeof(*t) + cgid_len + len; 		buffer = blk_tr->array_buffer.buffer;		trace_ctx = tracing_gen_ctx_flags(0);		event = trace_buffer_lock_reserve(buffer, TRACE_BLK,						  trace_len, trace_ctx);		if (!event)			return;		t = ring_buffer_event_data(event);		record_blktrace_event2(t, pid, cpu, 0, 0,				       action, bt->dev, 0, cgid, cgid_len,				       (void *)data, len);		trace_buffer_unlock_commit(blk_tr, buffer, event, trace_ctx);		return;	} 	if (!bt->rchan)		return; 	relay_blktrace_event(bt, 0, pid, cpu, 0, 0, action, 0, cgid,			     cgid_len, (void *)data, len);} /* * 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;	raw_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);	}	raw_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 __blk_trace_note_message(struct blk_trace *bt,		struct cgroup_subsys_state *css, const char *fmt, ...){	int n;	va_list args;	unsigned long flags;	char *buf;	u64 cgid = 0; 	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); #ifdef CONFIG_BLK_CGROUP	if (css && (blk_tracer_flags.val & TRACE_BLK_OPT_CGROUP))		cgid = cgroup_id(css->cgroup);	else		cgid = 1;#endif	trace_note(bt, current->pid, BLK_TN_MESSAGE, buf, n, cgid);	local_irq_restore(flags);}EXPORT_SYMBOL_GPL(__blk_trace_note_message); static int act_log_check(struct blk_trace *bt, u64 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) ((__force u32)(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,			    const blk_opf_t opf, u64 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;	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;	const enum req_op op = opf & REQ_OP_MASK;	size_t trace_len; 	if (unlikely(bt->trace_state != Blktrace_running && !blk_tracer))		return; 	what |= ddir_act[op_is_write(op) ? WRITE : READ];	what |= MASK_TC_BIT(opf, SYNC);	what |= MASK_TC_BIT(opf, RAHEAD);	what |= MASK_TC_BIT(opf, META);	what |= MASK_TC_BIT(opf, PREFLUSH);	what |= MASK_TC_BIT(opf, FUA); 	switch (op) {	case REQ_OP_DISCARD:	case REQ_OP_SECURE_ERASE:		what |= BLK_TC_ACT(BLK_TC_DISCARD);		break;	case REQ_OP_FLUSH:		what |= BLK_TC_ACT(BLK_TC_FLUSH);		break;	case REQ_OP_ZONE_APPEND:		what |= BLK_TC_ACT(BLK_TC_ZONE_APPEND);		break;	case REQ_OP_ZONE_RESET:		what |= BLK_TC_ACT(BLK_TC_ZONE_RESET);		break;	case REQ_OP_ZONE_RESET_ALL:		what |= BLK_TC_ACT(BLK_TC_ZONE_RESET_ALL);		break;	case REQ_OP_ZONE_FINISH:		what |= BLK_TC_ACT(BLK_TC_ZONE_FINISH);		break;	case REQ_OP_ZONE_OPEN:		what |= BLK_TC_ACT(BLK_TC_ZONE_OPEN);		break;	case REQ_OP_ZONE_CLOSE:		what |= BLK_TC_ACT(BLK_TC_ZONE_CLOSE);		break;	case REQ_OP_WRITE_ZEROES:		what |= BLK_TC_ACT(BLK_TC_WRITE_ZEROES);		break;	default:		break;	} 	/* Drop trace events for zone operations with blktrace v1 */	if (bt->version == 1 && (what >> BLK_TC_SHIFT) > BLK_TC_END_V1) {		pr_debug_ratelimited("blktrace v1 cannot trace zone operation 0x%llx\n",				(unsigned long long)what);		return;	} 	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);		switch (bt->version) {		case 1:			trace_len = sizeof(struct blk_io_trace);			break;		case 2:		default:			/*			 * ftrace always uses v2 (blk_io_trace2) format.			 *			 * For sysfs-enabled tracing path (enabled via			 * /sys/block/DEV/trace/enable), blk_trace_setup_queue()			 * never initializes bt->version, leaving it 0 from			 * kzalloc(). We must handle version==0 safely here.			 *			 * Fall through to default to ensure we never hit the			 * old bug where default set trace_len=0, causing			 * buffer underflow and memory corruption.			 *			 * Always use v2 format for ftrace and normalize			 * bt->version to 2 when uninitialized.			 */			trace_len = sizeof(struct blk_io_trace2);			if (bt->version == 0)				bt->version = 2;			break;		}		trace_len += pdu_len + cgid_len;		event = trace_buffer_lock_reserve(buffer, TRACE_BLK,						  trace_len, trace_ctx);		if (!event)			return; 		switch (bt->version) {		case 1:			record_blktrace_event(ring_buffer_event_data(event),					      pid, cpu, sector, bytes,					      what, bt->dev, error, cgid, cgid_len,					      pdu_data, pdu_len);			break;		case 2:		default:			/*			 * Use v2 recording function (record_blktrace_event2)			 * which writes blk_io_trace2 structure with correct			 * field layout:			 *   - 32-bit pid at offset 28			 *   - 64-bit action at offset 32			 *			 * Fall through to default handles version==0 case			 * (from sysfs path), ensuring we always use correct			 * v2 recording function to match the v2 buffer			 * allocated above.			 */			record_blktrace_event2(ring_buffer_event_data(event),					       pid, cpu, sector, bytes,					       what, bt->dev, error, cgid, cgid_len,					       pdu_data, pdu_len);			break;		} 		trace_buffer_unlock_commit(blk_tr, buffer, event, trace_ctx);		return;	} 	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);	sequence = per_cpu_ptr(bt->sequence, cpu);	(*sequence)++;	relay_blktrace_event(bt, *sequence, pid, cpu, sector, bytes,			     what, error, cgid, cgid_len, pdu_data, pdu_len);	local_irq_restore(flags);} static void blk_trace_free(struct request_queue *q, struct blk_trace *bt){	relay_close(bt->rchan); 	/*	 * If 'bt->dir' is not set, then both 'dropped' and 'msg' are created	 * under 'q->debugfs_dir', thus lookup and remove them.	 */	if (!bt->dir) {		debugfs_lookup_and_remove("dropped", q->debugfs_dir);		debugfs_lookup_and_remove("msg", q->debugfs_dir);	} else {		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)

Lines 1–500 of 2200. Load more