libmultipath/structs_vec.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <unistd.h>
   4
   5 #include "checkers.h"
   6 #include "vector.h"
   7 #include "defaults.h"
   8 #include "debug.h"
   9 #include "structs.h"
  10 #include "structs_vec.h"
  11 #include "waiter.h"
  12 #include "devmapper.h"
  13 #include "dmparser.h"
  14 #include "config.h"
  15 #include "propsel.h"
  16 #include "sysfs.h"
  17 #include "discovery.h"
  18 #include "prio.h"
  19
  20 /*
  21  * creates or updates mpp->paths reading mpp->pg
  22  */
  23 extern int
  24 update_mpp_paths(struct multipath * mpp, vector pathvec)
  25 {
  26         struct pathgroup * pgp;
  27         struct path * pp;
  28         int i,j;
  29
  30         if (!mpp || !mpp->pg)
  31                 return 0;
  32
  33         if (!mpp->paths &&
  34             !(mpp->paths = vector_alloc()))
  35                 return 1;
  36
  37         vector_foreach_slot (mpp->pg, pgp, i) {
  38                 vector_foreach_slot (pgp->paths, pp, j) {
  39                         if (!find_path_by_devt(mpp->paths, pp->dev_t) &&
  40                             (find_path_by_devt(pathvec, pp->dev_t)) &&
  41                             store_path(mpp->paths, pp))
  42                                 return 1;
  43                 }
  44         }
  45         return 0;
  46 }
  47
  48 extern int
  49 adopt_paths (vector pathvec, struct multipath * mpp, int get_info)
  50 {
  51         int i;
  52         struct path * pp;
  53
  54         if (!mpp)
  55                 return 0;
  56
  57         if (update_mpp_paths(mpp, pathvec))
  58                 return 1;
  59
  60         vector_foreach_slot (pathvec, pp, i) {
  61                 if (!strncmp(mpp->wwid, pp->wwid, WWID_SIZE)) {
  62                         condlog(3, "%s: ownership set to %s",
  63                                 pp->dev, mpp->alias);
  64                         pp->mpp = mpp;
  65
  66                         if (!mpp->paths && !(mpp->paths = vector_alloc()))
  67                                 return 1;
  68
  69                         if (!find_path_by_dev(mpp->paths, pp->dev) &&
  70                             store_path(mpp->paths, pp))
  71                                         return 1;
  72                         if (get_info)
  73                                 pathinfo(pp, conf->hwtable,
  74                                          DI_PRIO | DI_CHECKER);
  75                 }
  76         }
  77         return 0;
  78 }
  79
  80 extern void
  81 orphan_path (struct path * pp)
  82 {
  83         pp->mpp = NULL;
  84         pp->dmstate = PSTATE_UNDEF;
  85         pp->uid_attribute = NULL;
  86         pp->prio = NULL;
  87         checker_put(&pp->checker);
  88         if (pp->fd >= 0)
  89                 close(pp->fd);
  90         pp->fd = -1;
  91 }
  92
  93 extern void
  94 orphan_paths (vector pathvec, struct multipath * mpp)
  95 {
  96         int i;
  97         struct path * pp;
  98
  99         vector_foreach_slot (pathvec, pp, i) {
 100                 if (pp->mpp == mpp) {
 101                         condlog(4, "%s: orphaned", pp->dev);
 102                         orphan_path(pp);
 103                 }
 104         }
 105 }
 106
 107 static void
 108 set_multipath_wwid (struct multipath * mpp)
 109 {
 110         if (mpp->wwid)
 111                 return;
 112
 113         dm_get_uuid(mpp->alias, mpp->wwid);
 114 }
 115
 116 #define KEEP_WAITER 0
 117 #define STOP_WAITER 1
 118 #define PURGE_VEC 1
 119
 120 static void
 121 _remove_map (struct multipath * mpp, struct vectors * vecs,
 122             int stop_waiter, int purge_vec)
 123 {
 124         int i;
 125
 126         condlog(4, "%s: remove multipath map", mpp->alias);
 127
 128         /*
 129          * stop the DM event waiter thread
 130          */
 131         if (stop_waiter)
 132                 stop_waiter_thread(mpp, vecs);
 133
 134         /*
 135          * clear references to this map
 136          */
 137         orphan_paths(vecs->pathvec, mpp);
 138
 139         if (purge_vec &&
 140             (i = find_slot(vecs->mpvec, (void *)mpp)) != -1)
 141                 vector_del_slot(vecs->mpvec, i);
 142
 143         /*
 144          * final free
 145          */
 146         free_multipath(mpp, KEEP_PATHS);
 147 }
 148
 149 extern void
 150 remove_map (struct multipath * mpp, struct vectors * vecs, int purge_vec)
 151 {
 152         _remove_map(mpp, vecs, KEEP_WAITER, purge_vec);
 153 }
 154
 155 extern void
 156 remove_map_and_stop_waiter (struct multipath * mpp, struct vectors * vecs,
 157                             int purge_vec)
 158 {
 159         _remove_map(mpp, vecs, STOP_WAITER, purge_vec);
 160 }
 161
 162 static void
 163 _remove_maps (struct vectors * vecs, int stop_waiter)
 164 {
 165         int i;
 166         struct multipath * mpp;
 167
 168         if (!vecs)
 169                 return;
 170
 171         vector_foreach_slot (vecs->mpvec, mpp, i) {
 172                 _remove_map(mpp, vecs, stop_waiter, 1);
 173                 i--;
 174         }
 175
 176         vector_free(vecs->mpvec);
 177         vecs->mpvec = NULL;
 178 }
 179
 180 extern void
 181 remove_maps (struct vectors * vecs)
 182 {
 183         _remove_maps(vecs, KEEP_WAITER);
 184 }
 185
 186 extern void
 187 remove_maps_and_stop_waiters (struct vectors * vecs)
 188 {
 189         _remove_maps(vecs, STOP_WAITER);
 190 }
 191
 192 static struct hwentry *
 193 extract_hwe_from_path(struct multipath * mpp)
 194 {
 195         struct path * pp = NULL;
 196         int pg_num = -1, p_num = -1, i;
 197         struct pathgroup * pgp = NULL;
 198
 199         condlog(3, "%s: searching paths for valid hwe", mpp->alias);
 200
 201         if (mpp && mpp->pg) {
 202                 vector_foreach_slot(mpp->pg, pgp, i) {
 203                         if (pgp->status == PGSTATE_ACTIVE ||
 204                             pgp->status == PGSTATE_ENABLED) {
 205                                 pg_num = i;
 206                                 break;
 207                         }
 208                 }
 209                 if (pg_num >= 0)
 210                         pgp = VECTOR_SLOT(mpp->pg, pg_num);
 211         }
 212
 213         if (pgp && pgp->paths) {
 214                 vector_foreach_slot(pgp->paths, pp, i) {
 215                         if (pp->dmstate == PSTATE_FAILED)
 216                                 continue;
 217                         if (strlen(pp->vendor_id) > 0 &&
 218                             strlen(pp->product_id) > 0 &&
 219                             strlen(pp->rev) > 0) {
 220                                 p_num = i;
 221                                 break;
 222                         }
 223                 }
 224                 if (p_num >= 0)
 225                         pp = VECTOR_SLOT(pgp->paths, i);
 226         }
 227
 228         if (pp) {
 229                 condlog(3, "%s: vendor = %s", pp->dev, pp->vendor_id);
 230                 condlog(3, "%s: product = %s", pp->dev, pp->product_id);
 231                 condlog(3, "%s: rev = %s", pp->dev, pp->rev);
 232                 if (!pp->hwe) {
 233                         condlog(3, "searching hwtable");
 234                         pp->hwe = find_hwe(conf->hwtable, pp->vendor_id,
 235                                            pp->product_id, pp->rev);
 236                 }
 237         }
 238
 239         return pp?pp->hwe:NULL;
 240 }
 241
 242 static int
 243 update_multipath_table (struct multipath *mpp, vector pathvec)
 244 {
 245         char params[PARAMS_SIZE] = {0};
 246
 247         if (!mpp)
 248                 return 1;
 249
 250         if (dm_get_map(mpp->alias, &mpp->size, params))
 251                 return 1;
 252
 253         if (disassemble_map(pathvec, params, mpp))
 254                 return 1;
 255
 256         return 0;
 257 }
 258
 259 static int
 260 update_multipath_status (struct multipath *mpp)
 261 {
 262         char status[PARAMS_SIZE] = {0};
 263
 264         if (!mpp)
 265                 return 1;
 266
 267         if(dm_get_status(mpp->alias, status))
 268                 return 1;
 269
 270         if (disassemble_status(status, mpp))
 271                 return 1;
 272
 273         return 0;
 274 }
 275
 276 extern int
 277 update_multipath_strings (struct multipath *mpp, vector pathvec)
 278 {
 279         if (!mpp)
 280                 return 1;
 281
 282         condlog(4, "%s: %s", mpp->alias, __FUNCTION__);
 283
 284         free_multipath_attributes(mpp);
 285         free_pgvec(mpp->pg, KEEP_PATHS);
 286         mpp->pg = NULL;
 287
 288         if (update_multipath_table(mpp, pathvec))
 289                 return 1;
 290
 291         if (update_multipath_status(mpp))
 292                 return 1;
 293
 294         return 0;
 295 }
 296
 297 extern void
 298 set_no_path_retry(struct multipath *mpp)
 299 {
 300         mpp->retry_tick = 0;
 301         mpp->nr_active = pathcount(mpp, PATH_UP) + pathcount(mpp, PATH_GHOST);
 302         if (mpp->nr_active > 0)
 303                 select_no_path_retry(mpp);
 304
 305         switch (mpp->no_path_retry) {
 306         case NO_PATH_RETRY_UNDEF:
 307                 break;
 308         case NO_PATH_RETRY_FAIL:
 309                 dm_queue_if_no_path(mpp->alias, 0);
 310                 break;
 311         case NO_PATH_RETRY_QUEUE:
 312                 dm_queue_if_no_path(mpp->alias, 1);
 313                 break;
 314         default:
 315                 dm_queue_if_no_path(mpp->alias, 1);
 316                 if (mpp->nr_active == 0) {
 317                         /* Enter retry mode */
 318                         mpp->retry_tick = mpp->no_path_retry * conf->checkint;
 319                         condlog(1, "%s: Entering recovery mode: max_retries=%d",
 320                                 mpp->alias, mpp->no_path_retry);
 321                 }
 322                 break;
 323         }
 324 }
 325
 326 extern int
 327 __setup_multipath (struct vectors * vecs, struct multipath * mpp, int reset)
 328 {
 329         if (dm_get_info(mpp->alias, &mpp->dmi)) {
 330                 /* Error accessing table */
 331                 condlog(3, "%s: cannot access table", mpp->alias);
 332                 goto out;
 333         }
 334
 335         if (!dm_map_present(mpp->alias)) {
 336                 /* Table has been removed */
 337                 condlog(3, "%s: table does not exist", mpp->alias);
 338                 goto out;
 339         }
 340
 341         set_multipath_wwid(mpp);
 342         mpp->mpe = find_mpe(mpp->wwid);
 343         condlog(3, "%s: discover", mpp->alias);
 344
 345         if (update_multipath_strings(mpp, vecs->pathvec)) {
 346                 condlog(0, "%s: failed to setup multipath", mpp->alias);
 347                 goto out;
 348         }
 349
 350         if (!mpp->hwe)
 351                 mpp->hwe = extract_hwe_from_path(mpp);
 352         if (!mpp->hwe) {
 353                 condlog(3, "%s: no hardware entry found, using defaults",
 354                         mpp->alias);
 355         }
 356         if (reset) {
 357                 select_rr_weight(mpp);
 358                 select_pgfailback(mpp);
 359                 set_no_path_retry(mpp);
 360                 select_pg_timeout(mpp);
 361                 select_flush_on_last_del(mpp);
 362         }
 363
 364         return 0;
 365 out:
 366         remove_map(mpp, vecs, PURGE_VEC);
 367         return 1;
 368 }
 369
 370 extern struct multipath *
 371 add_map_without_path (struct vectors * vecs, char * alias)
 372 {
 373         struct multipath * mpp = alloc_multipath();
 374
 375         if (!mpp || !alias)
 376                 return NULL;
 377
 378         mpp->alias = STRDUP(alias);
 379
 380         if (setup_multipath(vecs, mpp))
 381                 return NULL; /* mpp freed in setup_multipath */
 382
 383         if (adopt_paths(vecs->pathvec, mpp, 1))
 384                 goto out;
 385
 386         if (!vector_alloc_slot(vecs->mpvec))
 387                 goto out;
 388
 389         vector_set_slot(vecs->mpvec, mpp);
 390
 391         if (start_waiter_thread(mpp, vecs))
 392                 goto out;
 393
 394         return mpp;
 395 out:
 396         remove_map(mpp, vecs, PURGE_VEC);
 397         return NULL;
 398 }
 399
 400 extern struct multipath *
 401 add_map_with_path (struct vectors * vecs,
 402                    struct path * pp, int add_vec)
 403 {
 404         struct multipath * mpp;
 405
 406         if (!(mpp = alloc_multipath()))
 407                 return NULL;
 408
 409         mpp->mpe = find_mpe(pp->wwid);
 410         mpp->hwe = pp->hwe;
 411
 412         strcpy(mpp->wwid, pp->wwid);
 413         if (select_alias(mpp))
 414                 goto out;
 415         mpp->size = pp->size;
 416
 417         if (adopt_paths(vecs->pathvec, mpp, 1))
 418                 goto out;
 419
 420         if (add_vec) {
 421                 if (!vector_alloc_slot(vecs->mpvec))
 422                         goto out;
 423
 424                 vector_set_slot(vecs->mpvec, mpp);
 425         }
 426
 427         return mpp;
 428
 429 out:
 430         remove_map(mpp, vecs, PURGE_VEC);
 431         return NULL;
 432 }
 433
 434 extern int
 435 verify_paths(struct multipath * mpp, struct vectors * vecs, vector rpvec)
 436 {
 437         struct path * pp;
 438         int count = 0;
 439         int i, j;
 440
 441         if (!mpp)
 442                 return 0;
 443
 444         vector_foreach_slot (mpp->paths, pp, i) {
 445                 /*
 446                  * see if path is in sysfs
 447                  */
 448                 if (!pp->udev || sysfs_get_dev(pp->udev, pp->dev_t,
 449                                                BLK_DEV_SIZE)) {
 450                         if (pp->state != PATH_DOWN) {
 451                                 condlog(1, "%s: removing valid path %s in state %d",
 452                                         mpp->alias, pp->dev, pp->state);
 453                         } else {
 454                                 condlog(3, "%s: failed to access path %s",
 455                                         mpp->alias, pp->dev);
 456                         }
 457                         count++;
 458                         vector_del_slot(mpp->paths, i);
 459                         i--;
 460
 461                         if (rpvec)
 462                                 store_path(rpvec, pp);
 463                         else {
 464                                 if ((j = find_slot(vecs->pathvec,
 465                                                    (void *)pp)) != -1)
 466                                         vector_del_slot(vecs->pathvec, j);
 467                                 free_path(pp);
 468                         }
 469                 } else {
 470                         condlog(4, "%s: verified path %s dev_t %s",
 471                                 mpp->alias, pp->dev, pp->dev_t);
 472                 }
 473         }
 474         return count;
 475 }
 476
 477 int update_multipath (struct vectors *vecs, char *mapname, int reset)
 478 {
 479         struct multipath *mpp;
 480         struct pathgroup  *pgp;
 481         struct path *pp;
 482         int i, j;
 483
 484         mpp = find_mp_by_alias(vecs->mpvec, mapname);
 485
 486         if (!mpp) {
 487                 condlog(3, "%s: multipath map not found\n", mapname);
 488                 return 2;
 489         }
 490
 491         free_pgvec(mpp->pg, KEEP_PATHS);
 492         mpp->pg = NULL;
 493
 494         if (__setup_multipath(vecs, mpp, reset))
 495                 return 1; /* mpp freed in setup_multipath */
 496
 497         adopt_paths(vecs->pathvec, mpp, 0);
 498         /*
 499          * compare checkers states with DM states
 500          */
 501         vector_foreach_slot (mpp->pg, pgp, i) {
 502                 vector_foreach_slot (pgp->paths, pp, j) {
 503                         if (pp->dmstate != PSTATE_FAILED)
 504                                 continue;
 505
 506                         if (pp->state != PATH_DOWN) {
 507                                 int oldstate = pp->state;
 508                                 condlog(2, "%s: mark as failed", pp->dev_t);
 509                                 mpp->stat_path_failures++;
 510                                 pp->state = PATH_DOWN;
 511                                 if (oldstate == PATH_UP ||
 512                                     oldstate == PATH_GHOST)
 513                                         update_queue_mode_del_path(mpp);
 514
 515                                 /*
 516                                  * if opportune,
 517                                  * schedule the next check earlier
 518                                  */
 519                                 if (pp->tick > conf->checkint)
 520                                         pp->tick = conf->checkint;
 521                         }
 522                 }
 523         }
 524
 525         return 0;
 526 }
 527
 528 /*
 529  * mpp->no_path_retry:
 530  *   -2 (QUEUE) : queue_if_no_path enabled, never turned off
 531  *   -1 (FAIL)  : fail_if_no_path
 532  *    0 (UNDEF) : nothing
 533  *   >0         : queue_if_no_path enabled, turned off after polling n times
 534  */
 535 void update_queue_mode_del_path(struct multipath *mpp)
 536 {
 537         if (--mpp->nr_active == 0 && mpp->no_path_retry > 0) {
 538                 /*
 539                  * Enter retry mode.
 540                  * meaning of +1: retry_tick may be decremented in
 541                  *                checkerloop before starting retry.
 542                  */
 543                 mpp->stat_queueing_timeouts++;
 544                 mpp->retry_tick = mpp->no_path_retry * conf->checkint + 1;
 545                 condlog(1, "%s: Entering recovery mode: max_retries=%d",
 546                         mpp->alias, mpp->no_path_retry);
 547         }
 548         condlog(2, "%s: remaining active paths: %d", mpp->alias, mpp->nr_active);
 549 }
 550
 551 void update_queue_mode_add_path(struct multipath *mpp)
 552 {
 553         if (mpp->nr_active++ == 0 && mpp->no_path_retry > 0) {
 554                 /* come back to normal mode from retry mode */
 555                 mpp->retry_tick = 0;
 556                 dm_queue_if_no_path(mpp->alias, 1);
 557                 condlog(2, "%s: queue_if_no_path enabled", mpp->alias);
 558                 condlog(1, "%s: Recovered to normal mode", mpp->alias);
 559         }
 560         condlog(2, "%s: remaining active paths: %d", mpp->alias, mpp->nr_active);
 561 }
 562