drivers/md/dm-uevent.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Device Mapper Uevent Support (dm-uevent)
0004  *
0005  * Copyright IBM Corporation, 2007
0006  *  Author: Mike Anderson <andmike@linux.vnet.ibm.com>
0007  */
0008 #include <linux/list.h>
0009 #include <linux/slab.h>
0010 #include <linux/kobject.h>
0011 #include <linux/dm-ioctl.h>
0012 #include <linux/export.h>
0013
0014 #include "dm.h"
0015 #include "dm-uevent.h"
0016
0017 #define DM_MSG_PREFIX "uevent"
0018
0019 static const struct {
0020     enum dm_uevent_type type;
0021     enum kobject_action action;
0022     char *name;
0023 } _dm_uevent_type_names[] = {
0024     {DM_UEVENT_PATH_FAILED, KOBJ_CHANGE, "PATH_FAILED"},
0025     {DM_UEVENT_PATH_REINSTATED, KOBJ_CHANGE, "PATH_REINSTATED"},
0026 };
0027
0028 static struct kmem_cache *_dm_event_cache;
0029
0030 struct dm_uevent {
0031     struct mapped_device *md;
0032     enum kobject_action action;
0033     struct kobj_uevent_env ku_env;
0034     struct list_head elist;
0035     char name[DM_NAME_LEN];
0036     char uuid[DM_UUID_LEN];
0037 };
0038
0039 static void dm_uevent_free(struct dm_uevent *event)
0040 {
0041     kmem_cache_free(_dm_event_cache, event);
0042 }
0043
0044 static struct dm_uevent *dm_uevent_alloc(struct mapped_device *md)
0045 {
0046     struct dm_uevent *event;
0047
0048     event = kmem_cache_zalloc(_dm_event_cache, GFP_ATOMIC);
0049     if (!event)
0050         return NULL;
0051
0052     INIT_LIST_HEAD(&event->elist);
0053     event->md = md;
0054
0055     return event;
0056 }
0057
0058 static struct dm_uevent *dm_build_path_uevent(struct mapped_device *md,
0059                           struct dm_target *ti,
0060                           enum kobject_action action,
0061                           const char *dm_action,
0062                           const char *path,
0063                           unsigned nr_valid_paths)
0064 {
0065     struct dm_uevent *event;
0066
0067     event = dm_uevent_alloc(md);
0068     if (!event) {
0069         DMERR("%s: dm_uevent_alloc() failed", __func__);
0070         goto err_nomem;
0071     }
0072
0073     event->action = action;
0074
0075     if (add_uevent_var(&event->ku_env, "DM_TARGET=%s", ti->type->name)) {
0076         DMERR("%s: add_uevent_var() for DM_TARGET failed",
0077               __func__);
0078         goto err_add;
0079     }
0080
0081     if (add_uevent_var(&event->ku_env, "DM_ACTION=%s", dm_action)) {
0082         DMERR("%s: add_uevent_var() for DM_ACTION failed",
0083               __func__);
0084         goto err_add;
0085     }
0086
0087     if (add_uevent_var(&event->ku_env, "DM_SEQNUM=%u",
0088                dm_next_uevent_seq(md))) {
0089         DMERR("%s: add_uevent_var() for DM_SEQNUM failed",
0090               __func__);
0091         goto err_add;
0092     }
0093
0094     if (add_uevent_var(&event->ku_env, "DM_PATH=%s", path)) {
0095         DMERR("%s: add_uevent_var() for DM_PATH failed", __func__);
0096         goto err_add;
0097     }
0098
0099     if (add_uevent_var(&event->ku_env, "DM_NR_VALID_PATHS=%d",
0100                nr_valid_paths)) {
0101         DMERR("%s: add_uevent_var() for DM_NR_VALID_PATHS failed",
0102               __func__);
0103         goto err_add;
0104     }
0105
0106     return event;
0107
0108 err_add:
0109     dm_uevent_free(event);
0110 err_nomem:
0111     return ERR_PTR(-ENOMEM);
0112 }
0113
0114 /**
0115  * dm_send_uevents - send uevents for given list
0116  *
0117  * @events: list of events to send
0118  * @kobj:   kobject generating event
0119  *
0120  */
0121 void dm_send_uevents(struct list_head *events, struct kobject *kobj)
0122 {
0123     int r;
0124     struct dm_uevent *event, *next;
0125
0126     list_for_each_entry_safe(event, next, events, elist) {
0127         list_del_init(&event->elist);
0128
0129         /*
0130          * When a device is being removed this copy fails and we
0131          * discard these unsent events.
0132          */
0133         if (dm_copy_name_and_uuid(event->md, event->name,
0134                       event->uuid)) {
0135             DMINFO("%s: skipping sending uevent for lost device",
0136                    __func__);
0137             goto uevent_free;
0138         }
0139
0140         if (add_uevent_var(&event->ku_env, "DM_NAME=%s", event->name)) {
0141             DMERR("%s: add_uevent_var() for DM_NAME failed",
0142                   __func__);
0143             goto uevent_free;
0144         }
0145
0146         if (add_uevent_var(&event->ku_env, "DM_UUID=%s", event->uuid)) {
0147             DMERR("%s: add_uevent_var() for DM_UUID failed",
0148                   __func__);
0149             goto uevent_free;
0150         }
0151
0152         r = kobject_uevent_env(kobj, event->action, event->ku_env.envp);
0153         if (r)
0154             DMERR("%s: kobject_uevent_env failed", __func__);
0155 uevent_free:
0156         dm_uevent_free(event);
0157     }
0158 }
0159 EXPORT_SYMBOL_GPL(dm_send_uevents);
0160
0161 /**
0162  * dm_path_uevent - called to create a new path event and queue it
0163  *
0164  * @event_type: path event type enum
0165  * @ti:         pointer to a dm_target
0166  * @path:       string containing pathname
0167  * @nr_valid_paths: number of valid paths remaining
0168  *
0169  */
0170 void dm_path_uevent(enum dm_uevent_type event_type, struct dm_target *ti,
0171            const char *path, unsigned nr_valid_paths)
0172 {
0173     struct mapped_device *md = dm_table_get_md(ti->table);
0174     struct dm_uevent *event;
0175
0176     if (event_type >= ARRAY_SIZE(_dm_uevent_type_names)) {
0177         DMERR("%s: Invalid event_type %d", __func__, event_type);
0178         return;
0179     }
0180
0181     event = dm_build_path_uevent(md, ti,
0182                      _dm_uevent_type_names[event_type].action,
0183                      _dm_uevent_type_names[event_type].name,
0184                      path, nr_valid_paths);
0185     if (IS_ERR(event))
0186         return;
0187
0188     dm_uevent_add(md, &event->elist);
0189 }
0190 EXPORT_SYMBOL_GPL(dm_path_uevent);
0191
0192 int dm_uevent_init(void)
0193 {
0194     _dm_event_cache = KMEM_CACHE(dm_uevent, 0);
0195     if (!_dm_event_cache)
0196         return -ENOMEM;
0197
0198     DMINFO("version 1.0.3");
0199
0200     return 0;
0201 }
0202
0203 void dm_uevent_exit(void)
0204 {
0205     kmem_cache_destroy(_dm_event_cache);
0206 }