src/vol/vg_scan.c

   1 /*
   2  * Copyright 2009-2010, Sine Nomine Associates and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 /*
  11  * demand attach fs
  12  * volume group membership cache
  13  * asynchronous partition scanner
  14  */
  15
  16 #include <afsconfig.h>
  17 #include <afs/param.h>
  18
  19 #include <roken.h>
  20
  21 #ifdef HAVE_SYS_FILE_H
  22 #include <sys/file.h>
  23 #endif
  24
  25 #ifdef AFS_DEMAND_ATTACH_FS
  26
  27 #include <afs/opr.h>
  28 #include <rx/rx_queue.h>
  29 #include <opr/lock.h>
  30 #include <lock.h>
  31 #include <afs/afsutil.h>
  32 #include "nfs.h"
  33 #include <afs/afsint.h>
  34 #include "ihandle.h"
  35 #include "vnode.h"
  36 #include "volume.h"
  37 #include "viceinode.h"
  38 #include "voldefs.h"
  39 #include "partition.h"
  40 #include <afs/errors.h>
  41
  42 #define __VOL_VG_CACHE_IMPL 1
  43
  44 #include "vg_cache.h"
  45 #include "vg_cache_impl.h"
  46
  47 static int _VVGC_scan_table_init(VVGCache_scan_table_t * tbl);
  48 static int _VVGC_scan_table_add(VVGCache_scan_table_t * tbl,
  49                                 struct DiskPartition64 * dp,
  50                                 VolumeId volid,
  51                                 VolumeId parent);
  52 static int _VVGC_scan_table_flush(VVGCache_scan_table_t * tbl,
  53                                   struct DiskPartition64 * dp);
  54 static void * _VVGC_scanner_thread(void *);
  55 static int _VVGC_scan_partition(struct DiskPartition64 * part);
  56 static VVGCache_dlist_entry_t * _VVGC_dlist_lookup_r(struct DiskPartition64 *dp,
  57                                                      VolumeId parent,
  58                                                      VolumeId child);
  59 static void _VVGC_flush_dlist(struct DiskPartition64 *dp);
  60
  61 /**
  62  * init a thread-local scan table.
  63  *
  64  * @param[in] tbl  scan table
  65  *
  66  * @return operation status
  67  *    @retval 0 success
  68  *
  69  * @internal
  70  */
  71 static int
  72 _VVGC_scan_table_init(VVGCache_scan_table_t * tbl)
  73 {
  74     memset(tbl, 0, sizeof(*tbl));
  75
  76     return 0;
  77 }
  78
  79 /**
  80  * add an entry to the thread-local scan table.
  81  *
  82  * @param[in] tbl     scan table
  83  * @param[in] dp      disk partition object
  84  * @param[in] volid   volume id
  85  * @param[in] parent  parent volume id
  86  *
  87  * @pre VOL_LOCK is NOT held
  88  *
  89  * @note if the table is full, this routine will acquire
  90  *       VOL_LOCK and flush the table to the global one.
  91  *
  92  * @return operation status
  93  *    @retval 0 success
  94  *    @retval nonzero a VVGCache_entry_add_r operation failed during a
  95  *                    flush of the thread-local table
  96  *
  97  * @internal
  98  */
  99 static int
 100 _VVGC_scan_table_add(VVGCache_scan_table_t * tbl,
 101                      struct DiskPartition64 * dp,
 102                      VolumeId volid,
 103                      VolumeId parent)
 104 {
 105     int code = 0;
 106
 107     if (tbl->idx == VVGC_SCAN_TBL_LEN) {
 108         code = _VVGC_scan_table_flush(tbl, dp);
 109     }
 110
 111     tbl->entries[tbl->idx].volid = volid;
 112     tbl->entries[tbl->idx].parent = parent;
 113     tbl->idx++;
 114
 115     return code;
 116 }
 117
 118 /**
 119  * flush thread-local scan table to the global VG cache.
 120  *
 121  * @param[in] tbl     scan table
 122  * @param[in] dp      disk partition object
 123  *
 124  * @pre VOL_LOCK is NOT held
 125  *
 126  * @return operation status
 127  *    @retval 0 success
 128  *    @retval nonzero a VVGCache_entry_add_r operation failed during a
 129  *                    flush of the thread-local table
 130  *
 131  * @internal
 132  */
 133 static int
 134 _VVGC_scan_table_flush(VVGCache_scan_table_t * tbl,
 135                        struct DiskPartition64 * dp)
 136 {
 137     int code = 0, res, i;
 138     afs_int32 newvg = 0;
 139     unsigned long newvols, newvgs;
 140
 141     newvols = tbl->newvols;
 142     newvgs = tbl->newvgs;
 143
 144     VOL_LOCK;
 145
 146     for (i = 0; i < tbl->idx; i++) {
 147         /*
 148          * We need to check the 'to-delete' list and prevent adding any entries
 149          * that are on it. The volser could potentially create a volume in one
 150          * VG, then delete it and put it on another VG. If we are doing a scan
 151          * when that happens, tbl->entries could have the entries for trying to
 152          * put the vol on both VGs, though at least one of them will also be on
 153          * the dlist.  If we put everything in tbl->entries on the VGC then try
 154          * to delete afterwards, putting one entry on the VGC cause an error,
 155          * and we'll fail to add it. So instead, avoid adding any new VGC
 156          * entries if it is on the dlist.
 157          */
 158         if (_VVGC_dlist_lookup_r(dp, tbl->entries[i].parent,
 159                                  tbl->entries[i].volid)) {
 160             continue;
 161         }
 162         res = VVGCache_entry_add_r(dp,
 163                                    tbl->entries[i].parent,
 164                                    tbl->entries[i].volid,
 165                                    &newvg);
 166         if (res) {
 167             code = res;
 168         } else {
 169             newvols++;
 170             newvgs += newvg;
 171         }
 172     }
 173
 174     /* flush the to-delete list while we're here. We don't need to preserve
 175      * the list across the entire scan, and flushing it each time we flush
 176      * a scan table will keep the size of the dlist down */
 177     _VVGC_flush_dlist(dp);
 178
 179     VOL_UNLOCK;
 180
 181     ViceLog(125, ("VVGC_scan_table_flush: flushed %d entries from "
 182                   "scan table to global VG cache\n", tbl->idx));
 183     ViceLog(125, ("VVGC_scan_table_flush: %s total: %lu vols, %lu groups\n",
 184                   VPartitionPath(dp), newvols, newvgs));
 185
 186     res = _VVGC_scan_table_init(tbl);
 187     if (res) {
 188         code = res;
 189     }
 190
 191     tbl->newvols = newvols;
 192     tbl->newvgs = newvgs;
 193
 194     return code;
 195 }
 196
 197 /**
 198  * record a volume header found by VWalkVolumeHeaders in a VGC scan table.
 199  *
 200  * @param[in] dp   the disk partition
 201  * @param[in] name full path to the .vol header (unused)
 202  * @param[in] hdr  the header data
 203  * @param[in] last whether this is the last try or not (unused)
 204  * @param[in] rock actually a VVGCache_scan_table_t* to add the volume to
 205  *
 206  * @return operation status
 207  *  @retval 0  success
 208  *  @retval -1 fatal error adding vol to the scan table
 209  */
 210 static int
 211 _VVGC_RecordHeader(struct DiskPartition64 *dp, const char *name,
 212                    struct VolumeDiskHeader *hdr, int last, void *rock)
 213 {
 214     int code;
 215     VVGCache_scan_table_t *tbl;
 216     tbl = (VVGCache_scan_table_t *)rock;
 217
 218     code = _VVGC_scan_table_add(tbl, dp, hdr->id, hdr->parent);
 219     if (code) {
 220         ViceLog(0, ("VVGC_scan_partition: error %d adding volume %s to scan table\n",
 221                      code, name));
 222         return -1;
 223     }
 224     return 0;
 225 }
 226
 227 /**
 228  * unlink a faulty volume header found by VWalkVolumeHeaders.
 229  *
 230  * @param[in] dp   the disk partition (unused)
 231  * @param[in] name the full path to the .vol header
 232  * @param[in] hdr  the header data (unused)
 233  * @param[in] rock unused
 234  */
 235 static void
 236 _VVGC_UnlinkHeader(struct DiskPartition64 *dp, const char *name,
 237                    struct VolumeDiskHeader *hdr, void *rock)
 238 {
 239     ViceLog(0, ("%s is not a legitimate volume header file; deleted\n", name));
 240     if (unlink(name)) {
 241         ViceLog(0, ("Unable to unlink %s (errno = %d)\n",
 242                     name, errno));
 243     }
 244 }
 245
 246 /**
 247  * scan a disk partition for .vol files
 248  *
 249  * @param[in] part   disk partition object
 250  *
 251  * @pre VOL_LOCK is NOT held
 252  *
 253  * @return operation status
 254  *    @retval 0 success
 255  *    @retval -1 invalid disk partition object
 256  *    @retval -2 failed to flush stale entries for this partition
 257  *
 258  * @internal
 259  */
 260 static int
 261 _VVGC_scan_partition(struct DiskPartition64 * part)
 262 {
 263     int code, res;
 264     DIR *dirp = NULL;
 265     VVGCache_scan_table_t tbl;
 266     char *part_path = NULL;
 267
 268     code = _VVGC_scan_table_init(&tbl);
 269     if (code) {
 270         ViceLog(0, ("VVGC_scan_partition: could not init scan table; error = %d\n",
 271             code));
 272         goto done;
 273     }
 274     part_path = VPartitionPath(part);
 275     if (part_path == NULL) {
 276         ViceLog(0, ("VVGC_scan_partition: invalid partition object given; aborting scan\n"));
 277         code = -1;
 278         goto done;
 279     }
 280
 281     VOL_LOCK;
 282     res = _VVGC_flush_part_r(part);
 283     if (res) {
 284         ViceLog(0, ("VVGC_scan_partition: error flushing partition %s; error = %d\n",
 285             VPartitionPath(part), res));
 286         code = -2;
 287     }
 288     VOL_UNLOCK;
 289     if (code) {
 290         goto done;
 291     }
 292
 293     dirp = opendir(part_path);
 294     if (dirp == NULL) {
 295         ViceLog(0, ("VVGC_scan_partition: could not open %s, aborting scan; error = %d\n",
 296             part_path, errno));
 297         code = -1;
 298         goto done;
 299     }
 300
 301     ViceLog(5, ("VVGC_scan_partition: scanning partition %s for VG cache\n",
 302                  part_path));
 303
 304     code = VWalkVolumeHeaders(part, part_path, _VVGC_RecordHeader,
 305                               _VVGC_UnlinkHeader, &tbl);
 306     if (code < 0) {
 307         goto done;
 308     }
 309
 310     _VVGC_scan_table_flush(&tbl, part);
 311
 312  done:
 313     if (dirp) {
 314         closedir(dirp);
 315         dirp = NULL;
 316     }
 317     if (code) {
 318         ViceLog(0, ("VVGC_scan_partition: error %d while scanning %s\n",
 319                     code, part_path));
 320     } else {
 321         ViceLog(0, ("VVGC_scan_partition: finished scanning %s: %lu volumes in %lu groups\n",
 322                      part_path, tbl.newvols, tbl.newvgs));
 323     }
 324
 325     VOL_LOCK;
 326
 327     _VVGC_flush_dlist(part);
 328     free(VVGCache.part[part->index].dlist_hash_buckets);
 329     VVGCache.part[part->index].dlist_hash_buckets = NULL;
 330
 331     if (code) {
 332         _VVGC_state_change(part, VVGC_PART_STATE_INVALID);
 333     } else {
 334         _VVGC_state_change(part, VVGC_PART_STATE_VALID);
 335     }
 336
 337     VOL_UNLOCK;
 338
 339     return code;
 340 }
 341
 342 /**
 343  * scanner thread.
 344  */
 345 static void *
 346 _VVGC_scanner_thread(void * args)
 347 {
 348     struct DiskPartition64 *part = args;
 349     int code;
 350
 351     code = _VVGC_scan_partition(part);
 352     if (code) {
 353         ViceLog(0, ("Error: _VVGC_scan_partition failed with code %d for partition %s\n",
 354             code, VPartitionPath(part)));
 355     }
 356
 357     return NULL;
 358 }
 359
 360 /**
 361  * start a background scan.
 362  *
 363  * @param[in] dp  disk partition object
 364  *
 365  * @return operation status
 366  *    @retval 0 success
 367  *    @retval -1 internal error
 368  *    @retval -3 racing against another thread
 369  *
 370  * @internal
 371  */
 372 int
 373 _VVGC_scan_start(struct DiskPartition64 * dp)
 374 {
 375     int code = 0;
 376     pthread_t tid;
 377     pthread_attr_t attrs;
 378     int i;
 379
 380     if (_VVGC_state_change(dp,
 381                            VVGC_PART_STATE_UPDATING)
 382         == VVGC_PART_STATE_UPDATING) {
 383         /* race */
 384         ViceLog(0, ("VVGC_scan_partition: race detected; aborting scanning partition %s\n",
 385                     VPartitionPath(dp)));
 386         code = -3;
 387         goto error;
 388     }
 389
 390     /* initialize partition's to-delete list */
 391     VVGCache.part[dp->index].dlist_hash_buckets =
 392         malloc(VolumeHashTable.Size * sizeof(struct rx_queue));
 393     if (!VVGCache.part[dp->index].dlist_hash_buckets) {
 394         code = -1;
 395         goto error;
 396     }
 397     for (i = 0; i < VolumeHashTable.Size; i++) {
 398         queue_Init(&VVGCache.part[dp->index].dlist_hash_buckets[i]);
 399     }
 400
 401     code = pthread_attr_init(&attrs);
 402     if (code) {
 403         goto error;
 404     }
 405
 406     code = pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_DETACHED);
 407     if (code) {
 408         goto error;
 409     }
 410
 411     code = pthread_create(&tid, &attrs, &_VVGC_scanner_thread, dp);
 412
 413     if (code) {
 414         VVGCache_part_state_t old_state;
 415
 416         ViceLog(0, ("_VVGC_scan_start: pthread_create failed with %d\n", code));
 417
 418         old_state = _VVGC_state_change(dp, VVGC_PART_STATE_INVALID);
 419         opr_Assert(old_state == VVGC_PART_STATE_UPDATING);
 420     }
 421
 422  error:
 423     if (code) {
 424         ViceLog(0, ("_VVGC_scan_start failed with code %d for partition %s\n",
 425                 code, VPartitionPath(dp)));
 426         if (VVGCache.part[dp->index].dlist_hash_buckets) {
 427             free(VVGCache.part[dp->index].dlist_hash_buckets);
 428             VVGCache.part[dp->index].dlist_hash_buckets = NULL;
 429         }
 430     }
 431
 432     return code;
 433 }
 434
 435 /**
 436  * looks up an entry on the to-delete list, if it exists.
 437  *
 438  * @param[in] dp     the partition whose dlist we are looking at
 439  * @param[in] parent the parent volume ID we're looking for
 440  * @param[in] child  the child volume ID we're looking for
 441  *
 442  * @return a pointer to the entry in the dlist for that entry
 443  *  @retval NULL the requested entry does not exist in the dlist
 444  */
 445 static VVGCache_dlist_entry_t *
 446 _VVGC_dlist_lookup_r(struct DiskPartition64 *dp, VolumeId parent,
 447                      VolumeId child)
 448 {
 449     int bucket = VVGC_HASH(child);
 450     VVGCache_dlist_entry_t *ent, *nent;
 451
 452     for (queue_Scan(&VVGCache.part[dp->index].dlist_hash_buckets[bucket],
 453                     ent, nent,
 454                     VVGCache_dlist_entry)) {
 455
 456         if (ent->child == child && ent->parent == parent) {
 457             return ent;
 458         }
 459     }
 460
 461     return NULL;
 462 }
 463
 464 /**
 465  * delete all of the entries in the dlist from the VGC.
 466  *
 467  * Traverses the to-delete list for the specified partition, and deletes
 468  * the specified entries from the global VGC. Also deletes the entries from
 469  * the dlist itself as it goes along.
 470  *
 471  * @param[in] dp  the partition whose dlist we are flushing
 472  */
 473 static void
 474 _VVGC_flush_dlist(struct DiskPartition64 *dp)
 475 {
 476     int i;
 477     VVGCache_dlist_entry_t *ent, *nent;
 478
 479     for (i = 0; i < VolumeHashTable.Size; i++) {
 480         for (queue_Scan(&VVGCache.part[dp->index].dlist_hash_buckets[i],
 481                         ent, nent,
 482                         VVGCache_dlist_entry)) {
 483
 484             _VVGC_entry_purge_r(dp, ent->parent, ent->child);
 485             queue_Remove(ent);
 486             free(ent);
 487         }
 488     }
 489 }
 490
 491 /**
 492  * add a VGC entry to the partition's to-delete list.
 493  *
 494  * This adds a VGC entry (a parent/child pair) to a list of VGC entries to
 495  * be deleted from the VGC at the end of a VGC scan. This is necessary,
 496  * while a VGC scan is ocurring, volumes may be deleted. Since a VGC scan
 497  * scans a partition in VVGC_SCAN_TBL_LEN chunks, a VGC delete operation
 498  * may delete a volume, only for it to be added again when the VGC scan's
 499  * table adds it to the VGC. So when a VGC entry is deleted and a VGC scan
 500  * is running, this function must be called to ensure it does not come
 501  * back onto the VGC.
 502  *
 503  * @param[in] dp      the partition to whose dlist we are adding
 504  * @param[in] parent  the parent volumeID of the VGC entry
 505  * @param[in] child   the child volumeID of the VGC entry
 506  *
 507  * @return operation status
 508  *  @retval 0 success
 509  *  @retval ENOMEM memory allocation error
 510  *
 511  * @pre VVGCache.part[dp->index].state == VVGC_PART_STATE_UPDATING
 512  *
 513  * @internal VGC use only
 514  */
 515 int
 516 _VVGC_dlist_add_r(struct DiskPartition64 *dp, VolumeId parent,
 517                   VolumeId child)
 518 {
 519     int bucket = VVGC_HASH(child);
 520     VVGCache_dlist_entry_t *entry;
 521
 522     entry = malloc(sizeof(*entry));
 523     if (!entry) {
 524         return ENOMEM;
 525     }
 526
 527     entry->child = child;
 528     entry->parent = parent;
 529
 530     queue_Append(&VVGCache.part[dp->index].dlist_hash_buckets[bucket],
 531                  entry);
 532     return 0;
 533 }
 534
 535 /**
 536  * delete a VGC entry from the partition's to-delete list.
 537  *
 538  * When a VGC scan is ocurring, and a volume is removed, but then created
 539  * again, we need to ensure that it does not get deleted from being on the
 540  * dlist. Call this function whenever adding a new entry to the VGC during
 541  * a VGC scan to ensure it doesn't get deleted later.
 542  *
 543  * @param[in] dp      the partition from whose dlist we are deleting
 544  * @param[in] parent  the parent volumeID of the VGC entry
 545  * @param[in] child   the child volumeID of the VGC entry
 546  *
 547  * @return operation status
 548  *  @retval 0 success
 549  *  @retval ENOENT the specified VGC entry is not on the dlist
 550  *
 551  * @pre VVGCache.part[dp->index].state == VVGC_PART_STATE_UPDATING
 552  *
 553  * @internal VGC use only
 554  *
 555  * @see _VVGC_dlist_add_r
 556  */
 557 int
 558 _VVGC_dlist_del_r(struct DiskPartition64 *dp, VolumeId parent,
 559                   VolumeId child)
 560 {
 561     VVGCache_dlist_entry_t *ent;
 562
 563     ent = _VVGC_dlist_lookup_r(dp, parent, child);
 564     if (!ent) {
 565         return ENOENT;
 566     }
 567
 568     queue_Remove(ent);
 569     free(ent);
 570
 571     return 0;
 572 }
 573
 574 #endif /* AFS_DEMAND_ATTACH_FS */