1 /*
2 * Copyright (c) 2014 Intel Corporation. All Rights Reserved
3 *
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 *
32 */
33
34 #if HAVE_CONFIG_H
35 # include <config.h>
36 #endif /* HAVE_CONFIG_H */
37
38 #include <poll.h>
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <fcntl.h>
42 #include <assert.h>
43 #include <string.h>
44 #include <limits.h>
45 #include <stdio.h>
46 #include <syslog.h>
47 #include <dirent.h>
48 #include <errno.h>
49 #include <unistd.h>
50 #include <getopt.h>
51 #include <stdlib.h>
52
53 #include <libudev.h>
54
55 struct udev *udev;
56 struct udev_monitor *mon;
57
58 #include "ibdiag_common.h"
59
60 #define SYS_HOSTNAME "/proc/sys/kernel/hostname"
61 #define DEF_SYS_DIR "/sys"
62 char *sys_dir = DEF_SYS_DIR;
63 #define SYS_INFINIBAND "class/infiniband"
64 #define DEFAULT_RETRY_RATE 60
65 #define DEFAULT_RETRY_COUNT 0
66 #define DEFAULT_ND_FORMAT "%h %d"
67
68 int failure_retry_rate = DEFAULT_RETRY_RATE;
69 int set_retry_cnt = DEFAULT_RETRY_COUNT;
70 int foreground = 0;
71 char *pidfile = NULL;
72
newline_to_null(char * str)73 static void newline_to_null(char *str)
74 {
75 char *term = index(str, '\n');
76 if (term)
77 *term = '\0';
78 }
79
strip_domain(char * str)80 static void strip_domain(char *str)
81 {
82 char *term = index(str, '.');
83 if (term)
84 *term = '\0';
85 }
86
build_node_desc(char * dest,size_t len,const char * device,const char * hostname)87 static void build_node_desc(char *dest, size_t len,
88 const char *device, const char *hostname)
89 {
90 char *end = dest + len-1;
91 const char *field;
92 char *src = ibd_nd_format;
93
94 while (*src && (dest < end)) {
95 if (*src != '%') {
96 *dest++ = *src++;
97 } else {
98 src++;
99 switch (*src) {
100 case 'h':
101 field = hostname;
102 while (*field && (*field != '.') && (dest < end))
103 *dest++ = *field++;
104 break;
105 case 'd':
106 field = device;
107 while (*field && (dest < end))
108 *dest++ = *field++;
109 break;
110 }
111 src++;
112 }
113 }
114 *dest = 0;
115 }
116
update_node_desc(const char * device,const char * hostname,int force)117 static int update_node_desc(const char *device, const char *hostname, int force)
118 {
119 int rc;
120 char nd[128];
121 char new_nd[64];
122 char nd_file[PATH_MAX];
123 FILE *f;
124
125 snprintf(nd_file, sizeof(nd_file), "%s/%s/%s/node_desc",
126 sys_dir, SYS_INFINIBAND, device);
127 nd_file[sizeof(nd_file)-1] = '\0';
128
129 f = fopen(nd_file, "r+");
130 if (!f) {
131 syslog(LOG_ERR, "Failed to open %s\n", nd_file);
132 return -EIO;
133 }
134
135 if (!fgets(nd, sizeof(nd), f)) {
136 syslog(LOG_ERR, "Failed to read %s\n", nd_file);
137 rc = -EIO;
138 goto error;
139 }
140 newline_to_null(nd);
141
142 build_node_desc(new_nd, sizeof(new_nd), device, hostname);
143
144 if (!force && strncmp(new_nd, nd, sizeof(new_nd)) == 0) {
145 syslog(LOG_INFO, "%s: no change (%s)\n", device, new_nd);
146 } else {
147 syslog(LOG_INFO, "%s: change (%s) -> (%s)\n",
148 device, nd, new_nd);
149 rewind(f);
150 fprintf(f, new_nd);
151 }
152
153 rc = 0;
154 error:
155 fclose(f);
156 return rc;
157 }
158
set_rdma_node_desc(const char * hostname,int force)159 static int set_rdma_node_desc(const char *hostname, int force)
160 {
161 DIR *class_dir;
162 struct dirent *dent;
163 char dev_dir[PATH_MAX];
164
165 snprintf(dev_dir, sizeof(dev_dir), "%s/%s", sys_dir, SYS_INFINIBAND);
166 dev_dir[sizeof(dev_dir)-1] = '\0';
167
168 class_dir = opendir(dev_dir);
169 if (!class_dir) {
170 syslog(LOG_INFO, "Failed to open %s", dev_dir);
171 return -ENOSYS;
172 }
173
174 while ((dent = readdir(class_dir))) {
175 int retry = set_retry_cnt;
176 if (dent->d_name[0] == '.')
177 continue;
178
179 while (update_node_desc(dent->d_name, hostname, force) && retry > 0) {
180 syslog(LOG_ERR, "retrying set Node Description on %s\n",
181 dent->d_name);
182 retry--;
183 }
184 }
185
186 closedir(class_dir);
187 return 0;
188 }
189
read_hostname(int fd,char * name,size_t len)190 static int read_hostname(int fd, char *name, size_t len)
191 {
192 int rc;
193 memset(name, 0, len);
194 if (read(fd, name, len-1) >= 0) {
195 newline_to_null(name);
196 strip_domain(name);
197 rc = 0;
198 } else {
199 syslog(LOG_ERR, "Read %s Failed\n", SYS_HOSTNAME);
200 rc = -EIO;
201 }
202 return rc;
203 }
204
process_opts(void * context,int ch,char * optarg)205 static int process_opts(void *context, int ch, char *optarg)
206 {
207 unsigned long tmp;
208 switch (ch) {
209 case 0:
210 pidfile = optarg;
211 break;
212 case 'f':
213 foreground = 1;
214 break;
215 case 't':
216 tmp = strtoul(optarg, NULL, 0);
217 if (tmp >= INT_MAX) {
218 syslog(LOG_ERR,
219 "Invalid retry rate specified: %lu s\n",
220 tmp);
221 } else {
222 failure_retry_rate = (int)tmp;
223 }
224 break;
225 case 'r':
226 tmp = strtoul(optarg, NULL, 0);
227 if (tmp >= INT_MAX) {
228 syslog(LOG_ERR,
229 "Invalid retry count specified: %lu\n",
230 tmp);
231 } else {
232 set_retry_cnt = (int)tmp;
233 }
234 break;
235 default:
236 return -1;
237 }
238 return 0;
239 }
240
241 #define MSG_MAX 2048
udev_log_fn(struct udev * ud,int priority,const char * file,int line,const char * fn,const char * format,va_list args)242 static void udev_log_fn(struct udev *ud, int priority, const char *file, int line,
243 const char *fn, const char *format, va_list args)
244 {
245 int off = 0;
246 char msg[MSG_MAX];
247 off = snprintf(msg, MSG_MAX, "libudev: %s:%d %s",
248 file, line, fn);
249 if (off < MSG_MAX-1)
250 vsnprintf(msg+off, MSG_MAX-off, format, args);
251 syslog(LOG_ERR, msg);
252 }
253
setup_udev(void)254 static void setup_udev(void)
255 {
256 udev = udev_new();
257 if (!udev) {
258 syslog(LOG_ERR, "udev_new failed\n");
259 return;
260 }
261
262 udev_set_log_fn(udev, udev_log_fn);
263 udev_set_log_priority(udev, LOG_INFO);
264 #if HAVE_UDEV_GET_SYS_PATH
265 sys_dir = (char *)udev_get_sys_path(udev);
266 #endif
267 }
268
get_udev_fd(void)269 static int get_udev_fd(void)
270 {
271 mon = udev_monitor_new_from_netlink(udev, "udev");
272 if (!mon) {
273 syslog(LOG_ERR, "udev monitoring failed\n");
274 return -1;
275 }
276
277 udev_monitor_filter_add_match_subsystem_devtype(mon, "infiniband", NULL);
278 udev_monitor_enable_receiving(mon);
279 return udev_monitor_get_fd(mon);
280 }
281
process_udev_event(int ud_fd,const char * hostname)282 static void process_udev_event(int ud_fd, const char *hostname)
283 {
284 struct udev_device *dev;
285
286 dev = udev_monitor_receive_device(mon);
287 if (dev) {
288 const char *device = udev_device_get_sysname(dev);
289 const char *action = udev_device_get_action(dev);
290
291 syslog(LOG_INFO, "Device event: %s, %s, %s\n",
292 udev_device_get_subsystem(dev),
293 device, action);
294
295 if (device && action
296 && strncmp(action, "add", sizeof("add")) == 0)
297 update_node_desc(device, hostname, 1);
298
299 udev_device_unref(dev);
300 }
301 }
302
monitor(void)303 static void monitor(void)
304 {
305 char hostname[128];
306 int hn_fd;
307 int rc;
308 struct pollfd fds[2];
309 int numfds = 1;
310 int ud_fd;
311
312 ud_fd = get_udev_fd();
313 if (ud_fd >= 0)
314 numfds = 2;
315
316 while (1) {
317 hn_fd = open(SYS_HOSTNAME, O_RDONLY);
318 if (hn_fd < 0) {
319 syslog(LOG_ERR,
320 "Open %s Failed: retry in %d seconds\n",
321 SYS_HOSTNAME, failure_retry_rate);
322 sleep(failure_retry_rate);
323 continue;
324 }
325
326 fds[0].fd = hn_fd;
327 fds[0].events = 0;
328 fds[0].revents = 0;
329
330 fds[1].fd = ud_fd;
331 fds[1].events = POLLIN;
332 fds[1].revents = 0;
333
334 rc = poll(fds, numfds, -1);
335
336 if (rc > 0) {
337 if (read_hostname(hn_fd, hostname, sizeof(hostname)) != 0)
338 hostname[0] = '\0';
339
340 if (fds[0].revents != 0)
341 syslog(LOG_ERR, "Hostname change: %s\n", hostname);
342
343 if (fds[1].revents != 0)
344 process_udev_event(ud_fd, hostname);
345
346 rc = set_rdma_node_desc((const char *)hostname, 0);
347 } else {
348 syslog(LOG_ERR, "Poll %s Failed\n", SYS_HOSTNAME);
349 rc = -EIO;
350 }
351
352 close(hn_fd);
353
354 if (rc)
355 sleep(failure_retry_rate);
356 }
357 }
358
remove_pidfile(void)359 static void remove_pidfile(void)
360 {
361 if (pidfile)
362 unlink(pidfile);
363 }
364
write_pidfile(void)365 static void write_pidfile(void)
366 {
367 FILE *f;
368 if (pidfile) {
369 remove_pidfile();
370 f = fopen(pidfile, "w");
371 if (f) {
372 fprintf(f, "%d\n", getpid());
373 fclose(f);
374 } else {
375 syslog(LOG_ERR, "Failed to write pidfile : %s\n",
376 pidfile);
377 exit(errno);
378 }
379 }
380 }
381
main(int argc,char * argv[])382 int main(int argc, char *argv[])
383 {
384 int fd;
385 char hostname[128];
386
387 openlog("rdma-ndd", LOG_PID | LOG_PERROR, LOG_DAEMON);
388
389 const struct ibdiag_opt opts[] = {
390 {"retry_timer", 't', 1, "<retry_timer>",
391 "Length of time to sleep when system errors occur "
392 "when attempting to poll and or read the hostname "
393 "from the system.\n"},
394 {"retry_count", 'r', 1, "<retry_count>",
395 "Number of times to attempt to retry setting "
396 "of the node description on failure\n"},
397 {"foreground", 'f', 0, NULL, "run in the foreground instead of as a daemon\n"},
398 {"pidfile", 0, 1, "<pidfile>", "specify a pid file (daemon mode only)\n"},
399 {0}
400 };
401
402 ibdiag_process_opts(argc, argv, NULL, "CPDLGtsKyevd", opts,
403 process_opts, "", NULL);
404
405 if (!ibd_nd_format)
406 ibd_nd_format = DEFAULT_ND_FORMAT;
407
408 if (!foreground) {
409 closelog();
410 openlog("rdma-ndd", LOG_PID, LOG_DAEMON);
411 if (daemon(0, 0) != 0) {
412 syslog(LOG_ERR, "Failed to daemonize\n");
413 exit(errno);
414 }
415 write_pidfile();
416 }
417
418 setup_udev();
419
420 syslog(LOG_INFO, "Node Descriptor format (%s)\n", ibd_nd_format);
421
422 fd = open(SYS_HOSTNAME, O_RDONLY);
423 if (read_hostname(fd, hostname, sizeof(hostname)) != 0)
424 hostname[0] = '\0';
425 set_rdma_node_desc((const char *)hostname, 1);
426 close(fd);
427
428 monitor();
429
430 remove_pidfile();
431
432 return 0;
433 }
434