path: root/drivers/block/drbd/drbd_tracing.c

/*
   drbd_tracing.c

   This file is part of DRBD by Philipp Reisner and Lars Ellenberg.

   Copyright (C) 2003-2008, LINBIT Information Technologies GmbH.
   Copyright (C) 2003-2008, Philipp Reisner <philipp.reisner@linbit.com>.
   Copyright (C) 2003-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.

   drbd is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   drbd is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with drbd; see the file COPYING.  If not, write to
   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

 */

#include <linux/module.h>
#include <linux/drbd.h>
#include <linux/ctype.h>
#include "drbd_int.h"
#include "drbd_tracing.h"
#include <linux/drbd_tag_magic.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Philipp Reisner, Lars Ellenberg");
MODULE_DESCRIPTION("DRBD tracepoint probes");
MODULE_PARM_DESC(trace_mask, "Bitmap of events to trace see drbd_tracing.c");
MODULE_PARM_DESC(trace_level, "Current tracing level (changeable in /sys)");
MODULE_PARM_DESC(trace_devs, "Bitmap of devices to trace (changeable in /sys)");

unsigned int trace_mask = 0;  /* Bitmap of events to trace */
int trace_level;              /* Current trace level */
int trace_devs;		      /* Bitmap of devices to trace */

module_param(trace_mask, uint, 0444);
module_param(trace_level, int, 0644);
module_param(trace_devs, int, 0644);

enum {
	TRACE_PACKET  = 0x0001,
	TRACE_RQ      = 0x0002,
	TRACE_UUID    = 0x0004,
	TRACE_RESYNC  = 0x0008,
	TRACE_EE      = 0x0010,
	TRACE_UNPLUG  = 0x0020,
	TRACE_NL      = 0x0040,
	TRACE_AL_EXT  = 0x0080,
	TRACE_INT_RQ  = 0x0100,
	TRACE_MD_IO   = 0x0200,
	TRACE_EPOCH   = 0x0400,
};

/* Buffer printing support
 * dbg_print_flags: used for Flags arg to drbd_print_buffer
 * - DBGPRINT_BUFFADDR; if set, each line starts with the
 *	 virtual address of the line being output. If clear,
 *	 each line starts with the offset from the beginning
 *	 of the buffer. */
enum dbg_print_flags {
    DBGPRINT_BUFFADDR = 0x0001,
};

