multipath-tools: replace <> with "" for local headers
[multipath-tools/.git] / multipathd / main.c
1 /*
2  * Copyright (c) 2004, 2005 Christophe Varoqui
3  * Copyright (c) 2005 Kiyoshi Ueda, NEC
4  * Copyright (c) 2005 Benjamin Marzinski, Redhat
5  * Copyright (c) 2005 Edward Goggin, EMC
6  */
7 #include <unistd.h>
8 #include <sys/stat.h>
9 #include <libdevmapper.h>
10 #include <wait.h>
11 #include <sys/mman.h>
12 #include <sys/types.h>
13 #include <fcntl.h>
14 #include <errno.h>
15 #include <sys/time.h>
16 #include <sys/resource.h>
17 #include <limits.h>
18 #include <linux/oom.h>
19 #include <libudev.h>
20 #include <urcu.h>
21 #ifdef USE_SYSTEMD
22 #include <systemd/sd-daemon.h>
23 #endif
24 #include <semaphore.h>
25 #include <time.h>
26
27 /*
28  * libcheckers
29  */
30 #include "checkers.h"
31
32 #ifdef USE_SYSTEMD
33 static int use_watchdog;
34 #endif
35
36 int uxsock_timeout;
37
38 /*
39  * libmultipath
40  */
41 #include "parser.h"
42 #include "vector.h"
43 #include <memory.h>
44 #include "config.h"
45 #include "util.h"
46 #include "hwtable.h"
47 #include "defaults.h"
48 #include "structs.h"
49 #include "blacklist.h"
50 #include "structs_vec.h"
51 #include "dmparser.h"
52 #include "devmapper.h"
53 #include "sysfs.h"
54 #include "dict.h"
55 #include "discovery.h"
56 #include "debug.h"
57 #include "propsel.h"
58 #include "uevent.h"
59 #include "switchgroup.h"
60 #include "print.h"
61 #include "configure.h"
62 #include "prio.h"
63 #include "wwids.h"
64 #include "pgpolicies.h"
65 #include "uevent.h"
66 #include "log.h"
67
68 #include "mpath_cmd.h"
69 #include "mpath_persist.h"
70
71 #include "prioritizers/alua_rtpg.h"
72
73 #include "main.h"
74 #include "pidfile.h"
75 #include "uxlsnr.h"
76 #include "uxclnt.h"
77 #include "cli.h"
78 #include "cli_handlers.h"
79 #include "lock.h"
80 #include "waiter.h"
81 #include "wwids.h"
82
83 #define FILE_NAME_SIZE 256
84 #define CMDSIZE 160
85
86 #define LOG_MSG(a, b) \
87 do { \
88         if (pp->offline) \
89                 condlog(a, "%s: %s - path offline", pp->mpp->alias, pp->dev); \
90         else if (strlen(b)) \
91                 condlog(a, "%s: %s - %s", pp->mpp->alias, pp->dev, b); \
92 } while(0)
93
94 struct mpath_event_param
95 {
96         char * devname;
97         struct multipath *mpp;
98 };
99
100 unsigned int mpath_mx_alloc_len;
101
102 int logsink;
103 int verbosity;
104 int bindings_read_only;
105 int ignore_new_devs;
106 enum daemon_status running_state = DAEMON_INIT;
107 pid_t daemon_pid;
108 pthread_mutex_t config_lock = PTHREAD_MUTEX_INITIALIZER;
109 pthread_cond_t config_cond = PTHREAD_COND_INITIALIZER;
110
111 /*
112  * global copy of vecs for use in sig handlers
113  */
114 struct vectors * gvecs;
115
116 struct udev * udev;
117
118 struct config *multipath_conf;
119
120 const char *
121 daemon_status(void)
122 {
123         switch (running_state) {
124         case DAEMON_INIT:
125                 return "init";
126         case DAEMON_START:
127                 return "startup";
128         case DAEMON_CONFIGURE:
129                 return "configure";
130         case DAEMON_IDLE:
131                 return "idle";
132         case DAEMON_RUNNING:
133                 return "running";
134         case DAEMON_SHUTDOWN:
135                 return "shutdown";
136         }
137         return NULL;
138 }
139
140 /*
141  * I love you too, systemd ...
142  */
143 const char *
144 sd_notify_status(void)
145 {
146         switch (running_state) {
147         case DAEMON_INIT:
148                 return "STATUS=init";
149         case DAEMON_START:
150                 return "STATUS=startup";
151         case DAEMON_CONFIGURE:
152                 return "STATUS=configure";
153         case DAEMON_IDLE:
154                 return "STATUS=idle";
155         case DAEMON_RUNNING:
156                 return "STATUS=running";
157         case DAEMON_SHUTDOWN:
158                 return "STATUS=shutdown";
159         }
160         return NULL;
161 }
162
163 static void config_cleanup(void *arg)
164 {
165         pthread_mutex_unlock(&config_lock);
166 }
167
168 void post_config_state(enum daemon_status state)
169 {
170         pthread_mutex_lock(&config_lock);
171         if (state != running_state) {
172                 running_state = state;
173                 pthread_cond_broadcast(&config_cond);
174 #ifdef USE_SYSTEMD
175                 sd_notify(0, sd_notify_status());
176 #endif
177         }
178         pthread_mutex_unlock(&config_lock);
179 }
180
181 int set_config_state(enum daemon_status state)
182 {
183         int rc = 0;
184
185         pthread_cleanup_push(config_cleanup, NULL);
186         pthread_mutex_lock(&config_lock);
187         if (running_state != state) {
188                 if (running_state != DAEMON_IDLE) {
189                         struct timespec ts;
190
191                         clock_gettime(CLOCK_REALTIME, &ts);
192                         ts.tv_sec += 1;
193                         rc = pthread_cond_timedwait(&config_cond,
194                                                     &config_lock, &ts);
195                 }
196                 if (!rc) {
197                         running_state = state;
198                         pthread_cond_broadcast(&config_cond);
199 #ifdef USE_SYSTEMD
200                         sd_notify(0, sd_notify_status());
201 #endif
202                 }
203         }
204         pthread_cleanup_pop(1);
205         return rc;
206 }
207
208 struct config *get_multipath_config(void)
209 {
210         rcu_read_lock();
211         return rcu_dereference(multipath_conf);
212 }
213
214 void put_multipath_config(struct config *conf)
215 {
216         rcu_read_unlock();
217 }
218
219 static int
220 need_switch_pathgroup (struct multipath * mpp, int refresh)
221 {
222         struct pathgroup * pgp;
223         struct path * pp;
224         unsigned int i, j;
225         struct config *conf;
226
227         if (!mpp || mpp->pgfailback == -FAILBACK_MANUAL)
228                 return 0;
229
230         /*
231          * Refresh path priority values
232          */
233         if (refresh) {
234                 vector_foreach_slot (mpp->pg, pgp, i) {
235                         vector_foreach_slot (pgp->paths, pp, j) {
236                                 conf = get_multipath_config();
237                                 pathinfo(pp, conf, DI_PRIO);
238                                 put_multipath_config(conf);
239                         }
240                 }
241         }
242
243         if (!mpp->pg || VECTOR_SIZE(mpp->paths) == 0)
244                 return 0;
245
246         mpp->bestpg = select_path_group(mpp);
247
248         if (mpp->bestpg != mpp->nextpg)
249                 return 1;
250
251         return 0;
252 }
253
254 static void
255 switch_pathgroup (struct multipath * mpp)
256 {
257         mpp->stat_switchgroup++;
258         dm_switchgroup(mpp->alias, mpp->bestpg);
259         condlog(2, "%s: switch to path group #%i",
260                  mpp->alias, mpp->bestpg);
261 }
262
263 static int
264 coalesce_maps(struct vectors *vecs, vector nmpv)
265 {
266         struct multipath * ompp;
267         vector ompv = vecs->mpvec;
268         unsigned int i, reassign_maps;
269         struct config *conf;
270
271         conf = get_multipath_config();
272         reassign_maps = conf->reassign_maps;
273         put_multipath_config(conf);
274         vector_foreach_slot (ompv, ompp, i) {
275                 condlog(3, "%s: coalesce map", ompp->alias);
276                 if (!find_mp_by_wwid(nmpv, ompp->wwid)) {
277                         /*
278                          * remove all current maps not allowed by the
279                          * current configuration
280                          */
281                         if (dm_flush_map(ompp->alias)) {
282                                 condlog(0, "%s: unable to flush devmap",
283                                         ompp->alias);
284                                 /*
285                                  * may be just because the device is open
286                                  */
287                                 if (setup_multipath(vecs, ompp) != 0) {
288                                         i--;
289                                         continue;
290                                 }
291                                 if (!vector_alloc_slot(nmpv))
292                                         return 1;
293
294                                 vector_set_slot(nmpv, ompp);
295
296                                 vector_del_slot(ompv, i);
297                                 i--;
298                         }
299                         else {
300                                 dm_lib_release();
301                                 condlog(2, "%s devmap removed", ompp->alias);
302                         }
303                 } else if (reassign_maps) {
304                         condlog(3, "%s: Reassign existing device-mapper"
305                                 " devices", ompp->alias);
306                         dm_reassign(ompp->alias);
307                 }
308         }
309         return 0;
310 }
311
312 void
313 sync_map_state(struct multipath *mpp)
314 {
315         struct pathgroup *pgp;
316         struct path *pp;
317         unsigned int i, j;
318
319         if (!mpp->pg)
320                 return;
321
322         vector_foreach_slot (mpp->pg, pgp, i){
323                 vector_foreach_slot (pgp->paths, pp, j){
324                         if (pp->state == PATH_UNCHECKED ||
325                             pp->state == PATH_WILD ||
326                             pp->state == PATH_DELAYED)
327                                 continue;
328                         if ((pp->dmstate == PSTATE_FAILED ||
329                              pp->dmstate == PSTATE_UNDEF) &&
330                             (pp->state == PATH_UP || pp->state == PATH_GHOST))
331                                 dm_reinstate_path(mpp->alias, pp->dev_t);
332                         else if ((pp->dmstate == PSTATE_ACTIVE ||
333                                   pp->dmstate == PSTATE_UNDEF) &&
334                                  (pp->state == PATH_DOWN ||
335                                   pp->state == PATH_SHAKY))
336                                 dm_fail_path(mpp->alias, pp->dev_t);
337                 }
338         }
339 }
340
341 static void
342 sync_maps_state(vector mpvec)
343 {
344         unsigned int i;
345         struct multipath *mpp;
346
347         vector_foreach_slot (mpvec, mpp, i)
348                 sync_map_state(mpp);
349 }
350
351 static int
352 flush_map(struct multipath * mpp, struct vectors * vecs, int nopaths)
353 {
354         int r;
355
356         if (nopaths)
357                 r = dm_flush_map_nopaths(mpp->alias, mpp->deferred_remove);
358         else
359                 r = dm_flush_map(mpp->alias);
360         /*
361          * clear references to this map before flushing so we can ignore
362          * the spurious uevent we may generate with the dm_flush_map call below
363          */
364         if (r) {
365                 /*
366                  * May not really be an error -- if the map was already flushed
367                  * from the device mapper by dmsetup(8) for instance.
368                  */
369                 if (r == 1)
370                         condlog(0, "%s: can't flush", mpp->alias);
371                 else {
372                         condlog(2, "%s: devmap deferred remove", mpp->alias);
373                         mpp->deferred_remove = DEFERRED_REMOVE_IN_PROGRESS;
374                 }
375                 return r;
376         }
377         else {
378                 dm_lib_release();
379                 condlog(2, "%s: map flushed", mpp->alias);
380         }
381
382         orphan_paths(vecs->pathvec, mpp);
383         remove_map_and_stop_waiter(mpp, vecs, 1);
384
385         return 0;
386 }
387
388 int
389 update_map (struct multipath *mpp, struct vectors *vecs)
390 {
391         int retries = 3;
392         char params[PARAMS_SIZE] = {0};
393
394 retry:
395         condlog(4, "%s: updating new map", mpp->alias);
396         if (adopt_paths(vecs->pathvec, mpp)) {
397                 condlog(0, "%s: failed to adopt paths for new map update",
398                         mpp->alias);
399                 retries = -1;
400                 goto fail;
401         }
402         verify_paths(mpp, vecs);
403         mpp->flush_on_last_del = FLUSH_UNDEF;
404         mpp->action = ACT_RELOAD;
405
406         if (setup_map(mpp, params, PARAMS_SIZE)) {
407                 condlog(0, "%s: failed to setup new map in update", mpp->alias);
408                 retries = -1;
409                 goto fail;
410         }
411         if (domap(mpp, params, 1) <= 0 && retries-- > 0) {
412                 condlog(0, "%s: map_udate sleep", mpp->alias);
413                 sleep(1);
414                 goto retry;
415         }
416         dm_lib_release();
417
418 fail:
419         if (setup_multipath(vecs, mpp))
420                 return 1;
421
422         sync_map_state(mpp);
423
424         if (retries < 0)
425                 condlog(0, "%s: failed reload in new map update", mpp->alias);
426         return 0;
427 }
428
429 static int
430 uev_add_map (struct uevent * uev, struct vectors * vecs)
431 {
432         char *alias;
433         int major = -1, minor = -1, rc;
434
435         condlog(3, "%s: add map (uevent)", uev->kernel);
436         alias = uevent_get_dm_name(uev);
437         if (!alias) {
438                 condlog(3, "%s: No DM_NAME in uevent", uev->kernel);
439                 major = uevent_get_major(uev);
440                 minor = uevent_get_minor(uev);
441                 alias = dm_mapname(major, minor);
442                 if (!alias) {
443                         condlog(2, "%s: mapname not found for %d:%d",
444                                 uev->kernel, major, minor);
445                         return 1;
446                 }
447         }
448         pthread_cleanup_push(cleanup_lock, &vecs->lock);
449         lock(vecs->lock);
450         pthread_testcancel();
451         rc = ev_add_map(uev->kernel, alias, vecs);
452         lock_cleanup_pop(vecs->lock);
453         FREE(alias);
454         return rc;
455 }
456
457 int
458 ev_add_map (char * dev, char * alias, struct vectors * vecs)
459 {
460         char * refwwid;
461         struct multipath * mpp;
462         int map_present;
463         int r = 1, delayed_reconfig, reassign_maps;
464         struct config *conf;
465
466         map_present = dm_map_present(alias);
467
468         if (map_present && !dm_is_mpath(alias)) {
469                 condlog(4, "%s: not a multipath map", alias);
470                 return 0;
471         }
472
473         mpp = find_mp_by_alias(vecs->mpvec, alias);
474
475         if (mpp) {
476                 if (mpp->wait_for_udev > 1) {
477                         if (update_map(mpp, vecs))
478                                 /* setup multipathd removed the map */
479                                 return 1;
480                 }
481                 conf = get_multipath_config();
482                 delayed_reconfig = conf->delayed_reconfig;
483                 reassign_maps = conf->reassign_maps;
484                 put_multipath_config(conf);
485                 if (mpp->wait_for_udev) {
486                         mpp->wait_for_udev = 0;
487                         if (delayed_reconfig &&
488                             !need_to_delay_reconfig(vecs)) {
489                                 condlog(2, "reconfigure (delayed)");
490                                 set_config_state(DAEMON_CONFIGURE);
491                                 return 0;
492                         }
493                 }
494                 /*
495                  * Not really an error -- we generate our own uevent
496                  * if we create a multipath mapped device as a result
497                  * of uev_add_path
498                  */
499                 if (reassign_maps) {
500                         condlog(3, "%s: Reassign existing device-mapper devices",
501                                 alias);
502                         dm_reassign(alias);
503                 }
504                 return 0;
505         }
506         condlog(2, "%s: adding map", alias);
507
508         /*
509          * now we can register the map
510          */
511         if (map_present) {
512                 if ((mpp = add_map_without_path(vecs, alias))) {
513                         sync_map_state(mpp);
514                         condlog(2, "%s: devmap %s registered", alias, dev);
515                         return 0;
516                 } else {
517                         condlog(2, "%s: uev_add_map failed", dev);
518                         return 1;
519                 }
520         }
521         r = get_refwwid(CMD_NONE, dev, DEV_DEVMAP, vecs->pathvec, &refwwid);
522
523         if (refwwid) {
524                 r = coalesce_paths(vecs, NULL, refwwid, 0, CMD_NONE);
525                 dm_lib_release();
526         }
527
528         if (!r)
529                 condlog(2, "%s: devmap %s added", alias, dev);
530         else if (r == 2)
531                 condlog(2, "%s: uev_add_map %s blacklisted", alias, dev);
532         else
533                 condlog(0, "%s: uev_add_map %s failed", alias, dev);
534
535         FREE(refwwid);
536         return r;
537 }
538
539 static int
540 uev_remove_map (struct uevent * uev, struct vectors * vecs)
541 {
542         char *alias;
543         int minor;
544         struct multipath *mpp;
545
546         condlog(2, "%s: remove map (uevent)", uev->kernel);
547         alias = uevent_get_dm_name(uev);
548         if (!alias) {
549                 condlog(3, "%s: No DM_NAME in uevent, ignoring", uev->kernel);
550                 return 0;
551         }
552         minor = uevent_get_minor(uev);
553
554         pthread_cleanup_push(cleanup_lock, &vecs->lock);
555         lock(vecs->lock);
556         pthread_testcancel();
557         mpp = find_mp_by_minor(vecs->mpvec, minor);
558
559         if (!mpp) {
560                 condlog(2, "%s: devmap not registered, can't remove",
561                         uev->kernel);
562                 goto out;
563         }
564         if (strcmp(mpp->alias, alias)) {
565                 condlog(2, "%s: minor number mismatch (map %d, event %d)",
566                         mpp->alias, mpp->dmi->minor, minor);
567                 goto out;
568         }
569
570         orphan_paths(vecs->pathvec, mpp);
571         remove_map_and_stop_waiter(mpp, vecs, 1);
572 out:
573         lock_cleanup_pop(vecs->lock);
574         FREE(alias);
575         return 0;
576 }
577
578 /* Called from CLI handler */
579 int
580 ev_remove_map (char * devname, char * alias, int minor, struct vectors * vecs)
581 {
582         struct multipath * mpp;
583
584         mpp = find_mp_by_minor(vecs->mpvec, minor);
585
586         if (!mpp) {
587                 condlog(2, "%s: devmap not registered, can't remove",
588                         devname);
589                 return 1;
590         }
591         if (strcmp(mpp->alias, alias)) {
592                 condlog(2, "%s: minor number mismatch (map %d, event %d)",
593                         mpp->alias, mpp->dmi->minor, minor);
594                 return 1;
595         }
596         return flush_map(mpp, vecs, 0);
597 }
598
599 static int
600 uev_add_path (struct uevent *uev, struct vectors * vecs)
601 {
602         struct path *pp;
603         int ret = 0, i;
604         struct config *conf;
605
606         condlog(2, "%s: add path (uevent)", uev->kernel);
607         if (strstr(uev->kernel, "..") != NULL) {
608                 /*
609                  * Don't allow relative device names in the pathvec
610                  */
611                 condlog(0, "%s: path name is invalid", uev->kernel);
612                 return 1;
613         }
614
615         pthread_cleanup_push(cleanup_lock, &vecs->lock);
616         lock(vecs->lock);
617         pthread_testcancel();
618         pp = find_path_by_dev(vecs->pathvec, uev->kernel);
619         if (pp) {
620                 int r;
621
622                 condlog(0, "%s: spurious uevent, path already in pathvec",
623                         uev->kernel);
624                 if (!pp->mpp && !strlen(pp->wwid)) {
625                         condlog(3, "%s: reinitialize path", uev->kernel);
626                         udev_device_unref(pp->udev);
627                         pp->udev = udev_device_ref(uev->udev);
628                         conf = get_multipath_config();
629                         r = pathinfo(pp, conf,
630                                      DI_ALL | DI_BLACKLIST);
631                         put_multipath_config(conf);
632                         if (r == PATHINFO_OK)
633                                 ret = ev_add_path(pp, vecs);
634                         else if (r == PATHINFO_SKIPPED) {
635                                 condlog(3, "%s: remove blacklisted path",
636                                         uev->kernel);
637                                 i = find_slot(vecs->pathvec, (void *)pp);
638                                 if (i != -1)
639                                         vector_del_slot(vecs->pathvec, i);
640                                 free_path(pp);
641                         } else {
642                                 condlog(0, "%s: failed to reinitialize path",
643                                         uev->kernel);
644                                 ret = 1;
645                         }
646                 }
647         }
648         lock_cleanup_pop(vecs->lock);
649         if (pp)
650                 return ret;
651
652         /*
653          * get path vital state
654          */
655         conf = get_multipath_config();
656         ret = alloc_path_with_pathinfo(conf, uev->udev,
657                                        DI_ALL, &pp);
658         put_multipath_config(conf);
659         if (!pp) {
660                 if (ret == PATHINFO_SKIPPED)
661                         return 0;
662                 condlog(3, "%s: failed to get path info", uev->kernel);
663                 return 1;
664         }
665         pthread_cleanup_push(cleanup_lock, &vecs->lock);
666         lock(vecs->lock);
667         pthread_testcancel();
668         ret = store_path(vecs->pathvec, pp);
669         if (!ret) {
670                 conf = get_multipath_config();
671                 pp->checkint = conf->checkint;
672                 put_multipath_config(conf);
673                 ret = ev_add_path(pp, vecs);
674         } else {
675                 condlog(0, "%s: failed to store path info, "
676                         "dropping event",
677                         uev->kernel);
678                 free_path(pp);
679                 ret = 1;
680         }
681         lock_cleanup_pop(vecs->lock);
682         return ret;
683 }
684
685 /*
686  * returns:
687  * 0: added
688  * 1: error
689  */
690 int
691 ev_add_path (struct path * pp, struct vectors * vecs)
692 {
693         struct multipath * mpp;
694         char params[PARAMS_SIZE] = {0};
695         int retries = 3;
696         int start_waiter = 0;
697         int ret;
698
699         /*
700          * need path UID to go any further
701          */
702         if (strlen(pp->wwid) == 0) {
703                 condlog(0, "%s: failed to get path uid", pp->dev);
704                 goto fail; /* leave path added to pathvec */
705         }
706         mpp = find_mp_by_wwid(vecs->mpvec, pp->wwid);
707         if (mpp && mpp->wait_for_udev) {
708                 mpp->wait_for_udev = 2;
709                 orphan_path(pp, "waiting for create to complete");
710                 return 0;
711         }
712
713         pp->mpp = mpp;
714 rescan:
715         if (mpp) {
716                 if (pp->size && mpp->size != pp->size) {
717                         condlog(0, "%s: failed to add new path %s, "
718                                 "device size mismatch",
719                                 mpp->alias, pp->dev);
720                         int i = find_slot(vecs->pathvec, (void *)pp);
721                         if (i != -1)
722                                 vector_del_slot(vecs->pathvec, i);
723                         free_path(pp);
724                         return 1;
725                 }
726
727                 condlog(4,"%s: adopting all paths for path %s",
728                         mpp->alias, pp->dev);
729                 if (adopt_paths(vecs->pathvec, mpp))
730                         goto fail; /* leave path added to pathvec */
731
732                 verify_paths(mpp, vecs);
733                 mpp->flush_on_last_del = FLUSH_UNDEF;
734                 mpp->action = ACT_RELOAD;
735         } else {
736                 if (!should_multipath(pp, vecs->pathvec)) {
737                         orphan_path(pp, "only one path");
738                         return 0;
739                 }
740                 condlog(4,"%s: creating new map", pp->dev);
741                 if ((mpp = add_map_with_path(vecs, pp, 1))) {
742                         mpp->action = ACT_CREATE;
743                         /*
744                          * We don't depend on ACT_CREATE, as domap will
745                          * set it to ACT_NOTHING when complete.
746                          */
747                         start_waiter = 1;
748                 }
749                 if (!start_waiter)
750                         goto fail; /* leave path added to pathvec */
751         }
752
753         /* persistent reservation check*/
754         mpath_pr_event_handle(pp);
755
756         /*
757          * push the map to the device-mapper
758          */
759         if (setup_map(mpp, params, PARAMS_SIZE)) {
760                 condlog(0, "%s: failed to setup map for addition of new "
761                         "path %s", mpp->alias, pp->dev);
762                 goto fail_map;
763         }
764         /*
765          * reload the map for the multipath mapped device
766          */
767 retry:
768         ret = domap(mpp, params, 1);
769         if (ret <= 0) {
770                 if (ret < 0 && retries-- > 0) {
771                         condlog(0, "%s: retry domap for addition of new "
772                                 "path %s", mpp->alias, pp->dev);
773                         sleep(1);
774                         goto retry;
775                 }
776                 condlog(0, "%s: failed in domap for addition of new "
777                         "path %s", mpp->alias, pp->dev);
778                 /*
779                  * deal with asynchronous uevents :((
780                  */
781                 if (mpp->action == ACT_RELOAD && retries-- > 0) {
782                         condlog(0, "%s: ev_add_path sleep", mpp->alias);
783                         sleep(1);
784                         update_mpp_paths(mpp, vecs->pathvec);
785                         goto rescan;
786                 }
787                 else if (mpp->action == ACT_RELOAD)
788                         condlog(0, "%s: giving up reload", mpp->alias);
789                 else
790                         goto fail_map;
791         }
792         dm_lib_release();
793
794         /*
795          * update our state from kernel regardless of create or reload
796          */
797         if (setup_multipath(vecs, mpp))
798                 goto fail; /* if setup_multipath fails, it removes the map */
799
800         sync_map_state(mpp);
801
802         if ((mpp->action == ACT_CREATE ||
803              (mpp->action == ACT_NOTHING && start_waiter && !mpp->waiter)) &&
804             start_waiter_thread(mpp, vecs))
805                         goto fail_map;
806
807         if (retries >= 0) {
808                 condlog(2, "%s [%s]: path added to devmap %s",
809                         pp->dev, pp->dev_t, mpp->alias);
810                 return 0;
811         } else
812                 goto fail;
813
814 fail_map:
815         remove_map(mpp, vecs, 1);
816 fail:
817         orphan_path(pp, "failed to add path");
818         return 1;
819 }
820
821 static int
822 uev_remove_path (struct uevent *uev, struct vectors * vecs)
823 {
824         struct path *pp;
825         int ret;
826
827         condlog(2, "%s: remove path (uevent)", uev->kernel);
828         pthread_cleanup_push(cleanup_lock, &vecs->lock);
829         lock(vecs->lock);
830         pthread_testcancel();
831         pp = find_path_by_dev(vecs->pathvec, uev->kernel);
832         if (pp)
833                 ret = ev_remove_path(pp, vecs);
834         lock_cleanup_pop(vecs->lock);
835         if (!pp) {
836                 /* Not an error; path might have been purged earlier */
837                 condlog(0, "%s: path already removed", uev->kernel);
838                 return 0;
839         }
840         return ret;
841 }
842
843 int
844 ev_remove_path (struct path *pp, struct vectors * vecs)
845 {
846         struct multipath * mpp;
847         int i, retval = 0;
848         char params[PARAMS_SIZE] = {0};
849
850         /*
851          * avoid referring to the map of an orphaned path
852          */
853         if ((mpp = pp->mpp)) {
854                 /*
855                  * transform the mp->pg vector of vectors of paths
856                  * into a mp->params string to feed the device-mapper
857                  */
858                 if (update_mpp_paths(mpp, vecs->pathvec)) {
859                         condlog(0, "%s: failed to update paths",
860                                 mpp->alias);
861                         goto fail;
862                 }
863                 if ((i = find_slot(mpp->paths, (void *)pp)) != -1)
864                         vector_del_slot(mpp->paths, i);
865
866                 /*
867                  * remove the map IFF removing the last path
868                  */
869                 if (VECTOR_SIZE(mpp->paths) == 0) {
870                         char alias[WWID_SIZE];
871
872                         /*
873                          * flush_map will fail if the device is open
874                          */
875                         strncpy(alias, mpp->alias, WWID_SIZE);
876                         if (mpp->flush_on_last_del == FLUSH_ENABLED) {
877                                 condlog(2, "%s Last path deleted, disabling queueing", mpp->alias);
878                                 mpp->retry_tick = 0;
879                                 mpp->no_path_retry = NO_PATH_RETRY_FAIL;
880                                 mpp->flush_on_last_del = FLUSH_IN_PROGRESS;
881                                 dm_queue_if_no_path(mpp->alias, 0);
882                         }
883                         if (!flush_map(mpp, vecs, 1)) {
884                                 condlog(2, "%s: removed map after"
885                                         " removing all paths",
886                                         alias);
887                                 retval = 0;
888                                 goto out;
889                         }
890                         /*
891                          * Not an error, continue
892                          */
893                 }
894
895                 if (setup_map(mpp, params, PARAMS_SIZE)) {
896                         condlog(0, "%s: failed to setup map for"
897                                 " removal of path %s", mpp->alias, pp->dev);
898                         goto fail;
899                 }
900
901                 if (mpp->wait_for_udev) {
902                         mpp->wait_for_udev = 2;
903                         goto out;
904                 }
905
906                 /*
907                  * reload the map
908                  */
909                 mpp->action = ACT_RELOAD;
910                 if (domap(mpp, params, 1) <= 0) {
911                         condlog(0, "%s: failed in domap for "
912                                 "removal of path %s",
913                                 mpp->alias, pp->dev);
914                         retval = 1;
915                 } else {
916                         /*
917                          * update our state from kernel
918                          */
919                         if (setup_multipath(vecs, mpp))
920                                 return 1;
921                         sync_map_state(mpp);
922
923                         condlog(2, "%s [%s]: path removed from map %s",
924                                 pp->dev, pp->dev_t, mpp->alias);
925                 }
926         }
927
928 out:
929         if ((i = find_slot(vecs->pathvec, (void *)pp)) != -1)
930                 vector_del_slot(vecs->pathvec, i);
931
932         free_path(pp);
933
934         return retval;
935
936 fail:
937         remove_map_and_stop_waiter(mpp, vecs, 1);
938         return 1;
939 }
940
941 static int
942 uev_update_path (struct uevent *uev, struct vectors * vecs)
943 {
944         int ro, retval = 0;
945
946         ro = uevent_get_disk_ro(uev);
947
948         if (ro >= 0) {
949                 struct path * pp;
950                 struct multipath *mpp = NULL;
951
952                 condlog(2, "%s: update path write_protect to '%d' (uevent)",
953                         uev->kernel, ro);
954                 pthread_cleanup_push(cleanup_lock, &vecs->lock);
955                 lock(vecs->lock);
956                 pthread_testcancel();
957                 /*
958                  * pthread_mutex_lock() and pthread_mutex_unlock()
959                  * need to be at the same indentation level, hence
960                  * this slightly convoluted codepath.
961                  */
962                 pp = find_path_by_dev(vecs->pathvec, uev->kernel);
963                 if (pp) {
964                         if (pp->initialized == INIT_REQUESTED_UDEV) {
965                                 retval = 2;
966                         } else {
967                                 mpp = pp->mpp;
968                                 if (mpp && mpp->wait_for_udev) {
969                                         mpp->wait_for_udev = 2;
970                                         mpp = NULL;
971                                         retval = 0;
972                                 }
973                         }
974                         if (mpp) {
975                                 retval = reload_map(vecs, mpp, 0, 1);
976
977                                 condlog(2, "%s: map %s reloaded (retval %d)",
978                                         uev->kernel, mpp->alias, retval);
979                         }
980                 }
981                 lock_cleanup_pop(vecs->lock);
982                 if (!pp) {
983                         condlog(0, "%s: spurious uevent, path not found",
984                                 uev->kernel);
985                         return 1;
986                 }
987                 if (retval == 2)
988                         return uev_add_path(uev, vecs);
989         }
990
991         return retval;
992 }
993
994 static int
995 map_discovery (struct vectors * vecs)
996 {
997         struct multipath * mpp;
998         unsigned int i;
999
1000         if (dm_get_maps(vecs->mpvec))
1001                 return 1;
1002
1003         vector_foreach_slot (vecs->mpvec, mpp, i)
1004                 if (setup_multipath(vecs, mpp))
1005                         return 1;
1006
1007         return 0;
1008 }
1009
1010 int
1011 uxsock_trigger (char * str, char ** reply, int * len, void * trigger_data)
1012 {
1013         struct vectors * vecs;
1014         int r;
1015
1016         *reply = NULL;
1017         *len = 0;
1018         vecs = (struct vectors *)trigger_data;
1019
1020         r = parse_cmd(str, reply, len, vecs, uxsock_timeout / 1000);
1021
1022         if (r > 0) {
1023                 if (r == ETIMEDOUT)
1024                         *reply = STRDUP("timeout\n");
1025                 else
1026                         *reply = STRDUP("fail\n");
1027                 *len = strlen(*reply) + 1;
1028                 r = 1;
1029         }
1030         else if (!r && *len == 0) {
1031                 *reply = STRDUP("ok\n");
1032                 *len = strlen(*reply) + 1;
1033                 r = 0;
1034         }
1035         /* else if (r < 0) leave *reply alone */
1036
1037         return r;
1038 }
1039
1040 static int
1041 uev_discard(char * devpath)
1042 {
1043         char *tmp;
1044         char a[11], b[11];
1045
1046         /*
1047          * keep only block devices, discard partitions
1048          */
1049         tmp = strstr(devpath, "/block/");
1050         if (tmp == NULL){
1051                 condlog(4, "no /block/ in '%s'", devpath);
1052                 return 1;
1053         }
1054         if (sscanf(tmp, "/block/%10s", a) != 1 ||
1055             sscanf(tmp, "/block/%10[^/]/%10s", a, b) == 2) {
1056                 condlog(4, "discard event on %s", devpath);
1057                 return 1;
1058         }
1059         return 0;
1060 }
1061
1062 int
1063 uev_trigger (struct uevent * uev, void * trigger_data)
1064 {
1065         int r = 0;
1066         struct vectors * vecs;
1067         struct config *conf;
1068
1069         vecs = (struct vectors *)trigger_data;
1070
1071         if (uev_discard(uev->devpath))
1072                 return 0;
1073
1074         pthread_cleanup_push(config_cleanup, NULL);
1075         pthread_mutex_lock(&config_lock);
1076         if (running_state != DAEMON_IDLE &&
1077             running_state != DAEMON_RUNNING)
1078                 pthread_cond_wait(&config_cond, &config_lock);
1079         pthread_cleanup_pop(1);
1080
1081         if (running_state == DAEMON_SHUTDOWN)
1082                 return 0;
1083
1084         /*
1085          * device map event
1086          * Add events are ignored here as the tables
1087          * are not fully initialised then.
1088          */
1089         if (!strncmp(uev->kernel, "dm-", 3)) {
1090                 if (!strncmp(uev->action, "change", 6)) {
1091                         r = uev_add_map(uev, vecs);
1092                         goto out;
1093                 }
1094                 if (!strncmp(uev->action, "remove", 6)) {
1095                         r = uev_remove_map(uev, vecs);
1096                         goto out;
1097                 }
1098                 goto out;
1099         }
1100
1101         /*
1102          * path add/remove event
1103          */
1104         conf = get_multipath_config();
1105         if (filter_devnode(conf->blist_devnode, conf->elist_devnode,
1106                            uev->kernel) > 0) {
1107                 put_multipath_config(conf);
1108                 goto out;
1109         }
1110         put_multipath_config(conf);
1111
1112         if (!strncmp(uev->action, "add", 3)) {
1113                 r = uev_add_path(uev, vecs);
1114                 goto out;
1115         }
1116         if (!strncmp(uev->action, "remove", 6)) {
1117                 r = uev_remove_path(uev, vecs);
1118                 goto out;
1119         }
1120         if (!strncmp(uev->action, "change", 6)) {
1121                 r = uev_update_path(uev, vecs);
1122                 goto out;
1123         }
1124
1125 out:
1126         return r;
1127 }
1128
1129 static void *rcu_unregister(void *param)
1130 {
1131         rcu_unregister_thread();
1132         return NULL;
1133 }
1134
1135 static void *
1136 ueventloop (void * ap)
1137 {
1138         struct udev *udev = ap;
1139
1140         pthread_cleanup_push(rcu_unregister, NULL);
1141         rcu_register_thread();
1142         if (uevent_listen(udev))
1143                 condlog(0, "error starting uevent listener");
1144         pthread_cleanup_pop(1);
1145         return NULL;
1146 }
1147
1148 static void *
1149 uevqloop (void * ap)
1150 {
1151         pthread_cleanup_push(rcu_unregister, NULL);
1152         rcu_register_thread();
1153         if (uevent_dispatch(&uev_trigger, ap))
1154                 condlog(0, "error starting uevent dispatcher");
1155         pthread_cleanup_pop(1);
1156         return NULL;
1157 }
1158 static void *
1159 uxlsnrloop (void * ap)
1160 {
1161         if (cli_init()) {
1162                 condlog(1, "Failed to init uxsock listener");
1163                 return NULL;
1164         }
1165         pthread_cleanup_push(rcu_unregister, NULL);
1166         rcu_register_thread();
1167         set_handler_callback(LIST+PATHS, cli_list_paths);
1168         set_handler_callback(LIST+PATHS+FMT, cli_list_paths_fmt);
1169         set_handler_callback(LIST+PATHS+RAW+FMT, cli_list_paths_raw);
1170         set_handler_callback(LIST+PATH, cli_list_path);
1171         set_handler_callback(LIST+MAPS, cli_list_maps);
1172         set_unlocked_handler_callback(LIST+STATUS, cli_list_status);
1173         set_unlocked_handler_callback(LIST+DAEMON, cli_list_daemon);
1174         set_handler_callback(LIST+MAPS+STATUS, cli_list_maps_status);
1175         set_handler_callback(LIST+MAPS+STATS, cli_list_maps_stats);
1176         set_handler_callback(LIST+MAPS+FMT, cli_list_maps_fmt);
1177         set_handler_callback(LIST+MAPS+RAW+FMT, cli_list_maps_raw);
1178         set_handler_callback(LIST+MAPS+TOPOLOGY, cli_list_maps_topology);
1179         set_handler_callback(LIST+TOPOLOGY, cli_list_maps_topology);
1180         set_handler_callback(LIST+MAPS+JSON, cli_list_maps_json);
1181         set_handler_callback(LIST+MAP+TOPOLOGY, cli_list_map_topology);
1182         set_handler_callback(LIST+MAP+FMT, cli_list_map_fmt);
1183         set_handler_callback(LIST+MAP+RAW+FMT, cli_list_map_fmt);
1184         set_handler_callback(LIST+MAP+JSON, cli_list_map_json);
1185         set_handler_callback(LIST+CONFIG, cli_list_config);
1186         set_handler_callback(LIST+BLACKLIST, cli_list_blacklist);
1187         set_handler_callback(LIST+DEVICES, cli_list_devices);
1188         set_handler_callback(LIST+WILDCARDS, cli_list_wildcards);
1189         set_handler_callback(ADD+PATH, cli_add_path);
1190         set_handler_callback(DEL+PATH, cli_del_path);
1191         set_handler_callback(ADD+MAP, cli_add_map);
1192         set_handler_callback(DEL+MAP, cli_del_map);
1193         set_handler_callback(SWITCH+MAP+GROUP, cli_switch_group);
1194         set_unlocked_handler_callback(RECONFIGURE, cli_reconfigure);
1195         set_handler_callback(SUSPEND+MAP, cli_suspend);
1196         set_handler_callback(RESUME+MAP, cli_resume);
1197         set_handler_callback(RESIZE+MAP, cli_resize);
1198         set_handler_callback(RELOAD+MAP, cli_reload);
1199         set_handler_callback(RESET+MAP, cli_reassign);
1200         set_handler_callback(REINSTATE+PATH, cli_reinstate);
1201         set_handler_callback(FAIL+PATH, cli_fail);
1202         set_handler_callback(DISABLEQ+MAP, cli_disable_queueing);
1203         set_handler_callback(RESTOREQ+MAP, cli_restore_queueing);
1204         set_handler_callback(DISABLEQ+MAPS, cli_disable_all_queueing);
1205         set_handler_callback(RESTOREQ+MAPS, cli_restore_all_queueing);
1206         set_unlocked_handler_callback(QUIT, cli_quit);
1207         set_unlocked_handler_callback(SHUTDOWN, cli_shutdown);
1208         set_handler_callback(GETPRSTATUS+MAP, cli_getprstatus);
1209         set_handler_callback(SETPRSTATUS+MAP, cli_setprstatus);
1210         set_handler_callback(UNSETPRSTATUS+MAP, cli_unsetprstatus);
1211         set_handler_callback(FORCEQ+DAEMON, cli_force_no_daemon_q);
1212         set_handler_callback(RESTOREQ+DAEMON, cli_restore_no_daemon_q);
1213
1214         umask(077);
1215         uxsock_listen(&uxsock_trigger, ap);
1216         pthread_cleanup_pop(1);
1217         return NULL;
1218 }
1219
1220 void
1221 exit_daemon (void)
1222 {
1223         post_config_state(DAEMON_SHUTDOWN);
1224 }
1225
1226 static void
1227 fail_path (struct path * pp, int del_active)
1228 {
1229         if (!pp->mpp)
1230                 return;
1231
1232         condlog(2, "checker failed path %s in map %s",
1233                  pp->dev_t, pp->mpp->alias);
1234
1235         dm_fail_path(pp->mpp->alias, pp->dev_t);
1236         if (del_active)
1237                 update_queue_mode_del_path(pp->mpp);
1238 }
1239
1240 /*
1241  * caller must have locked the path list before calling that function
1242  */
1243 static int
1244 reinstate_path (struct path * pp, int add_active)
1245 {
1246         int ret = 0;
1247
1248         if (!pp->mpp)
1249                 return 0;
1250
1251         if (dm_reinstate_path(pp->mpp->alias, pp->dev_t)) {
1252                 condlog(0, "%s: reinstate failed", pp->dev_t);
1253                 ret = 1;
1254         } else {
1255                 condlog(2, "%s: reinstated", pp->dev_t);
1256                 if (add_active)
1257                         update_queue_mode_add_path(pp->mpp);
1258         }
1259         return ret;
1260 }
1261
1262 static void
1263 enable_group(struct path * pp)
1264 {
1265         struct pathgroup * pgp;
1266
1267         /*
1268          * if path is added through uev_add_path, pgindex can be unset.
1269          * next update_strings() will set it, upon map reload event.
1270          *
1271          * we can safely return here, because upon map reload, all
1272          * PG will be enabled.
1273          */
1274         if (!pp->mpp->pg || !pp->pgindex)
1275                 return;
1276
1277         pgp = VECTOR_SLOT(pp->mpp->pg, pp->pgindex - 1);
1278
1279         if (pgp->status == PGSTATE_DISABLED) {
1280                 condlog(2, "%s: enable group #%i", pp->mpp->alias, pp->pgindex);
1281                 dm_enablegroup(pp->mpp->alias, pp->pgindex);
1282         }
1283 }
1284
1285 static void
1286 mpvec_garbage_collector (struct vectors * vecs)
1287 {
1288         struct multipath * mpp;
1289         unsigned int i;
1290
1291         if (!vecs->mpvec)
1292                 return;
1293
1294         vector_foreach_slot (vecs->mpvec, mpp, i) {
1295                 if (mpp && mpp->alias && !dm_map_present(mpp->alias)) {
1296                         condlog(2, "%s: remove dead map", mpp->alias);
1297                         remove_map_and_stop_waiter(mpp, vecs, 1);
1298                         i--;
1299                 }
1300         }
1301 }
1302
1303 /* This is called after a path has started working again. It the multipath
1304  * device for this path uses the followover failback type, and this is the
1305  * best pathgroup, and this is the first path in the pathgroup to come back
1306  * up, then switch to this pathgroup */
1307 static int
1308 followover_should_failback(struct path * pp)
1309 {
1310         struct pathgroup * pgp;
1311         struct path *pp1;
1312         int i;
1313
1314         if (pp->mpp->pgfailback != -FAILBACK_FOLLOWOVER ||
1315             !pp->mpp->pg || !pp->pgindex ||
1316             pp->pgindex != pp->mpp->bestpg)
1317                 return 0;
1318
1319         pgp = VECTOR_SLOT(pp->mpp->pg, pp->pgindex - 1);
1320         vector_foreach_slot(pgp->paths, pp1, i) {
1321                 if (pp1 == pp)
1322                         continue;
1323                 if (pp1->chkrstate != PATH_DOWN && pp1->chkrstate != PATH_SHAKY)
1324                         return 0;
1325         }
1326         return 1;
1327 }
1328
1329 static void
1330 missing_uev_wait_tick(struct vectors *vecs)
1331 {
1332         struct multipath * mpp;
1333         unsigned int i;
1334         int timed_out = 0, delayed_reconfig;
1335         struct config *conf;
1336
1337         vector_foreach_slot (vecs->mpvec, mpp, i) {
1338                 if (mpp->wait_for_udev && --mpp->uev_wait_tick <= 0) {
1339                         timed_out = 1;
1340                         condlog(0, "%s: timeout waiting on creation uevent. enabling reloads", mpp->alias);
1341                         if (mpp->wait_for_udev > 1 && update_map(mpp, vecs)) {
1342                                 /* update_map removed map */
1343                                 i--;
1344                                 continue;
1345                         }
1346                         mpp->wait_for_udev = 0;
1347                 }
1348         }
1349
1350         conf = get_multipath_config();
1351         delayed_reconfig = conf->delayed_reconfig;
1352         put_multipath_config(conf);
1353         if (timed_out && delayed_reconfig &&
1354             !need_to_delay_reconfig(vecs)) {
1355                 condlog(2, "reconfigure (delayed)");
1356                 set_config_state(DAEMON_CONFIGURE);
1357         }
1358 }
1359
1360 static void
1361 defered_failback_tick (vector mpvec)
1362 {
1363         struct multipath * mpp;
1364         unsigned int i;
1365
1366         vector_foreach_slot (mpvec, mpp, i) {
1367                 /*
1368                  * defered failback getting sooner
1369                  */
1370                 if (mpp->pgfailback > 0 && mpp->failback_tick > 0) {
1371                         mpp->failback_tick--;
1372
1373                         if (!mpp->failback_tick && need_switch_pathgroup(mpp, 1))
1374                                 switch_pathgroup(mpp);
1375                 }
1376         }
1377 }
1378
1379 static void
1380 retry_count_tick(vector mpvec)
1381 {
1382         struct multipath *mpp;
1383         unsigned int i;
1384
1385         vector_foreach_slot (mpvec, mpp, i) {
1386                 if (mpp->retry_tick > 0) {
1387                         mpp->stat_total_queueing_time++;
1388                         condlog(4, "%s: Retrying.. No active path", mpp->alias);
1389                         if(--mpp->retry_tick == 0) {
1390                                 dm_queue_if_no_path(mpp->alias, 0);
1391                                 condlog(2, "%s: Disable queueing", mpp->alias);
1392                         }
1393                 }
1394         }
1395 }
1396
1397 int update_prio(struct path *pp, int refresh_all)
1398 {
1399         int oldpriority;
1400         struct path *pp1;
1401         struct pathgroup * pgp;
1402         int i, j, changed = 0;
1403         struct config *conf;
1404
1405         if (refresh_all) {
1406                 vector_foreach_slot (pp->mpp->pg, pgp, i) {
1407                         vector_foreach_slot (pgp->paths, pp1, j) {
1408                                 oldpriority = pp1->priority;
1409                                 conf = get_multipath_config();
1410                                 pathinfo(pp1, conf, DI_PRIO);
1411                                 put_multipath_config(conf);
1412                                 if (pp1->priority != oldpriority)
1413                                         changed = 1;
1414                         }
1415                 }
1416                 return changed;
1417         }
1418         oldpriority = pp->priority;
1419         conf = get_multipath_config();
1420         pathinfo(pp, conf, DI_PRIO);
1421         put_multipath_config(conf);
1422
1423         if (pp->priority == oldpriority)
1424                 return 0;
1425         return 1;
1426 }
1427
1428 int update_path_groups(struct multipath *mpp, struct vectors *vecs, int refresh)
1429 {
1430         if (reload_map(vecs, mpp, refresh, 1))
1431                 return 1;
1432
1433         dm_lib_release();
1434         if (setup_multipath(vecs, mpp) != 0)
1435                 return 1;
1436         sync_map_state(mpp);
1437
1438         return 0;
1439 }
1440
1441 /*
1442  * Returns '1' if the path has been checked, '-1' if it was blacklisted
1443  * and '0' otherwise
1444  */
1445 int
1446 check_path (struct vectors * vecs, struct path * pp, int ticks)
1447 {
1448         int newstate;
1449         int new_path_up = 0;
1450         int chkr_new_path_up = 0;
1451         int add_active;
1452         int disable_reinstate = 0;
1453         int oldchkrstate = pp->chkrstate;
1454         int retrigger_tries, checkint;
1455         struct config *conf;
1456         int ret;
1457
1458         if ((pp->initialized == INIT_OK ||
1459              pp->initialized == INIT_REQUESTED_UDEV) && !pp->mpp)
1460                 return 0;
1461
1462         if (pp->tick)
1463                 pp->tick -= (pp->tick > ticks) ? ticks : pp->tick;
1464         if (pp->tick)
1465                 return 0; /* don't check this path yet */
1466
1467         conf = get_multipath_config();
1468         retrigger_tries = conf->retrigger_tries;
1469         checkint = conf->checkint;
1470         put_multipath_config(conf);
1471         if (!pp->mpp && pp->initialized == INIT_MISSING_UDEV &&
1472             pp->retriggers < retrigger_tries) {
1473                 condlog(2, "%s: triggering change event to reinitialize",
1474                         pp->dev);
1475                 pp->initialized = INIT_REQUESTED_UDEV;
1476                 pp->retriggers++;
1477                 sysfs_attr_set_value(pp->udev, "uevent", "change",
1478                                      strlen("change"));
1479                 return 0;
1480         }
1481
1482         /*
1483          * provision a next check soonest,
1484          * in case we exit abnormaly from here
1485          */
1486         pp->tick = checkint;
1487
1488         newstate = path_offline(pp);
1489         /*
1490          * Wait for uevent for removed paths;
1491          * some LLDDs like zfcp keep paths unavailable
1492          * without sending uevents.
1493          */
1494         if (newstate == PATH_REMOVED)
1495                 newstate = PATH_DOWN;
1496
1497         if (newstate == PATH_UP) {
1498                 conf = get_multipath_config();
1499                 newstate = get_state(pp, conf, 1);
1500                 put_multipath_config(conf);
1501         } else
1502                 checker_clear_message(&pp->checker);
1503
1504         if (newstate == PATH_WILD || newstate == PATH_UNCHECKED) {
1505                 condlog(2, "%s: unusable path", pp->dev);
1506                 conf = get_multipath_config();
1507                 pathinfo(pp, conf, 0);
1508                 put_multipath_config(conf);
1509                 return 1;
1510         }
1511         if (!pp->mpp) {
1512                 if (!strlen(pp->wwid) && pp->initialized != INIT_MISSING_UDEV &&
1513                     (newstate == PATH_UP || newstate == PATH_GHOST)) {
1514                         condlog(2, "%s: add missing path", pp->dev);
1515                         conf = get_multipath_config();
1516                         ret = pathinfo(pp, conf, DI_ALL | DI_BLACKLIST);
1517                         if (ret == PATHINFO_OK) {
1518                                 ev_add_path(pp, vecs);
1519                                 pp->tick = 1;
1520                         } else if (ret == PATHINFO_SKIPPED) {
1521                                 put_multipath_config(conf);
1522                                 return -1;
1523                         }
1524                         put_multipath_config(conf);
1525                 }
1526                 return 0;
1527         }
1528         /*
1529          * Async IO in flight. Keep the previous path state
1530          * and reschedule as soon as possible
1531          */
1532         if (newstate == PATH_PENDING) {
1533                 pp->tick = 1;
1534                 return 0;
1535         }
1536         /*
1537          * Synchronize with kernel state
1538          */
1539         if (update_multipath_strings(pp->mpp, vecs->pathvec, 1)) {
1540                 condlog(1, "%s: Could not synchronize with kernel state",
1541                         pp->dev);
1542                 pp->dmstate = PSTATE_UNDEF;
1543         }
1544         /* if update_multipath_strings orphaned the path, quit early */
1545         if (!pp->mpp)
1546                 return 0;
1547
1548         if ((newstate == PATH_UP || newstate == PATH_GHOST) &&
1549              pp->wait_checks > 0) {
1550                 if (pp->mpp && pp->mpp->nr_active > 0) {
1551                         pp->state = PATH_DELAYED;
1552                         pp->wait_checks--;
1553                         return 1;
1554                 } else
1555                         pp->wait_checks = 0;
1556         }
1557
1558         /*
1559          * don't reinstate failed path, if its in stand-by
1560          * and if target supports only implicit tpgs mode.
1561          * this will prevent unnecessary i/o by dm on stand-by
1562          * paths if there are no other active paths in map.
1563          */
1564         disable_reinstate = (newstate == PATH_GHOST &&
1565                             pp->mpp->nr_active == 0 &&
1566                             pp->tpgs == TPGS_IMPLICIT) ? 1 : 0;
1567
1568         pp->chkrstate = newstate;
1569         if (newstate != pp->state) {
1570                 int oldstate = pp->state;
1571                 pp->state = newstate;
1572
1573                 if (strlen(checker_message(&pp->checker)))
1574                         LOG_MSG(1, checker_message(&pp->checker));
1575
1576                 /*
1577                  * upon state change, reset the checkint
1578                  * to the shortest delay
1579                  */
1580                 conf = get_multipath_config();
1581                 pp->checkint = conf->checkint;
1582                 put_multipath_config(conf);
1583
1584                 if (newstate == PATH_DOWN || newstate == PATH_SHAKY) {
1585                         /*
1586                          * proactively fail path in the DM
1587                          */
1588                         if (oldstate == PATH_UP ||
1589                             oldstate == PATH_GHOST) {
1590                                 fail_path(pp, 1);
1591                                 if (pp->mpp->delay_wait_checks > 0 &&
1592                                     pp->watch_checks > 0) {
1593                                         pp->wait_checks = pp->mpp->delay_wait_checks;
1594                                         pp->watch_checks = 0;
1595                                 }
1596                         }else
1597                                 fail_path(pp, 0);
1598
1599                         /*
1600                          * cancel scheduled failback
1601                          */
1602                         pp->mpp->failback_tick = 0;
1603
1604                         pp->mpp->stat_path_failures++;
1605                         return 1;
1606                 }
1607
1608                 if(newstate == PATH_UP || newstate == PATH_GHOST){
1609                         if ( pp->mpp && pp->mpp->prflag ){
1610                                 /*
1611                                  * Check Persistent Reservation.
1612                                  */
1613                         condlog(2, "%s: checking persistent reservation "
1614                                 "registration", pp->dev);
1615                         mpath_pr_event_handle(pp);
1616                         }
1617                 }
1618
1619                 /*
1620                  * reinstate this path
1621                  */
1622                 if (oldstate != PATH_UP &&
1623                     oldstate != PATH_GHOST) {
1624                         if (pp->mpp->delay_watch_checks > 0)
1625                                 pp->watch_checks = pp->mpp->delay_watch_checks;
1626                         add_active = 1;
1627                 } else {
1628                         if (pp->watch_checks > 0)
1629                                 pp->watch_checks--;
1630                         add_active = 0;
1631                 }
1632                 if (!disable_reinstate && reinstate_path(pp, add_active)) {
1633                         condlog(3, "%s: reload map", pp->dev);
1634                         ev_add_path(pp, vecs);
1635                         pp->tick = 1;
1636                         return 0;
1637                 }
1638                 new_path_up = 1;
1639
1640                 if (oldchkrstate != PATH_UP && oldchkrstate != PATH_GHOST)
1641                         chkr_new_path_up = 1;
1642
1643                 /*
1644                  * if at least one path is up in a group, and
1645                  * the group is disabled, re-enable it
1646                  */
1647                 if (newstate == PATH_UP)
1648                         enable_group(pp);
1649         }
1650         else if (newstate == PATH_UP || newstate == PATH_GHOST) {
1651                 if ((pp->dmstate == PSTATE_FAILED ||
1652                     pp->dmstate == PSTATE_UNDEF) &&
1653                     !disable_reinstate) {
1654                         /* Clear IO errors */
1655                         if (reinstate_path(pp, 0)) {
1656                                 condlog(3, "%s: reload map", pp->dev);
1657                                 ev_add_path(pp, vecs);
1658                                 pp->tick = 1;
1659                                 return 0;
1660                         }
1661                 } else {
1662                         unsigned int max_checkint;
1663                         LOG_MSG(4, checker_message(&pp->checker));
1664                         conf = get_multipath_config();
1665                         max_checkint = conf->max_checkint;
1666                         put_multipath_config(conf);
1667                         if (pp->checkint != max_checkint) {
1668                                 /*
1669                                  * double the next check delay.
1670                                  * max at conf->max_checkint
1671                                  */
1672                                 if (pp->checkint < (max_checkint / 2))
1673                                         pp->checkint = 2 * pp->checkint;
1674                                 else
1675                                         pp->checkint = max_checkint;
1676
1677                                 condlog(4, "%s: delay next check %is",
1678                                         pp->dev_t, pp->checkint);
1679                         }
1680                         if (pp->watch_checks > 0)
1681                                 pp->watch_checks--;
1682                         pp->tick = pp->checkint;
1683                 }
1684         }
1685         else if (newstate == PATH_DOWN &&
1686                  strlen(checker_message(&pp->checker))) {
1687                 int log_checker_err;
1688
1689                 conf = get_multipath_config();
1690                 log_checker_err = conf->log_checker_err;
1691                 put_multipath_config(conf);
1692                 if (log_checker_err == LOG_CHKR_ERR_ONCE)
1693                         LOG_MSG(3, checker_message(&pp->checker));
1694                 else
1695                         LOG_MSG(2, checker_message(&pp->checker));
1696         }
1697
1698         pp->state = newstate;
1699
1700
1701         if (pp->mpp->wait_for_udev)
1702                 return 1;
1703         /*
1704          * path prio refreshing
1705          */
1706         condlog(4, "path prio refresh");
1707
1708         if (update_prio(pp, new_path_up) &&
1709             (pp->mpp->pgpolicyfn == (pgpolicyfn *)group_by_prio) &&
1710              pp->mpp->pgfailback == -FAILBACK_IMMEDIATE)
1711                 update_path_groups(pp->mpp, vecs, !new_path_up);
1712         else if (need_switch_pathgroup(pp->mpp, 0)) {
1713                 if (pp->mpp->pgfailback > 0 &&
1714                     (new_path_up || pp->mpp->failback_tick <= 0))
1715                         pp->mpp->failback_tick =
1716                                 pp->mpp->pgfailback + 1;
1717                 else if (pp->mpp->pgfailback == -FAILBACK_IMMEDIATE ||
1718                          (chkr_new_path_up && followover_should_failback(pp)))
1719                         switch_pathgroup(pp->mpp);
1720         }
1721         return 1;
1722 }
1723
1724 static void *
1725 checkerloop (void *ap)
1726 {
1727         struct vectors *vecs;
1728         struct path *pp;
1729         int count = 0;
1730         unsigned int i;
1731         struct itimerval timer_tick_it;
1732         struct timeval last_time;
1733         struct config *conf;
1734
1735         pthread_cleanup_push(rcu_unregister, NULL);
1736         rcu_register_thread();
1737         mlockall(MCL_CURRENT | MCL_FUTURE);
1738         vecs = (struct vectors *)ap;
1739         condlog(2, "path checkers start up");
1740
1741         /*
1742          * init the path check interval
1743          */
1744         vector_foreach_slot (vecs->pathvec, pp, i) {
1745                 conf = get_multipath_config();
1746                 pp->checkint = conf->checkint;
1747                 put_multipath_config(conf);
1748         }
1749
1750         /* Tweak start time for initial path check */
1751         if (gettimeofday(&last_time, NULL) != 0)
1752                 last_time.tv_sec = 0;
1753         else
1754                 last_time.tv_sec -= 1;
1755
1756         while (1) {
1757                 struct timeval diff_time, start_time, end_time;
1758                 int num_paths = 0, ticks = 0, signo, strict_timing, rc = 0;
1759                 sigset_t mask;
1760
1761                 if (gettimeofday(&start_time, NULL) != 0)
1762                         start_time.tv_sec = 0;
1763                 if (start_time.tv_sec && last_time.tv_sec) {
1764                         timersub(&start_time, &last_time, &diff_time);
1765                         condlog(4, "tick (%lu.%06lu secs)",
1766                                 diff_time.tv_sec, diff_time.tv_usec);
1767                         last_time.tv_sec = start_time.tv_sec;
1768                         last_time.tv_usec = start_time.tv_usec;
1769                         ticks = diff_time.tv_sec;
1770                 } else {
1771                         ticks = 1;
1772                         condlog(4, "tick (%d ticks)", ticks);
1773                 }
1774 #ifdef USE_SYSTEMD
1775                 if (use_watchdog)
1776                         sd_notify(0, "WATCHDOG=1");
1777 #endif
1778                 rc = set_config_state(DAEMON_RUNNING);
1779                 if (rc == ETIMEDOUT) {
1780                         condlog(4, "timeout waiting for DAEMON_IDLE");
1781                         continue;
1782                 }
1783                 if (vecs->pathvec) {
1784                         pthread_cleanup_push(cleanup_lock, &vecs->lock);
1785                         lock(vecs->lock);
1786                         pthread_testcancel();
1787                         vector_foreach_slot (vecs->pathvec, pp, i) {
1788                                 rc = check_path(vecs, pp, ticks);
1789                                 if (rc < 0) {
1790                                         vector_del_slot(vecs->pathvec, i);
1791                                         free_path(pp);
1792                                         i--;
1793                                 } else
1794                                         num_paths += rc;
1795                         }
1796                         lock_cleanup_pop(vecs->lock);
1797                 }
1798                 if (vecs->mpvec) {
1799                         pthread_cleanup_push(cleanup_lock, &vecs->lock);
1800                         lock(vecs->lock);
1801                         pthread_testcancel();
1802                         defered_failback_tick(vecs->mpvec);
1803                         retry_count_tick(vecs->mpvec);
1804                         missing_uev_wait_tick(vecs);
1805                         lock_cleanup_pop(vecs->lock);
1806                 }
1807                 if (count)
1808                         count--;
1809                 else {
1810                         pthread_cleanup_push(cleanup_lock, &vecs->lock);
1811                         lock(vecs->lock);
1812                         pthread_testcancel();
1813                         condlog(4, "map garbage collection");
1814                         mpvec_garbage_collector(vecs);
1815                         count = MAPGCINT;
1816                         lock_cleanup_pop(vecs->lock);
1817                 }
1818
1819                 diff_time.tv_usec = 0;
1820                 if (start_time.tv_sec &&
1821                     gettimeofday(&end_time, NULL) == 0) {
1822                         timersub(&end_time, &start_time, &diff_time);
1823                         if (num_paths) {
1824                                 unsigned int max_checkint;
1825
1826                                 condlog(3, "checked %d path%s in %lu.%06lu secs",
1827                                         num_paths, num_paths > 1 ? "s" : "",
1828                                         diff_time.tv_sec, diff_time.tv_usec);
1829                                 conf = get_multipath_config();
1830                                 max_checkint = conf->max_checkint;
1831                                 put_multipath_config(conf);
1832                                 if (diff_time.tv_sec > max_checkint)
1833                                         condlog(1, "path checkers took longer "
1834                                                 "than %lu seconds, consider "
1835                                                 "increasing max_polling_interval",
1836                                                 diff_time.tv_sec);
1837                         }
1838                 }
1839
1840                 post_config_state(DAEMON_IDLE);
1841                 conf = get_multipath_config();
1842                 strict_timing = conf->strict_timing;
1843                 put_multipath_config(conf);
1844                 if (!strict_timing)
1845                         sleep(1);
1846                 else {
1847                         timer_tick_it.it_interval.tv_sec = 0;
1848                         timer_tick_it.it_interval.tv_usec = 0;
1849                         if (diff_time.tv_usec) {
1850                                 timer_tick_it.it_value.tv_sec = 0;
1851                                 timer_tick_it.it_value.tv_usec =
1852                                         (unsigned long)1000000 - diff_time.tv_usec;
1853                         } else {
1854                                 timer_tick_it.it_value.tv_sec = 1;
1855                                 timer_tick_it.it_value.tv_usec = 0;
1856                         }
1857                         setitimer(ITIMER_REAL, &timer_tick_it, NULL);
1858
1859                         sigemptyset(&mask);
1860                         sigaddset(&mask, SIGALRM);
1861                         condlog(3, "waiting for %lu.%06lu secs",
1862                                 timer_tick_it.it_value.tv_sec,
1863                                 timer_tick_it.it_value.tv_usec);
1864                         if (sigwait(&mask, &signo) != 0) {
1865                                 condlog(3, "sigwait failed with error %d",
1866                                         errno);
1867                                 conf = get_multipath_config();
1868                                 conf->strict_timing = 0;
1869                                 put_multipath_config(conf);
1870                                 break;
1871                         }
1872                 }
1873         }
1874         pthread_cleanup_pop(1);
1875         return NULL;
1876 }
1877
1878 int
1879 configure (struct vectors * vecs, int start_waiters)
1880 {
1881         struct multipath * mpp;
1882         struct path * pp;
1883         vector mpvec;
1884         int i, ret;
1885         struct config *conf;
1886
1887         if (!vecs->pathvec && !(vecs->pathvec = vector_alloc()))
1888                 return 1;
1889
1890         if (!vecs->mpvec && !(vecs->mpvec = vector_alloc()))
1891                 return 1;
1892
1893         if (!(mpvec = vector_alloc()))
1894                 return 1;
1895
1896         /*
1897          * probe for current path (from sysfs) and map (from dm) sets
1898          */
1899         ret = path_discovery(vecs->pathvec, DI_ALL);
1900         if (ret < 0)
1901                 return 1;
1902
1903         vector_foreach_slot (vecs->pathvec, pp, i){
1904                 conf = get_multipath_config();
1905                 if (filter_path(conf, pp) > 0){
1906                         vector_del_slot(vecs->pathvec, i);
1907                         free_path(pp);
1908                         i--;
1909                 }
1910                 else
1911                         pp->checkint = conf->checkint;
1912                 put_multipath_config(conf);
1913         }
1914         if (map_discovery(vecs))
1915                 return 1;
1916
1917         /*
1918          * create new set of maps & push changed ones into dm
1919          */
1920         if (coalesce_paths(vecs, mpvec, NULL, 1, CMD_NONE))
1921                 return 1;
1922
1923         /*
1924          * may need to remove some maps which are no longer relevant
1925          * e.g., due to blacklist changes in conf file
1926          */
1927         if (coalesce_maps(vecs, mpvec))
1928                 return 1;
1929
1930         dm_lib_release();
1931
1932         sync_maps_state(mpvec);
1933         vector_foreach_slot(mpvec, mpp, i){
1934                 remember_wwid(mpp->wwid);
1935                 update_map_pr(mpp);
1936         }
1937
1938         /*
1939          * purge dm of old maps
1940          */
1941         remove_maps(vecs);
1942
1943         /*
1944          * save new set of maps formed by considering current path state
1945          */
1946         vector_free(vecs->mpvec);
1947         vecs->mpvec = mpvec;
1948
1949         /*
1950          * start dm event waiter threads for these new maps
1951          */
1952         vector_foreach_slot(vecs->mpvec, mpp, i) {
1953                 if (setup_multipath(vecs, mpp))
1954                         return 1;
1955                 if (start_waiters)
1956                         if (start_waiter_thread(mpp, vecs))
1957                                 return 1;
1958         }
1959         return 0;
1960 }
1961
1962 int
1963 need_to_delay_reconfig(struct vectors * vecs)
1964 {
1965         struct multipath *mpp;
1966         int i;
1967
1968         if (!VECTOR_SIZE(vecs->mpvec))
1969                 return 0;
1970
1971         vector_foreach_slot(vecs->mpvec, mpp, i) {
1972                 if (mpp->wait_for_udev)
1973                         return 1;
1974         }
1975         return 0;
1976 }
1977
1978 void rcu_free_config(struct rcu_head *head)
1979 {
1980         struct config *conf = container_of(head, struct config, rcu);
1981
1982         free_config(conf);
1983 }
1984
1985 int
1986 reconfigure (struct vectors * vecs)
1987 {
1988         struct config * old, *conf;
1989
1990         conf = load_config(DEFAULT_CONFIGFILE);
1991         if (!conf)
1992                 return 1;
1993
1994         /*
1995          * free old map and path vectors ... they use old conf state
1996          */
1997         if (VECTOR_SIZE(vecs->mpvec))
1998                 remove_maps_and_stop_waiters(vecs);
1999
2000         free_pathvec(vecs->pathvec, FREE_PATHS);
2001         vecs->pathvec = NULL;
2002
2003         /* Re-read any timezone changes */
2004         tzset();
2005
2006         dm_drv_version(conf->version, TGT_MPATH);
2007         if (verbosity)
2008                 conf->verbosity = verbosity;
2009         if (bindings_read_only)
2010                 conf->bindings_read_only = bindings_read_only;
2011         if (ignore_new_devs)
2012                 conf->ignore_new_devs = ignore_new_devs;
2013         uxsock_timeout = conf->uxsock_timeout;
2014
2015         old = rcu_dereference(multipath_conf);
2016         rcu_assign_pointer(multipath_conf, conf);
2017         call_rcu(&old->rcu, rcu_free_config);
2018
2019         configure(vecs, 1);
2020
2021
2022         return 0;
2023 }
2024
2025 static struct vectors *
2026 init_vecs (void)
2027 {
2028         struct vectors * vecs;
2029
2030         vecs = (struct vectors *)MALLOC(sizeof(struct vectors));
2031
2032         if (!vecs)
2033                 return NULL;
2034
2035         vecs->lock.mutex =
2036                 (pthread_mutex_t *)MALLOC(sizeof(pthread_mutex_t));
2037
2038         if (!vecs->lock.mutex)
2039                 goto out;
2040
2041         pthread_mutex_init(vecs->lock.mutex, NULL);
2042         vecs->lock.depth = 0;
2043
2044         return vecs;
2045
2046 out:
2047         FREE(vecs);
2048         condlog(0, "failed to init paths");
2049         return NULL;
2050 }
2051
2052 static void *
2053 signal_set(int signo, void (*func) (int))
2054 {
2055         int r;
2056         struct sigaction sig;
2057         struct sigaction osig;
2058
2059         sig.sa_handler = func;
2060         sigemptyset(&sig.sa_mask);
2061         sig.sa_flags = 0;
2062
2063         r = sigaction(signo, &sig, &osig);
2064
2065         if (r < 0)
2066                 return (SIG_ERR);
2067         else
2068                 return (osig.sa_handler);
2069 }
2070
2071 void
2072 handle_signals(void)
2073 {
2074         if (reconfig_sig) {
2075                 condlog(2, "reconfigure (signal)");
2076                 set_config_state(DAEMON_CONFIGURE);
2077         }
2078         if (log_reset_sig) {
2079                 condlog(2, "reset log (signal)");
2080                 pthread_mutex_lock(&logq_lock);
2081                 log_reset("multipathd");
2082                 pthread_mutex_unlock(&logq_lock);
2083         }
2084         reconfig_sig = 0;
2085         log_reset_sig = 0;
2086 }
2087
2088 static void
2089 sighup (int sig)
2090 {
2091         reconfig_sig = 1;
2092 }
2093
2094 static void
2095 sigend (int sig)
2096 {
2097         exit_daemon();
2098 }
2099
2100 static void
2101 sigusr1 (int sig)
2102 {
2103         log_reset_sig = 1;
2104 }
2105
2106 static void
2107 sigusr2 (int sig)
2108 {
2109         condlog(3, "SIGUSR2 received");
2110 }
2111
2112 static void
2113 signal_init(void)
2114 {
2115         sigset_t set;
2116
2117         sigemptyset(&set);
2118         sigaddset(&set, SIGHUP);
2119         sigaddset(&set, SIGUSR1);
2120         sigaddset(&set, SIGUSR2);
2121         sigaddset(&set, SIGALRM);
2122         pthread_sigmask(SIG_BLOCK, &set, NULL);
2123
2124         signal_set(SIGHUP, sighup);
2125         signal_set(SIGUSR1, sigusr1);
2126         signal_set(SIGUSR2, sigusr2);
2127         signal_set(SIGINT, sigend);
2128         signal_set(SIGTERM, sigend);
2129         signal(SIGPIPE, SIG_IGN);
2130 }
2131
2132 static void
2133 setscheduler (void)
2134 {
2135         int res;
2136         static struct sched_param sched_param = {
2137                 .sched_priority = 99
2138         };
2139
2140         res = sched_setscheduler (0, SCHED_RR, &sched_param);
2141
2142         if (res == -1)
2143                 condlog(LOG_WARNING, "Could not set SCHED_RR at priority 99");
2144         return;
2145 }
2146
2147 static void
2148 set_oom_adj (void)
2149 {
2150 #ifdef OOM_SCORE_ADJ_MIN
2151         int retry = 1;
2152         char *file = "/proc/self/oom_score_adj";
2153         int score = OOM_SCORE_ADJ_MIN;
2154 #else
2155         int retry = 0;
2156         char *file = "/proc/self/oom_adj";
2157         int score = OOM_ADJUST_MIN;
2158 #endif
2159         FILE *fp;
2160         struct stat st;
2161         char *envp;
2162
2163         envp = getenv("OOMScoreAdjust");
2164         if (envp) {
2165                 condlog(3, "Using systemd provided OOMScoreAdjust");
2166                 return;
2167         }
2168         do {
2169                 if (stat(file, &st) == 0){
2170                         fp = fopen(file, "w");
2171                         if (!fp) {
2172                                 condlog(0, "couldn't fopen %s : %s", file,
2173                                         strerror(errno));
2174                                 return;
2175                         }
2176                         fprintf(fp, "%i", score);
2177                         fclose(fp);
2178                         return;
2179                 }
2180                 if (errno != ENOENT) {
2181                         condlog(0, "couldn't stat %s : %s", file,
2182                                 strerror(errno));
2183                         return;
2184                 }
2185 #ifdef OOM_ADJUST_MIN
2186                 file = "/proc/self/oom_adj";
2187                 score = OOM_ADJUST_MIN;
2188 #else
2189                 retry = 0;
2190 #endif
2191         } while (retry--);
2192         condlog(0, "couldn't adjust oom score");
2193 }
2194
2195 static int
2196 child (void * param)
2197 {
2198         pthread_t check_thr, uevent_thr, uxlsnr_thr, uevq_thr;
2199         pthread_attr_t log_attr, misc_attr, uevent_attr;
2200         struct vectors * vecs;
2201         struct multipath * mpp;
2202         int i;
2203 #ifdef USE_SYSTEMD
2204         unsigned long checkint;
2205 #endif
2206         int rc;
2207         int pid_fd = -1;
2208         struct config *conf;
2209         char *envp;
2210
2211         mlockall(MCL_CURRENT | MCL_FUTURE);
2212         signal_init();
2213         rcu_init();
2214
2215         setup_thread_attr(&misc_attr, 64 * 1024, 1);
2216         setup_thread_attr(&uevent_attr, DEFAULT_UEVENT_STACKSIZE * 1024, 1);
2217         setup_thread_attr(&waiter_attr, 32 * 1024, 1);
2218
2219         if (logsink == 1) {
2220                 setup_thread_attr(&log_attr, 64 * 1024, 0);
2221                 log_thread_start(&log_attr);
2222                 pthread_attr_destroy(&log_attr);
2223         }
2224         pid_fd = pidfile_create(DEFAULT_PIDFILE, daemon_pid);
2225         if (pid_fd < 0) {
2226                 condlog(1, "failed to create pidfile");
2227                 if (logsink == 1)
2228                         log_thread_stop();
2229                 exit(1);
2230         }
2231
2232         post_config_state(DAEMON_START);
2233
2234         condlog(2, "--------start up--------");
2235         condlog(2, "read " DEFAULT_CONFIGFILE);
2236
2237         conf = load_config(DEFAULT_CONFIGFILE);
2238         if (!conf)
2239                 goto failed;
2240
2241         if (verbosity)
2242                 conf->verbosity = verbosity;
2243         if (bindings_read_only)
2244                 conf->bindings_read_only = bindings_read_only;
2245         if (ignore_new_devs)
2246                 conf->ignore_new_devs = ignore_new_devs;
2247         uxsock_timeout = conf->uxsock_timeout;
2248         multipath_conf = conf;
2249         dm_init(conf->verbosity);
2250         dm_drv_version(conf->version, TGT_MPATH);
2251         if (init_checkers(conf->multipath_dir)) {
2252                 condlog(0, "failed to initialize checkers");
2253                 goto failed;
2254         }
2255         if (init_prio(conf->multipath_dir)) {
2256                 condlog(0, "failed to initialize prioritizers");
2257                 goto failed;
2258         }
2259
2260         setlogmask(LOG_UPTO(conf->verbosity + 3));
2261
2262         envp = getenv("LimitNOFILE");
2263
2264         if (envp) {
2265                 condlog(2,"Using systemd provided open fds limit of %s", envp);
2266         } else if (conf->max_fds) {
2267                 struct rlimit fd_limit;
2268
2269                 if (getrlimit(RLIMIT_NOFILE, &fd_limit) < 0) {
2270                         condlog(0, "can't get open fds limit: %s",
2271                                 strerror(errno));
2272                         fd_limit.rlim_cur = 0;
2273                         fd_limit.rlim_max = 0;
2274                 }
2275                 if (fd_limit.rlim_cur < conf->max_fds) {
2276                         fd_limit.rlim_cur = conf->max_fds;
2277                         if (fd_limit.rlim_max < conf->max_fds)
2278                                 fd_limit.rlim_max = conf->max_fds;
2279                         if (setrlimit(RLIMIT_NOFILE, &fd_limit) < 0) {
2280                                 condlog(0, "can't set open fds limit to "
2281                                         "%lu/%lu : %s",
2282                                         fd_limit.rlim_cur, fd_limit.rlim_max,
2283                                         strerror(errno));
2284                         } else {
2285                                 condlog(3, "set open fds limit to %lu/%lu",
2286                                         fd_limit.rlim_cur, fd_limit.rlim_max);
2287                         }
2288                 }
2289
2290         }
2291
2292         vecs = gvecs = init_vecs();
2293         if (!vecs)
2294                 goto failed;
2295
2296         setscheduler();
2297         set_oom_adj();
2298
2299         dm_udev_set_sync_support(0);
2300 #ifdef USE_SYSTEMD
2301         envp = getenv("WATCHDOG_USEC");
2302         if (envp && sscanf(envp, "%lu", &checkint) == 1) {
2303                 /* Value is in microseconds */
2304                 conf->max_checkint = checkint / 1000000;
2305                 /* Rescale checkint */
2306                 if (conf->checkint > conf->max_checkint)
2307                         conf->checkint = conf->max_checkint;
2308                 else
2309                         conf->checkint = conf->max_checkint / 4;
2310                 condlog(3, "enabling watchdog, interval %d max %d",
2311                         conf->checkint, conf->max_checkint);
2312                 use_watchdog = conf->checkint;
2313         }
2314 #endif
2315         /*
2316          * Signal start of configuration
2317          */
2318         post_config_state(DAEMON_CONFIGURE);
2319
2320         /*
2321          * Start uevent listener early to catch events
2322          */
2323         if ((rc = pthread_create(&uevent_thr, &uevent_attr, ueventloop, udev))) {
2324                 condlog(0, "failed to create uevent thread: %d", rc);
2325                 goto failed;
2326         }
2327         pthread_attr_destroy(&uevent_attr);
2328         if ((rc = pthread_create(&uxlsnr_thr, &misc_attr, uxlsnrloop, vecs))) {
2329                 condlog(0, "failed to create cli listener: %d", rc);
2330                 goto failed;
2331         }
2332
2333         /*
2334          * start threads
2335          */
2336         if ((rc = pthread_create(&check_thr, &misc_attr, checkerloop, vecs))) {
2337                 condlog(0,"failed to create checker loop thread: %d", rc);
2338                 goto failed;
2339         }
2340         if ((rc = pthread_create(&uevq_thr, &misc_attr, uevqloop, vecs))) {
2341                 condlog(0, "failed to create uevent dispatcher: %d", rc);
2342                 goto failed;
2343         }
2344         pthread_attr_destroy(&misc_attr);
2345
2346 #ifdef USE_SYSTEMD
2347         sd_notify(0, "READY=1");
2348 #endif
2349
2350         while (running_state != DAEMON_SHUTDOWN) {
2351                 pthread_cleanup_push(config_cleanup, NULL);
2352                 pthread_mutex_lock(&config_lock);
2353                 if (running_state != DAEMON_CONFIGURE &&
2354                     running_state != DAEMON_SHUTDOWN) {
2355                         pthread_cond_wait(&config_cond, &config_lock);
2356                 }
2357                 pthread_cleanup_pop(1);
2358                 if (running_state == DAEMON_CONFIGURE) {
2359                         pthread_cleanup_push(cleanup_lock, &vecs->lock);
2360                         lock(vecs->lock);
2361                         pthread_testcancel();
2362                         if (!need_to_delay_reconfig(vecs)) {
2363                                 reconfigure(vecs);
2364                         } else {
2365                                 conf->delayed_reconfig = 1;
2366                         }
2367                         lock_cleanup_pop(vecs->lock);
2368                         post_config_state(DAEMON_IDLE);
2369                 }
2370         }
2371
2372         lock(vecs->lock);
2373         if (conf->queue_without_daemon == QUE_NO_DAEMON_OFF)
2374                 vector_foreach_slot(vecs->mpvec, mpp, i)
2375                         dm_queue_if_no_path(mpp->alias, 0);
2376         remove_maps_and_stop_waiters(vecs);
2377         unlock(vecs->lock);
2378
2379         pthread_cancel(check_thr);
2380         pthread_cancel(uevent_thr);
2381         pthread_cancel(uxlsnr_thr);
2382         pthread_cancel(uevq_thr);
2383
2384         lock(vecs->lock);
2385         free_pathvec(vecs->pathvec, FREE_PATHS);
2386         vecs->pathvec = NULL;
2387         unlock(vecs->lock);
2388         /* Now all the waitevent threads will start rushing in. */
2389         while (vecs->lock.depth > 0) {
2390                 sleep (1); /* This is weak. */
2391                 condlog(3, "Have %d wait event checkers threads to de-alloc,"
2392                         " waiting...", vecs->lock.depth);
2393         }
2394         pthread_mutex_destroy(vecs->lock.mutex);
2395         FREE(vecs->lock.mutex);
2396         vecs->lock.depth = 0;
2397         vecs->lock.mutex = NULL;
2398         FREE(vecs);
2399         vecs = NULL;
2400
2401         cleanup_checkers();
2402         cleanup_prio();
2403
2404         dm_lib_release();
2405         dm_lib_exit();
2406
2407         /* We're done here */
2408         condlog(3, "unlink pidfile");
2409         unlink(DEFAULT_PIDFILE);
2410
2411         condlog(2, "--------shut down-------");
2412
2413         if (logsink == 1)
2414                 log_thread_stop();
2415
2416         /*
2417          * Freeing config must be done after condlog() and dm_lib_exit(),
2418          * because logging functions like dlog() and dm_write_log()
2419          * reference the config.
2420          */
2421         free_config(conf);
2422         conf = NULL;
2423         udev_unref(udev);
2424         udev = NULL;
2425         pthread_attr_destroy(&waiter_attr);
2426 #ifdef _DEBUG_
2427         dbg_free_final(NULL);
2428 #endif
2429
2430 #ifdef USE_SYSTEMD
2431         sd_notify(0, "ERRNO=0");
2432 #endif
2433         exit(0);
2434
2435 failed:
2436 #ifdef USE_SYSTEMD
2437         sd_notify(0, "ERRNO=1");
2438 #endif
2439         if (pid_fd >= 0)
2440                 close(pid_fd);
2441         exit(1);
2442 }
2443
2444 static int
2445 daemonize(void)
2446 {
2447         int pid;
2448         int dev_null_fd;
2449
2450         if( (pid = fork()) < 0){
2451                 fprintf(stderr, "Failed first fork : %s\n", strerror(errno));
2452                 return -1;
2453         }
2454         else if (pid != 0)
2455                 return pid;
2456
2457         setsid();
2458
2459         if ( (pid = fork()) < 0)
2460                 fprintf(stderr, "Failed second fork : %s\n", strerror(errno));
2461         else if (pid != 0)
2462                 _exit(0);
2463
2464         if (chdir("/") < 0)
2465                 fprintf(stderr, "cannot chdir to '/', continuing\n");
2466
2467         dev_null_fd = open("/dev/null", O_RDWR);
2468         if (dev_null_fd < 0){
2469                 fprintf(stderr, "cannot open /dev/null for input & output : %s\n",
2470                         strerror(errno));
2471                 _exit(0);
2472         }
2473
2474         close(STDIN_FILENO);
2475         if (dup(dev_null_fd) < 0) {
2476                 fprintf(stderr, "cannot dup /dev/null to stdin : %s\n",
2477                         strerror(errno));
2478                 _exit(0);
2479         }
2480         close(STDOUT_FILENO);
2481         if (dup(dev_null_fd) < 0) {
2482                 fprintf(stderr, "cannot dup /dev/null to stdout : %s\n",
2483                         strerror(errno));
2484                 _exit(0);
2485         }
2486         close(STDERR_FILENO);
2487         if (dup(dev_null_fd) < 0) {
2488                 fprintf(stderr, "cannot dup /dev/null to stderr : %s\n",
2489                         strerror(errno));
2490                 _exit(0);
2491         }
2492         close(dev_null_fd);
2493         daemon_pid = getpid();
2494         return 0;
2495 }
2496
2497 int
2498 main (int argc, char *argv[])
2499 {
2500         extern char *optarg;
2501         extern int optind;
2502         int arg;
2503         int err;
2504         int foreground = 0;
2505         struct config *conf;
2506
2507         logsink = 1;
2508
2509         if (getuid() != 0) {
2510                 fprintf(stderr, "need to be root\n");
2511                 exit(1);
2512         }
2513
2514         /* make sure we don't lock any path */
2515         if (chdir("/") < 0)
2516                 fprintf(stderr, "can't chdir to root directory : %s\n",
2517                         strerror(errno));
2518         umask(umask(077) | 022);
2519
2520         udev = udev_new();
2521
2522         while ((arg = getopt(argc, argv, ":dsv:k::Bn")) != EOF ) {
2523         switch(arg) {
2524                 case 'd':
2525                         foreground = 1;
2526                         if (logsink > 0)
2527                                 logsink = 0;
2528                         //debug=1; /* ### comment me out ### */
2529                         break;
2530                 case 'v':
2531                         if (sizeof(optarg) > sizeof(char *) ||
2532                             !isdigit(optarg[0]))
2533                                 exit(1);
2534
2535                         verbosity = atoi(optarg);
2536                         break;
2537                 case 's':
2538                         logsink = -1;
2539                         break;
2540                 case 'k':
2541                         conf = load_config(DEFAULT_CONFIGFILE);
2542                         if (!conf)
2543                                 exit(1);
2544                         if (verbosity)
2545                                 conf->verbosity = verbosity;
2546                         uxclnt(optarg, uxsock_timeout + 100);
2547                         exit(0);
2548                 case 'B':
2549                         bindings_read_only = 1;
2550                         break;
2551                 case 'n':
2552                         ignore_new_devs = 1;
2553                         break;
2554                 default:
2555                         fprintf(stderr, "Invalid argument '-%c'\n",
2556                                 optopt);
2557                         exit(1);
2558                 }
2559         }
2560         if (optind < argc) {
2561                 char cmd[CMDSIZE];
2562                 char * s = cmd;
2563                 char * c = s;
2564
2565                 conf = load_config(DEFAULT_CONFIGFILE);
2566                 if (!conf)
2567                         exit(1);
2568                 if (verbosity)
2569                         conf->verbosity = verbosity;
2570                 memset(cmd, 0x0, CMDSIZE);
2571                 while (optind < argc) {
2572                         if (strchr(argv[optind], ' '))
2573                                 c += snprintf(c, s + CMDSIZE - c, "\"%s\" ", argv[optind]);
2574                         else
2575                                 c += snprintf(c, s + CMDSIZE - c, "%s ", argv[optind]);
2576                         optind++;
2577                 }
2578                 c += snprintf(c, s + CMDSIZE - c, "\n");
2579                 uxclnt(s, uxsock_timeout + 100);
2580                 exit(0);
2581         }
2582
2583         if (foreground) {
2584                 if (!isatty(fileno(stdout)))
2585                         setbuf(stdout, NULL);
2586                 err = 0;
2587                 daemon_pid = getpid();
2588         } else
2589                 err = daemonize();
2590
2591         if (err < 0)
2592                 /* error */
2593                 exit(1);
2594         else if (err > 0)
2595                 /* parent dies */
2596                 exit(0);
2597         else
2598                 /* child lives */
2599                 return (child(NULL));
2600 }
2601
2602 void *  mpath_pr_event_handler_fn (void * pathp )
2603 {
2604         struct multipath * mpp;
2605         int i,j, ret, isFound;
2606         struct path * pp = (struct path *)pathp;
2607         unsigned char *keyp;
2608         uint64_t prkey;
2609         struct prout_param_descriptor *param;
2610         struct prin_resp *resp;
2611
2612         mpp = pp->mpp;
2613
2614         resp = mpath_alloc_prin_response(MPATH_PRIN_RKEY_SA);
2615         if (!resp){
2616                 condlog(0,"%s Alloc failed for prin response", pp->dev);
2617                 return NULL;
2618         }
2619
2620         ret = prin_do_scsi_ioctl(pp->dev, MPATH_PRIN_RKEY_SA, resp, 0);
2621         if (ret != MPATH_PR_SUCCESS )
2622         {
2623                 condlog(0,"%s : pr in read keys service action failed. Error=%d", pp->dev, ret);
2624                 goto out;
2625         }
2626
2627         condlog(3, " event pr=%d addlen=%d",resp->prin_descriptor.prin_readkeys.prgeneration,
2628                         resp->prin_descriptor.prin_readkeys.additional_length );
2629
2630         if (resp->prin_descriptor.prin_readkeys.additional_length == 0 )
2631         {
2632                 condlog(1, "%s: No key found. Device may not be registered.", pp->dev);
2633                 ret = MPATH_PR_SUCCESS;
2634                 goto out;
2635         }
2636         prkey = 0;
2637         keyp = (unsigned char *)mpp->reservation_key;
2638         for (j = 0; j < 8; ++j) {
2639                 if (j > 0)
2640                         prkey <<= 8;
2641                 prkey |= *keyp;
2642                 ++keyp;
2643         }
2644         condlog(2, "Multipath  reservation_key: 0x%" PRIx64 " ", prkey);
2645
2646         isFound =0;
2647         for (i = 0; i < resp->prin_descriptor.prin_readkeys.additional_length/8; i++ )
2648         {
2649                 condlog(2, "PR IN READKEYS[%d]  reservation key:",i);
2650                 dumpHex((char *)&resp->prin_descriptor.prin_readkeys.key_list[i*8], 8 , -1);
2651                 if (!memcmp(mpp->reservation_key, &resp->prin_descriptor.prin_readkeys.key_list[i*8], 8))
2652                 {
2653                         condlog(2, "%s: pr key found in prin readkeys response", mpp->alias);
2654                         isFound =1;
2655                         break;
2656                 }
2657         }
2658         if (!isFound)
2659         {
2660                 condlog(0, "%s: Either device not registered or ", pp->dev);
2661                 condlog(0, "host is not authorised for registration. Skip path");
2662                 ret = MPATH_PR_OTHER;
2663                 goto out;
2664         }
2665
2666         param= malloc(sizeof(struct prout_param_descriptor));
2667         memset(param, 0 , sizeof(struct prout_param_descriptor));
2668
2669         for (j = 7; j >= 0; --j) {
2670                 param->sa_key[j] = (prkey & 0xff);
2671                 prkey >>= 8;
2672         }
2673         param->num_transportid = 0;
2674
2675         condlog(3, "device %s:%s", pp->dev, pp->mpp->wwid);
2676
2677         ret = prout_do_scsi_ioctl(pp->dev, MPATH_PROUT_REG_IGN_SA, 0, 0, param, 0);
2678         if (ret != MPATH_PR_SUCCESS )
2679         {
2680                 condlog(0,"%s: Reservation registration failed. Error: %d", pp->dev, ret);
2681         }
2682         mpp->prflag = 1;
2683
2684         free(param);
2685 out:
2686         free(resp);
2687         return NULL;
2688 }
2689
2690 int mpath_pr_event_handle(struct path *pp)
2691 {
2692         pthread_t thread;
2693         int rc;
2694         pthread_attr_t attr;
2695         struct multipath * mpp;
2696
2697         mpp = pp->mpp;
2698
2699         if (!mpp->reservation_key)
2700                 return -1;
2701
2702         pthread_attr_init(&attr);
2703         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
2704
2705         rc = pthread_create(&thread, NULL , mpath_pr_event_handler_fn, pp);
2706         if (rc) {
2707                 condlog(0, "%s: ERROR; return code from pthread_create() is %d", pp->dev, rc);
2708                 return -1;
2709         }
2710         pthread_attr_destroy(&attr);
2711         rc = pthread_join(thread, NULL);
2712         return 0;
2713 }