xref: /titanic_44/usr/src/cmd/zevadm/zevadm.c (revision aafc540fedcd29b30eb3e489b51908a545618f14)

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <stropts.h>
#include <poll.h>
#include <string.h>
#include <sys/fs/zev.h>
#include <errno.h>
#include <libnvpair.h>

#define OP_STATISTICS		(1 << 0)
#define OP_POLL_EVENTS		(1 << 1)
#define OP_MUTE_POOL		(1 << 2)
#define OP_UNMUTE_POOL		(1 << 3)
#define OP_SET_MAX_QUEUE_LEN	(1 << 4)

#define ZEV_DEVICE "/devices/pseudo/zev@0:zev"

static char *zev_device = ZEV_DEVICE;

static char *zev_op_name[] = {
	"ZEV_OP_ERROR",
	"ZEV_OP_ZFS_MOUNT",
	"ZEV_OP_ZFS_UMOUNT",
	"ZEV_OP_ZVOL_WRITE",
	"ZEV_OP_ZVOL_TRUNCATE",
	"ZEV_OP_ZNODE_CLOSE_AFTER_UPDATE",
	"ZEV_OP_ZNODE_CREATE",
	"ZEV_OP_ZNODE_MKDIR",
	"ZEV_OP_ZNODE_MAKE_XATTR_DIR",
	"ZEV_OP_ZNODE_REMOVE",
	"ZEV_OP_ZNODE_RMDIR",
	"ZEV_OP_ZNODE_LINK",
	"ZEV_OP_ZNODE_SYMLINK",
	"ZEV_OP_ZNODE_RENAME",
	"ZEV_OP_ZNODE_WRITE",
	"ZEV_OP_ZNODE_TRUNCATE",
	"ZEV_OP_ZNODE_SETATTR",
	"ZEV_OP_ZNODE_ACL",
	NULL
};

static void
zev_statistics(int fd)
{
	zev_statistics_t zs;
	if (ioctl(fd, ZEV_IOC_GET_STATISTICS, &zs)) {
		perror("getting statistics data failed");
		exit (EXIT_FAILURE);
	}
	printf("ZEV module state:\n");

	printf("    queue length in bytes   : %lu\n", zs.zev_queue_len);
	printf("    queue length limit      : %lu\n", zs.zev_max_queue_len);
	printf("    poll wakeup throttle    : %lu\n\n",
	    zs.zev_poll_wakeup_queue_len);
	printf("    bytes read from device  : %lu\n", zs.zev_bytes_read);
	printf("    module internal errors  : %lu\n\n", zs.zev_cnt_errors);

	printf("ZFS event statistics:\n");

	printf("    total ZFS events        : %lu\n", zs.zev_cnt_total_events);
	printf("    ZFS mount               : %lu\n", zs.zev_cnt_zfs_mount);
	printf("    ZFS umount              : %lu\n", zs.zev_cnt_zfs_umount);
	printf("    ZVOL write              : %lu\n", zs.zev_cnt_zvol_write);
	printf("    ZVOL truncate           : %lu\n", zs.zev_cnt_zvol_truncate);
	printf("    ZNODE close after update: %lu\n",
	    zs.zev_cnt_znode_close_after_update);
	printf("    ZNODE create            : %lu\n", zs.zev_cnt_znode_create);
	printf("    ZNODE remove            : %lu\n", zs.zev_cnt_znode_remove);
	printf("    ZNODE link              : %lu\n", zs.zev_cnt_znode_link);
	printf("    ZNODE symlink           : %lu\n", zs.zev_cnt_znode_symlink);
	printf("    ZNODE rename            : %lu\n", zs.zev_cnt_znode_rename);
	printf("    ZNODE write             : %lu\n", zs.zev_cnt_znode_write);
	printf("    ZNODE truncate          : %lu\n",
	    zs.zev_cnt_znode_truncate);
	printf("    ZNODE setattr           : %lu\n", zs.zev_cnt_znode_setattr);
	printf("    ZNODE acl               : %lu\n", zs.zev_cnt_znode_acl);
}

