eal/linux: use strlcpy in uevent parsing
[dpdk.git] / lib / librte_eal / linuxapp / eal / eal_dev.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2018 Intel Corporation
3  */
4
5 #include <string.h>
6 #include <unistd.h>
7 #include <sys/socket.h>
8 #include <linux/netlink.h>
9
10 #include <rte_string_fns.h>
11 #include <rte_log.h>
12 #include <rte_compat.h>
13 #include <rte_dev.h>
14 #include <rte_malloc.h>
15 #include <rte_interrupts.h>
16 #include <rte_alarm.h>
17
18 #include "eal_private.h"
19
20 static struct rte_intr_handle intr_handle = {.fd = -1 };
21 static bool monitor_started;
22
23 #define EAL_UEV_MSG_LEN 4096
24 #define EAL_UEV_MSG_ELEM_LEN 128
25
26 static void dev_uev_handler(__rte_unused void *param);
27
28 /* identify the system layer which reports this event. */
29 enum eal_dev_event_subsystem {
30         EAL_DEV_EVENT_SUBSYSTEM_PCI, /* PCI bus device event */
31         EAL_DEV_EVENT_SUBSYSTEM_UIO, /* UIO driver device event */
32         EAL_DEV_EVENT_SUBSYSTEM_VFIO, /* VFIO driver device event */
33         EAL_DEV_EVENT_SUBSYSTEM_MAX
34 };
35
36 static int
37 dev_uev_socket_fd_create(void)
38 {
39         struct sockaddr_nl addr;
40         int ret;
41
42         intr_handle.fd = socket(PF_NETLINK, SOCK_RAW | SOCK_CLOEXEC |
43                         SOCK_NONBLOCK,
44                         NETLINK_KOBJECT_UEVENT);
45         if (intr_handle.fd < 0) {
46                 RTE_LOG(ERR, EAL, "create uevent fd failed.\n");
47                 return -1;
48         }
49
50         memset(&addr, 0, sizeof(addr));
51         addr.nl_family = AF_NETLINK;
52         addr.nl_pid = 0;
53         addr.nl_groups = 0xffffffff;
54
55         ret = bind(intr_handle.fd, (struct sockaddr *) &addr, sizeof(addr));
56         if (ret < 0) {
57                 RTE_LOG(ERR, EAL, "Failed to bind uevent socket.\n");
58                 goto err;
59         }
60
61         return 0;
62 err:
63         close(intr_handle.fd);
64         intr_handle.fd = -1;
65         return ret;
66 }
67
68 static int
69 dev_uev_parse(const char *buf, struct rte_dev_event *event, int length)
70 {
71         char action[EAL_UEV_MSG_ELEM_LEN];
72         char subsystem[EAL_UEV_MSG_ELEM_LEN];
73         char pci_slot_name[EAL_UEV_MSG_ELEM_LEN];
74         int i = 0;
75
76         memset(action, 0, EAL_UEV_MSG_ELEM_LEN);
77         memset(subsystem, 0, EAL_UEV_MSG_ELEM_LEN);
78         memset(pci_slot_name, 0, EAL_UEV_MSG_ELEM_LEN);
79
80         while (i < length) {
81                 for (; i < length; i++) {
82                         if (*buf)
83                                 break;
84                         buf++;
85                 }
86                 /**
87                  * check device uevent from kernel side, no need to check
88                  * uevent from udev.
89                  */
90                 if (!strncmp(buf, "libudev", 7)) {
91                         buf += 7;
92                         i += 7;
93                         return -1;
94                 }
95                 if (!strncmp(buf, "ACTION=", 7)) {
96                         buf += 7;
97                         i += 7;
98                         strlcpy(action, buf, sizeof(action));
99                 } else if (!strncmp(buf, "SUBSYSTEM=", 10)) {
100                         buf += 10;
101                         i += 10;
102                         strlcpy(subsystem, buf, sizeof(subsystem));
103                 } else if (!strncmp(buf, "PCI_SLOT_NAME=", 14)) {
104                         buf += 14;
105                         i += 14;
106                         strlcpy(pci_slot_name, buf, sizeof(subsystem));
107                         event->devname = strdup(pci_slot_name);
108                 }
109                 for (; i < length; i++) {
110                         if (*buf == '\0')
111                                 break;
112                         buf++;
113                 }
114         }
115
116         /* parse the subsystem layer */
117         if (!strncmp(subsystem, "uio", 3))
118                 event->subsystem = EAL_DEV_EVENT_SUBSYSTEM_UIO;
119         else if (!strncmp(subsystem, "pci", 3))
120                 event->subsystem = EAL_DEV_EVENT_SUBSYSTEM_PCI;
121         else if (!strncmp(subsystem, "vfio", 4))
122                 event->subsystem = EAL_DEV_EVENT_SUBSYSTEM_VFIO;
123         else
124                 return -1;
125
126         /* parse the action type */
127         if (!strncmp(action, "add", 3))
128                 event->type = RTE_DEV_EVENT_ADD;
129         else if (!strncmp(action, "remove", 6))
130                 event->type = RTE_DEV_EVENT_REMOVE;
131         else
132                 return -1;
133         return 0;
134 }
135
136 static void
137 dev_delayed_unregister(void *param)
138 {
139         rte_intr_callback_unregister(&intr_handle, dev_uev_handler, param);
140         close(intr_handle.fd);
141         intr_handle.fd = -1;
142 }
143
144 static void
145 dev_uev_handler(__rte_unused void *param)
146 {
147         struct rte_dev_event uevent;
148         int ret;
149         char buf[EAL_UEV_MSG_LEN];
150
151         memset(&uevent, 0, sizeof(struct rte_dev_event));
152         memset(buf, 0, EAL_UEV_MSG_LEN);
153
154         ret = recv(intr_handle.fd, buf, EAL_UEV_MSG_LEN, MSG_DONTWAIT);
155         if (ret < 0 && errno == EAGAIN)
156                 return;
157         else if (ret <= 0) {
158                 /* connection is closed or broken, can not up again. */
159                 RTE_LOG(ERR, EAL, "uevent socket connection is broken.\n");
160                 rte_eal_alarm_set(1, dev_delayed_unregister, NULL);
161                 return;
162         }
163
164         ret = dev_uev_parse(buf, &uevent, EAL_UEV_MSG_LEN);
165         if (ret < 0) {
166                 RTE_LOG(DEBUG, EAL, "It is not an valid event "
167                         "that need to be handle.\n");
168                 return;
169         }
170
171         RTE_LOG(DEBUG, EAL, "receive uevent(name:%s, type:%d, subsystem:%d)\n",
172                 uevent.devname, uevent.type, uevent.subsystem);
173
174         if (uevent.devname)
175                 dev_callback_process(uevent.devname, uevent.type);
176 }
177
178 int __rte_experimental
179 rte_dev_event_monitor_start(void)
180 {
181         int ret;
182
183         if (monitor_started)
184                 return 0;
185
186         ret = dev_uev_socket_fd_create();
187         if (ret) {
188                 RTE_LOG(ERR, EAL, "error create device event fd.\n");
189                 return -1;
190         }
191
192         intr_handle.type = RTE_INTR_HANDLE_DEV_EVENT;
193         ret = rte_intr_callback_register(&intr_handle, dev_uev_handler, NULL);
194
195         if (ret) {
196                 RTE_LOG(ERR, EAL, "fail to register uevent callback.\n");
197                 return -1;
198         }
199
200         monitor_started = true;
201
202         return 0;
203 }
204
205 int __rte_experimental
206 rte_dev_event_monitor_stop(void)
207 {
208         int ret;
209
210         if (!monitor_started)
211                 return 0;
212
213         ret = rte_intr_callback_unregister(&intr_handle, dev_uev_handler,
214                                            (void *)-1);
215         if (ret < 0) {
216                 RTE_LOG(ERR, EAL, "fail to unregister uevent callback.\n");
217                 return ret;
218         }
219
220         close(intr_handle.fd);
221         intr_handle.fd = -1;
222         monitor_started = false;
223         return 0;
224 }