/* Macro stuff */
static char *nl_packet_name(int packet_type)
{
/* Generate packet type strings */
#define NL_PACKET(name, number, fields) \
	[P_ ## name] = # name,
#define NL_INTEGER Argh!
#define NL_BIT Argh!
#define NL_INT64 Argh!
#define NL_STRING Argh!

	static char *nl_tag_name[P_nl_after_last_packet] = {
#include "linux/drbd_nl.h"
	};

	return (packet_type < sizeof(nl_tag_name)/sizeof(nl_tag_name[0])) ?
	    nl_tag_name[packet_type] : "*Unknown*";
}
/* /Macro stuff */

static inline int is_mdev_trace(struct drbd_conf *mdev, unsigned int level)
{
	return trace_level >= level && ((1 << mdev_to_minor(mdev)) & trace_devs);
}

static void probe_drbd_unplug(struct drbd_conf *mdev, char *msg)
{
	if (!is_mdev_trace(mdev, TRACE_LVL_ALWAYS))
		return;

	dev_info(DEV, "%s, ap_bio_count=%d\n", msg, atomic_read(&mdev->ap_bio_cnt));
}

static void probe_drbd_uuid(struct drbd_conf *mdev, enum drbd_uuid_index index)
{
	static char *uuid_str[UI_EXTENDED_SIZE] = {
		[UI_CURRENT] = "CURRENT",
		[UI_BITMAP] = "BITMAP",
		[UI_HISTORY_START] = "HISTORY_START",
		[UI_HISTORY_END] = "HISTORY_END",
		[UI_SIZE] = "SIZE",
		[UI_FLAGS] = "FLAGS",
	};

	if (!is_mdev_trace(mdev, TRACE_LVL_ALWAYS))
		return;

	if (index >= UI_EXTENDED_SIZE) {
		dev_warn(DEV, " uuid_index >= EXTENDED_SIZE\n");
		return;
	}

	dev_info(DEV, " uuid[%s] now %016llX\n",
		 uuid_str[index],
		 (unsigned long long)mdev->ldev->md.uuid[index]);
}

static void probe_drbd_md_io(struct drbd_conf *mdev, int rw,
			     struct drbd_backing_dev *bdev)
{
	if (!is_mdev_trace(mdev, TRACE_LVL_ALWAYS))
		return;

	dev_info(DEV, " %s metadata superblock now\n",
		 rw == READ ? "Reading" : "Writing");
}

static void probe_drbd_ee(struct drbd_conf *mdev, struct drbd_epoch_entry *e, char* msg)
{
	if (!is_mdev_trace(mdev, TRACE_LVL_ALWAYS))
		return;

	dev_info(DEV, "EE %s sec=%llus size=%u e=%p\n",
		 msg, (unsigned long long)e->sector, e->size, e);
}

static void probe_drbd_epoch(struct drbd_conf *mdev, struct drbd_epoch *epoch,
			     enum epoch_event ev)
{
	static char *epoch_event_str[] = {
		[EV_PUT] = "put",
		[EV_GOT_BARRIER_NR] = "got_barrier_nr",
		[EV_BARRIER_DONE] = "barrier_done",
		[EV_BECAME_LAST] = "became_last",
		[EV_TRACE_FLUSH] = "issuing_flush",
		[EV_TRACE_ADD_BARRIER] = "added_barrier",
		[EV_TRACE_SETTING_BI] = "just set barrier_in_next_epoch",
	};

	if (!is_mdev_trace(mdev, TRACE_LVL_ALWAYS))
		return;

	ev &= ~EV_CLEANUP;

	switch (ev) {
	case EV_TRACE_ALLOC:
		dev_info(DEV, "Allocate epoch %p/xxxx { } nr_epochs=%d\n", epoch, mdev->epochs);
		break;
	case EV_TRACE_FREE:
		dev_info(DEV, "Freeing epoch %p/%d { size=%d } nr_epochs=%d\n",
			 epoch, epoch->barrier_nr, atomic_read(&epoch->epoch_size),
			 mdev->epochs);
		break;
	default:
		dev_info(DEV, "Update epoch  %p/%d { size=%d active=%d %c%c n%c%c } ev=%s\n",
			 epoch, epoch->barrier_nr, atomic_read(&epoch->epoch_size),
			 atomic_read(&epoch->active),
			 test_bit(DE_HAVE_BARRIER_NUMBER, &epoch->flags) ? 'n' : '-',
			 test_bit(DE_CONTAINS_A_BARRIER, &epoch->flags) ? 'b' : '-',
			 test_bit(DE_BARRIER_IN_NEXT_EPOCH_ISSUED, &epoch->flags) ? 'i' : '-',
			 test_bit(DE_BARRIER_IN_NEXT_EPOCH_DONE, &epoch->flags) ? 'd' : '-',
			 epoch_event_str[ev]);
	}
}

static void probe_drbd_netlink(void *data, int is_req)
{
	struct cn_msg *msg = data;

	if (is_req) {
		struct drbd_nl_cfg_req *nlp = (struct drbd_nl_cfg_req *)msg->data;

		printk(KERN_INFO "drbd%d: "
			 "Netlink: << %s (%d) - seq: %x, ack: %x, len: %x\n",
			 nlp->drbd_minor,
			 nl_packet_name(nlp->packet_type),
			 nlp->packet_type,
			 msg->seq, msg->ack, msg->len);
	} else {
		struct drbd_nl_cfg_reply *nlp = (struct drbd_nl_cfg_reply *)msg->data;

		printk(KERN_INFO "drbd%d: "
		       "Netlink: >> %s (%d) - seq: %x, ack: %x, len: %x\n",
		       nlp->minor,
		       nlp->packet_type == P_nl_after_last_packet ?
		       "Empty-Reply" : nl_packet_name(nlp->packet_type),
		       nlp->packet_type,
		       msg->seq, msg->ack, msg->len);
	}
}

static void probe_drbd_actlog(struct drbd_conf *mdev, sector_t sector, char* msg)
{
	unsigned int enr = (sector >> (AL_EXTENT_SHIFT-9));

	if (!is_mdev_trace(mdev, TRACE_LVL_ALWAYS))
		return;

	dev_info(DEV, "%s (sec=%llus, al_enr=%u, rs_enr=%d)\n",
		 msg, (unsigned long long) sector, enr,
		 (int)BM_SECT_TO_EXT(sector));
}

/**
 * drbd_print_buffer() - Hexdump arbitrary binary data into a buffer
 * @prefix:	String is output at the beginning of each line output.
 * @flags:	Currently only defined flag: DBGPRINT_BUFFADDR; if set, each
 *		line starts with the virtual address of the line being
 *		output. If clear, each line starts with the offset from the
 *		beginning of the buffer.
 * @size:	Indicates the size of each entry in the buffer. Supported
 * 		values are sizeof(char), sizeof(short) and sizeof(int)
 * @buffer:	Start address of buffer
 * @buffer_va:	Virtual address of start of buffer (normally the same
 *		as Buffer, but having it separate allows it to hold
 *		file address for example)
 * @length:	length of buffer
 */
static void drbd_print_buffer(const char *prefix, unsigned int flags, int size,
			      const void *buffer, const void *buffer_va,
			      unsigned int length)

#define LINE_SIZE       16
#define LINE_ENTRIES    (int)(LINE_SIZE/size)
{
	const unsigned char *pstart;
	const unsigned char *pstart_va;
	const unsigned char *pend;
	char bytes_str[LINE_SIZE*3+8], ascii_str[LINE_SIZE+8];
	char *pbytes = bytes_str, *pascii = ascii_str;
	int  offset = 0;
	long sizemask;
	int  field_width;
	int  index;
	const unsigned char *pend_str;
	const unsigned char *p;
	int count;

	/* verify size parameter */
	if (size != sizeof(char) &&
	    size != sizeof(short) &&
	    size != sizeof(int)) {
		printk(KERN_DEBUG "drbd_print_buffer: "
			"ERROR invalid size %d\n", size);
		return;
	}

	sizemask = size-1;
	field_width = size*2;

	/* Adjust start/end to be on appropriate boundary for size */
	buffer = (const char *)((long)buffer & ~sizemask);
	pend   = (const unsigned char *)
		(((long)buffer + length + sizemask) & ~sizemask);

	if (flags & DBGPRINT_BUFFADDR) {
		/* Move start back to nearest multiple of line size,
		 * if printing address. This results in nicely formatted output
		 * with addresses being on line size (16) byte boundaries */
		pstart = (const unsigned char *)((long)buffer & ~(LINE_SIZE-1));
	} else {
		pstart = (const unsigned char *)buffer;
	}

	/* Set value of start VA to print if addresses asked for */
	pstart_va = (const unsigned char *)buffer_va
		 - ((const unsigned char *)buffer-pstart);

	/* Calculate end position to nicely align right hand side */
	pend_str = pstart + (((pend-pstart) + LINE_SIZE-1) & ~(LINE_SIZE-1));

	/* Init strings */
	*pbytes = *pascii = '\0';

	/* Start at beginning of first line */
	p = pstart;
	count = 0;

	while (p < pend_str) {
		if (p < (const unsigned char *)buffer || p >= pend) {
			/* Before start of buffer or after end- print spaces */
			pbytes += sprintf(pbytes, "%*c ", field_width, ' ');
			pascii += sprintf(pascii, "%*c", size, ' ');
			p += size;
		} else {
			/* Add hex and ascii to strings */
			int val;
			switch (size) {
			default:
			case 1:
				val = *(unsigned char *)p;
				break;
			case 2:
				val = *(unsigned short *)p;
				break;
			case 4:
				val = *(unsigned int *)p;
				break;
			}

			pbytes += sprintf(pbytes, "%0*x ", field_width, val);

			for (index = size; index; index--) {
				*pascii++ = isprint(*p) ? *p : '.';
				p++;
			}
		}

		count++;

		if (count == LINE_ENTRIES || p >= pend_str) {
			/* Null terminate and print record */
			*pascii = '\0';
			printk(KERN_DEBUG "%s%8.8lx: %*s|%*s|\n",
			       prefix,
			       (flags & DBGPRINT_BUFFADDR)
			       ? (long)pstart_va:(long)offset,
			       LINE_ENTRIES*(field_width+1), bytes_str,
			       LINE_SIZE, ascii_str);

			/* Move onto next line */
			pstart_va += (p-pstart);
			pstart = p;
			count  = 0;
			offset += LINE_SIZE;

			/* Re-init strings */
			pbytes = bytes_str;
			pascii = ascii_str;
			*pbytes = *pascii = '\0';
		}
	}
}

static void probe_drbd_resync(struct drbd_conf *mdev, int level, const char *fmt, va_list args)
{
	char str[256];

	if (!is_mdev_trace(mdev, level))
		return;

	if (vsnprintf(str, 256, fmt, args) >= 256)
		str[255] = 0;

	printk(KERN_INFO "%s %s: %s", dev_driver_string(disk_to_dev(mdev->vdisk)),
	       dev_name(disk_to_dev(mdev->vdisk)), str);
}

static void probe_drbd_bio(struct drbd_conf *mdev, const char *pfx, struct bio *bio, int complete,
			   struct drbd_request *r)
{
#if defined(CONFIG_LBDAF) || defined(CONFIG_LBD)
#define SECTOR_FORMAT "%Lx"
#else
#define SECTOR_FORMAT "%lx"
#endif
#define SECTOR_SHIFT 9

	unsigned long lowaddr = (unsigned long)(bio->bi_sector << SECTOR_SHIFT);
	char *faddr = (char *)(lowaddr);
	char rb[sizeof(void *)*2+6] = { 0, };
	struct bio_vec *bvec;
	int segno;

	const int rw = bio->bi_rw;
	const int biorw      = (rw & (RW_MASK|RWA_MASK));
	const int biobarrier = (rw & (1<<BIO_RW_BARRIER));
	const int biosync = (rw & ((1<<BIO_RW_UNPLUG) | (1<<BIO_RW_SYNCIO)));

	if (!is_mdev_trace(mdev, TRACE_LVL_ALWAYS))
		return;

	if (r)
		sprintf(rb, "Req:%p ", r);

	dev_info(DEV, "%s %s:%s%s%s Bio:%p %s- %soffset " SECTOR_FORMAT ", size %x\n",
		 complete ? "<<<" : ">>>",
		 pfx,
		 biorw == WRITE ? "Write" : "Read",
		 biobarrier ? " : B" : "",
		 biosync ? " : S" : "",
		 bio,
		 rb,
		 complete ? (bio_flagged(bio, BIO_UPTODATE) ? "Success, " : "Failed, ") : "",
		 bio->bi_sector << SECTOR_SHIFT,
		 bio->bi_size);

	if (trace_level >= TRACE_LVL_METRICS &&
	    ((biorw == WRITE) ^ complete)) {
		printk(KERN_DEBUG "  ind     page   offset   length\n");
		__bio_for_each_segment(bvec, bio, segno, 0) {
			printk(KERN_DEBUG "  [%d] %p %8.8x %8.8x\n", segno,
			       bvec->bv_page, bvec->bv_offset, bvec->bv_len);

			if (trace_level >= TRACE_LVL_ALL) {
				char *bvec_buf;
				unsigned long flags;

				bvec_buf = bvec_kmap_irq(bvec, &flags);

				drbd_print_buffer("    ", DBGPRINT_BUFFADDR, 1,
						  bvec_buf,
						  faddr,
						  (bvec->bv_len <= 0x80)
						  ? bvec->bv_len : 0x80);

				bvec_kunmap_irq(bvec_buf, &flags);

				if (bvec->bv_len > 0x40)
					printk(KERN_DEBUG "    ....\n");

				faddr += bvec->bv_len;
			}
		}
	}
}

static void probe_drbd_req(struct drbd_request *req, enum drbd_req_event what, char *msg)
{
	static const char *rq_event_names[] = {
		[created] = "created",
		[to_be_send] = "to_be_send",
		[to_be_submitted] = "to_be_submitted",
		[queue_for_net_write] = "queue_for_net_write",
		[queue_for_net_read] = "queue_for_net_read",
		[send_canceled] = "send_canceled",
		[send_failed] = "send_failed",
		[handed_over_to_network] = "handed_over_to_network",
		[connection_lost_while_pending] =
					"connection_lost_while_pending",
		[recv_acked_by_peer] = "recv_acked_by_peer",
		[write_acked_by_peer] = "write_acked_by_peer",
		[neg_acked] = "neg_acked",
		[conflict_discarded_by_peer] = "conflict_discarded_by_peer",
		[barrier_acked] = "barrier_acked",
		[data_received] = "data_received",
		[read_completed_with_error] = "read_completed_with_error",
		[read_ahead_completed_with_error] = "reada_completed_with_error",
		[write_completed_with_error] = "write_completed_with_error",
		[completed_ok] = "completed_ok",
	};

	struct drbd_conf *mdev = req->mdev;

	const int rw = (req->master_bio == NULL ||
			bio_data_dir(req->master_bio) == WRITE) ?
		'W' : 'R';
	const unsigned long s = req->rq_state;

	if (what != nothing) {
		dev_info(DEV, "__req_mod(%p %c ,%s)\n", req, rw, rq_event_names[what]);
	} else {
		dev_info(DEV, "%s %p %c L%c%c%cN%c%c%c%c%c %u (%llus +%u) %s\n",
			 msg, req, rw,
			 s & RQ_LOCAL_PENDING ? 'p' : '-',
			 s & RQ_LOCAL_COMPLETED ? 'c' : '-',
			 s & RQ_LOCAL_OK ? 'o' : '-',
			 s & RQ_NET_PENDING ? 'p' : '-',
			 s & RQ_NET_QUEUED ? 'q' : '-',
			 s & RQ_NET_SENT ? 's' : '-',
			 s & RQ_NET_DONE ? 'd' : '-',
			 s & RQ_NET_OK ? 'o' : '-',
			 req->epoch,
			 (unsigned long long)req->sector,
			 req->size,
			 drbd_conn_str(mdev->state.conn));
	}
}


#define drbd_peer_str drbd_role_str
#define drbd_pdsk_str drbd_disk_str

#define PSM(A)							\
do {								\
	if (mask.A) {						\
		int i = snprintf(p, len, " " #A "( %s )",	\
				 drbd_##A##_str(val.A));	\
		if (i >= len)					\
			return op;				\
		p += i;						\
		len -= i;					\
	}							\
} while (0)

static char *dump_st(char *p, int len, union drbd_state mask, union drbd_state val)
{
	char *op = p;
	*p = '\0';
	PSM(role);
	PSM(peer);
	PSM(conn);
	PSM(disk);
	PSM(pdsk);

	return op;
}

#define INFOP(fmt, args...) \
do { \
	if (trace_level >= TRACE_LVL_ALL) { \
		dev_info(DEV, "%s:%d: %s [%d] %s %s " fmt , \
		     file, line, current->comm, current->pid, \
		     sockname, recv ? "<<<" : ">>>" , \
		     ## args); \
	} else { \
		dev_info(DEV, "%s %s " fmt, sockname, \
		     recv ? "<<<" : ">>>" , \
		     ## args); \
	} \
} while (0)

static char *_dump_block_id(u64 block_id, char *buff)
{
	if (is_syncer_block_id(block_id))
		strcpy(buff, "SyncerId");
	else
		sprintf(buff, "%llx", (unsigned long long)block_id);

	return buff;
}

static void probe_drbd_packet(struct drbd_conf *mdev, struct socket *sock,
			      int recv, union p_polymorph *p, char *file, int line)
{
	char *sockname = sock == mdev->meta.socket ? "meta" : "data";
	int cmd = (recv == 2) ? p->header.command : be16_to_cpu(p->header.command);
	char tmp[300];
	union drbd_state m, v;

	switch (cmd) {
	case P_HAND_SHAKE:
		INFOP("%s (protocol %u-%u)\n", cmdname(cmd),
			be32_to_cpu(p->handshake.protocol_min),
			be32_to_cpu(p->handshake.protocol_max));
		break;

	case P_BITMAP: /* don't report this */
	case P_COMPRESSED_BITMAP: /* don't report this */
		break;

	case P_DATA:
		INFOP("%s (sector %llus, id %s, seq %u, f %x)\n", cmdname(cmd),
		      (unsigned long long)be64_to_cpu(p->data.sector),
		      _dump_block_id(p->data.block_id, tmp),
		      be32_to_cpu(p->data.seq_num),
		      be32_to_cpu(p->data.dp_flags)
			);
		break;

	case P_DATA_REPLY:
	case P_RS_DATA_REPLY:
		INFOP("%s (sector %llus, id %s)\n", cmdname(cmd),
		      (unsigned long long)be64_to_cpu(p->data.sector),
		      _dump_block_id(p->data.block_id, tmp)
			);
		break;

	case P_RECV_ACK:
	case P_WRITE_ACK:
	case P_RS_WRITE_ACK:
	case P_DISCARD_ACK:
	case P_NEG_ACK:
	case P_NEG_RS_DREPLY:
		INFOP("%s (sector %llus, size %u, id %s, seq %u)\n",
			cmdname(cmd),
		      (long long)be64_to_cpu(p->block_ack.sector),
		      be32_to_cpu(p->block_ack.blksize),
		      _dump_block_id(p->block_ack.block_id, tmp),
		      be32_to_cpu(p->block_ack.seq_num)
			);
		break;

	case P_DATA_REQUEST:
	case P_RS_DATA_REQUEST:
		INFOP("%s (sector %llus, size %u, id %s)\n", cmdname(cmd),
		      (long long)be64_to_cpu(p->block_req.sector),
		      be32_to_cpu(p->block_req.blksize),
		      _dump_block_id(p->block_req.block_id, tmp)
			);
		break;

	case P_BARRIER:
	case P_BARRIER_ACK:
		INFOP("%s (barrier %u)\n", cmdname(cmd), p->barrier.barrier);
		break;

	case P_SYNC_PARAM:
	case P_SYNC_PARAM89:
		INFOP("%s (rate %u, verify-alg \"%.64s\", csums-alg \"%.64s\")\n",
			cmdname(cmd), be32_to_cpu(p->rs_param_89.rate),
			p->rs_param_89.verify_alg, p->rs_param_89.csums_alg);
		break;

	case P_UUIDS:
		INFOP("%s Curr:%016llX, Bitmap:%016llX, "
		      "HisSt:%016llX, HisEnd:%016llX\n",
		      cmdname(cmd),
		      (unsigned long long)be64_to_cpu(p->uuids.uuid[UI_CURRENT]),
		      (unsigned long long)be64_to_cpu(p->uuids.uuid[UI_BITMAP]),
		      (unsigned long long)be64_to_cpu(p->uuids.uuid[UI_HISTORY_START]),
		      (unsigned long long)be64_to_cpu(p->uuids.uuid[UI_HISTORY_END]));
		break;

	case P_SIZES:
		INFOP("%s (d %lluMiB, u %lluMiB, c %lldMiB, "
		      "max bio %x, q order %x)\n",
		      cmdname(cmd),
		      (long long)(be64_to_cpu(p->sizes.d_size)>>(20-9)),
		      (long long)(be64_to_cpu(p->sizes.u_size)>>(20-9)),
		      (long long)(be64_to_cpu(p->sizes.c_size)>>(20-9)),
		      be32_to_cpu(p->sizes.max_segment_size),
		      be32_to_cpu(p->sizes.queue_order_type));
		break;

	case P_STATE:
		v.i = be32_to_cpu(p->state.state);
		m.i = 0xffffffff;
		dump_st(tmp, sizeof(tmp), m, v);
		INFOP("%s (s %x {%s})\n", cmdname(cmd), v.i, tmp);
		break;

	case P_STATE_CHG_REQ:
		m.i = be32_to_cpu(p->req_state.mask);
		v.i = be32_to_cpu(p->req_state.val);
		dump_st(tmp, sizeof(tmp), m, v);
		INFOP("%s (m %x v %x {%s})\n", cmdname(cmd), m.i, v.i, tmp);
		break;

	case P_STATE_CHG_REPLY:
		INFOP("%s (ret %x)\n", cmdname(cmd),
		      be32_to_cpu(p->req_state_reply.retcode));
		break;

	case P_PING:
	case P_PING_ACK:
		/*
		 * Dont trace pings at summary level
		 */
		if (trace_level < TRACE_LVL_ALL)
			break;
		/* fall through... */
	default:
		INFOP("%s (%u)\n", cmdname(cmd), cmd);
		break;
	}
}


static int __init drbd_trace_init(void)
{
	int ret;

	if (trace_mask & TRACE_UNPLUG) {
		ret = register_trace_drbd_unplug(probe_drbd_unplug);
		WARN_ON(ret);
	}
	if (trace_mask & TRACE_UUID) {
		ret = register_trace_drbd_uuid(probe_drbd_uuid);
		WARN_ON(ret);
	}
	if (trace_mask & TRACE_EE) {
		ret = register_trace_drbd_ee(probe_drbd_ee);
		WARN_ON(ret);
	}
	if (trace_mask & TRACE_PACKET) {
		ret = register_trace_drbd_packet(probe_drbd_packet);
		WARN_ON(ret);
	}
	if (trace_mask & TRACE_MD_IO) {
		ret = register_trace_drbd_md_io(probe_drbd_md_io);
		WARN_ON(ret);
	}
	if (trace_mask & TRACE_EPOCH) {
		ret = register_trace_drbd_epoch(probe_drbd_epoch);
		WARN_ON(ret);
	}
	if (trace_mask & TRACE_NL) {
		ret = register_trace_drbd_netlink(probe_drbd_netlink);
		WARN_ON(ret);
	}
	if (trace_mask & TRACE_AL_EXT) {
		ret = register_trace_drbd_actlog(probe_drbd_actlog);
		WARN_ON(ret);
	}
	if (trace_mask & TRACE_RQ) {
		ret = register_trace_drbd_bio(probe_drbd_bio);
		WARN_ON(ret);
	}
	if (trace_mask & TRACE_INT_RQ) {
		ret = register_trace_drbd_req(probe_drbd_req);
		WARN_ON(ret);
	}
	if (trace_mask & TRACE_RESYNC) {
		ret = register_trace__drbd_resync(probe_drbd_resync);
		WARN_ON(ret);
	}
	return 0;
}

module_init(drbd_trace_init);

static void __exit drbd_trace_exit(void)
{
	if (trace_mask & TRACE_UNPLUG)
		unregister_trace_drbd_unplug(probe_drbd_unplug);
	if (trace_mask & TRACE_UUID)
		unregister_trace_drbd_uuid(probe_drbd_uuid);
	if (trace_mask & TRACE_EE)
		unregister_trace_drbd_ee(probe_drbd_ee);
	if (trace_mask & TRACE_PACKET)
		unregister_trace_drbd_packet(probe_drbd_packet);
	if (trace_mask & TRACE_MD_IO)
		unregister_trace_drbd_md_io(probe_drbd_md_io);
	if (trace_mask & TRACE_EPOCH)
		unregister_trace_drbd_epoch(probe_drbd_epoch);
	if (trace_mask & TRACE_NL)
		unregister_trace_drbd_netlink(probe_drbd_netlink);
	if (trace_mask & TRACE_AL_EXT)
		unregister_trace_drbd_actlog(probe_drbd_actlog);
	if (trace_mask & TRACE_RQ)
		unregister_trace_drbd_bio(probe_drbd_bio);
	if (trace_mask & TRACE_INT_RQ)
		unregister_trace_drbd_req(probe_drbd_req);
	if (trace_mask & TRACE_RESYNC)
		unregister_trace__drbd_resync(probe_drbd_resync);

	tracepoint_synchronize_unregister();
}

module_exit(drbd_trace_exit);