static void
zev_print_event(char *buf, int len)
{
	nvlist_t *nvl;
	nvpair_t *curr, *next;
	int err;
	char *key;
	data_type_t type;
	uchar_t op;
	uint64_t op_time;
	char *when;
	time_t ot;
	boolean_t val_bool;
	uint64_t val_uint64;
	char *val_string;
	uchar_t val_byte;
	int32_t val_int32;

	if (0 != nvlist_unpack(buf, len, &nvl, NV_ENCODE_NATIVE)) {
		fprintf(stderr, "zev event garbled: can't unpack nvlist\n");
		exit(1);
	}

	if (0 != nvlist_lookup_byte(nvl, "op", &op)) {
		fprintf(stderr, "zev event garbled: no op specified\n");
		exit(1);
	}
	if (op < ZEV_OP_MIN || op > ZEV_OP_MAX) {
		fprintf(stderr, "zev event garbled: op %d is outside range\n",
		        op);
		exit(1);
	}
	if (0 != nvlist_lookup_uint64(nvl, "op_time", &op_time)) {
		fprintf(stderr, "zev event garbled: no op_time specified\n");
		exit(1);
	}
	ot = op_time;
	when = ctime(&ot);
	when[24] = '\0';
	printf("%s %s", when, zev_op_name[op - ZEV_OP_MIN]);

	curr = nvlist_next_nvpair(nvl, NULL);
	while (curr != NULL) {
		nvpair_t *next = nvlist_next_nvpair(nvl, curr);
		key = nvpair_name(curr);
		if (!strcmp(key, "op"))
			goto skip;
		if (!strcmp(key, "op_time"))
			goto skip;
		type = nvpair_type(curr);
		switch (type) {
		case DATA_TYPE_BOOLEAN_VALUE:
			nvlist_lookup_boolean_value(nvl, key, &val_bool);
			printf(" %s=%s", key, (val_bool ? "true" : "false"));
			break;
		case DATA_TYPE_BYTE:
			nvlist_lookup_byte(nvl, key, &val_byte);
			printf(" %s=%d", key, val_byte);
			break;
		case DATA_TYPE_UINT64:
			nvlist_lookup_uint64(nvl, key, &val_uint64);
			printf(" %s=%llu", key, val_uint64);
			break;
		case DATA_TYPE_INT32:
			nvlist_lookup_int32(nvl, key, &val_int32);
			printf(" %s=%d", key, val_int32);
			break;
		case DATA_TYPE_STRING:
			nvlist_lookup_string(nvl, key, &val_string);
			printf(" %s=%s", key, val_string);
			break;
		default:
			fprintf(stderr, "unexpected nvlist data type: %d\n",
			        type);
			exit(1);
		}
skip:
		curr = next;
	}
	printf("\n");
}

static void
zev_poll_events(int fd)
{
	struct pollfd pfd[1];
	int ret;
	char buf[4096];
	while (1) {
		pfd[0].fd = fd;
		pfd[0].events = POLLIN;
		ret = poll(pfd, 1, 1000);
		if (ret < 0) {
			perror("poll failed");
			exit(EXIT_FAILURE);
		}
		if (!(pfd[0].revents & POLLIN))
			continue;
		/* data available */
		ret = read(fd, buf, sizeof(buf));
		if (ret < 0) {
			perror("read failed");
			exit(EXIT_FAILURE);
		}
		if (ret == 0)
			continue;
		zev_print_event(buf, ret);
	}
	return;
}

