1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License Version 1.0 (CDDL-1.0).
6 * You can obtain a copy of the license from the top-level file
7 * "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
8 * You may not use this file except in compliance with the license.
9 *
10 * CDDL HEADER END
11 */
12
13/*
14 * Copyright (c) 2016, 2017, Intel Corporation.
15 */
16
17#ifdef HAVE_LIBUDEV
18
19#include <errno.h>
20#include <fcntl.h>
21#include <libnvpair.h>
22#include <libudev.h>
23#include <libzfs.h>
24#include <libzutil.h>
25#include <pthread.h>
26#include <stdlib.h>
27#include <string.h>
28
29#include <sys/sysevent/eventdefs.h>
30#include <sys/sysevent/dev.h>
31
32#include "zed_log.h"
33#include "zed_disk_event.h"
34#include "agents/zfs_agents.h"
35
36/*
37 * Portions of ZED need to see disk events for disks belonging to ZFS pools.
38 * A libudev monitor is established to monitor block device actions and pass
39 * them on to internal ZED logic modules.  Initially, zfs_mod.c is the only
40 * consumer and is the Linux equivalent for the illumos syseventd ZFS SLM
41 * module responsible for handling disk events for ZFS.
42 */
43
44pthread_t g_mon_tid;
45struct udev *g_udev;
46struct udev_monitor *g_mon;
47
48
49#define	DEV_BYID_PATH	"/dev/disk/by-id/"
50
51/* 64MB is minimum usable disk for ZFS */
52#define	MINIMUM_SECTORS		131072
53
54
55/*
56 * Post disk event to SLM module
57 *
58 * occurs in the context of monitor thread
59 */
60static void
61zed_udev_event(const char *class, const char *subclass, nvlist_t *nvl)
62{
63	char *strval;
64	uint64_t numval;
65
66	zed_log_msg(LOG_INFO, "zed_disk_event:");
67	zed_log_msg(LOG_INFO, "\tclass: %s", class);
68	zed_log_msg(LOG_INFO, "\tsubclass: %s", subclass);
69	if (nvlist_lookup_string(nvl, DEV_NAME, &strval) == 0)
70		zed_log_msg(LOG_INFO, "\t%s: %s", DEV_NAME, strval);
71	if (nvlist_lookup_string(nvl, DEV_PATH, &strval) == 0)
72		zed_log_msg(LOG_INFO, "\t%s: %s", DEV_PATH, strval);
73	if (nvlist_lookup_string(nvl, DEV_IDENTIFIER, &strval) == 0)
74		zed_log_msg(LOG_INFO, "\t%s: %s", DEV_IDENTIFIER, strval);
75	if (nvlist_lookup_string(nvl, DEV_PHYS_PATH, &strval) == 0)
76		zed_log_msg(LOG_INFO, "\t%s: %s", DEV_PHYS_PATH, strval);
77	if (nvlist_lookup_uint64(nvl, DEV_SIZE, &numval) == 0)
78		zed_log_msg(LOG_INFO, "\t%s: %llu", DEV_SIZE, numval);
79	if (nvlist_lookup_uint64(nvl, ZFS_EV_POOL_GUID, &numval) == 0)
80		zed_log_msg(LOG_INFO, "\t%s: %llu", ZFS_EV_POOL_GUID, numval);
81	if (nvlist_lookup_uint64(nvl, ZFS_EV_VDEV_GUID, &numval) == 0)
82		zed_log_msg(LOG_INFO, "\t%s: %llu", ZFS_EV_VDEV_GUID, numval);
83
84	(void) zfs_agent_post_event(class, subclass, nvl);
85}
86
87/*
88 * dev_event_nvlist: place event schema into an nv pair list
89 *
90 * NAME			VALUE (example)
91 * --------------	--------------------------------------------------------
92 * DEV_NAME		/dev/sdl
93 * DEV_PATH		/devices/pci0000:00/0000:00:03.0/0000:04:00.0/host0/...
94 * DEV_IDENTIFIER	ata-Hitachi_HTS725050A9A362_100601PCG420VLJ37DMC
95 * DEV_PHYS_PATH	pci-0000:04:00.0-sas-0x4433221101000000-lun-0
96 * DEV_IS_PART		---
97 * DEV_SIZE		500107862016
98 * ZFS_EV_POOL_GUID	17523635698032189180
99 * ZFS_EV_VDEV_GUID	14663607734290803088
100 */
101static nvlist_t *
102dev_event_nvlist(struct udev_device *dev)
103{
104	nvlist_t *nvl;
105	char strval[128];
106	const char *value, *path;
107	uint64_t guid;
108
109	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
110		return (NULL);
111
112	if (zfs_device_get_devid(dev, strval, sizeof (strval)) == 0)
113		(void) nvlist_add_string(nvl, DEV_IDENTIFIER, strval);
114	if (zfs_device_get_physical(dev, strval, sizeof (strval)) == 0)
115		(void) nvlist_add_string(nvl, DEV_PHYS_PATH, strval);
116	if ((path = udev_device_get_devnode(dev)) != NULL)
117		(void) nvlist_add_string(nvl, DEV_NAME, path);
118	if ((value = udev_device_get_devpath(dev)) != NULL)
119		(void) nvlist_add_string(nvl, DEV_PATH, value);
120	value = udev_device_get_devtype(dev);
121	if ((value != NULL && strcmp("partition", value) == 0) ||
122	    (udev_device_get_property_value(dev, "ID_PART_ENTRY_NUMBER")
123	    != NULL)) {
124		(void) nvlist_add_boolean(nvl, DEV_IS_PART);
125	}
126	if ((value = udev_device_get_sysattr_value(dev, "size")) != NULL) {
127		uint64_t numval = DEV_BSIZE;
128
129		numval *= strtoull(value, NULL, 10);
130		(void) nvlist_add_uint64(nvl, DEV_SIZE, numval);
131	}
132
133	/*
134	 * Grab the pool and vdev guids from blkid cache
135	 */
136	value = udev_device_get_property_value(dev, "ID_FS_UUID");
137	if (value != NULL && (guid = strtoull(value, NULL, 10)) != 0)
138		(void) nvlist_add_uint64(nvl, ZFS_EV_POOL_GUID, guid);
139
140	value = udev_device_get_property_value(dev, "ID_FS_UUID_SUB");
141	if (value != NULL && (guid = strtoull(value, NULL, 10)) != 0)
142		(void) nvlist_add_uint64(nvl, ZFS_EV_VDEV_GUID, guid);
143
144	/*
145	 * Either a vdev guid or a devid must be present for matching
146	 */
147	if (!nvlist_exists(nvl, DEV_IDENTIFIER) &&
148	    !nvlist_exists(nvl, ZFS_EV_VDEV_GUID)) {
149		nvlist_free(nvl);
150		return (NULL);
151	}
152
153	return (nvl);
154}
155
156/*
157 *  Listen for block device uevents
158 */
159static void *
160zed_udev_monitor(void *arg)
161{
162	struct udev_monitor *mon = arg;
163	char *tmp, *tmp2;
164
165	zed_log_msg(LOG_INFO, "Waiting for new udev disk events...");
166
167	while (1) {
168		struct udev_device *dev;
169		const char *action, *type, *part, *sectors;
170		const char *bus, *uuid;
171		const char *class, *subclass;
172		nvlist_t *nvl;
173		boolean_t is_zfs = B_FALSE;
174
175		/* allow a cancellation while blocked (recvmsg) */
176		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
177
178		/* blocks at recvmsg until an event occurs */
179		if ((dev = udev_monitor_receive_device(mon)) == NULL) {
180			zed_log_msg(LOG_WARNING, "zed_udev_monitor: receive "
181			    "device error %d", errno);
182			continue;
183		}
184
185		/* allow all steps to complete before a cancellation */
186		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
187
188		/*
189		 * Strongly typed device is the preferred filter
190		 */
191		type = udev_device_get_property_value(dev, "ID_FS_TYPE");
192		if (type != NULL && type[0] != '\0') {
193			if (strcmp(type, "zfs_member") == 0) {
194				is_zfs = B_TRUE;
195			} else {
196				/* not ours, so skip */
197				zed_log_msg(LOG_INFO, "zed_udev_monitor: skip "
198				    "%s (in use by %s)",
199				    udev_device_get_devnode(dev), type);
200				udev_device_unref(dev);
201				continue;
202			}
203		}
204
205		/*
206		 * if this is a disk and it is partitioned, then the
207		 * zfs label will reside in a DEVTYPE=partition and
208		 * we can skip passing this event
209		 */
210		type = udev_device_get_property_value(dev, "DEVTYPE");
211		part = udev_device_get_property_value(dev,
212		    "ID_PART_TABLE_TYPE");
213		if (type != NULL && type[0] != '\0' &&
214		    strcmp(type, "disk") == 0 &&
215		    part != NULL && part[0] != '\0') {
216			/* skip and wait for partition event */
217			udev_device_unref(dev);
218			continue;
219		}
220
221		/*
222		 * ignore small partitions
223		 */
224		sectors = udev_device_get_property_value(dev,
225		    "ID_PART_ENTRY_SIZE");
226		if (sectors == NULL)
227			sectors = udev_device_get_sysattr_value(dev, "size");
228		if (sectors != NULL &&
229		    strtoull(sectors, NULL, 10) < MINIMUM_SECTORS) {
230			udev_device_unref(dev);
231			continue;
232		}
233
234		/*
235		 * If the blkid probe didn't find ZFS, then a persistent
236		 * device id string is required in the message schema
237		 * for matching with vdevs. Preflight here for expected
238		 * udev information.
239		 */
240		bus = udev_device_get_property_value(dev, "ID_BUS");
241		uuid = udev_device_get_property_value(dev, "DM_UUID");
242		if (!is_zfs && (bus == NULL && uuid == NULL)) {
243			zed_log_msg(LOG_INFO, "zed_udev_monitor: %s no devid "
244			    "source", udev_device_get_devnode(dev));
245			udev_device_unref(dev);
246			continue;
247		}
248
249		action = udev_device_get_action(dev);
250		if (strcmp(action, "add") == 0) {
251			class = EC_DEV_ADD;
252			subclass = ESC_DISK;
253		} else if (strcmp(action, "remove") == 0) {
254			class = EC_DEV_REMOVE;
255			subclass = ESC_DISK;
256		} else if (strcmp(action, "change") == 0) {
257			class = EC_DEV_STATUS;
258			subclass = ESC_DEV_DLE;
259		} else {
260			zed_log_msg(LOG_WARNING, "zed_udev_monitor: %s unknown",
261			    action);
262			udev_device_unref(dev);
263			continue;
264		}
265
266		/*
267		 * Special case an EC_DEV_ADD for multipath devices
268		 *
269		 * When a multipath device is created, udev reports the
270		 * following:
271		 *
272		 * 1.	"add" event of the dm device for the multipath device
273		 *	(like /dev/dm-3).
274		 * 2.	"change" event to create the actual multipath device
275		 *	symlink (like /dev/mapper/mpatha).  The event also
276		 *	passes back the relevant DM vars we care about, like
277		 *	DM_UUID.
278		 * 3.	Another "change" event identical to #2 (that we ignore).
279		 *
280		 * To get the behavior we want, we treat the "change" event
281		 * in #2 as a "add" event; as if "/dev/mapper/mpatha" was
282		 * a new disk being added.
283		 */
284		if (strcmp(class, EC_DEV_STATUS) == 0 &&
285		    udev_device_get_property_value(dev, "DM_UUID") &&
286		    udev_device_get_property_value(dev, "MPATH_SBIN_PATH")) {
287			tmp = (char *)udev_device_get_devnode(dev);
288			tmp2 = zfs_get_underlying_path(tmp);
289			if (tmp && tmp2 && (strcmp(tmp, tmp2) != 0)) {
290				/*
291				 * We have a real underlying device, which
292				 * means that this multipath "change" event is
293				 * an "add" event.
294				 *
295				 * If the multipath device and the underlying
296				 * dev are the same name (i.e. /dev/dm-5), then
297				 * there is no real underlying disk for this
298				 * multipath device, and so this "change" event
299				 * really is a multipath removal.
300				 */
301				class = EC_DEV_ADD;
302				subclass = ESC_DISK;
303			} else {
304				tmp = (char *)
305				    udev_device_get_property_value(dev,
306				    "DM_NR_VALID_PATHS");
307				/* treat as a multipath remove */
308				if (tmp != NULL && strcmp(tmp, "0") == 0) {
309					class = EC_DEV_REMOVE;
310					subclass = ESC_DISK;
311				}
312			}
313			free(tmp2);
314		}
315
316		/*
317		 * Special case an EC_DEV_ADD for scsi_debug devices
318		 *
319		 * These devices require a udevadm trigger command after
320		 * creation in order to register the vdev_id scsidebug alias
321		 * rule (adds a persistent path (phys_path) used for fault
322		 * management automated tests in the ZFS test suite.
323		 *
324		 * After udevadm trigger command, event registers as a "change"
325		 * event but needs to instead be handled as another "add" event
326		 * to allow for disk labeling and partitioning to occur.
327		 */
328		if (strcmp(class, EC_DEV_STATUS) == 0 &&
329		    udev_device_get_property_value(dev, "ID_VDEV") &&
330		    udev_device_get_property_value(dev, "ID_MODEL")) {
331			const char *id_model, *id_model_sd = "scsi_debug";
332
333			id_model = udev_device_get_property_value(dev,
334			    "ID_MODEL");
335			if (strcmp(id_model, id_model_sd) == 0) {
336				class = EC_DEV_ADD;
337				subclass = ESC_DISK;
338			}
339		}
340
341		if ((nvl = dev_event_nvlist(dev)) != NULL) {
342			zed_udev_event(class, subclass, nvl);
343			nvlist_free(nvl);
344		}
345
346		udev_device_unref(dev);
347	}
348
349	return (NULL);
350}
351
352int
353zed_disk_event_init()
354{
355	int fd, fflags;
356
357	if ((g_udev = udev_new()) == NULL) {
358		zed_log_msg(LOG_WARNING, "udev_new failed (%d)", errno);
359		return (-1);
360	}
361
362	/* Set up a udev monitor for block devices */
363	g_mon = udev_monitor_new_from_netlink(g_udev, "udev");
364	udev_monitor_filter_add_match_subsystem_devtype(g_mon, "block", "disk");
365	udev_monitor_filter_add_match_subsystem_devtype(g_mon, "block",
366	    "partition");
367	udev_monitor_enable_receiving(g_mon);
368
369	/* Make sure monitoring socket is blocking */
370	fd = udev_monitor_get_fd(g_mon);
371	if ((fflags = fcntl(fd, F_GETFL)) & O_NONBLOCK)
372		(void) fcntl(fd, F_SETFL, fflags & ~O_NONBLOCK);
373
374	/* spawn a thread to monitor events */
375	if (pthread_create(&g_mon_tid, NULL, zed_udev_monitor, g_mon) != 0) {
376		udev_monitor_unref(g_mon);
377		udev_unref(g_udev);
378		zed_log_msg(LOG_WARNING, "pthread_create failed");
379		return (-1);
380	}
381
382	pthread_setname_np(g_mon_tid, "udev monitor");
383	zed_log_msg(LOG_INFO, "zed_disk_event_init");
384
385	return (0);
386}
387
388void
389zed_disk_event_fini()
390{
391	/* cancel monitor thread at recvmsg() */
392	(void) pthread_cancel(g_mon_tid);
393	(void) pthread_join(g_mon_tid, NULL);
394
395	/* cleanup udev resources */
396	udev_monitor_unref(g_mon);
397	udev_unref(g_udev);
398
399	zed_log_msg(LOG_INFO, "zed_disk_event_fini");
400}
401
402#else
403
404#include "zed_disk_event.h"
405
406int
407zed_disk_event_init()
408{
409	return (0);
410}
411
412void
413zed_disk_event_fini()
414{
415}
416
417#endif /* HAVE_LIBUDEV */
418