src/tviced/serialize_state.c

   1 /*
   2  * Copyright 2006, 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  * fileserver state serialization
  13  */
  14
  15 #include <afsconfig.h>
  16 #include <afs/param.h>
  17
  18 RCSID
  19     ("$Header$");
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>             /* for malloc() */
  23 #include <time.h>               /* ANSI standard location for time stuff */
  24 #include <string.h>
  25 #ifdef AFS_NT40_ENV
  26 #include <fcntl.h>
  27 #include <io.h>
  28 #else
  29 #include <sys/time.h>
  30 #include <sys/file.h>
  31 #endif
  32 #include <afs/assert.h>
  33 #include <sys/stat.h>
  34
  35 #include <afs/stds.h>
  36
  37 #include <rx/xdr.h>
  38 #include <lwp.h>
  39 #include <lock.h>
  40 #include <afs/afsint.h>
  41 #include <afs/rxgen_consts.h>
  42 #include <afs/nfs.h>
  43 #include <afs/errors.h>
  44 #include <afs/ihandle.h>
  45 #include <afs/vnode.h>
  46 #include <afs/volume.h>
  47 #include <afs/acl.h>
  48 #include <afs/ptclient.h>
  49 #include <afs/prs_fs.h>
  50 #include <afs/afsutil.h>
  51 #include <rx/rx.h>
  52 #include <afs/cellconfig.h>
  53 #include <stdlib.h>
  54
  55 #include "../viced/viced_prototypes.h"
  56 #include "../viced/viced.h"
  57 #include "../viced/host.h"
  58 #include "../viced/callback.h"
  59 #include "serialize_state.h"
  60
  61 /*@+fcnmacros +macrofcndecl@*/
  62 #ifdef O_LARGEFILE
  63 #ifdef S_SPLINT_S
  64 extern off64_t afs_lseek(int FD, off64_t O, int F);
  65 #endif /*S_SPLINT_S */
  66 #define afs_lseek(FD, O, F)     lseek64(FD, (off64_t)(O), F)
  67 #define afs_stat                stat64
  68 #define afs_fstat               fstat64
  69 #define afs_open                open64
  70 #define afs_fopen               fopen64
  71 #define afs_ftruncate           ftruncate64
  72 #define afs_mmap                mmap64
  73 #ifdef AFS_AIX_ENV
  74 extern void * mmap64();  /* ugly hack since aix build env appears to be somewhat broken */
  75 #endif
  76 #else /* !O_LARGEFILE */
  77 #ifdef S_SPLINT_S
  78 extern off_t afs_lseek(int FD, off_t O, int F);
  79 #endif /*S_SPLINT_S */
  80 #define afs_lseek(FD, O, F)     lseek(FD, (off_t)(O), F)
  81 #define afs_stat                stat
  82 #define afs_fstat               fstat
  83 #define afs_open                open
  84 #define afs_fopen               fopen
  85 #define afs_ftruncate           ftruncate
  86 #define afs_mmap                mmap
  87 #endif /* !O_LARGEFILE */
  88 /*@=fcnmacros =macrofcndecl@*/
  89
  90
  91 #ifdef AFS_DEMAND_ATTACH_FS
  92
  93 /*
  94  * demand attach fs
  95  * state dump routines
  96  *
  97  * in order to make state dump/restore as fast as possible,
  98  * we use memory mapped files
  99  *
 100  * if this causes problems on certain platforms, the APIs
 101  * have been written so that it will be very simple to go
 102  * back to standard I/O for just those poorly written platforms
 103  */
 104 #ifndef _WIN32
 105 #define FS_STATE_USE_MMAP
 106 #endif
 107
 108 #ifdef FS_STATE_USE_MMAP
 109 #define FS_STATE_INIT_FILESIZE (8 * 1024 * 1024)  /* truncate to 8MB initially */
 110 #include <sys/mman.h>
 111 #endif
 112
 113 static int fs_stateCreateDump(struct fs_dump_state * state);
 114 static int fs_stateLoadDump(struct fs_dump_state * state);
 115 static int fs_stateInvalidateDump(struct fs_dump_state * state);
 116 static int fs_stateCommitDump(struct fs_dump_state * state);
 117 static int fs_stateCloseDump(struct fs_dump_state * state);
 118
 119 #ifdef FS_STATE_USE_MMAP
 120 static int fs_stateSizeFile(struct fs_dump_state * state);
 121 static int fs_stateResizeFile(struct fs_dump_state * state, size_t min_add);
 122 static int fs_stateTruncateFile(struct fs_dump_state * state);
 123
 124 static int fs_stateMapFile(struct fs_dump_state * state);
 125 static int fs_stateUnmapFile(struct fs_dump_state * state);
 126
 127 static int fs_stateIncCursor(struct fs_dump_state * state, size_t len);
 128 static int fs_stateCheckIOSafety(struct fs_dump_state * state,
 129                                  size_t len);
 130 #endif
 131
 132 static int fs_stateFillHeader(struct fs_state_header * hdr);
 133 static int fs_stateCheckHeader(struct fs_state_header * hdr);
 134
 135 static int fs_stateAlloc(struct fs_dump_state * state);
 136 static int fs_stateFree(struct fs_dump_state * state);
 137
 138 extern afsUUID FS_HostUUID;
 139 extern char cml_version_number[];
 140
 141 /*
 142  * demand attach fs
 143  * save all fileserver state
 144  */
 145 int
 146 fs_stateSave(void)
 147 {
 148     int ret = 0, verified = 1;
 149     struct fs_dump_state state;
 150
 151     /* save and restore need to be atomic wrt other host package operations */
 152     H_LOCK;
 153
 154     ViceLog(0, ("fs_stateSave: commencing fileserver state dump\n"));
 155
 156     if (fs_stateAlloc(&state)) {
 157         ViceLog(0, ("fs_stateSave: memory allocation failed; dump aborted\n"));
 158         ret = 1;
 159         goto done;
 160     }
 161
 162     /* XXX
 163      * on busy servers, these checks will inevitably fail since stuff drops H_LOCK
 164      * all over the place (with structs left in inconsistent states) while RPCs to
 165      * clients happen (grumble, grumble, the host package needs to be rewritten...)
 166      *
 167      * the current hack is to force the background threads that deal with host and
 168      * callback state offline early in the shutdown process, do VShutdown, come
 169      * back and wait for those threads to die, THEN do the state dump
 170      *
 171      * BUT, this still has one flaw -- what do we do about rx worker threads that
 172      * are blocked in the host package making an RPC call to a cm???
 173      *
 174      * perhaps we need a refcounter that keeps track of threads blocked in rpc calls
 175      * with H_LOCK dropped (and the host struct likely left in an inconsistent state)
 176      *
 177      * or better yet, we need to associate a state machine with each host object
 178      * (kind of like demand attach Volume structures).
 179      *
 180      * sigh. I suspect we'll need to revisit this issue
 181      */
 182
 183     if (fs_state.options.fs_state_verify_before_save) {
 184         ViceLog(0, ("fs_stateSave: performing internal consistency checks before proceeding with state dump\n"));
 185
 186         if (h_stateVerify(&state)) {
 187             ViceLog(0, ("fs_stateSave: error: host table consistency checks failed; state dump will not be marked clean\n"));
 188             verified = 0;
 189             ret = 1;
 190         }
 191
 192         if (cb_stateVerify(&state)) {
 193             ViceLog(0, ("fs_stateSave: error: callback table consistency checks failed; state dump will not be marked clean\n"));
 194             verified = 0;
 195             ret = 1;
 196         }
 197
 198         /* if a consistency check asserted the bail flag, reset it */
 199         state.bail = 0;
 200
 201         ViceLog(0, ("fs_stateSave: proceeding with dump\n"));
 202     }
 203
 204     if (fs_stateCreateDump(&state)) {
 205         ViceLog(0, ("fs_stateSave: error: dump create failed\n"));
 206         ret = 1;
 207         goto done;
 208     }
 209
 210     if (h_stateSave(&state)) {
 211         ViceLog(0, ("fs_stateSave: error: host state dump failed\n"));
 212         ret = 1;
 213         goto done;
 214     }
 215
 216     if (cb_stateSave(&state)) {
 217         ViceLog(0, ("fs_stateSave: error: callback state dump failed\n"));
 218         ret = 1;
 219         goto done;
 220     }
 221
 222     if (!verified) {
 223         state.bail = 1;
 224     }
 225
 226     if (fs_stateCommitDump(&state)) {
 227         ViceLog(0, ("fs_stateSave: error: dump commit failed\n"));
 228         ret = 1;
 229         goto done;
 230     }
 231
 232     if (verified) {
 233         ViceLog(0, ("fs_stateSave: fileserver state dump completed successfully\n"));
 234     } else {
 235         ViceLog(0, ("fs_stateSave: fileserver state dump completed, but not marked clean.\n"));
 236         ViceLog(0, ("fs_stateSave: please save a copy of '%s' for use by technical support\n",
 237                     state.fn));
 238     }
 239
 240  done:
 241     if (state.fd >= 0)
 242         fs_stateCloseDump(&state);
 243     fs_stateFree(&state);
 244     H_UNLOCK;
 245     return ret;
 246 }
 247
 248 /*
 249  * demand attach fs
 250  * restore all fileserver state
 251  *
 252  * this function must appear as one atomic operation to the host and callback
 253  * packages, hence H_LOCK is held for the entirety of the process.
 254  */
 255 int
 256 fs_stateRestore(void)
 257 {
 258     int ret = 0;
 259     struct fs_dump_state state;
 260
 261     /* save and restore need to be atomic wrt other host package operations */
 262     H_LOCK;
 263
 264     ViceLog(0, ("fs_stateRestore: commencing fileserver state restore\n"));
 265
 266     if (fs_stateAlloc(&state)) {
 267         ViceLog(0, ("fs_stateRestore: memory allocation failed\n"));
 268         ret = 1;
 269         goto done;
 270     }
 271
 272     if (fs_stateLoadDump(&state)) {
 273         ViceLog(0, ("fs_stateRestore: failed to load dump file '%s'\n", state.fn));
 274         ret = 1;
 275         goto done;
 276     }
 277
 278     if (fs_stateInvalidateDump(&state)) {
 279         ViceLog(0, ("fs_stateRestore: failed to invalidate dump file '%s'\n", state.fn));
 280         ret = 1;
 281         goto done;
 282     }
 283
 284
 285     if (state.flags.do_host_restore) {
 286         if (h_stateRestore(&state)) {
 287             ViceLog(0, ("fs_stateRestore: error: host state restore failed. exiting avoid further corruption\n"));
 288             exit(0);
 289         }
 290         ViceLog(0, ("fs_stateRestore: host table restored\n"));
 291
 292         if (cb_stateRestore(&state)) {
 293             ViceLog(0, ("fs_stateRestore: error: callback state restore failed. exiting to avoid further corruption\n"));
 294             exit(0);
 295         }
 296         ViceLog(0, ("fs_stateRestore: FileEntry and CallBack tables restored\n"));
 297
 298         if (h_stateRestoreIndices(&state)) {
 299             ViceLog(0, ("fs_stateRestore: error: host index remapping failed. exiting to avoid further corruption\n"));
 300             exit(0);
 301         }
 302         ViceLog(0, ("fs_stateRestore: host table indices remapped\n"));
 303
 304         if (cb_stateRestoreIndices(&state)) {
 305             ViceLog(0, ("fs_stateRestore: error: callback index remapping failed. exiting to avoid further corruption\n"));
 306             exit(0);
 307         }
 308         ViceLog(0, ("fs_stateRestore: FileEntry and CallBack indices remapped\n"));
 309     }
 310
 311     ViceLog(0, ("fs_stateRestore: restore phase complete\n"));
 312
 313     if (fs_state.options.fs_state_verify_after_restore) {
 314         ViceLog(0, ("fs_stateRestore: beginning state verification phase\n"));
 315
 316         if (state.flags.do_host_restore) {
 317             if (h_stateVerify(&state)) {
 318                 ViceLog(0, ("fs_stateRestore: error: host table consistency checks failed; exiting to avoid further corruption\n"));
 319                 exit(0);
 320             }
 321
 322             if (cb_stateVerify(&state)) {
 323                 ViceLog(0, ("fs_stateRestore: error: callback table consistency checks failed; exiting to avoid further corruption\n"));
 324                 exit(0);
 325             }
 326         }
 327
 328         ViceLog(0, ("fs_stateRestore: fileserver state verification complete\n"));
 329     }
 330
 331     ViceLog(0, ("fs_stateRestore: restore was successful\n"));
 332
 333  done:
 334     if (state.fd >= 0) {
 335         fs_stateInvalidateDump(&state);
 336         fs_stateCloseDump(&state);
 337     }
 338     fs_stateFree(&state);
 339     H_UNLOCK;
 340     return ret;
 341 }
 342
 343 static int
 344 fs_stateCreateDump(struct fs_dump_state * state)
 345 {
 346     int fd, ret = 0;
 347     char savedump[MAXPATHLEN];
 348     struct afs_stat status;
 349
 350     afs_snprintf(savedump, sizeof(savedump), "%s.old", state->fn);
 351
 352     if (afs_stat(state->fn, &status) == 0) {
 353         renamefile(state->fn, savedump);
 354     }
 355
 356     if (((fd = afs_open(state->fn,
 357                         O_RDWR | O_CREAT | O_TRUNC,
 358                         S_IRUSR | S_IWUSR)) == -1) ||
 359         (afs_fstat(fd, &status) == -1)) {
 360         ViceLog(0, ("fs_stateCreateDump: failed to create state dump file '%s'\n",
 361                     state->fn));
 362         ret = 1;
 363         goto done;
 364     }
 365
 366     state->fd = fd;
 367     state->mode = FS_STATE_DUMP_MODE;
 368     memset(state->hdr, 0, sizeof(struct fs_state_header));
 369     fs_stateIncEOF(state, sizeof(struct fs_state_header));
 370
 371 #ifdef FS_STATE_USE_MMAP
 372     if (fs_stateSizeFile(state)) {
 373         ViceLog(0, ("fs_stateCreateDump: failed to resize state dump file '%s'\n",
 374                     state->fn));
 375         ret = 1;
 376         goto done;
 377     }
 378
 379     if (fs_stateMapFile(state)) {
 380         ViceLog(0, ("fs_stateCreateDump: failed to memory map state dump file '%s'\n",
 381                     state->fn));
 382         ret = 1;
 383         goto done;
 384     }
 385 #endif
 386
 387     ret = fs_stateInvalidateDump(state);
 388
 389  done:
 390     return ret;
 391 }
 392
 393 static int
 394 fs_stateInvalidateDump(struct fs_dump_state * state)
 395 {
 396     afs_uint64 z;
 397     int ret = 0;
 398     struct fs_state_header hdr;
 399
 400 #ifdef FS_STATE_USE_MMAP
 401     if (state->mmap.map == NULL) {
 402         return 1;
 403     }
 404 #endif
 405
 406     memcpy(&hdr, state->hdr, sizeof(hdr));
 407     hdr.valid = 0;
 408     ZeroInt64(z);
 409
 410     /* write a bogus header to flag dump in progress */
 411     if (fs_stateWriteHeader(state, &z, &hdr, sizeof(hdr))) {
 412         ViceLog(0, ("fs_stateInvalidateDump: failed to invalidate old dump file header '%s'\n",
 413                     state->fn));
 414         ret = 1;
 415         goto done;
 416     }
 417     if (fs_stateSync(state)) {
 418         ViceLog(0, ("fs_stateInvalidateDump: failed to sync changes to disk\n"));
 419         ret = 1;
 420         goto done;
 421     }
 422
 423  done:
 424     return ret;
 425 }
 426
 427 static int
 428 fs_stateCommitDump(struct fs_dump_state * state)
 429 {
 430     afs_uint64 z;
 431     int ret = 0;
 432
 433     ZeroInt64(z);
 434
 435 #ifdef FS_STATE_USE_MMAP
 436     if (fs_stateTruncateFile(state)) {
 437         ViceLog(0, ("fs_stateCommitDump: failed to truncate dump file to proper size\n"));
 438         ret = 1;
 439         goto done;
 440     }
 441 #endif
 442
 443     /* ensure that all pending data I/Os for the state file have been committed
 444      * _before_ we make the metadata I/Os */
 445     if (fs_stateSync(state)) {
 446         ViceLog(0, ("fs_stateCommitDump: failed to sync changes to disk\n"));
 447         ret = 1;
 448         goto done;
 449     }
 450
 451 #ifdef FS_STATE_USE_MMAP
 452     /* XXX madvise may not exist on all platforms, so
 453      * we may need to add some ifdefs at some point... */
 454     {
 455         madvise((((char *)state->mmap.map) + sizeof(struct fs_state_header)),
 456                 state->mmap.size - sizeof(struct fs_state_header),
 457                 MADV_DONTNEED);
 458     }
 459 #endif
 460
 461     /* build the header, and write it to disk */
 462     fs_stateFillHeader(state->hdr);
 463     if (state->bail) {
 464         state->hdr->valid = 0;
 465     }
 466     if (fs_stateWriteHeader(state, &z, state->hdr, sizeof(struct fs_state_header))) {
 467         ViceLog(0, ("fs_stateCommitDump: failed to write header to dump file '%s'\n",
 468                     state->fn));
 469         ret = 1;
 470         goto done;
 471     }
 472     if (fs_stateSync(state)) {
 473         ViceLog(0, ("fs_stateCommitDump: failed to sync new header to disk\n"));
 474         ret = 1;
 475         goto done;
 476     }
 477
 478  done:
 479     return ret;
 480 }
 481
 482 static int
 483 fs_stateLoadDump(struct fs_dump_state * state)
 484 {
 485     afs_uint64 z;
 486     int fd, ret = 0;
 487     struct afs_stat status;
 488     afs_int32 now = FT_ApproxTime();
 489
 490     ZeroInt64(z);
 491
 492     if ((fd = afs_open(state->fn, O_RDWR)) == -1 ||
 493         (afs_fstat(fd, &status) == -1)) {
 494         ViceLog(0, ("fs_stateLoadDump: failed to load state dump file '%s'\n",
 495                     state->fn));
 496         ret = 1;
 497         goto done;
 498     }
 499     state->fd = fd;
 500     state->mode = FS_STATE_LOAD_MODE;
 501     state->file_len = status.st_size;
 502
 503 #ifdef FS_STATE_USE_MMAP
 504     if (fs_stateMapFile(state)) {
 505         ViceLog(0, ("fs_stateLoadDump: failed to memory map state dump file '%s'\n",
 506                     state->fn));
 507         ret = 1;
 508         goto done;
 509     }
 510 #endif
 511
 512     if (fs_stateReadHeader(state, &z, state->hdr, sizeof(struct fs_state_header))) {
 513         ViceLog(0, ("fs_stateLoadDump: failed to read header from dump file '%s'\n",
 514                     state->fn));
 515         ret = 1;
 516         goto done;
 517     }
 518
 519     /* check the validity of the header */
 520     if (fs_stateCheckHeader(state->hdr)) {
 521         ViceLog(1, ("fs_stateLoadDump: header failed validity checks; not restoring '%s'\n",
 522                     state->fn));
 523         ret = 1;
 524         goto done;
 525     }
 526
 527     if ((state->hdr->timestamp + HOST_STATE_VALID_WINDOW) >= now) {
 528         state->flags.do_host_restore = 1;
 529     } else {
 530         ViceLog(0, ("fs_stateLoadDump: warning: dump is too old for host and callback restore; skipping those steps\n"));
 531     }
 532
 533  done:
 534     return ret;
 535 }
 536
 537 static int
 538 fs_stateCloseDump(struct fs_dump_state * state)
 539 {
 540 #ifdef FS_STATE_USE_MMAP
 541     fs_stateUnmapFile(state);
 542 #endif
 543     close(state->fd);
 544     return 0;
 545 }
 546
 547 int
 548 fs_stateWrite(struct fs_dump_state * state,
 549               void * buf, size_t len)
 550 {
 551     int ret = 0;
 552
 553 #ifdef FS_STATE_USE_MMAP
 554     if (fs_stateCheckIOSafety(state, len)) {
 555         if (fs_stateResizeFile(state, len)) {
 556             ViceLog(0, ("fs_stateWrite: could not resize dump file '%s'\n",
 557                         state->fn));
 558             ret = 1;
 559             goto done;
 560         }
 561     }
 562
 563     memcpy(state->mmap.cursor, buf, len);
 564     fs_stateIncCursor(state, len);
 565 #else
 566     if (write(state->fd, buf, len) != len) {
 567         ViceLog(0, ("fs_stateWrite: write failed\n"));
 568         ret = 1;
 569         goto done;
 570     }
 571 #endif
 572
 573  done:
 574     return ret;
 575 }
 576
 577 int
 578 fs_stateRead(struct fs_dump_state * state,
 579              void * buf, size_t len)
 580 {
 581     int ret = 0;
 582
 583 #ifdef FS_STATE_USE_MMAP
 584     if (fs_stateCheckIOSafety(state, len)) {
 585         ViceLog(0, ("fs_stateRead: read beyond EOF for dump file '%s'\n",
 586                     state->fn));
 587         ret = 1;
 588         goto done;
 589     }
 590
 591     memcpy(buf, state->mmap.cursor, len);
 592     fs_stateIncCursor(state, len);
 593 #else
 594     if (read(state->fd, buf, len) != len) {
 595         ViceLog(0, ("fs_stateRead: read failed\n"));
 596         ret = 1;
 597         goto done;
 598     }
 599 #endif
 600
 601  done:
 602     return ret;
 603 }
 604
 605 int
 606 fs_stateWriteV(struct fs_dump_state * state,
 607                struct iovec * iov, int niov)
 608 {
 609     int i, ret = 0;
 610     size_t len = 0;
 611
 612     for (i=0; i < niov; i++) {
 613         len += iov[i].iov_len;
 614     }
 615
 616 #ifdef FS_STATE_USE_MMAP
 617     if (fs_stateCheckIOSafety(state, len)) {
 618         if (fs_stateResizeFile(state, len)) {
 619             ViceLog(0, ("fs_stateWrite: could not resize dump file '%s'\n",
 620                         state->fn));
 621             ret = 1;
 622             goto done;
 623         }
 624     }
 625
 626     for (i=0; i < niov; i++) {
 627         memcpy(state->mmap.cursor, iov[i].iov_base, iov[i].iov_len);
 628         fs_stateIncCursor(state, iov[i].iov_len);
 629     }
 630 #else
 631     if (writev(state->fd, iov, niov) != len) {
 632         ViceLog(0, ("fs_stateWriteV: write failed\n"));
 633         ret = 1;
 634         goto done;
 635     }
 636 #endif
 637
 638  done:
 639     return ret;
 640 }
 641
 642 int
 643 fs_stateReadV(struct fs_dump_state * state,
 644               struct iovec * iov, int niov)
 645 {
 646     int i, ret = 0;
 647     size_t len = 0;
 648
 649     for (i=0; i < niov; i++) {
 650         len += iov[i].iov_len;
 651     }
 652
 653 #ifdef FS_STATE_USE_MMAP
 654     if (fs_stateCheckIOSafety(state, len)) {
 655         ViceLog(0, ("fs_stateRead: read beyond EOF for dump file '%s'\n",
 656                     state->fn));
 657         ret = 1;
 658         goto done;
 659     }
 660
 661     for (i=0; i < niov; i++) {
 662         memcpy(iov[i].iov_base, state->mmap.cursor, iov[i].iov_len);
 663         fs_stateIncCursor(state, iov[i].iov_len);
 664     }
 665 #else
 666     if (readv(state->fd, iov, niov) != len) {
 667         ViceLog(0, ("fs_stateReadV: read failed\n"));
 668         ret = 1;
 669         goto done;
 670     }
 671 #endif
 672
 673  done:
 674     return ret;
 675 }
 676
 677 int
 678 fs_stateWriteHeader(struct fs_dump_state * state,
 679                     afs_uint64 * offset,
 680                     void * hdr, size_t len)
 681 {
 682     int ret = 0;
 683
 684     if (fs_stateSeek(state, offset)) {
 685         ViceLog(0, ("fs_stateWriteHeader: could not seek to correct position in dump file '%s'\n",
 686                     state->fn));
 687         ret = 1;
 688         goto done;
 689     }
 690
 691     if (fs_stateWrite(state, hdr, len)) {
 692         ViceLog(0, ("fs_stateWriteHeader: write failed\n"));
 693         ret = 1;
 694         goto done;
 695     }
 696
 697  done:
 698     return ret;
 699 }
 700
 701 int
 702 fs_stateReadHeader(struct fs_dump_state * state,
 703                    afs_uint64 * offset,
 704                    void * hdr, size_t len)
 705 {
 706     int ret = 0;
 707
 708     if (fs_stateSeek(state, offset)) {
 709         ViceLog(0, ("fs_stateReadHeader: could not seek to correct position in dump file '%s'\n",
 710                     state->fn));
 711         ret = 1;
 712         goto done;
 713     }
 714
 715     if (fs_stateRead(state, hdr,len)) {
 716         ViceLog(0, ("fs_stateReadHeader: read failed\n"));
 717         ret = 1;
 718         goto done;
 719     }
 720
 721  done:
 722     return ret;
 723 }
 724
 725 #ifdef FS_STATE_USE_MMAP
 726 static int
 727 fs_stateSizeFile(struct fs_dump_state * state)
 728 {
 729     int ret = 0;
 730     state->file_len = FS_STATE_INIT_FILESIZE;
 731     if (afs_ftruncate(state->fd, state->file_len) != 0)
 732         ret = 1;
 733     return ret;
 734 }
 735
 736 static int
 737 fs_stateResizeFile(struct fs_dump_state * state, size_t min_add)
 738 {
 739     int ret = 0;
 740     afs_foff_t inc;
 741
 742 #ifdef FS_STATE_USE_MMAP
 743     fs_stateUnmapFile(state);
 744 #endif
 745
 746     inc = ((min_add / FS_STATE_INIT_FILESIZE)+1) * FS_STATE_INIT_FILESIZE;
 747     state->file_len += inc;
 748
 749     if (afs_ftruncate(state->fd, state->file_len) != 0) {
 750         ViceLog(0, ("fs_stateResizeFile: truncate failed\n"));
 751         ret = 1;
 752         goto done;
 753     }
 754
 755 #ifdef FS_STATE_USE_MMAP
 756     if (fs_stateMapFile(state)) {
 757         ViceLog(0, ("fs_stateResizeFile: remapping memory mapped file failed\n"));
 758         ret = 1;
 759         goto done;
 760     }
 761 #endif
 762
 763  done:
 764     return ret;
 765 }
 766
 767 static int
 768 fs_stateTruncateFile(struct fs_dump_state * state)
 769 {
 770     int ret = 0;
 771
 772 #ifdef AFS_LARGEFILE_ENV
 773     if (afs_ftruncate(state->fd, state->eof_offset) != 0) {
 774         ret = 1;
 775     }
 776 #else
 777     afs_uint32 hi, lo;
 778     SplitInt64(state->eof_offset, hi, lo);
 779     if (afs_ftruncate(state->fd, lo) != 0) {
 780         ret = 1;
 781     }
 782 #endif
 783
 784     return ret;
 785 }
 786 #endif
 787
 788 #ifdef FS_STATE_USE_MMAP
 789 static int
 790 fs_stateMapFile(struct fs_dump_state * state)
 791 {
 792     int ret = 0, flags;
 793
 794     switch(state->mode) {
 795     case FS_STATE_LOAD_MODE:
 796         flags = PROT_READ | PROT_WRITE;   /* loading involves a header invalidation */
 797         break;
 798     case FS_STATE_DUMP_MODE:
 799         flags = PROT_WRITE;
 800         break;
 801     default:
 802         ViceLog(0, ("fs_stateMapFile: invalid dump state mode\n"));
 803         return 1;
 804     }
 805
 806     state->mmap.map = afs_mmap(NULL,
 807                                state->file_len,
 808                                flags,
 809                                MAP_SHARED,
 810                                state->fd,
 811                                0);
 812
 813     if (state->mmap.map == MAP_FAILED) {
 814         state->mmap.size = 0;
 815         state->mmap.map = NULL;
 816         ViceLog(0, ("fs_stateMapFile: failed to memory map file '%s'\n",
 817                     state->fn));
 818         ret = 1;
 819         goto done;
 820     }
 821
 822     state->mmap.size = state->file_len;
 823     state->mmap.cursor = state->mmap.map;
 824     state->mmap.offset = 0;
 825
 826     /* for state loading, accesses will be sequential, so let's give
 827      * the VM subsystem a heads up */
 828     if (state->mode == FS_STATE_LOAD_MODE) {
 829         /* XXX madvise may not exist on all platforms, so
 830          * we may need to add some ifdefs at some point... */
 831         flags = MADV_SEQUENTIAL | MADV_WILLNEED;
 832 #ifdef AFS_SUN510_ENV
 833         flags |= MADV_ACCESS_LWP;   /* added in solaris 9 12/02 */
 834 #endif
 835         madvise(state->mmap.map, state->mmap.size, flags);
 836     }
 837
 838  done:
 839     return ret;
 840 }
 841
 842 static int
 843 fs_stateUnmapFile(struct fs_dump_state * state)
 844 {
 845     int ret = 0;
 846
 847     if (munmap(state->mmap.map, state->mmap.size) == -1) {
 848         ViceLog(0, ("fs_stateUnmapFile: failed to unmap dump file '%s'\n",
 849                     state->fn));
 850         ret = 1;
 851         goto done;
 852     }
 853
 854  done:
 855     return ret;
 856 }
 857 #endif /* FS_STATE_USE_MMAP */
 858
 859 #ifdef FS_STATE_USE_MMAP
 860 int
 861 fs_stateSync(struct fs_dump_state * state)
 862 {
 863     int ret = 0;
 864
 865     msync(state->mmap.map, state->mmap.size, MS_SYNC);
 866
 867  done:
 868     return ret;
 869 }
 870 #else /* !FS_STATE_USE_MMAP */
 871 int
 872 fs_stateSync(struct fs_dump_state * state)
 873 {
 874     int ret = 0;
 875
 876     if (fsync(state->fd) == -1)
 877         ret = 1;
 878
 879  done:
 880     return ret;
 881 }
 882 #endif /* !FS_STATE_USE_MMAP */
 883
 884 int
 885 fs_stateIncEOF(struct fs_dump_state * state, afs_int32 len)
 886 {
 887     afs_uint64 temp;
 888     FillInt64(temp, 0, len);
 889     AddUInt64(state->eof_offset, temp, &state->eof_offset);
 890     return 0;
 891 }
 892
 893 #ifdef FS_STATE_USE_MMAP
 894 static int
 895 fs_stateIncCursor(struct fs_dump_state * state, size_t len)
 896 {
 897     char * p;
 898
 899     state->mmap.offset += len;
 900
 901     p = (char *) state->mmap.cursor;
 902     p += len;
 903     state->mmap.cursor = (void *) p;
 904
 905     return 0;
 906 }
 907
 908 static int
 909 fs_stateCheckIOSafety(struct fs_dump_state * state, size_t len)
 910 {
 911     int ret = 0;
 912
 913     if ((state->mmap.offset + len) > state->mmap.size) {
 914         ret = 1;
 915     }
 916     return ret;
 917 }
 918 #endif /* FS_STATE_USE_MMAP */
 919
 920 #ifdef FS_STATE_USE_MMAP
 921 int
 922 fs_stateSeek(struct fs_dump_state * state, afs_uint64 * offset)
 923 {
 924     int ret = 0;
 925     char * p;
 926     afs_uint32 hi, lo;
 927
 928     SplitInt64(*offset, hi, lo);
 929
 930     /* update cursor */
 931     p = (char *) state->mmap.map;
 932 #ifdef AFS_64BIT_ENV
 933     p += *offset;
 934 #else
 935     p += lo;
 936 #endif
 937     state->mmap.cursor = (void *) p;
 938
 939     /* update offset */
 940 #ifdef AFS_LARGEFILE_ENV
 941     state->mmap.offset = *offset;
 942 #else
 943     if (hi)
 944         ret = 1;
 945     state->mmap.offset = lo;
 946 #endif
 947
 948     return ret;
 949 }
 950 #else /* !FS_STATE_USE_MMAP */
 951 int
 952 fs_stateSeek(struct fs_dump_state * state, afs_uint64 * offset)
 953 {
 954     int ret = 0;
 955 #ifndef AFS_LARGEFILE_ENV
 956     afs_uint32 high, low;
 957
 958     SplitInt64(*offset, high, low);
 959     if (high) {
 960         ret = 1;
 961         goto done;
 962     }
 963
 964     if (afs_lseek(state->fd, low, SEEK_SET) == -1)
 965         ret = 1;
 966 #else
 967     if (afs_lseek(state->fd, *offset, SEEK_SET) == -1)
 968         ret = 1;
 969 #endif
 970     return ret;
 971 }
 972 #endif /* !FS_STATE_USE_MMAP */
 973
 974 static int
 975 fs_stateFillHeader(struct fs_state_header * hdr)
 976 {
 977     hdr->stamp.magic = FS_STATE_MAGIC;
 978     hdr->stamp.version = FS_STATE_VERSION;
 979 #ifdef SYS_NAME_ID
 980     hdr->sys_name = SYS_NAME_ID;
 981 #else
 982     hdr->sys_name = 0xFFFFFFFF;
 983 #endif
 984     hdr->timestamp = FT_ApproxTime();
 985     hdr->server_uuid = FS_HostUUID;
 986     hdr->valid = 1;
 987 #ifdef WORDS_BIGENDIAN
 988     hdr->endianness = 1;
 989 #else
 990     hdr->endianness = 0;
 991 #endif
 992 #ifdef FS_STATS_DETAILED
 993     hdr->stats_detailed = 1;
 994 #else
 995     hdr->stats_detailed = 0;
 996 #endif
 997     if (strlcpy(hdr->server_version_string, cml_version_number, sizeof(hdr->server_version_string))
 998         >= sizeof(hdr->server_version_string)) {
 999         ViceLog(0, ("fs_stateFillHeader: WARNING -- cml_version_number field truncated\n"));
1000     }
1001     return 0;
1002 }
1003
1004 static int
1005 fs_stateCheckHeader(struct fs_state_header * hdr)
1006 {
1007     int ret = 0;
1008
1009     if (!hdr->valid) {
1010         ViceLog(0, ("fs_stateCheckHeader: dump was previously flagged invalid\n"));
1011         ret = 1;
1012     }
1013 #ifdef WORDS_BIGENDIAN
1014     else if (!hdr->endianness) {
1015         ViceLog(0, ("fs_stateCheckHeader: wrong endianness\n"));
1016         ret = 1;
1017     }
1018 #else /* AFSLITTLE_ENDIAN */
1019     else if (hdr->endianness) {
1020         ViceLog(0, ("fs_stateCheckHeader: wrong endianness\n"));
1021         ret = 1;
1022     }
1023 #endif /* AFSLITTLE_ENDIAN */
1024
1025     else if (hdr->stamp.magic != FS_STATE_MAGIC) {
1026         ViceLog(0, ("fs_stateCheckHeader: invalid dump header\n"));
1027         ret = 1;
1028     }
1029     else if (hdr->stamp.version != FS_STATE_VERSION) {
1030         ViceLog(0, ("fs_stateCheckHeader: unknown dump format version number\n"));
1031         ret = 1;
1032     }
1033
1034 #ifdef FS_STATS_DETAILED
1035     else if (!hdr->stats_detailed) {
1036         ViceLog(0, ("fs_stateCheckHeader: wrong config flags\n"));
1037         ret = 1;
1038     }
1039 #else /* FS_STATS_DETAILED */
1040     else if (hdr->stats_detailed) {
1041         ViceLog(0, ("fs_stateCheckHeader: wrong config flags\n"));
1042         ret = 1;
1043     }
1044 #endif /* FS_STATS_DETAILED */
1045
1046     else if (!afs_uuid_equal(&hdr->server_uuid, &FS_HostUUID)) {
1047         ViceLog(0, ("fs_stateCheckHeader: server UUID does not match this server's UUID\n"));
1048         ret = 1;
1049     }
1050
1051     /* the cml_version_string is included for informational purposes only.  If someone ever
1052      * wants to limit state dump reloading based upon the contents of this string, just
1053      * uncomment the following code.  uncommenting this code is _strongly discouraged_ because
1054      * we already make use of the version stamps in the various dump headers to deal with
1055      * data structure version incompatabilities.
1056     else if (strncmp(hdr->server_version_string, cml_version_number,
1057                      sizeof(hdr->server_version_string)) != 0) {
1058         ViceLog(0, ("fs_stateCheckHeader: dump from different server version\n"));
1059         ret = 1;
1060     }
1061     */
1062
1063     else if (strncmp(hdr->server_version_string, cml_version_number,
1064                      sizeof(hdr->server_version_string)) != 0) {
1065         ViceLog(0, ("fs_stateCheckHeader: dump from different server version ; attempting state reload anyway\n"));
1066     }
1067
1068
1069     return ret;
1070 }
1071
1072 static int
1073 fs_stateAlloc(struct fs_dump_state * state)
1074 {
1075     int ret = 0;
1076     memset(state, 0, sizeof(struct fs_dump_state));
1077     state->fd = -1;
1078     state->fn = AFSDIR_SERVER_FSSTATE_FILEPATH;
1079     state->hdr = (struct fs_state_header *)malloc(sizeof(struct fs_state_header));
1080     state->h_hdr = (struct host_state_header *)malloc(sizeof(struct host_state_header));
1081     state->cb_hdr = (struct callback_state_header *)malloc(sizeof(struct callback_state_header));
1082     state->cb_timeout_hdr = (struct callback_state_timeout_header *)
1083       malloc(sizeof(struct callback_state_timeout_header));
1084     state->cb_fehash_hdr = (struct callback_state_fehash_header *)
1085       malloc(sizeof(struct callback_state_fehash_header));
1086     if ((state->hdr == NULL) || (state->h_hdr == NULL) || (state->cb_hdr == NULL) ||
1087         (state->cb_timeout_hdr == NULL) || (state->cb_fehash_hdr == NULL))
1088         ret = 1;
1089     return ret;
1090 }
1091
1092 static int
1093 fs_stateFree(struct fs_dump_state * state)
1094 {
1095     if (state->hdr)
1096         free(state->hdr);
1097     if (state->h_hdr)
1098         free(state->h_hdr);
1099     if (state->cb_hdr)
1100         free(state->cb_hdr);
1101     if (state->cb_timeout_hdr)
1102         free(state->cb_timeout_hdr);
1103     if (state->cb_fehash_hdr)
1104         free(state->cb_fehash_hdr);
1105     if (state->h_map.entries)
1106         free(state->h_map.entries);
1107     if (state->fe_map.entries)
1108         free(state->fe_map.entries);
1109     if (state->cb_map.entries)
1110         free(state->cb_map.entries);
1111     return 0;
1112 }
1113
1114 #endif /* AFS_DEMAND_ATTACH_FS */