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