static void
usage(char *progname)
{
	fprintf(stderr, "usage: %s [-s] [-d <dev>]\n", progname);
	fprintf(stderr, "   -s         show zev statistics\n");
	fprintf(stderr, "   -p         poll for ZFS events\n");
	fprintf(stderr, "   -q <bytes> set maximum event queue length\n");
	fprintf(stderr, "   -t <bytes> set queue length poll throttle\n");
	fprintf(stderr, "   -m <pool>  mute pool, no events for this pool\n");
	fprintf(stderr, "   -M <pool>  unmute pool\n");
	fprintf(stderr, "   -d <dev>   device file to use. default is '%s'\n",
	    ZEV_DEVICE);
	exit (EXIT_FAILURE);
}

static int
zev_set_max_queue_len(int fd, char *optarg)
{
	uint64_t maxqueuelen;

	errno = 0;
	maxqueuelen = strtol(optarg, (char **)NULL, 10);
	if (errno) {
		fprintf(stderr, "invalid queue length parameter: %s\n", optarg);
		return (EXIT_FAILURE);
	}
	if (ioctl(fd, ZEV_IOC_SET_MAX_QUEUE_LEN, &maxqueuelen)) {
		perror("setting max queue length failed");
		return (EXIT_FAILURE);
	}
	return (0);
}

static int
zev_set_poll_wakeup_queue_len(int fd, char *optarg)
{
	uint64_t queuelen;

	errno = 0;
	queuelen = strtol(optarg, (char **)NULL, 10);
	if (errno) {
		fprintf(stderr, "invalid queue length parameter: %s\n", optarg);
		return (EXIT_FAILURE);
	}
	if (ioctl(fd, ZEV_IOC_SET_POLL_WAKEUP_QUEUE_LEN, &queuelen)) {
		perror("setting poll wakeup queue length failed");
		return (EXIT_FAILURE);
	}
	return (0);
}

static int
zev_mute_unmute_impl(int fd, char *poolname, int mute)
{
	zev_ioctl_poolarg_t pa;
	int len;
	int op = mute ? ZEV_IOC_MUTE_POOL : ZEV_IOC_UNMUTE_POOL;
	len = strlen(poolname);
	if (len <= 0 || len >= sizeof(pa.zev_poolname)) {
		fprintf(stderr, "invalid poolname: %s\n", poolname);
		return (EXIT_FAILURE);
	}
	strcpy(pa.zev_poolname, poolname);
	pa.zev_poolname_len = len;
	if (ioctl(fd, op, &pa)) {
		perror("muting pool data failed");
		return (EXIT_FAILURE);
	}
	return (0);
}

int
zev_mute_pool(int fd, char *poolname)
{
	return zev_mute_unmute_impl(fd, poolname, 1);
}

int
zev_unmute_pool(int fd, char *poolname)
{
	return zev_mute_unmute_impl(fd, poolname, 0);
}

int
main(int argc, char **argv)
{
	int fd;
	int c;
	int ops = 0;
	extern char *optarg;

	/* open device */
	fd = open(zev_device, O_RDONLY);
	if (fd < 0) {
		perror("opening zev device failed");
		return EXIT_FAILURE;
	}
	while ((c = getopt(argc, argv, "spdq:t:m:M:h?")) != -1) {
		switch(c) {
		case 's':
			ops |= OP_STATISTICS;
			break;
		case 'p':
			ops |= OP_POLL_EVENTS;
			break;
		case 'd':
			zev_device = optarg;
			break;
		case 'q':
			return zev_set_max_queue_len(fd, optarg);
		case 't':
			return zev_set_poll_wakeup_queue_len(fd, optarg);
		case 'm':
			return zev_mute_pool(fd, optarg);
		case 'M':
			return zev_unmute_pool(fd, optarg);
		case 'h':
		case '?':
		default:
			usage(argv[0]);
		}
	}
	if (!ops)
		usage(argv[0]);
	if (ops & OP_STATISTICS)
		zev_statistics(fd);
	if (ops & OP_POLL_EVENTS)
		zev_poll_events(fd);
	close(fd);
	return EXIT_SUCCESS;
}