libmultipath/configure.c

   1 /*
   2  * Copyright (c) 2003, 2004, 2005 Christophe Varoqui
   3  * Copyright (c) 2005 Benjamin Marzinski, Redhat
   4  * Copyright (c) 2005 Kiyoshi Ueda, NEC
   5  * Copyright (c) 2005 Patrick Caulfield, Redhat
   6  * Copyright (c) 2005 Edward Goggin, EMC
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <string.h>
  13 #include <sys/file.h>
  14 #include <errno.h>
  15 #include <libdevmapper.h>
  16 #include <libudev.h>
  17 #include <mpath_cmd.h>
  18
  19 #include "checkers.h"
  20 #include "vector.h"
  21 #include "memory.h"
  22 #include "devmapper.h"
  23 #include "defaults.h"
  24 #include "structs.h"
  25 #include "structs_vec.h"
  26 #include "dmparser.h"
  27 #include "config.h"
  28 #include "blacklist.h"
  29 #include "propsel.h"
  30 #include "discovery.h"
  31 #include "debug.h"
  32 #include "switchgroup.h"
  33 #include "print.h"
  34 #include "configure.h"
  35 #include "pgpolicies.h"
  36 #include "dict.h"
  37 #include "alias.h"
  38 #include "prio.h"
  39 #include "util.h"
  40 #include "uxsock.h"
  41 #include "wwids.h"
  42
  43 /* group paths in pg by host adapter
  44  */
  45 int group_by_host_adapter(struct pathgroup *pgp, vector adapters)
  46 {
  47         struct adapter_group *agp;
  48         struct host_group *hgp;
  49         struct path *pp, *pp1;
  50         char adapter_name1[SLOT_NAME_SIZE];
  51         char adapter_name2[SLOT_NAME_SIZE];
  52         int i, j;
  53         int found_hostgroup = 0;
  54
  55         while (VECTOR_SIZE(pgp->paths) > 0) {
  56
  57                 pp = VECTOR_SLOT(pgp->paths, 0);
  58
  59                 if (sysfs_get_host_adapter_name(pp, adapter_name1))
  60                         goto out;
  61                 /* create a new host adapter group
  62                  */
  63                 agp = alloc_adaptergroup();
  64                 if (!agp)
  65                         goto out;
  66                 agp->pgp = pgp;
  67
  68                 strncpy(agp->adapter_name, adapter_name1, SLOT_NAME_SIZE);
  69                 store_adaptergroup(adapters, agp);
  70
  71                 /* create a new host port group
  72                  */
  73                 hgp = alloc_hostgroup();
  74                 if (!hgp)
  75                         goto out;
  76                 if (store_hostgroup(agp->host_groups, hgp))
  77                         goto out;
  78
  79                 hgp->host_no = pp->sg_id.host_no;
  80                 agp->num_hosts++;
  81                 if (store_path(hgp->paths, pp))
  82                         goto out;
  83
  84                 hgp->num_paths++;
  85                 /* delete path from path group
  86                  */
  87                 vector_del_slot(pgp->paths, 0);
  88
  89                 /* add all paths belonging to same host adapter
  90                  */
  91                 vector_foreach_slot(pgp->paths, pp1, i) {
  92                         if (sysfs_get_host_adapter_name(pp1, adapter_name2))
  93                                 goto out;
  94                         if (strcmp(adapter_name1, adapter_name2) == 0) {
  95                                 found_hostgroup = 0;
  96                                 vector_foreach_slot(agp->host_groups, hgp, j) {
  97                                         if (hgp->host_no == pp1->sg_id.host_no) {
  98                                                 if (store_path(hgp->paths, pp1))
  99                                                         goto out;
 100                                                 hgp->num_paths++;
 101                                                 found_hostgroup = 1;
 102                                                 break;
 103                                         }
 104                                 }
 105                                 if (!found_hostgroup) {
 106                                         /* this path belongs to new host port
 107                                          * within this adapter
 108                                          */
 109                                         hgp = alloc_hostgroup();
 110                                         if (!hgp)
 111                                                 goto out;
 112
 113                                         if (store_hostgroup(agp->host_groups, hgp))
 114                                                 goto out;
 115
 116                                         agp->num_hosts++;
 117                                         if (store_path(hgp->paths, pp1))
 118                                                 goto out;
 119
 120                                         hgp->host_no = pp1->sg_id.host_no;
 121                                         hgp->num_paths++;
 122                                 }
 123                                 /* delete paths from original path_group
 124                                  * as they are added into adapter group now
 125                                  */
 126                                 vector_del_slot(pgp->paths, i);
 127                                 i--;
 128                         }
 129                 }
 130         }
 131         return 0;
 132
 133 out:    /* add back paths into pg as re-ordering failed
 134          */
 135         vector_foreach_slot(adapters, agp, i) {
 136                         vector_foreach_slot(agp->host_groups, hgp, j) {
 137                                 while (VECTOR_SIZE(hgp->paths) > 0) {
 138                                         pp = VECTOR_SLOT(hgp->paths, 0);
 139                                         if (store_path(pgp->paths, pp))
 140                                                 condlog(3, "failed to restore "
 141                                                 "path %s into path group",
 142                                                  pp->dev);
 143                                         vector_del_slot(hgp->paths, 0);
 144                                 }
 145                         }
 146                 }
 147         free_adaptergroup(adapters);
 148         return 1;
 149 }
 150
 151 /* re-order paths in pg by alternating adapters and host ports
 152  * for optimized selection
 153  */
 154 int order_paths_in_pg_by_alt_adapters(struct pathgroup *pgp, vector adapters,
 155                  int total_paths)
 156 {
 157         int next_adapter_index = 0;
 158         struct adapter_group *agp;
 159         struct host_group *hgp;
 160         struct path *pp;
 161
 162         while (total_paths > 0) {
 163                 agp = VECTOR_SLOT(adapters, next_adapter_index);
 164                 if (!agp) {
 165                         condlog(0, "can't get adapter group %d", next_adapter_index);
 166                         return 1;
 167                 }
 168
 169                 hgp = VECTOR_SLOT(agp->host_groups, agp->next_host_index);
 170                 if (!hgp) {
 171                         condlog(0, "can't get host group %d of adapter group %d", next_adapter_index, agp->next_host_index);
 172                         return 1;
 173                 }
 174
 175                 if (!hgp->num_paths) {
 176                         agp->next_host_index++;
 177                         agp->next_host_index %= agp->num_hosts;
 178                         next_adapter_index++;
 179                         next_adapter_index %= VECTOR_SIZE(adapters);
 180                         continue;
 181                 }
 182
 183                 pp  = VECTOR_SLOT(hgp->paths, 0);
 184
 185                 if (store_path(pgp->paths, pp))
 186                         return 1;
 187
 188                 total_paths--;
 189
 190                 vector_del_slot(hgp->paths, 0);
 191
 192                 hgp->num_paths--;
 193
 194                 agp->next_host_index++;
 195                 agp->next_host_index %= agp->num_hosts;
 196                 next_adapter_index++;
 197                 next_adapter_index %= VECTOR_SIZE(adapters);
 198         }
 199
 200         /* all paths are added into path_group
 201          * in crafted child order
 202          */
 203         return 0;
 204 }
 205
 206 /* round-robin: order paths in path group to alternate
 207  * between all host adapters
 208  */
 209 int rr_optimize_path_order(struct pathgroup *pgp)
 210 {
 211         vector adapters;
 212         struct path *pp;
 213         int total_paths;
 214         int i;
 215
 216         total_paths = VECTOR_SIZE(pgp->paths);
 217         vector_foreach_slot(pgp->paths, pp, i) {
 218                 if (pp->sg_id.proto_id != SCSI_PROTOCOL_FCP &&
 219                         pp->sg_id.proto_id != SCSI_PROTOCOL_SAS &&
 220                         pp->sg_id.proto_id != SCSI_PROTOCOL_ISCSI &&
 221                         pp->sg_id.proto_id != SCSI_PROTOCOL_SRP) {
 222                         /* return success as default path order
 223                          * is maintained in path group
 224                          */
 225                         return 0;
 226                 }
 227         }
 228         adapters = vector_alloc();
 229         if (!adapters)
 230                 return 0;
 231
 232         /* group paths in path group by host adapters
 233          */
 234         if (group_by_host_adapter(pgp, adapters)) {
 235                 /* already freed adapters */
 236                 condlog(3, "Failed to group paths by adapters");
 237                 return 0;
 238         }
 239
 240         /* re-order paths in pg to alternate between adapters and host ports
 241          */
 242         if (order_paths_in_pg_by_alt_adapters(pgp, adapters, total_paths)) {
 243                 condlog(3, "Failed to re-order paths in pg by adapters "
 244                         "and host ports");
 245                 free_adaptergroup(adapters);
 246                 /* return failure as original paths are
 247                  * removed form pgp
 248                  */
 249                 return 1;
 250         }
 251
 252         free_adaptergroup(adapters);
 253         return 0;
 254 }
 255
 256 extern int
 257 setup_map (struct multipath * mpp, char * params, int params_size)
 258 {
 259         struct pathgroup * pgp;
 260         int i;
 261
 262         /*
 263          * don't bother if devmap size is unknown
 264          */
 265         if (mpp->size <= 0) {
 266                 condlog(3, "%s: devmap size is unknown", mpp->alias);
 267                 return 1;
 268         }
 269
 270         /*
 271          * free features, selector, and hwhandler properties if they are being reused
 272          */
 273         free_multipath_attributes(mpp);
 274
 275         /*
 276          * properties selectors
 277          */
 278         select_pgfailback(mpp);
 279         select_pgpolicy(mpp);
 280         select_selector(mpp);
 281         select_features(mpp);
 282         select_hwhandler(mpp);
 283         select_rr_weight(mpp);
 284         select_minio(mpp);
 285         select_no_path_retry(mpp);
 286         select_mode(mpp);
 287         select_uid(mpp);
 288         select_gid(mpp);
 289         select_fast_io_fail(mpp);
 290         select_dev_loss(mpp);
 291         select_reservation_key(mpp);
 292         select_retain_hwhandler(mpp);
 293         select_deferred_remove(mpp);
 294         select_delay_watch_checks(mpp);
 295         select_delay_wait_checks(mpp);
 296
 297         sysfs_set_scsi_tmo(mpp);
 298         /*
 299          * assign paths to path groups -- start with no groups and all paths
 300          * in mpp->paths
 301          */
 302         if (mpp->pg) {
 303                 vector_foreach_slot (mpp->pg, pgp, i)
 304                         free_pathgroup(pgp, KEEP_PATHS);
 305
 306                 vector_free(mpp->pg);
 307                 mpp->pg = NULL;
 308         }
 309         if (mpp->pgpolicyfn && mpp->pgpolicyfn(mpp))
 310                 return 1;
 311
 312         mpp->nr_active = pathcount(mpp, PATH_UP) + pathcount(mpp, PATH_GHOST);
 313
 314         /*
 315          * ponders each path group and determine highest prio pg
 316          * to switch over (default to first)
 317          */
 318         mpp->bestpg = select_path_group(mpp);
 319
 320         /* re-order paths in all path groups in an optimized way
 321          * for round-robin path selectors to get maximum throughput.
 322          */
 323         if (!strncmp(mpp->selector, "round-robin", 11)) {
 324                 vector_foreach_slot(mpp->pg, pgp, i) {
 325                         if (VECTOR_SIZE(pgp->paths) <= 2)
 326                                 continue;
 327                         if (rr_optimize_path_order(pgp)) {
 328                                 condlog(2, "cannot re-order paths for "
 329                                         "optimization: %s",
 330                                         mpp->alias);
 331                                 return 1;
 332                         }
 333                 }
 334         }
 335
 336         /*
 337          * transform the mp->pg vector of vectors of paths
 338          * into a mp->params strings to feed the device-mapper
 339          */
 340         if (assemble_map(mpp, params, params_size)) {
 341                 condlog(0, "%s: problem assembing map", mpp->alias);
 342                 return 1;
 343         }
 344         return 0;
 345 }
 346
 347 static void
 348 compute_pgid(struct pathgroup * pgp)
 349 {
 350         struct path * pp;
 351         int i;
 352
 353         vector_foreach_slot (pgp->paths, pp, i)
 354                 pgp->id ^= (long)pp;
 355 }
 356
 357 static int
 358 pgcmp (struct multipath * mpp, struct multipath * cmpp)
 359 {
 360         int i, j;
 361         struct pathgroup * pgp;
 362         struct pathgroup * cpgp;
 363         int r = 0;
 364
 365         if (!mpp)
 366                 return 0;
 367
 368         vector_foreach_slot (mpp->pg, pgp, i) {
 369                 compute_pgid(pgp);
 370
 371                 vector_foreach_slot (cmpp->pg, cpgp, j) {
 372                         if (pgp->id == cpgp->id &&
 373                             !pathcmp(pgp, cpgp)) {
 374                                 r = 0;
 375                                 break;
 376                         }
 377                         r++;
 378                 }
 379                 if (r)
 380                         return r;
 381         }
 382         return r;
 383 }
 384
 385 static void
 386 select_action (struct multipath * mpp, vector curmp, int force_reload)
 387 {
 388         struct multipath * cmpp;
 389         struct multipath * cmpp_by_name;
 390
 391         cmpp = find_mp_by_wwid(curmp, mpp->wwid);
 392         cmpp_by_name = find_mp_by_alias(curmp, mpp->alias);
 393
 394         if (!cmpp_by_name) {
 395                 if (cmpp) {
 396                         condlog(2, "%s: rename %s to %s", mpp->wwid,
 397                                 cmpp->alias, mpp->alias);
 398                         strncpy(mpp->alias_old, cmpp->alias, WWID_SIZE);
 399                         mpp->action = ACT_RENAME;
 400                         if (force_reload)
 401                                 mpp->action = ACT_FORCERENAME;
 402                         return;
 403                 }
 404                 mpp->action = ACT_CREATE;
 405                 condlog(3, "%s: set ACT_CREATE (map does not exist)",
 406                         mpp->alias);
 407                 return;
 408         }
 409
 410         if (!cmpp) {
 411                 condlog(2, "%s: remove (wwid changed)", mpp->alias);
 412                 dm_flush_map(mpp->alias);
 413                 strncpy(cmpp_by_name->wwid, mpp->wwid, WWID_SIZE);
 414                 drop_multipath(curmp, cmpp_by_name->wwid, KEEP_PATHS);
 415                 mpp->action = ACT_CREATE;
 416                 condlog(3, "%s: set ACT_CREATE (map wwid change)",
 417                         mpp->alias);
 418                 return;
 419         }
 420
 421         if (cmpp != cmpp_by_name) {
 422                 condlog(2, "%s: unable to rename %s to %s (%s is used by %s)",
 423                         mpp->wwid, cmpp->alias, mpp->alias,
 424                         mpp->alias, cmpp_by_name->wwid);
 425                 /* reset alias to existing alias */
 426                 FREE(mpp->alias);
 427                 mpp->alias = STRDUP(cmpp->alias);
 428                 mpp->action = ACT_NOTHING;
 429                 return;
 430         }
 431
 432         if (pathcount(mpp, PATH_UP) == 0) {
 433                 mpp->action = ACT_NOTHING;
 434                 condlog(3, "%s: set ACT_NOTHING (no usable path)",
 435                         mpp->alias);
 436                 return;
 437         }
 438         if (force_reload) {
 439                 mpp->action = ACT_RELOAD;
 440                 condlog(3, "%s: set ACT_RELOAD (forced by user)",
 441                         mpp->alias);
 442                 return;
 443         }
 444         if (cmpp->size != mpp->size) {
 445                 mpp->action = ACT_RESIZE;
 446                 condlog(3, "%s: set ACT_RESIZE (size change)",
 447                         mpp->alias);
 448                 return;
 449         }
 450         if (!mpp->no_path_retry &&
 451             (strlen(cmpp->features) != strlen(mpp->features) ||
 452              strcmp(cmpp->features, mpp->features))) {
 453                 mpp->action =  ACT_RELOAD;
 454                 condlog(3, "%s: set ACT_RELOAD (features change)",
 455                         mpp->alias);
 456                 return;
 457         }
 458         if (mpp->retain_hwhandler != RETAIN_HWHANDLER_ON &&
 459             (strlen(cmpp->hwhandler) != strlen(mpp->hwhandler) ||
 460              strncmp(cmpp->hwhandler, mpp->hwhandler,
 461                     strlen(mpp->hwhandler)))) {
 462                 mpp->action = ACT_RELOAD;
 463                 condlog(3, "%s: set ACT_RELOAD (hwhandler change)",
 464                         mpp->alias);
 465                 return;
 466         }
 467         if (!cmpp->selector || strncmp(cmpp->selector, mpp->selector,
 468                     strlen(mpp->selector))) {
 469                 mpp->action = ACT_RELOAD;
 470                 condlog(3, "%s: set ACT_RELOAD (selector change)",
 471                         mpp->alias);
 472                 return;
 473         }
 474         if (cmpp->minio != mpp->minio) {
 475                 mpp->action = ACT_RELOAD;
 476                 condlog(3, "%s: set ACT_RELOAD (minio change, %u->%u)",
 477                         mpp->alias, cmpp->minio, mpp->minio);
 478                 return;
 479         }
 480         if (!cmpp->pg || VECTOR_SIZE(cmpp->pg) != VECTOR_SIZE(mpp->pg)) {
 481                 mpp->action = ACT_RELOAD;
 482                 condlog(3, "%s: set ACT_RELOAD (path group number change)",
 483                         mpp->alias);
 484                 return;
 485         }
 486         if (pgcmp(mpp, cmpp)) {
 487                 mpp->action = ACT_RELOAD;
 488                 condlog(3, "%s: set ACT_RELOAD (path group topology change)",
 489                         mpp->alias);
 490                 return;
 491         }
 492         if (cmpp->nextpg != mpp->bestpg) {
 493                 mpp->action = ACT_SWITCHPG;
 494                 condlog(3, "%s: set ACT_SWITCHPG (next path group change)",
 495                         mpp->alias);
 496                 return;
 497         }
 498         mpp->action = ACT_NOTHING;
 499         condlog(3, "%s: set ACT_NOTHING (map unchanged)",
 500                 mpp->alias);
 501         return;
 502 }
 503
 504 extern int
 505 reinstate_paths (struct multipath * mpp)
 506 {
 507         int i, j;
 508         struct pathgroup * pgp;
 509         struct path * pp;
 510
 511         if (!mpp->pg)
 512                 return 0;
 513
 514         vector_foreach_slot (mpp->pg, pgp, i) {
 515                 if (!pgp->paths)
 516                         continue;
 517
 518                 vector_foreach_slot (pgp->paths, pp, j) {
 519                         if (pp->state != PATH_UP &&
 520                             (pgp->status == PGSTATE_DISABLED ||
 521                              pgp->status == PGSTATE_ACTIVE))
 522                                 continue;
 523
 524                         if (pp->dmstate == PSTATE_FAILED) {
 525                                 if (dm_reinstate_path(mpp->alias, pp->dev_t))
 526                                         condlog(0, "%s: error reinstating",
 527                                                 pp->dev);
 528                         }
 529                 }
 530         }
 531         return 0;
 532 }
 533
 534 static int
 535 lock_multipath (struct multipath * mpp, int lock)
 536 {
 537         struct pathgroup * pgp;
 538         struct path * pp;
 539         int i, j;
 540         int x, y;
 541
 542         if (!mpp || !mpp->pg)
 543                 return 0;
 544
 545         vector_foreach_slot (mpp->pg, pgp, i) {
 546                 if (!pgp->paths)
 547                         continue;
 548                 vector_foreach_slot(pgp->paths, pp, j) {
 549                         if (lock && flock(pp->fd, LOCK_SH | LOCK_NB) &&
 550                             errno == EWOULDBLOCK)
 551                                 goto fail;
 552                         else if (!lock)
 553                                 flock(pp->fd, LOCK_UN);
 554                 }
 555         }
 556         return 0;
 557 fail:
 558         vector_foreach_slot (mpp->pg, pgp, x) {
 559                 if (x > i)
 560                         return 1;
 561                 if (!pgp->paths)
 562                         continue;
 563                 vector_foreach_slot(pgp->paths, pp, y) {
 564                         if (x == i && y >= j)
 565                                 return 1;
 566                         flock(pp->fd, LOCK_UN);
 567                 }
 568         }
 569         return 1;
 570 }
 571
 572 /*
 573  * Return value:
 574  */
 575 #define DOMAP_RETRY     -1
 576 #define DOMAP_FAIL      0
 577 #define DOMAP_OK        1
 578 #define DOMAP_EXIST     2
 579 #define DOMAP_DRY       3
 580
 581 extern int
 582 domap (struct multipath * mpp, char * params)
 583 {
 584         int r = DOMAP_FAIL;
 585
 586         /*
 587          * last chance to quit before touching the devmaps
 588          */
 589         if (conf->cmd == CMD_DRY_RUN && mpp->action != ACT_NOTHING) {
 590                 print_multipath_topology(mpp, conf->verbosity);
 591                 return DOMAP_DRY;
 592         }
 593
 594         if (mpp->action == ACT_CREATE &&
 595             dm_map_present(mpp->alias)) {
 596                 condlog(3, "%s: map already present", mpp->alias);
 597                 mpp->action = ACT_RELOAD;
 598         }
 599
 600         switch (mpp->action) {
 601         case ACT_REJECT:
 602         case ACT_NOTHING:
 603                 return DOMAP_EXIST;
 604
 605         case ACT_SWITCHPG:
 606                 dm_switchgroup(mpp->alias, mpp->bestpg);
 607                 /*
 608                  * we may have avoided reinstating paths because there where in
 609                  * active or disabled PG. Now that the topology has changed,
 610                  * retry.
 611                  */
 612                 reinstate_paths(mpp);
 613                 return DOMAP_EXIST;
 614
 615         case ACT_CREATE:
 616                 if (lock_multipath(mpp, 1)) {
 617                         condlog(3, "%s: failed to create map (in use)",
 618                                 mpp->alias);
 619                         return DOMAP_RETRY;
 620                 }
 621
 622                 r = dm_addmap_create(mpp, params);
 623
 624                 lock_multipath(mpp, 0);
 625                 break;
 626
 627         case ACT_RELOAD:
 628                 r = dm_addmap_reload(mpp, params, 0);
 629                 break;
 630
 631         case ACT_RESIZE:
 632                 r = dm_addmap_reload(mpp, params, 1);
 633                 break;
 634
 635         case ACT_RENAME:
 636                 r = dm_rename(mpp->alias_old, mpp->alias);
 637                 break;
 638
 639         case ACT_FORCERENAME:
 640                 r = dm_rename(mpp->alias_old, mpp->alias);
 641                 if (r)
 642                         r = dm_addmap_reload(mpp, params, 0);
 643                 break;
 644
 645         default:
 646                 break;
 647         }
 648
 649         if (r == DOMAP_OK) {
 650                 /*
 651                  * DM_DEVICE_CREATE, DM_DEVICE_RENAME, or DM_DEVICE_RELOAD
 652                  * succeeded
 653                  */
 654                 if (mpp->action == ACT_CREATE)
 655                         remember_wwid(mpp->wwid);
 656                 if (!conf->daemon) {
 657                         /* multipath client mode */
 658                         dm_switchgroup(mpp->alias, mpp->bestpg);
 659                 } else  {
 660                         /* multipath daemon mode */
 661                         mpp->stat_map_loads++;
 662                         condlog(2, "%s: load table [0 %llu %s %s]", mpp->alias,
 663                                 mpp->size, TGT_MPATH, params);
 664                         /*
 665                          * Required action is over, reset for the stateful daemon.
 666                          * But don't do it for creation as we use in the caller the
 667                          * mpp->action to figure out whether to start the watievent checker.
 668                          */
 669                         if (mpp->action != ACT_CREATE)
 670                                 mpp->action = ACT_NOTHING;
 671                         else {
 672                                 mpp->wait_for_udev = 1;
 673                                 mpp->uev_wait_tick = conf->uev_wait_timeout;
 674                         }
 675                 }
 676                 dm_setgeometry(mpp);
 677                 return DOMAP_OK;
 678         }
 679         return DOMAP_FAIL;
 680 }
 681
 682 static int
 683 deadmap (struct multipath * mpp)
 684 {
 685         int i, j;
 686         struct pathgroup * pgp;
 687         struct path * pp;
 688
 689         if (!mpp->pg)
 690                 return 1;
 691
 692         vector_foreach_slot (mpp->pg, pgp, i) {
 693                 if (!pgp->paths)
 694                         continue;
 695
 696                 vector_foreach_slot (pgp->paths, pp, j)
 697                         if (strlen(pp->dev))
 698                                 return 0; /* alive */
 699         }
 700
 701         return 1; /* dead */
 702 }
 703
 704 int check_daemon(void)
 705 {
 706         int fd;
 707         char *reply;
 708         int ret = 0;
 709
 710         fd = mpath_connect();
 711         if (fd == -1)
 712                 return 0;
 713
 714         if (send_packet(fd, "show daemon") != 0)
 715                 goto out;
 716         if (recv_packet(fd, &reply, conf->uxsock_timeout) != 0)
 717                 goto out;
 718
 719         if (strstr(reply, "shutdown"))
 720                 goto out_free;
 721
 722         ret = 1;
 723
 724 out_free:
 725         FREE(reply);
 726 out:
 727         mpath_disconnect(fd);
 728         return ret;
 729 }
 730
 731 extern int
 732 coalesce_paths (struct vectors * vecs, vector newmp, char * refwwid, int force_reload)
 733 {
 734         int r = 1;
 735         int k, i;
 736         char params[PARAMS_SIZE];
 737         struct multipath * mpp;
 738         struct path * pp1;
 739         struct path * pp2;
 740         vector curmp = vecs->mpvec;
 741         vector pathvec = vecs->pathvec;
 742
 743         /* ignore refwwid if it's empty */
 744         if (refwwid && !strlen(refwwid))
 745                 refwwid = NULL;
 746
 747         if (force_reload) {
 748                 vector_foreach_slot (pathvec, pp1, k) {
 749                         pp1->mpp = NULL;
 750                 }
 751         }
 752         vector_foreach_slot (pathvec, pp1, k) {
 753                 /* skip this path for some reason */
 754
 755                 /* 1. if path has no unique id or wwid blacklisted */
 756                 if (strlen(pp1->wwid) == 0 ||
 757                     filter_path(conf, pp1) > 0) {
 758                         orphan_path(pp1, "wwid blacklisted");
 759                         continue;
 760                 }
 761
 762                 /* 2. if path already coalesced */
 763                 if (pp1->mpp)
 764                         continue;
 765
 766                 /* 3. if path has disappeared */
 767                 if (pp1->state == PATH_REMOVED) {
 768                         orphan_path(pp1, "path removed");
 769                         continue;
 770                 }
 771
 772                 /* 4. path is out of scope */
 773                 if (refwwid && strncmp(pp1->wwid, refwwid, WWID_SIZE))
 774                         continue;
 775
 776                 /* If find_multipaths was selected check if the path is valid */
 777                 if (!refwwid && !should_multipath(pp1, pathvec)) {
 778                         orphan_path(pp1, "only one path");
 779                         continue;
 780                 }
 781
 782                 /*
 783                  * at this point, we know we really got a new mp
 784                  */
 785                 mpp = add_map_with_path(vecs, pp1, 0);
 786                 if (!mpp)
 787                         return 1;
 788
 789                 if (pp1->priority == PRIO_UNDEF)
 790                         mpp->action = ACT_REJECT;
 791
 792                 if (!mpp->paths) {
 793                         condlog(0, "%s: skip coalesce (no paths)", mpp->alias);
 794                         remove_map(mpp, vecs, 0);
 795                         continue;
 796                 }
 797
 798                 for (i = k + 1; i < VECTOR_SIZE(pathvec); i++) {
 799                         pp2 = VECTOR_SLOT(pathvec, i);
 800
 801                         if (strcmp(pp1->wwid, pp2->wwid))
 802                                 continue;
 803
 804                         if (!mpp->size && pp2->size)
 805                                 mpp->size = pp2->size;
 806
 807                         if (mpp->size && pp2->size &&
 808                             pp2->size != mpp->size) {
 809                                 /*
 810                                  * ouch, avoid feeding that to the DM
 811                                  */
 812                                 condlog(0, "%s: size %llu, expected %llu. "
 813                                         "Discard", pp2->dev_t, pp2->size,
 814                                         mpp->size);
 815                                 mpp->action = ACT_REJECT;
 816                         }
 817                         if (pp2->priority == PRIO_UNDEF)
 818                                 mpp->action = ACT_REJECT;
 819                 }
 820                 verify_paths(mpp, vecs);
 821
 822                 params[0] = '\0';
 823                 if (setup_map(mpp, params, PARAMS_SIZE)) {
 824                         remove_map(mpp, vecs, 0);
 825                         continue;
 826                 }
 827
 828                 if (mpp->action == ACT_UNDEF)
 829                         select_action(mpp, curmp, force_reload);
 830
 831                 r = domap(mpp, params);
 832
 833                 if (r == DOMAP_FAIL || r == DOMAP_RETRY) {
 834                         condlog(3, "%s: domap (%u) failure "
 835                                    "for create/reload map",
 836                                 mpp->alias, r);
 837                         if (r == DOMAP_FAIL) {
 838                                 condlog(2, "%s: %s map",
 839                                         mpp->alias, (mpp->action == ACT_CREATE)?
 840                                         "ignoring" : "removing");
 841                                 remove_map(mpp, vecs, 0);
 842                                 continue;
 843                         } else /* if (r == DOMAP_RETRY) */
 844                                 return r;
 845                 }
 846                 if (r == DOMAP_DRY)
 847                         continue;
 848
 849                 if (!conf->daemon && !conf->allow_queueing && !check_daemon()) {
 850                         if (mpp->no_path_retry != NO_PATH_RETRY_UNDEF &&
 851                             mpp->no_path_retry != NO_PATH_RETRY_FAIL)
 852                                 condlog(3, "%s: multipathd not running, unset "
 853                                         "queue_if_no_path feature", mpp->alias);
 854                         if (!dm_queue_if_no_path(mpp->alias, 0))
 855                                 remove_feature(&mpp->features,
 856                                                "queue_if_no_path");
 857                 }
 858                 else if (mpp->no_path_retry != NO_PATH_RETRY_UNDEF) {
 859                         if (mpp->no_path_retry == NO_PATH_RETRY_FAIL) {
 860                                 condlog(3, "%s: unset queue_if_no_path feature",
 861                                         mpp->alias);
 862                                 if (!dm_queue_if_no_path(mpp->alias, 0))
 863                                         remove_feature(&mpp->features,
 864                                                        "queue_if_no_path");
 865                         } else {
 866                                 condlog(3, "%s: set queue_if_no_path feature",
 867                                         mpp->alias);
 868                                 if (!dm_queue_if_no_path(mpp->alias, 1))
 869                                         add_feature(&mpp->features,
 870                                                     "queue_if_no_path");
 871                         }
 872                 }
 873
 874                 if (!conf->daemon && mpp->action != ACT_NOTHING)
 875                         print_multipath_topology(mpp, conf->verbosity);
 876
 877                 if (newmp) {
 878                         if (mpp->action != ACT_REJECT) {
 879                                 if (!vector_alloc_slot(newmp))
 880                                         return 1;
 881                                 vector_set_slot(newmp, mpp);
 882                         }
 883                         else
 884                                 remove_map(mpp, vecs, 0);
 885                 }
 886         }
 887         /*
 888          * Flush maps with only dead paths (ie not in sysfs)
 889          * Keep maps with only failed paths
 890          */
 891         if (newmp) {
 892                 vector_foreach_slot (newmp, mpp, i) {
 893                         char alias[WWID_SIZE];
 894                         int j;
 895
 896                         if (!deadmap(mpp))
 897                                 continue;
 898
 899                         strncpy(alias, mpp->alias, WWID_SIZE);
 900
 901                         if ((j = find_slot(newmp, (void *)mpp)) != -1)
 902                                 vector_del_slot(newmp, j);
 903
 904                         remove_map(mpp, vecs, 0);
 905
 906                         if (dm_flush_map(alias))
 907                                 condlog(2, "%s: remove failed (dead)",
 908                                         alias);
 909                         else
 910                                 condlog(2, "%s: remove (dead)", alias);
 911                 }
 912         }
 913         return 0;
 914 }
 915
 916 /*
 917  * returns:
 918  * 0 - success
 919  * 1 - failure
 920  * 2 - blacklist
 921  */
 922 extern int
 923 get_refwwid (char * dev, enum devtypes dev_type, vector pathvec, char **wwid)
 924 {
 925         int ret = 1;
 926         struct path * pp;
 927         char buff[FILE_NAME_SIZE];
 928         char * refwwid = NULL, tmpwwid[WWID_SIZE];
 929
 930         if (!wwid)
 931                 return 1;
 932         *wwid = NULL;
 933
 934         if (dev_type == DEV_NONE)
 935                 return 1;
 936
 937         if (dev_type == DEV_DEVNODE) {
 938                 if (basenamecpy(dev, buff, FILE_NAME_SIZE) == 0) {
 939                         condlog(1, "basename failed for '%s' (%s)",
 940                                 dev, buff);
 941                         return 1;
 942                 }
 943
 944                 pp = find_path_by_dev(pathvec, buff);
 945                 if (!pp) {
 946                         struct udev_device *udevice = udev_device_new_from_subsystem_sysname(conf->udev, "block", buff);
 947
 948                         if (!udevice) {
 949                                 condlog(2, "%s: can't get udev device", buff);
 950                                 return 1;
 951                         }
 952                         ret = store_pathinfo(pathvec, conf->hwtable, udevice,
 953                                              DI_SYSFS | DI_WWID, &pp);
 954                         udev_device_unref(udevice);
 955                         if (!pp) {
 956                                 if (ret == 1)
 957                                         condlog(0, "%s: can't store path info",
 958                                                 dev);
 959                                 return ret;
 960                         }
 961                 }
 962                 if (pp->udev && pp->uid_attribute &&
 963                     filter_property(conf, pp->udev) > 0)
 964                         return 2;
 965
 966                 refwwid = pp->wwid;
 967                 goto out;
 968         }
 969
 970         if (dev_type == DEV_DEVT) {
 971                 strchop(dev);
 972                 if (devt2devname(buff, FILE_NAME_SIZE, dev)) {
 973                         condlog(0, "%s: cannot find block device\n", dev);
 974                         return 1;
 975                 }
 976                 pp = find_path_by_dev(pathvec, buff);
 977                 if (!pp) {
 978                         struct udev_device *udevice = udev_device_new_from_devnum(conf->udev, 'b', parse_devt(dev));
 979
 980                         if (!udevice) {
 981                                 condlog(2, "%s: can't get udev device", dev);
 982                                 return 1;
 983                         }
 984                         ret = store_pathinfo(pathvec, conf->hwtable, udevice,
 985                                              DI_SYSFS | DI_WWID, &pp);
 986                         udev_device_unref(udevice);
 987                         if (!pp) {
 988                                 if (ret == 1)
 989                                         condlog(0, "%s can't store path info",
 990                                                 buff);
 991                                 return ret;
 992                         }
 993                 }
 994                 if (pp->udev && pp->uid_attribute &&
 995                     filter_property(conf, pp->udev) > 0)
 996                         return 2;
 997
 998                 refwwid = pp->wwid;
 999                 goto out;
1000         }
1001
1002         if (dev_type == DEV_UEVENT) {
1003                 struct udev_device *udevice = udev_device_new_from_environment(conf->udev);
1004
1005                 if (!udevice) {
1006                         condlog(2, "%s: can't get udev device", dev);
1007                         return 1;
1008                 }
1009                 ret = store_pathinfo(pathvec, conf->hwtable, udevice,
1010                                      DI_SYSFS | DI_WWID, &pp);
1011                 udev_device_unref(udevice);
1012                 if (!pp) {
1013                         if (ret == 1)
1014                                 condlog(0, "%s: can't store path info",
1015                                         dev);
1016                         return ret;
1017                 }
1018                 if (pp->udev && pp->uid_attribute &&
1019                     filter_property(conf, pp->udev) > 0)
1020                         return 2;
1021
1022                 refwwid = pp->wwid;
1023                 goto out;
1024         }
1025
1026         if (dev_type == DEV_DEVMAP) {
1027
1028                 if (((dm_get_uuid(dev, tmpwwid)) == 0) && (strlen(tmpwwid))) {
1029                         refwwid = tmpwwid;
1030                         goto check;
1031                 }
1032
1033                 /*
1034                  * may be a binding
1035                  */
1036                 if (get_user_friendly_wwid(dev, tmpwwid,
1037                                            conf->bindings_file) == 0) {
1038                         refwwid = tmpwwid;
1039                         goto check;
1040                 }
1041
1042                 /*
1043                  * or may be an alias
1044                  */
1045                 refwwid = get_mpe_wwid(dev);
1046
1047                 /*
1048                  * or directly a wwid
1049                  */
1050                 if (!refwwid)
1051                         refwwid = dev;
1052
1053 check:
1054                 if (refwwid && strlen(refwwid)) {
1055                         if (filter_wwid(conf->blist_wwid, conf->elist_wwid,
1056                                         refwwid, NULL) > 0)
1057                         return 2;
1058                 }
1059         }
1060 out:
1061         if (refwwid && strlen(refwwid)) {
1062                 *wwid = STRDUP(refwwid);
1063                 return 0;
1064         }
1065
1066         return 1;
1067 }
1068
1069 extern int reload_map(struct vectors *vecs, struct multipath *mpp, int refresh)
1070 {
1071         char params[PARAMS_SIZE] = {0};
1072         struct path *pp;
1073         int i, r;
1074
1075         update_mpp_paths(mpp, vecs->pathvec);
1076         if (refresh) {
1077                 vector_foreach_slot (mpp->paths, pp, i) {
1078                         r = pathinfo(pp, conf->hwtable, DI_PRIO);
1079                         if (r) {
1080                                 condlog(2, "%s: failed to refresh pathinfo",
1081                                         mpp->alias);
1082                                 return 1;
1083                         }
1084                 }
1085         }
1086         if (setup_map(mpp, params, PARAMS_SIZE)) {
1087                 condlog(0, "%s: failed to setup map", mpp->alias);
1088                 return 1;
1089         }
1090         select_action(mpp, vecs->mpvec, 1);
1091
1092         r = domap(mpp, params);
1093         if (r == DOMAP_FAIL || r == DOMAP_RETRY) {
1094                 condlog(3, "%s: domap (%u) failure "
1095                         "for reload map", mpp->alias, r);
1096                 return 1;
1097         }
1098         if (mpp->no_path_retry != NO_PATH_RETRY_UNDEF) {
1099                 if (mpp->no_path_retry == NO_PATH_RETRY_FAIL)
1100                         dm_queue_if_no_path(mpp->alias, 0);
1101                 else
1102                         dm_queue_if_no_path(mpp->alias, 1);
1103         }
1104
1105         return 0;
1106 }