src/vol/fssync-server.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation 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  * Portions Copyright (c) 2006-2010 Sine Nomine Associates
  10  */
  11
  12 /*
  13         System:         VICE-TWO
  14         Module:         fssync.c
  15         Institution:    The Information Technology Center, Carnegie-Mellon University
  16
  17  */
  18 #ifndef AFS_PTHREAD_ENV
  19 #define USUAL_PRIORITY (LWP_MAX_PRIORITY - 2)
  20
  21 /*
  22  * stack size increased from 8K because the HP machine seemed to have trouble
  23  * with the smaller stack
  24  */
  25 #define USUAL_STACK_SIZE        (24 * 1024)
  26 #endif /* !AFS_PTHREAD_ENV */
  27
  28 /*
  29    fssync-server.c
  30    File server synchronization with external volume utilities.
  31    server-side implementation
  32  */
  33
  34 /* This controls the size of an fd_set; it must be defined early before
  35  * the system headers define that type and the macros that operate on it.
  36  * Its value should be as large as the maximum file descriptor limit we
  37  * are likely to run into on any platform.  Right now, that is 65536
  38  * which is the default hard fd limit on Solaris 9 */
  39 #ifndef _WIN32
  40 #define FD_SETSIZE 65536
  41 #endif
  42
  43 #include <afsconfig.h>
  44 #include <afs/param.h>
  45
  46 #include <roken.h>
  47
  48 #include <sys/types.h>
  49 #include <stdio.h>
  50 #ifdef HAVE_STDINT_H
  51 # include <stdint.h>
  52 #endif
  53 #ifdef AFS_NT40_ENV
  54 #include <winsock2.h>
  55 #include <time.h>
  56 #else
  57 #include <sys/param.h>
  58 #include <sys/socket.h>
  59 #include <netinet/in.h>
  60 #include <netdb.h>
  61 #include <sys/time.h>
  62 #include <unistd.h>
  63 #endif
  64 #include <errno.h>
  65 #include <afs/afs_assert.h>
  66 #include <signal.h>
  67 #include <string.h>
  68
  69 #include <rx/xdr.h>
  70 #include <afs/afsint.h>
  71 #include "nfs.h"
  72 #include <afs/errors.h>
  73 #include "daemon_com.h"
  74 #include "daemon_com_inline.h"
  75 #include "fssync.h"
  76 #include "fssync_inline.h"
  77 #include "salvsync.h"
  78 #include "lwp.h"
  79 #include "lock.h"
  80 #include <afs/afssyscalls.h>
  81 #include "ihandle.h"
  82 #include "vnode.h"
  83 #include "volume.h"
  84 #include "volume_inline.h"
  85 #include "partition.h"
  86 #include "vg_cache.h"
  87 #include "common.h"
  88
  89 #ifdef HAVE_POLL
  90 #include <sys/poll.h>
  91 #endif /* HAVE_POLL */
  92
  93 #ifdef USE_UNIX_SOCKETS
  94 #include <sys/un.h>
  95 #include <afs/afsutil.h>
  96 #endif /* USE_UNIX_SOCKETS */
  97
  98 #ifdef FSSYNC_BUILD_SERVER
  99
 100 int (*V_BreakVolumeCallbacks) (VolumeId volume);
 101
 102 #define MAXHANDLERS     4       /* Up to 4 clients; must be at least 2, so that
 103                                  * move = dump+restore can run on single server */
 104 #define MAXOFFLINEVOLUMES 128   /* This needs to be as big as the maximum
 105                                  * number that would be offline for 1 operation.
 106                                  * Current winner is salvage, which needs all
 107                                  * cloned read-only copies offline when salvaging
 108                                  * a single read-write volume */
 109
 110
 111
 112 static struct offlineInfo OfflineVolumes[MAXHANDLERS][MAXOFFLINEVOLUMES];
 113
 114 /**
 115  * fssync server socket handle.
 116  */
 117 static SYNC_server_state_t fssync_server_state =
 118     { OSI_NULLSOCKET,                       /* file descriptor */
 119       FSSYNC_ENDPOINT_DECL,     /* server endpoint */
 120       FSYNC_PROTO_VERSION,      /* protocol version */
 121       5,                        /* bind() retry limit */
 122       100,                      /* listen() queue depth */
 123       "FSSYNC",                 /* protocol name string */
 124     };
 125
 126 #ifdef AFS_DEMAND_ATTACH_FS
 127 /**
 128  * a queue of volume pointers to salvage in the background.
 129  */
 130 struct fsync_salv_node {
 131     struct rx_queue q;
 132     Volume *vp;                     /**< volume to salvage */
 133     unsigned char update_salv_prio; /**< whether we should update the salvage priority or not */
 134 };
 135 static struct {
 136     struct rx_queue head;
 137     pthread_cond_t cv;
 138 } fsync_salv;
 139
 140 static void * FSYNC_salvageThread(void *);
 141 static void FSYNC_backgroundSalvage(Volume *vp);
 142 #endif /* AFS_DEMAND_ATTACH_FS */
 143
 144 /* Forward declarations */
 145 static void * FSYNC_sync(void *);
 146 static void FSYNC_newconnection(osi_socket afd);
 147 static void FSYNC_com(osi_socket fd);
 148 static void FSYNC_Drop(osi_socket fd);
 149 static void AcceptOn(void);
 150 static void AcceptOff(void);
 151 static void InitHandler(void);
 152 static int AddHandler(osi_socket fd, void (*aproc)(osi_socket));
 153 static int FindHandler(osi_socket afd);
 154 static int FindHandler_r(osi_socket afd);
 155 static int RemoveHandler(osi_socket afd);
 156 #if defined(HAVE_POLL) && defined (AFS_PTHREAD_ENV)
 157 static void CallHandler(struct pollfd *fds, int nfds, int mask);
 158 static void GetHandler(struct pollfd *fds, int maxfds, int events, int *nfds);
 159 #else
 160 static void CallHandler(fd_set * fdsetp);
 161 static void GetHandler(fd_set * fdsetp, int *maxfdp);
 162 #endif
 163 extern int LogLevel;
 164
 165 static afs_int32 FSYNC_com_VolOp(osi_socket fd, SYNC_command * com, SYNC_response * res);
 166
 167 #ifdef AFS_DEMAND_ATTACH_FS
 168 static afs_int32 FSYNC_com_VolError(FSSYNC_VolOp_command * com, SYNC_response * res);
 169 #endif
 170 static afs_int32 FSYNC_com_VolOn(FSSYNC_VolOp_command * com, SYNC_response * res);
 171 static afs_int32 FSYNC_com_VolOff(FSSYNC_VolOp_command * com, SYNC_response * res);
 172 static afs_int32 FSYNC_com_VolMove(FSSYNC_VolOp_command * com, SYNC_response * res);
 173 static afs_int32 FSYNC_com_VolBreakCBKs(FSSYNC_VolOp_command * com, SYNC_response * res);
 174 static afs_int32 FSYNC_com_VolDone(FSSYNC_VolOp_command * com, SYNC_response * res);
 175 static afs_int32 FSYNC_com_VolQuery(FSSYNC_VolOp_command * com, SYNC_response * res);
 176 static afs_int32 FSYNC_com_VolHdrQuery(FSSYNC_VolOp_command * com, SYNC_response * res);
 177 #ifdef AFS_DEMAND_ATTACH_FS
 178 static afs_int32 FSYNC_com_VGUpdate(osi_socket fd, SYNC_command * com, SYNC_response * res);
 179 static afs_int32 FSYNC_com_VolOpQuery(FSSYNC_VolOp_command * com, SYNC_response * res);
 180 static afs_int32 FSYNC_com_VGQuery(FSSYNC_VolOp_command * com, SYNC_response * res);
 181 static afs_int32 FSYNC_com_VGScan(FSSYNC_VolOp_command * com, SYNC_response * res);
 182 static afs_int32 FSYNC_com_VGScanAll(FSSYNC_VolOp_command * com, SYNC_response * res);
 183 #endif /* AFS_DEMAND_ATTACH_FS */
 184
 185 static afs_int32 FSYNC_com_VnQry(osi_socket fd, SYNC_command * com, SYNC_response * res);
 186
 187 static afs_int32 FSYNC_com_StatsOp(osi_socket fd, SYNC_command * com, SYNC_response * res);
 188
 189 static afs_int32 FSYNC_com_StatsOpGeneral(FSSYNC_StatsOp_command * scom, SYNC_response * res);
 190
 191 #ifdef AFS_DEMAND_ATTACH_FS
 192 static afs_int32 FSYNC_com_StatsOpViceP(FSSYNC_StatsOp_command * scom, SYNC_response * res);
 193 static afs_int32 FSYNC_com_StatsOpHash(FSSYNC_StatsOp_command * scom, SYNC_response * res);
 194 static afs_int32 FSYNC_com_StatsOpHdr(FSSYNC_StatsOp_command * scom, SYNC_response * res);
 195 static afs_int32 FSYNC_com_StatsOpVLRU(FSSYNC_StatsOp_command * scom, SYNC_response * res);
 196 #endif
 197
 198 static void FSYNC_com_to_info(FSSYNC_VolOp_command * vcom, FSSYNC_VolOp_info * info);
 199
 200 static int FSYNC_partMatch(FSSYNC_VolOp_command * vcom, Volume * vp, int match_anon);
 201
 202
 203 /*
 204  * This lock controls access to the handler array. The overhead
 205  * is minimal in non-preemptive environments.
 206  */
 207 struct Lock FSYNC_handler_lock;
 208
 209 void
 210 FSYNC_fsInit(void)
 211 {
 212 #ifdef AFS_PTHREAD_ENV
 213     pthread_t tid;
 214     pthread_attr_t tattr;
 215 #else /* AFS_PTHREAD_ENV */
 216     PROCESS pid;
 217 #endif /* AFS_PTHREAD_ENV */
 218
 219     Lock_Init(&FSYNC_handler_lock);
 220
 221 #ifdef AFS_PTHREAD_ENV
 222     osi_Assert(pthread_attr_init(&tattr) == 0);
 223     osi_Assert(pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED) == 0);
 224     osi_Assert(pthread_create(&tid, &tattr, FSYNC_sync, NULL) == 0);
 225 #else /* AFS_PTHREAD_ENV */
 226     osi_Assert(LWP_CreateProcess
 227            (FSYNC_sync, USUAL_STACK_SIZE, USUAL_PRIORITY, (void *)0,
 228             "FSYNC_sync", &pid) == LWP_SUCCESS);
 229 #endif /* AFS_PTHREAD_ENV */
 230
 231 #ifdef AFS_DEMAND_ATTACH_FS
 232     queue_Init(&fsync_salv.head);
 233     CV_INIT(&fsync_salv.cv, "fsync salv", CV_DEFAULT, 0);
 234     osi_Assert(pthread_create(&tid, &tattr, FSYNC_salvageThread, NULL) == 0);
 235 #endif /* AFS_DEMAND_ATTACH_FS */
 236 }
 237
 238 #if defined(HAVE_POLL) && defined(AFS_PTHREAD_ENV)
 239 static struct pollfd FSYNC_readfds[MAXHANDLERS];
 240 #else
 241 static fd_set FSYNC_readfds;
 242 #endif
 243
 244
 245 static void *
 246 FSYNC_sync(void * args)
 247 {
 248     extern int VInit;
 249     int code;
 250 #ifdef AFS_PTHREAD_ENV
 251     int tid;
 252 #endif
 253     SYNC_server_state_t * state = &fssync_server_state;
 254 #ifdef AFS_DEMAND_ATTACH_FS
 255     VThreadOptions_t * thread_opts;
 256     int min_vinit = 2;
 257 #else
 258     /*
 259      * For non-DAFS, only wait until we begin attaching volumes (instead
 260      * of waiting until all volumes are attached), since it can take
 261      * awhile until VInit == 2.
 262      */
 263     int min_vinit = 1;
 264 #endif /* AFS_DEMAND_ATTACH_FS */
 265
 266     /* we must not be called before vol package initialization, since we use
 267      * vol package mutexes and conds etc */
 268     osi_Assert(VInit);
 269
 270     SYNC_getAddr(&state->endpoint, &state->addr);
 271     SYNC_cleanupSock(state);
 272
 273 #ifndef AFS_NT40_ENV
 274     (void)signal(SIGPIPE, SIG_IGN);
 275 #endif
 276
 277 #ifdef AFS_PTHREAD_ENV
 278     /* set our 'thread-id' so that the host hold table works */
 279     tid = rx_NewThreadId();
 280     pthread_setspecific(rx_thread_id_key, (void *)(intptr_t)tid);
 281     Log("Set thread id %d for FSYNC_sync\n", tid);
 282 #endif /* AFS_PTHREAD_ENV */
 283
 284     VOL_LOCK;
 285
 286     while (VInit < min_vinit) {
 287         /* Let somebody else run until all volumes have been preattached
 288          * (DAFS), or we have started attaching volumes (non-DAFS). This
 289          * doesn't mean that all volumes have been attached.
 290          */
 291 #ifdef AFS_PTHREAD_ENV
 292         VOL_CV_WAIT(&vol_vinit_cond);
 293 #else /* AFS_PTHREAD_ENV */
 294         LWP_DispatchProcess();
 295 #endif /* AFS_PTHREAD_ENV */
 296     }
 297
 298     VOL_UNLOCK;
 299
 300     state->fd = SYNC_getSock(&state->endpoint);
 301     code = SYNC_bindSock(state);
 302     osi_Assert(!code);
 303
 304 #ifdef AFS_DEMAND_ATTACH_FS
 305     /*
 306      * make sure the volume package is incapable of recursively executing
 307      * salvsync calls on this thread, since there is a possibility of
 308      * deadlock.
 309      */
 310     thread_opts = malloc(sizeof(VThreadOptions_t));
 311     if (thread_opts == NULL) {
 312         Log("failed to allocate memory for thread-specific volume package options structure\n");
 313         return NULL;
 314     }
 315     memcpy(thread_opts, &VThread_defaults, sizeof(VThread_defaults));
 316     thread_opts->disallow_salvsync = 1;
 317     osi_Assert(pthread_setspecific(VThread_key, thread_opts) == 0);
 318
 319     code = VVGCache_PkgInit();
 320     osi_Assert(code == 0);
 321 #endif
 322
 323     InitHandler();
 324     AcceptOn();
 325
 326     for (;;) {
 327 #if defined(HAVE_POLL) && defined(AFS_PTHREAD_ENV)
 328         int nfds;
 329         GetHandler(FSYNC_readfds, MAXHANDLERS, POLLIN|POLLPRI, &nfds);
 330         if (poll(FSYNC_readfds, nfds, -1) >=1)
 331             CallHandler(FSYNC_readfds, nfds, POLLIN|POLLPRI);
 332 #else
 333         int maxfd;
 334         GetHandler(&FSYNC_readfds, &maxfd);
 335         /* Note: check for >= 1 below is essential since IOMGR_select
 336          * doesn't have exactly same semantics as select.
 337          */
 338 #ifdef AFS_PTHREAD_ENV
 339         if (select(maxfd + 1, &FSYNC_readfds, NULL, NULL, NULL) >= 1)
 340 #else /* AFS_PTHREAD_ENV */
 341         if (IOMGR_Select(maxfd + 1, &FSYNC_readfds, NULL, NULL, NULL) >= 1)
 342 #endif /* AFS_PTHREAD_ENV */
 343             CallHandler(&FSYNC_readfds);
 344 #endif
 345     }
 346     return NULL; /* hush now, little gcc */
 347 }
 348
 349 #ifdef AFS_DEMAND_ATTACH_FS
 350 /**
 351  * thread for salvaging volumes in the background.
 352  *
 353  * Since FSSYNC handlers cannot issue SALVSYNC requests in order to avoid
 354  * deadlock issues, this thread exists so code in the FSSYNC handler thread
 355  * can hand off volumes to be salvaged in the background.
 356  *
 357  * @param[in] args  unused
 358  *
 359  * @note DEMAND_ATTACH_FS only
 360  */
 361 static void *
 362 FSYNC_salvageThread(void * args)
 363 {
 364     Volume *vp;
 365     struct fsync_salv_node *node;
 366
 367     VOL_LOCK;
 368
 369     for (;;) {
 370         while (queue_IsEmpty(&fsync_salv.head)) {
 371             VOL_CV_WAIT(&fsync_salv.cv);
 372         }
 373
 374         node = queue_First(&fsync_salv.head, fsync_salv_node);
 375         queue_Remove(node);
 376
 377         vp = node->vp;
 378         if (node->update_salv_prio) {
 379             if (VUpdateSalvagePriority_r(vp)) {
 380                 ViceLog(0, ("FSYNC_salvageThread: unable to raise salvage priority "
 381                             "for volume %lu\n", afs_printable_uint32_lu(vp->hashid)));
 382             }
 383         }
 384
 385         free(node);
 386         node = NULL;
 387
 388         VCancelReservation_r(vp);
 389     }
 390
 391     VOL_UNLOCK;
 392
 393     return NULL;
 394 }
 395
 396 /**
 397  * salvage a volume in the background.
 398  *
 399  * Salvages cannot be scheduled directly from the main FSYNC thread, so
 400  * instead call this function to schedule a salvage asynchronously in the
 401  * FSYNC_salvageThread thread.
 402  *
 403  * @param[in] vp  volume to pointer to salvage
 404  *
 405  * @pre VOL_LOCK held
 406  *
 407  * @note DEMAND_ATTACH_FS only
 408  */
 409 static void
 410 FSYNC_backgroundSalvage(Volume *vp)
 411 {
 412     struct fsync_salv_node *node;
 413     Error ec;
 414
 415     VCreateReservation_r(vp);
 416
 417     node = malloc(sizeof(struct fsync_salv_node));
 418     node->vp = vp;
 419
 420     /* Save this value, to know if we should VUpdateSalvagePriority_r.
 421      * We need to save it here, snce VRequestSalvage_r will change it. */
 422     node->update_salv_prio = vp->salvage.requested;
 423
 424     if (VRequestSalvage_r(&ec, vp, SALVSYNC_ERROR, 0)) {
 425         ViceLog(0, ("FSYNC_backgroundSalvage: unable to request salvage for volume %lu\n",
 426                     afs_printable_uint32_lu(vp->hashid)));
 427     }
 428
 429     queue_Append(&fsync_salv.head, node);
 430     CV_BROADCAST(&fsync_salv.cv);
 431 }
 432 #endif /* AFS_DEMAND_ATTACH_FS */
 433
 434 static void
 435 FSYNC_newconnection(osi_socket afd)
 436 {
 437 #ifdef USE_UNIX_SOCKETS
 438     struct sockaddr_un other;
 439 #else  /* USE_UNIX_SOCKETS */
 440     struct sockaddr_in other;
 441 #endif
 442     osi_socket fd;
 443     socklen_t junk;
 444     junk = sizeof(other);
 445     fd = accept(afd, (struct sockaddr *)&other, &junk);
 446     if (fd == OSI_NULLSOCKET) {
 447         Log("FSYNC_newconnection:  accept failed, errno==%d\n", errno);
 448         osi_Assert(1 == 2);
 449     } else if (!AddHandler(fd, FSYNC_com)) {
 450         AcceptOff();
 451         osi_Assert(AddHandler(fd, FSYNC_com));
 452     }
 453 }
 454
 455 /* this function processes commands from an fssync file descriptor (fd) */
 456 afs_int32 FS_cnt = 0;
 457 static void
 458 FSYNC_com(osi_socket fd)
 459 {
 460     SYNC_command com;
 461     SYNC_response res;
 462     SYNC_PROTO_BUF_DECL(com_buf);
 463     SYNC_PROTO_BUF_DECL(res_buf);
 464
 465     memset(&res.hdr, 0, sizeof(res.hdr));
 466
 467     com.payload.buf = (void *)com_buf;
 468     com.payload.len = SYNC_PROTO_MAX_LEN;
 469     res.hdr.response_len = sizeof(res.hdr);
 470     res.payload.len = SYNC_PROTO_MAX_LEN;
 471     res.payload.buf = (void *)res_buf;
 472
 473     FS_cnt++;
 474     if (SYNC_getCom(&fssync_server_state, fd, &com)) {
 475         Log("FSYNC_com:  read failed; dropping connection (cnt=%d)\n", FS_cnt);
 476         FSYNC_Drop(fd);
 477         return;
 478     }
 479
 480     if (com.recv_len < sizeof(com.hdr)) {
 481         Log("FSSYNC_com:  invalid protocol message length (%u)\n", com.recv_len);
 482         res.hdr.response = SYNC_COM_ERROR;
 483         res.hdr.reason = SYNC_REASON_MALFORMED_PACKET;
 484         res.hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
 485         goto respond;
 486     }
 487
 488     if (com.hdr.proto_version != FSYNC_PROTO_VERSION) {
 489         Log("FSYNC_com:  invalid protocol version (%u)\n", com.hdr.proto_version);
 490         res.hdr.response = SYNC_COM_ERROR;
 491         res.hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
 492         goto respond;
 493     }
 494
 495     if (com.hdr.command == SYNC_COM_CHANNEL_CLOSE) {
 496         res.hdr.response = SYNC_OK;
 497         res.hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
 498
 499         /* don't respond, just drop; senders of SYNC_COM_CHANNEL_CLOSE
 500          * never wait for a response. */
 501         goto done;
 502     }
 503
 504     ViceLog(125, ("FSYNC_com: from fd %d got command %ld (%s) reason %ld (%s) "
 505                   "pt %ld (%s) pid %ld\n", (int)fd,
 506                   afs_printable_int32_ld(com.hdr.command),
 507                   FSYNC_com2string(com.hdr.command),
 508                   afs_printable_int32_ld(com.hdr.reason),
 509                   FSYNC_reason2string(com.hdr.reason),
 510                   afs_printable_int32_ld(com.hdr.programType),
 511                   VPTypeToString(com.hdr.programType),
 512                   afs_printable_int32_ld(com.hdr.pid)));
 513
 514     res.hdr.com_seq = com.hdr.com_seq;
 515
 516     VOL_LOCK;
 517     switch (com.hdr.command) {
 518     case FSYNC_VOL_ON:
 519     case FSYNC_VOL_ATTACH:
 520     case FSYNC_VOL_LEAVE_OFF:
 521     case FSYNC_VOL_OFF:
 522     case FSYNC_VOL_FORCE_ERROR:
 523     case FSYNC_VOL_LISTVOLUMES:
 524     case FSYNC_VOL_NEEDVOLUME:
 525     case FSYNC_VOL_MOVE:
 526     case FSYNC_VOL_BREAKCBKS:
 527     case FSYNC_VOL_DONE:
 528     case FSYNC_VOL_QUERY:
 529     case FSYNC_VOL_QUERY_HDR:
 530 #ifdef AFS_DEMAND_ATTACH_FS
 531     case FSYNC_VOL_QUERY_VOP:
 532     case FSYNC_VG_QUERY:
 533     case FSYNC_VG_SCAN:
 534     case FSYNC_VG_SCAN_ALL:
 535 #endif
 536         res.hdr.response = FSYNC_com_VolOp(fd, &com, &res);
 537         break;
 538     case FSYNC_VOL_STATS_GENERAL:
 539     case FSYNC_VOL_STATS_VICEP:
 540     case FSYNC_VOL_STATS_HASH:
 541     case FSYNC_VOL_STATS_HDR:
 542     case FSYNC_VOL_STATS_VLRU:
 543         res.hdr.response = FSYNC_com_StatsOp(fd, &com, &res);
 544         break;
 545     case FSYNC_VOL_QUERY_VNODE:
 546         res.hdr.response = FSYNC_com_VnQry(fd, &com, &res);
 547         break;
 548 #ifdef AFS_DEMAND_ATTACH_FS
 549     case FSYNC_VG_ADD:
 550     case FSYNC_VG_DEL:
 551         res.hdr.response = FSYNC_com_VGUpdate(fd, &com, &res);
 552         break;
 553 #endif
 554     default:
 555         res.hdr.response = SYNC_BAD_COMMAND;
 556         break;
 557     }
 558     VOL_UNLOCK;
 559
 560     ViceLog(125, ("FSYNC_com: fd %d responding with code %ld (%s) reason %ld "
 561                   "(%s)\n", (int)fd,
 562                   afs_printable_int32_ld(res.hdr.response),
 563                   SYNC_res2string(res.hdr.response),
 564                   afs_printable_int32_ld(res.hdr.reason),
 565                   FSYNC_reason2string(res.hdr.reason)));
 566
 567  respond:
 568     SYNC_putRes(&fssync_server_state, fd, &res);
 569
 570  done:
 571     if (res.hdr.flags & SYNC_FLAG_CHANNEL_SHUTDOWN) {
 572         FSYNC_Drop(fd);
 573     }
 574 }
 575
 576 static afs_int32
 577 FSYNC_com_VolOp(osi_socket fd, SYNC_command * com, SYNC_response * res)
 578 {
 579     int i;
 580     afs_int32 code = SYNC_OK;
 581     FSSYNC_VolOp_command vcom;
 582
 583     if (com->recv_len != (sizeof(com->hdr) + sizeof(FSSYNC_VolOp_hdr))) {
 584         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
 585         res->hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
 586         return SYNC_COM_ERROR;
 587     }
 588
 589     vcom.hdr = &com->hdr;
 590     vcom.vop = (FSSYNC_VolOp_hdr *) com->payload.buf;
 591     vcom.com = com;
 592
 593     vcom.volumes = OfflineVolumes[FindHandler(fd)];
 594     for (vcom.v = NULL, i = 0; i < MAXOFFLINEVOLUMES; i++) {
 595         if ((vcom.volumes[i].volumeID == vcom.vop->volume) &&
 596             (strncmp(vcom.volumes[i].partName, vcom.vop->partName,
 597                      sizeof(vcom.volumes[i].partName)) == 0)) {
 598             vcom.v = &vcom.volumes[i];
 599             break;
 600         }
 601     }
 602
 603     ViceLog(125, ("FSYNC_com_VolOp: fd %d got command for vol %lu part %.16s\n",
 604                   (int)fd, afs_printable_uint32_lu(vcom.vop->volume),
 605                   vcom.vop->partName));
 606
 607     switch (com->hdr.command) {
 608     case FSYNC_VOL_ON:
 609     case FSYNC_VOL_ATTACH:
 610     case FSYNC_VOL_LEAVE_OFF:
 611         code = FSYNC_com_VolOn(&vcom, res);
 612         break;
 613     case FSYNC_VOL_OFF:
 614     case FSYNC_VOL_NEEDVOLUME:
 615         code = FSYNC_com_VolOff(&vcom, res);
 616         break;
 617     case FSYNC_VOL_LISTVOLUMES:
 618         code = SYNC_OK;
 619         break;
 620     case FSYNC_VOL_MOVE:
 621         code = FSYNC_com_VolMove(&vcom, res);
 622         break;
 623     case FSYNC_VOL_BREAKCBKS:
 624         code = FSYNC_com_VolBreakCBKs(&vcom, res);
 625         break;
 626     case FSYNC_VOL_DONE:
 627         code = FSYNC_com_VolDone(&vcom, res);
 628         break;
 629     case FSYNC_VOL_QUERY:
 630         code = FSYNC_com_VolQuery(&vcom, res);
 631         break;
 632     case FSYNC_VOL_QUERY_HDR:
 633         code = FSYNC_com_VolHdrQuery(&vcom, res);
 634         break;
 635 #ifdef AFS_DEMAND_ATTACH_FS
 636     case FSYNC_VOL_FORCE_ERROR:
 637         code = FSYNC_com_VolError(&vcom, res);
 638         break;
 639     case FSYNC_VOL_QUERY_VOP:
 640         code = FSYNC_com_VolOpQuery(&vcom, res);
 641         break;
 642     case FSYNC_VG_QUERY:
 643         code = FSYNC_com_VGQuery(&vcom, res);
 644         break;
 645     case FSYNC_VG_SCAN:
 646         code = FSYNC_com_VGScan(&vcom, res);
 647         break;
 648     case FSYNC_VG_SCAN_ALL:
 649         code = FSYNC_com_VGScanAll(&vcom, res);
 650         break;
 651 #endif /* AFS_DEMAND_ATTACH_FS */
 652     default:
 653         code = SYNC_BAD_COMMAND;
 654     }
 655
 656     return code;
 657 }
 658
 659 /**
 660  * service an FSYNC request to bring a volume online.
 661  *
 662  * @param[in]   vcom  pointer command object
 663  * @param[out]  res   object in which to store response packet
 664  *
 665  * @return operation status
 666  *   @retval SYNC_OK volume transitioned online
 667  *   @retval SYNC_FAILED invalid command protocol message
 668  *   @retval SYNC_DENIED operation could not be completed
 669  *
 670  * @note this is an FSYNC RPC server stub
 671  *
 672  * @note this procedure handles the following FSSYNC command codes:
 673  *       - FSYNC_VOL_ON
 674  *       - FSYNC_VOL_ATTACH
 675  *       - FSYNC_VOL_LEAVE_OFF
 676  *
 677  * @note the supplementary reason code contains additional details.
 678  *       When SYNC_DENIED is returned, the specific reason is
 679  *       placed in the response packet reason field.
 680  *
 681  * @internal
 682  */
 683 static afs_int32
 684 FSYNC_com_VolOn(FSSYNC_VolOp_command * vcom, SYNC_response * res)
 685 {
 686     afs_int32 code = SYNC_OK;
 687 #ifndef AFS_DEMAND_ATTACH_FS
 688     char tvolName[VMAXPATHLEN];
 689 #endif
 690     Volume * vp;
 691     Error error;
 692
 693     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
 694         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
 695         code = SYNC_FAILED;
 696         goto done;
 697     }
 698
 699     /* so, we need to attach the volume */
 700
 701 #ifdef AFS_DEMAND_ATTACH_FS
 702     /* check DAFS permissions */
 703     vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
 704     if (vp &&
 705         FSYNC_partMatch(vcom, vp, 1) &&
 706         vp->pending_vol_op &&
 707         (vcom->hdr->programType != vp->pending_vol_op->com.programType)) {
 708         /* a different program has this volume checked out. deny. */
 709         Log("FSYNC_VolOn: WARNING: program type %u has attempted to manipulate "
 710             "state for volume %u using command code %u while the volume is "
 711             "checked out by program type %u for command code %u.\n",
 712             vcom->hdr->programType,
 713             vcom->vop->volume,
 714             vcom->hdr->command,
 715             vp->pending_vol_op->com.programType,
 716             vp->pending_vol_op->com.command);
 717         code = SYNC_DENIED;
 718         res->hdr.reason = FSYNC_EXCLUSIVE;
 719         goto done;
 720     }
 721 #endif
 722
 723     if (vcom->v)
 724         vcom->v->volumeID = 0;
 725
 726
 727     if (vcom->hdr->command == FSYNC_VOL_LEAVE_OFF) {
 728         /* nothing much to do if we're leaving the volume offline */
 729 #ifdef AFS_DEMAND_ATTACH_FS
 730         if (vp) {
 731             VCreateReservation_r(vp);
 732             VWaitExclusiveState_r(vp);
 733         }
 734         if (vp && V_attachState(vp) != VOL_STATE_DELETED) {
 735             if (FSYNC_partMatch(vcom, vp, 1)) {
 736                 if ((V_attachState(vp) == VOL_STATE_UNATTACHED) ||
 737                     (V_attachState(vp) == VOL_STATE_PREATTACHED)) {
 738                     VChangeState_r(vp, VOL_STATE_UNATTACHED);
 739                     VDeregisterVolOp_r(vp);
 740                 } else {
 741                     code = SYNC_DENIED;
 742                     res->hdr.reason = FSYNC_BAD_STATE;
 743                 }
 744             } else {
 745                 code = SYNC_DENIED;
 746                 res->hdr.reason = FSYNC_WRONG_PART;
 747             }
 748         } else {
 749             code = SYNC_FAILED;
 750             res->hdr.reason = FSYNC_UNKNOWN_VOLID;
 751         }
 752
 753         if (vp) {
 754             VCancelReservation_r(vp);
 755             vp = NULL;
 756         }
 757 #endif
 758         goto done;
 759     }
 760
 761 #ifdef AFS_DEMAND_ATTACH_FS
 762     /* first, check to see whether we have such a volume defined */
 763     vp = VPreAttachVolumeById_r(&error,
 764                                 vcom->vop->partName,
 765                                 vcom->vop->volume);
 766     if (vp) {
 767         VCreateReservation_r(vp);
 768         VWaitExclusiveState_r(vp);
 769         VDeregisterVolOp_r(vp);
 770         VCancelReservation_r(vp);
 771         vp = NULL;
 772     }
 773 #else /* !AFS_DEMAND_ATTACH_FS */
 774     tvolName[0] = OS_DIRSEPC;
 775     snprintf(&tvolName[1], sizeof(tvolName)-1, VFORMAT, afs_printable_uint32_lu(vcom->vop->volume));
 776     tvolName[sizeof(tvolName)-1] = '\0';
 777
 778     vp = VAttachVolumeByName_r(&error, vcom->vop->partName, tvolName,
 779                                V_VOLUPD);
 780     if (vp)
 781         VPutVolume_r(vp);
 782     if (error) {
 783         code = SYNC_DENIED;
 784         res->hdr.reason = error;
 785     }
 786 #endif /* !AFS_DEMAND_ATTACH_FS */
 787
 788  done:
 789     return code;
 790 }
 791
 792 /**
 793  * service an FSYNC request to take a volume offline.
 794  *
 795  * @param[in]   vcom  pointer command object
 796  * @param[out]  res   object in which to store response packet
 797  *
 798  * @return operation status
 799  *   @retval SYNC_OK volume transitioned offline
 800  *   @retval SYNC_FAILED invalid command protocol message
 801  *   @retval SYNC_DENIED operation could not be completed
 802  *
 803  * @note this is an FSYNC RPC server stub
 804  *
 805  * @note this procedure handles the following FSSYNC command codes:
 806  *       - FSYNC_VOL_OFF
 807  *       - FSYNC_VOL_NEEDVOLUME
 808  *
 809  * @note the supplementary reason code contains additional details.
 810  *       When SYNC_DENIED is returned, the specific reason is
 811  *       placed in the response packet reason field.
 812  *
 813  * @internal
 814  */
 815 static afs_int32
 816 FSYNC_com_VolOff(FSSYNC_VolOp_command * vcom, SYNC_response * res)
 817 {
 818     FSSYNC_VolOp_info info;
 819     afs_int32 code = SYNC_OK;
 820     int i;
 821     Volume * vp;
 822     Error error;
 823 #ifdef AFS_DEMAND_ATTACH_FS
 824     Volume *nvp, *rvp = NULL;
 825 #endif
 826
 827     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
 828         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
 829         code = SYNC_FAILED;
 830         goto done;
 831     }
 832
 833     /* not already offline, we need to find a slot for newly offline volume */
 834     if (vcom->hdr->programType == debugUtility) {
 835         /* debug utilities do not have their operations tracked */
 836         vcom->v = NULL;
 837     } else {
 838         if (!vcom->v) {
 839             for (i = 0; i < MAXOFFLINEVOLUMES; i++) {
 840                 if (vcom->volumes[i].volumeID == 0) {
 841                     vcom->v = &vcom->volumes[i];
 842                     break;
 843                 }
 844             }
 845         }
 846         if (!vcom->v) {
 847             goto deny;
 848         }
 849     }
 850
 851     FSYNC_com_to_info(vcom, &info);
 852
 853 #ifdef AFS_DEMAND_ATTACH_FS
 854     vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
 855 #else
 856     vp = VGetVolume_r(&error, vcom->vop->volume);
 857 #endif
 858
 859     if (vp) {
 860             if (!FSYNC_partMatch(vcom, vp, 1)) {
 861             /* volume on desired partition is not online, so we
 862              * should treat this as an offline volume.
 863              */
 864 #ifndef AFS_DEMAND_ATTACH_FS
 865             VPutVolume_r(vp);
 866 #endif
 867             vp = NULL;
 868             goto done;
 869         }
 870     }
 871
 872 #ifdef AFS_DEMAND_ATTACH_FS
 873     if (vp) {
 874         ProgramType type = (ProgramType) vcom->hdr->programType;
 875
 876         /* do initial filtering of requests */
 877
 878         /* enforce mutual exclusion for volume ops */
 879         if (vp->pending_vol_op) {
 880             if (vp->pending_vol_op->com.programType != type) {
 881                 if (vp->pending_vol_op->com.command == FSYNC_VOL_OFF &&
 882                     vp->pending_vol_op->com.reason == FSYNC_SALVAGE) {
 883
 884                     Log("denying offline request for volume %lu; volume is salvaging\n",
 885                         afs_printable_uint32_lu(vp->hashid));
 886
 887                     res->hdr.reason = FSYNC_SALVAGE;
 888                     goto deny;
 889                 }
 890                 Log("volume %u already checked out\n", vp->hashid);
 891                 /* XXX debug */
 892                 Log("vp->vop = { com = { ver=%u, prog=%d, com=%d, reason=%d, len=%u, flags=0x%x }, vop = { vol=%u, part='%s' } }\n",
 893                     vp->pending_vol_op->com.proto_version,
 894                     vp->pending_vol_op->com.programType,
 895                     vp->pending_vol_op->com.command,
 896                     vp->pending_vol_op->com.reason,
 897                     vp->pending_vol_op->com.command_len,
 898                     vp->pending_vol_op->com.flags,
 899                     vp->pending_vol_op->vop.volume,
 900                     vp->pending_vol_op->vop.partName );
 901                 Log("vcom = { com = { ver=%u, prog=%d, com=%d, reason=%d, len=%u, flags=0x%x } , vop = { vol=%u, part='%s' } }\n",
 902                     vcom->hdr->proto_version,
 903                     vcom->hdr->programType,
 904                     vcom->hdr->command,
 905                     vcom->hdr->reason,
 906                     vcom->hdr->command_len,
 907                     vcom->hdr->flags,
 908                     vcom->vop->volume,
 909                     vcom->vop->partName);
 910                 res->hdr.reason = FSYNC_EXCLUSIVE;
 911                 goto deny;
 912             } else {
 913                 Log("warning: volume %u recursively checked out by programType id %d\n",
 914                     vp->hashid, vcom->hdr->programType);
 915             }
 916         }
 917
 918         /* wait for exclusive ops, so we have an accurate picture of the
 919          * vol attach state */
 920         VCreateReservation_r(vp);
 921         VWaitExclusiveState_r(vp);
 922         rvp = vp;
 923
 924         /* filter based upon requestor
 925          *
 926          * volume utilities / volserver are not allowed to check out
 927          * volumes which are in an error state
 928          *
 929          * unknown utility programs will be denied on principal
 930          */
 931         switch (type) {
 932         case salvageServer:
 933             /* it is possible for the salvageserver to checkout a
 934              * volume for salvage before its scheduling request
 935              * has been sent to the salvageserver */
 936             if (vp->salvage.requested && !vp->salvage.scheduled) {
 937                 vp->salvage.scheduled = 1;
 938             }
 939
 940             /* If the volume is in VOL_STATE_SALVAGE_REQ, we need to wait
 941              * for the vol to go offline before we can give it away. Also
 942              * make sure we don't come out with vp in an excl state. */
 943             while (V_attachState(vp) == VOL_STATE_SALVAGE_REQ ||
 944                    VIsExclusiveState(V_attachState(vp))) {
 945
 946                 VOL_CV_WAIT(&V_attachCV(vp));
 947             }
 948
 949         case debugUtility:
 950             break;
 951
 952         case volumeUtility:
 953         case volumeServer:
 954             if (VIsSalvaging(vp)) {
 955                 Log("denying offline request for volume %lu; volume is in salvaging state\n",
 956                     afs_printable_uint32_lu(vp->hashid));
 957                 res->hdr.reason = FSYNC_SALVAGE;
 958
 959                 /* the volume hasn't been checked out yet by the salvager,
 960                  * but we think the volume is salvaging; schedule a
 961                  * a salvage to update the salvage priority */
 962                 FSYNC_backgroundSalvage(vp);
 963
 964                 goto deny;
 965             }
 966             if (VIsErrorState(V_attachState(vp))) {
 967                 goto deny;
 968             }
 969             break;
 970
 971         default:
 972             Log("bad program type passed to FSSYNC\n");
 973             goto deny;
 974         }
 975
 976         /* short circuit for offline volume states
 977          * so we can avoid I/O penalty of attachment */
 978         switch (V_attachState(vp)) {
 979         case VOL_STATE_UNATTACHED:
 980         case VOL_STATE_PREATTACHED:
 981         case VOL_STATE_SALVAGING:
 982         case VOL_STATE_ERROR:
 983         case VOL_STATE_DELETED:
 984             /* register the volume operation metadata with the volume
 985              *
 986              * if the volume is currently pre-attached, attach2()
 987              * will evaluate the vol op metadata to determine whether
 988              * attaching the volume would be safe */
 989             VRegisterVolOp_r(vp, &info);
 990             vp->pending_vol_op->vol_op_state = FSSYNC_VolOpRunningUnknown;
 991             goto done;
 992         default:
 993             break;
 994         }
 995
 996         /* convert to heavyweight ref */
 997         nvp = VGetVolumeByVp_r(&error, vp);
 998         if (!nvp) {
 999             /*
1000              * It's possible for VGetVolumeByVp_r to have dropped and
1001              * re-acquired VOL_LOCK, so volume state may have changed
1002              * back to one of the states we tested for above. Since
1003              * GetVolume can return NULL in some of those states, just
1004              * test for the states again here.
1005              */
1006             switch (V_attachState(vp)) {
1007             case VOL_STATE_UNATTACHED:
1008             case VOL_STATE_PREATTACHED:
1009             case VOL_STATE_SALVAGING:
1010             case VOL_STATE_ERROR:
1011             case VOL_STATE_DELETED:
1012                 /* register the volume operation metadata with the volume
1013                  *
1014                  * if the volume is currently pre-attached, attach2()
1015                  * will evaluate the vol op metadata to determine whether
1016                  * attaching the volume would be safe */
1017                 VRegisterVolOp_r(vp, &info);
1018                 vp->pending_vol_op->vol_op_state = FSSYNC_VolOpRunningUnknown;
1019                 goto done;
1020             default:
1021                 break;
1022             }
1023
1024             Log("FSYNC_com_VolOff: failed to get heavyweight reference to volume %u (state=%u, flags=0x%x)\n",
1025                 vcom->vop->volume, V_attachState(vp), V_attachFlags(vp));
1026             res->hdr.reason = FSYNC_VOL_PKG_ERROR;
1027             goto deny;
1028         } else if (nvp != vp) {
1029             /* i don't think this should ever happen, but just in case... */
1030             Log("FSYNC_com_VolOff: warning: potentially dangerous race detected\n");
1031             vp = nvp;
1032         }
1033
1034         /* kill off lightweight ref to ensure we can't deadlock against ourselves later... */
1035         VCancelReservation_r(rvp);
1036         rvp = NULL;
1037
1038         /* register the volume operation metadata with the volume */
1039         VRegisterVolOp_r(vp, &info);
1040
1041     }
1042 #endif /* AFS_DEMAND_ATTACH_FS */
1043
1044     if (vp) {
1045         if (VVolOpLeaveOnline_r(vp, &info)) {
1046             VUpdateVolume_r(&error, vp, VOL_UPDATE_WAIT);       /* At least get volume stats right */
1047             if (LogLevel) {
1048                 Log("FSYNC: Volume %u (%s) was left on line for an external %s request\n",
1049                     V_id(vp), V_name(vp),
1050                     vcom->hdr->reason == V_CLONE ? "clone" :
1051                     vcom->hdr->reason == V_READONLY ? "readonly" :
1052                     vcom->hdr->reason == V_DUMP ? "dump" :
1053                     vcom->hdr->reason == FSYNC_SALVAGE ? "salvage" :
1054                     "UNKNOWN");
1055             }
1056 #ifdef AFS_DEMAND_ATTACH_FS
1057             vp->pending_vol_op->vol_op_state = FSSYNC_VolOpRunningOnline;
1058 #endif
1059             VPutVolume_r(vp);
1060         } else {
1061             if (VVolOpSetVBusy_r(vp, &info)) {
1062                 vp->specialStatus = VBUSY;
1063             }
1064
1065             /* remember what volume we got, so we can keep track of how
1066              * many volumes the volserver or whatever is using.  Note that
1067              * vp is valid since leaveonline is only set when vp is valid.
1068              */
1069             if (vcom->v) {
1070                 vcom->v->volumeID = vcom->vop->volume;
1071                 strlcpy(vcom->v->partName, vp->partition->name, sizeof(vcom->v->partName));
1072             }
1073
1074 #ifdef AFS_DEMAND_ATTACH_FS
1075             VCreateReservation_r(vp);
1076             VOfflineForVolOp_r(&error, vp, "A volume utility is running.");
1077             if (error==0) {
1078                 osi_Assert(vp->nUsers==0);
1079                 vp->pending_vol_op->vol_op_state = FSSYNC_VolOpRunningOffline;
1080             }
1081             else {
1082                 VWaitExclusiveState_r(vp);
1083                 VDeregisterVolOp_r(vp);
1084                 code = SYNC_DENIED;
1085             }
1086             VCancelReservation_r(vp);
1087 #else
1088             VOffline_r(vp, "A volume utility is running.");
1089 #endif
1090             vp = NULL;
1091         }
1092     }
1093     goto done;
1094
1095  deny:
1096     code = SYNC_DENIED;
1097
1098  done:
1099 #ifdef AFS_DEMAND_ATTACH_FS
1100     if (rvp) {
1101         VCancelReservation_r(rvp);
1102     }
1103 #endif
1104     return code;
1105 }
1106
1107 /**
1108  * service an FSYNC request to mark a volume as moved.
1109  *
1110  * @param[in]   vcom  pointer command object
1111  * @param[out]  res   object in which to store response packet
1112  *
1113  * @return operation status
1114  *   @retval SYNC_OK volume marked as moved to a remote server
1115  *   @retval SYNC_FAILED invalid command protocol message
1116  *   @retval SYNC_DENIED current volume state does not permit this operation
1117  *
1118  * @note this is an FSYNC RPC server stub
1119  *
1120  * @note this operation also breaks all callbacks for the given volume
1121  *
1122  * @note this procedure handles the following FSSYNC command codes:
1123  *       - FSYNC_VOL_MOVE
1124  *
1125  * @note the supplementary reason code contains additional details.  For
1126  *       instance, SYNC_OK is still returned when the partition specified
1127  *       does not match the one registered in the volume object -- reason
1128  *       will be FSYNC_WRONG_PART in this case.
1129  *
1130  * @internal
1131  */
1132 static afs_int32
1133 FSYNC_com_VolMove(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1134 {
1135     afs_int32 code = SYNC_DENIED;
1136     Error error;
1137     Volume * vp;
1138
1139     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
1140         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1141         code = SYNC_FAILED;
1142         goto done;
1143     }
1144
1145     /* Yuch:  the "reason" for the move is the site it got moved to... */
1146     /* still set specialStatus so we stop sending back VBUSY.
1147      * also should still break callbacks.  Note that I don't know
1148      * how to tell if we should break all or not, so we just do it
1149      * since it doesn't matter much if we do an extra break
1150      * volume callbacks on a volume move within the same server */
1151 #ifdef AFS_DEMAND_ATTACH_FS
1152     vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
1153 #else
1154     vp = VGetVolume_r(&error, vcom->vop->volume);
1155 #endif
1156     if (vp) {
1157         if (FSYNC_partMatch(vcom, vp, 1)) {
1158 #ifdef AFS_DEMAND_ATTACH_FS
1159             if ((V_attachState(vp) == VOL_STATE_UNATTACHED) ||
1160                 (V_attachState(vp) == VOL_STATE_PREATTACHED)) {
1161 #endif
1162                 code = SYNC_OK;
1163                 vp->specialStatus = VMOVED;
1164 #ifdef AFS_DEMAND_ATTACH_FS
1165             } else {
1166                 res->hdr.reason = FSYNC_BAD_STATE;
1167             }
1168 #endif
1169         } else {
1170             res->hdr.reason = FSYNC_WRONG_PART;
1171         }
1172 #ifndef AFS_DEMAND_ATTACH_FS
1173         VPutVolume_r(vp);
1174 #endif /* !AFS_DEMAND_ATTACH_FS */
1175     } else {
1176         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1177     }
1178
1179     if ((code == SYNC_OK) && (V_BreakVolumeCallbacks != NULL)) {
1180         Log("fssync: volume %u moved to %x; breaking all call backs\n",
1181             vcom->vop->volume, vcom->hdr->reason);
1182         VOL_UNLOCK;
1183         (*V_BreakVolumeCallbacks) (vcom->vop->volume);
1184         VOL_LOCK;
1185     }
1186
1187
1188  done:
1189     return code;
1190 }
1191
1192 /**
1193  * service an FSYNC request to mark a volume as destroyed.
1194  *
1195  * @param[in]   vcom  pointer command object
1196  * @param[out]  res   object in which to store response packet
1197  *
1198  * @return operation status
1199  *   @retval SYNC_OK volume marked as destroyed
1200  *   @retval SYNC_FAILED invalid command protocol message
1201  *   @retval SYNC_DENIED current volume state does not permit this operation
1202  *
1203  * @note this is an FSYNC RPC server stub
1204  *
1205  * @note this procedure handles the following FSSYNC command codes:
1206  *       - FSYNC_VOL_DONE
1207  *
1208  * @note the supplementary reason code contains additional details.  For
1209  *       instance, SYNC_OK is still returned when the partition specified
1210  *       does not match the one registered in the volume object -- reason
1211  *       will be FSYNC_WRONG_PART in this case.
1212  *
1213  * @internal
1214  */
1215 static afs_int32
1216 FSYNC_com_VolDone(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1217 {
1218     afs_int32 code = SYNC_FAILED;
1219     Error error;
1220     Volume * vp;
1221
1222     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
1223         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1224         goto done;
1225     }
1226
1227     /* don't try to put online, this call is made only after deleting
1228      * a volume, in which case we want to remove the vol # from the
1229      * OfflineVolumes array only */
1230     if (vcom->v)
1231         vcom->v->volumeID = 0;
1232
1233     vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
1234     if (vp) {
1235         if (FSYNC_partMatch(vcom, vp, 1)) {
1236 #ifdef AFS_DEMAND_ATTACH_FS
1237             VCreateReservation_r(vp);
1238             VWaitExclusiveState_r(vp);
1239
1240             if ((V_attachState(vp) == VOL_STATE_UNATTACHED) ||
1241                 (V_attachState(vp) == VOL_STATE_PREATTACHED) ||
1242                 VIsErrorState(V_attachState(vp))) {
1243
1244                 /* Change state to DELETED, not UNATTACHED, so clients get
1245                  * a VNOVOL error when they try to access from now on. */
1246
1247                 VChangeState_r(vp, VOL_STATE_DELETED);
1248                 VDeregisterVolOp_r(vp);
1249
1250                 /* Volume is gone; clear out old salvage stats */
1251                 memset(&vp->salvage, 0, sizeof(vp->salvage));
1252
1253                 /* Someday we should free the vp, too, after about 2 hours,
1254                  * possibly by putting the vp back on the VLRU. */
1255
1256                 code = SYNC_OK;
1257             } else if (V_attachState(vp) == VOL_STATE_DELETED) {
1258                 VDeregisterVolOp_r(vp);
1259                 res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1260
1261             } else {
1262                 code = SYNC_DENIED;
1263                 res->hdr.reason = FSYNC_BAD_STATE;
1264             }
1265
1266             VCancelReservation_r(vp);
1267             vp = NULL;
1268 #else /* AFS_DEMAND_ATTACH_FS */
1269             if (!vp->specialStatus) {
1270                 vp->specialStatus = VNOVOL;
1271             }
1272             code = SYNC_OK;
1273 #endif /* !AFS_DEMAND_ATTACH_FS */
1274         } else {
1275             code = SYNC_OK; /* XXX is this really a good idea? */
1276             res->hdr.reason = FSYNC_WRONG_PART;
1277         }
1278     } else {
1279         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1280     }
1281
1282  done:
1283     return code;
1284 }
1285
1286 #ifdef AFS_DEMAND_ATTACH_FS
1287 /**
1288  * service an FSYNC request to transition a volume to the hard error state.
1289  *
1290  * @param[in]   vcom  pointer command object
1291  * @param[out]  res   object in which to store response packet
1292  *
1293  * @return operation status
1294  *   @retval SYNC_OK volume transitioned to hard error state
1295  *   @retval SYNC_FAILED invalid command protocol message
1296  *   @retval SYNC_DENIED (see note)
1297  *
1298  * @note this is an FSYNC RPC server stub
1299  *
1300  * @note this procedure handles the following FSSYNC command codes:
1301  *       - FSYNC_VOL_FORCE_ERROR
1302  *
1303  * @note SYNC_DENIED is returned in the following cases:
1304  *        - no partition name is specified (reason field set to
1305  *          FSYNC_WRONG_PART).
1306  *        - volume id not known to fileserver (reason field set
1307  *          to FSYNC_UNKNOWN_VOLID).
1308  *
1309  * @note demand attach fileserver only
1310  *
1311  * @internal
1312  */
1313 static afs_int32
1314 FSYNC_com_VolError(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1315 {
1316     Error error;
1317     Volume * vp;
1318     afs_int32 code = SYNC_FAILED;
1319
1320     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
1321         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1322         goto done;
1323     }
1324
1325     vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
1326
1327     if (!vp && vcom->hdr->reason == FSYNC_SALVAGE) {
1328         /* The requested volume doesn't seem to exist. However, it is possible
1329          * that this is triggered by trying to create or clone a volume that
1330          * was prevented from succeeding by a half-created volume in the way.
1331          * (e.g. we tried to create volume X, but volume X exists except that
1332          * its .vol header was deleted for some reason) So, still try to
1333          * a salvage for that volume ID. */
1334
1335         Log("FSYNC_com_VolError: attempting to schedule salvage for unknown "
1336             "volume %lu part %s\n", afs_printable_uint32_lu(vcom->vop->volume),
1337             vcom->vop->partName);
1338         vp = VPreAttachVolumeById_r(&error, vcom->vop->partName,
1339                                     vcom->vop->volume);
1340     }
1341
1342     if (vp) {
1343         if (FSYNC_partMatch(vcom, vp, 0)) {
1344             /* null out salvsync control state, as it's no longer relevant */
1345             memset(&vp->salvage, 0, sizeof(vp->salvage));
1346
1347             VCreateReservation_r(vp);
1348             VWaitExclusiveState_r(vp);
1349             VDeregisterVolOp_r(vp);
1350
1351             if (vcom->hdr->reason == FSYNC_SALVAGE) {
1352                 FSYNC_backgroundSalvage(vp);
1353             } else {
1354                 VChangeState_r(vp, VOL_STATE_ERROR);
1355             }
1356
1357             VCancelReservation_r(vp);
1358             vp = NULL;
1359
1360             code = SYNC_OK;
1361         } else {
1362             res->hdr.reason = FSYNC_WRONG_PART;
1363         }
1364     } else {
1365         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1366     }
1367
1368  done:
1369     return code;
1370 }
1371 #endif /* AFS_DEMAND_ATTACH_FS */
1372
1373 /**
1374  * service an FSYNC request to break all callbacks for this volume.
1375  *
1376  * @param[in]   vcom  pointer command object
1377  * @param[out]  res   object in which to store response packet
1378  *
1379  * @return operation status
1380  *   @retval SYNC_OK callback breaks scheduled for volume
1381  *
1382  * @note this is an FSYNC RPC server stub
1383  *
1384  * @note this procedure handles the following FSSYNC command codes:
1385  *       - FSYNC_VOL_BREAKCBKS
1386  *
1387  * @note demand attach fileserver only
1388  *
1389  * @todo should do partition matching
1390  *
1391  * @internal
1392  */
1393 static afs_int32
1394 FSYNC_com_VolBreakCBKs(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1395 {
1396     /* if the volume is being restored, break all callbacks on it */
1397     if (V_BreakVolumeCallbacks) {
1398         Log("fssync: breaking all call backs for volume %u\n",
1399             vcom->vop->volume);
1400         VOL_UNLOCK;
1401         (*V_BreakVolumeCallbacks) (vcom->vop->volume);
1402         VOL_LOCK;
1403     }
1404     return SYNC_OK;
1405 }
1406
1407 /**
1408  * service an FSYNC request to return the Volume object.
1409  *
1410  * @param[in]   vcom  pointer command object
1411  * @param[out]  res   object in which to store response packet
1412  *
1413  * @return operation status
1414  *   @retval SYNC_OK      volume object returned to caller
1415  *   @retval SYNC_FAILED  bad command packet, or failed to locate volume object
1416  *
1417  * @note this is an FSYNC RPC server stub
1418  *
1419  * @note this procedure handles the following FSSYNC command codes:
1420  *       - FSYNC_VOL_QUERY
1421  *
1422  * @internal
1423  */
1424 static afs_int32
1425 FSYNC_com_VolQuery(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1426 {
1427     afs_int32 code = SYNC_FAILED;
1428     Error error;
1429     Volume * vp;
1430
1431     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
1432         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1433         goto done;
1434     }
1435
1436 #ifdef AFS_DEMAND_ATTACH_FS
1437     vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
1438 #else /* !AFS_DEMAND_ATTACH_FS */
1439     vp = VGetVolume_r(&error, vcom->vop->volume);
1440 #endif /* !AFS_DEMAND_ATTACH_FS */
1441
1442     if (vp) {
1443         if (FSYNC_partMatch(vcom, vp, 1)) {
1444             if (res->payload.len >= sizeof(Volume)) {
1445                 memcpy(res->payload.buf, vp, sizeof(Volume));
1446                 res->hdr.response_len += sizeof(Volume);
1447                 code = SYNC_OK;
1448             } else {
1449                 res->hdr.reason = SYNC_REASON_PAYLOAD_TOO_BIG;
1450             }
1451         } else {
1452             res->hdr.reason = FSYNC_WRONG_PART;
1453         }
1454 #ifndef AFS_DEMAND_ATTACH_FS
1455         VPutVolume_r(vp);
1456 #endif
1457     } else {
1458         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1459     }
1460
1461  done:
1462     return code;
1463 }
1464
1465 /**
1466  * service an FSYNC request to return the Volume header.
1467  *
1468  * @param[in]   vcom  pointer command object
1469  * @param[out]  res   object in which to store response packet
1470  *
1471  * @return operation status
1472  *   @retval SYNC_OK volume header returned to caller
1473  *   @retval SYNC_FAILED  bad command packet, or failed to locate volume header
1474  *
1475  * @note this is an FSYNC RPC server stub
1476  *
1477  * @note this procedure handles the following FSSYNC command codes:
1478  *       - FSYNC_VOL_QUERY_HDR
1479  *
1480  * @internal
1481  */
1482 static afs_int32
1483 FSYNC_com_VolHdrQuery(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1484 {
1485     afs_int32 code = SYNC_FAILED;
1486     Error error;
1487     Volume * vp;
1488
1489     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
1490         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1491         goto done;
1492     }
1493     if (res->payload.len < sizeof(VolumeDiskData)) {
1494         res->hdr.reason = SYNC_REASON_PAYLOAD_TOO_BIG;
1495         goto done;
1496     }
1497
1498 #ifdef AFS_DEMAND_ATTACH_FS
1499     vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
1500 #else /* !AFS_DEMAND_ATTACH_FS */
1501     vp = VGetVolume_r(&error, vcom->vop->volume);
1502 #endif
1503
1504     if (vp) {
1505         if (FSYNC_partMatch(vcom, vp, 1)) {
1506 #ifdef AFS_DEMAND_ATTACH_FS
1507             if ((vp->header == NULL) ||
1508                 !(V_attachFlags(vp) & VOL_HDR_ATTACHED) ||
1509                 !(V_attachFlags(vp) & VOL_HDR_LOADED)) {
1510                 res->hdr.reason = FSYNC_HDR_NOT_ATTACHED;
1511                 goto cleanup;
1512             }
1513 #else /* !AFS_DEMAND_ATTACH_FS */
1514             if (!vp || !vp->header) {
1515                 res->hdr.reason = FSYNC_HDR_NOT_ATTACHED;
1516                 goto cleanup;
1517             }
1518 #endif /* !AFS_DEMAND_ATTACH_FS */
1519         } else {
1520             res->hdr.reason = FSYNC_WRONG_PART;
1521             goto cleanup;
1522         }
1523     } else {
1524         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1525         goto done;
1526     }
1527
1528     memcpy(res->payload.buf, &V_disk(vp), sizeof(VolumeDiskData));
1529     res->hdr.response_len += sizeof(VolumeDiskData);
1530     code = SYNC_OK;
1531
1532  cleanup:
1533 #ifndef AFS_DEMAND_ATTACH_FS
1534     VPutVolume_r(vp);
1535 #endif
1536
1537  done:
1538     return code;
1539 }
1540
1541 #ifdef AFS_DEMAND_ATTACH_FS
1542 static afs_int32
1543 FSYNC_com_VolOpQuery(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1544 {
1545     afs_int32 code = SYNC_OK;
1546     Error error;
1547     Volume * vp;
1548
1549     vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
1550
1551     if (vp && vp->pending_vol_op) {
1552         osi_Assert(sizeof(FSSYNC_VolOp_info) <= res->payload.len);
1553         memcpy(res->payload.buf, vp->pending_vol_op, sizeof(FSSYNC_VolOp_info));
1554         res->hdr.response_len += sizeof(FSSYNC_VolOp_info);
1555     } else {
1556         if (!vp || V_attachState(vp) == VOL_STATE_DELETED) {
1557             res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1558         } else if (!FSYNC_partMatch(vcom, vp, 1)) {
1559             res->hdr.reason = FSYNC_WRONG_PART;
1560         } else {
1561             res->hdr.reason = FSYNC_NO_PENDING_VOL_OP;
1562         }
1563         code = SYNC_FAILED;
1564     }
1565     return code;
1566 }
1567
1568 static afs_int32
1569 FSYNC_com_VGQuery(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1570 {
1571     afs_int32 code = SYNC_FAILED;
1572     int rc;
1573     struct DiskPartition64 * dp;
1574
1575     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
1576         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1577         goto done;
1578     }
1579
1580     dp = VGetPartition_r(vcom->vop->partName, 0);
1581     if (dp == NULL) {
1582         res->hdr.reason = FSYNC_BAD_PART;
1583         goto done;
1584     }
1585
1586     osi_Assert(sizeof(FSSYNC_VGQry_response_t) <= res->payload.len);
1587
1588     rc = VVGCache_query_r(dp, vcom->vop->volume, res->payload.buf);
1589     switch (rc) {
1590     case 0:
1591         res->hdr.response_len += sizeof(FSSYNC_VGQry_response_t);
1592         code = SYNC_OK;
1593         break;
1594     case EAGAIN:
1595         res->hdr.reason = FSYNC_PART_SCANNING;
1596         break;
1597     case ENOENT:
1598         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1599         break;
1600     default:
1601         break;
1602     }
1603
1604  done:
1605     return code;
1606 }
1607
1608 static afs_int32
1609 FSYNC_com_VGUpdate(osi_socket fd, SYNC_command * com, SYNC_response * res)
1610 {
1611     afs_int32 code = SYNC_FAILED;
1612     struct DiskPartition64 * dp;
1613     FSSYNC_VGUpdate_command_t * vgucom;
1614     int rc;
1615
1616     if (com->recv_len != (sizeof(com->hdr) + sizeof(*vgucom))) {
1617         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1618         res->hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
1619         code = SYNC_COM_ERROR;
1620         goto done;
1621     }
1622
1623     vgucom = com->payload.buf;
1624
1625     ViceLog(125, ("FSYNC_com_VGUpdate: fd %d got command for parent %lu child "
1626                   "%lu partName %.16s\n", (int)fd,
1627                   afs_printable_uint32_lu(vgucom->parent),
1628                   afs_printable_uint32_lu(vgucom->child),
1629                   vgucom->partName));
1630
1631     if (SYNC_verifyProtocolString(vgucom->partName, sizeof(vgucom->partName))) {
1632         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1633         goto done;
1634     }
1635
1636     dp = VGetPartition_r(vgucom->partName, 0);
1637     if (dp == NULL) {
1638         res->hdr.reason = FSYNC_BAD_PART;
1639         goto done;
1640     }
1641
1642     switch(com->hdr.command) {
1643     case FSYNC_VG_ADD:
1644         rc = VVGCache_entry_add_r(dp, vgucom->parent, vgucom->child, NULL);
1645         break;
1646
1647     case FSYNC_VG_DEL:
1648         rc = VVGCache_entry_del_r(dp, vgucom->parent, vgucom->child);
1649         break;
1650
1651     default:
1652         Log("FSYNC_com_VGUpdate called improperly\n");
1653         rc = -1;
1654         break;
1655     }
1656
1657     /* EINVAL means the partition VGC doesn't exist at all; not really
1658      * an error */
1659     if (rc == 0 || rc == EINVAL) {
1660         code = SYNC_OK;
1661     }
1662
1663     if (rc == ENOENT) {
1664         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1665     } else {
1666         res->hdr.reason = FSYNC_WHATEVER;
1667     }
1668
1669  done:
1670     return code;
1671 }
1672
1673 static afs_int32
1674 FSYNC_com_VGScan(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1675 {
1676     afs_int32 code = SYNC_FAILED;
1677     struct DiskPartition64 * dp;
1678
1679     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
1680         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1681         goto done;
1682     }
1683
1684     dp = VGetPartition_r(vcom->vop->partName, 0);
1685     if (dp == NULL) {
1686         res->hdr.reason = FSYNC_BAD_PART;
1687         goto done;
1688     }
1689
1690     if (VVGCache_scanStart_r(dp) == 0) {
1691         code = SYNC_OK;
1692     }
1693
1694  done:
1695     return code;
1696 }
1697
1698 static afs_int32
1699 FSYNC_com_VGScanAll(FSSYNC_VolOp_command * com, SYNC_response * res)
1700 {
1701     afs_int32 code = SYNC_FAILED;
1702
1703     if (VVGCache_scanStart_r(NULL) == 0) {
1704         code = SYNC_OK;
1705     }
1706
1707     return code;
1708 }
1709 #endif /* AFS_DEMAND_ATTACH_FS */
1710
1711 static afs_int32
1712 FSYNC_com_VnQry(osi_socket fd, SYNC_command * com, SYNC_response * res)
1713 {
1714     afs_int32 code = SYNC_OK;
1715     FSSYNC_VnQry_hdr * qry = com->payload.buf;
1716     Volume * vp;
1717     Vnode * vnp;
1718     Error error;
1719
1720     if (com->recv_len != (sizeof(com->hdr) + sizeof(FSSYNC_VnQry_hdr))) {
1721         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1722         res->hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
1723         return SYNC_COM_ERROR;
1724     }
1725
1726     ViceLog(125, ("FSYNC_com_VnQry: fd %d got command for vol %lu vnode %lu "
1727                   "uniq %lu spare %lu partName %.16s\n", (int)fd,
1728                   afs_printable_uint32_lu(qry->volume),
1729                   afs_printable_uint32_lu(qry->vnode),
1730                   afs_printable_uint32_lu(qry->unique),
1731                   afs_printable_uint32_lu(qry->spare),
1732                   qry->partName));
1733
1734 #ifdef AFS_DEMAND_ATTACH_FS
1735     vp = VLookupVolume_r(&error, qry->volume, NULL);
1736 #else /* !AFS_DEMAND_ATTACH_FS */
1737     vp = VGetVolume_r(&error, qry->volume);
1738 #endif /* !AFS_DEMAND_ATTACH_FS */
1739
1740     if (!vp) {
1741         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1742         code = SYNC_FAILED;
1743         goto done;
1744     }
1745
1746     vnp = VLookupVnode(vp, qry->vnode);
1747     if (!vnp) {
1748         res->hdr.reason = FSYNC_UNKNOWN_VNID;
1749         code = SYNC_FAILED;
1750         goto cleanup;
1751     }
1752
1753     if (Vn_class(vnp)->residentSize > res->payload.len) {
1754         res->hdr.reason = SYNC_REASON_ENCODING_ERROR;
1755         code = SYNC_FAILED;
1756         goto cleanup;
1757     }
1758
1759     memcpy(res->payload.buf, vnp, Vn_class(vnp)->residentSize);
1760     res->hdr.response_len += Vn_class(vnp)->residentSize;
1761
1762  cleanup:
1763 #ifndef AFS_DEMAND_ATTACH_FS
1764     VPutVolume_r(vp);
1765 #endif
1766
1767  done:
1768     return code;
1769 }
1770
1771 static afs_int32
1772 FSYNC_com_StatsOp(osi_socket fd, SYNC_command * com, SYNC_response * res)
1773 {
1774     afs_int32 code = SYNC_OK;
1775     FSSYNC_StatsOp_command scom;
1776
1777     if (com->recv_len != (sizeof(com->hdr) + sizeof(FSSYNC_StatsOp_hdr))) {
1778         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1779         res->hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
1780         return SYNC_COM_ERROR;
1781     }
1782
1783     scom.hdr = &com->hdr;
1784     scom.sop = (FSSYNC_StatsOp_hdr *) com->payload.buf;
1785     scom.com = com;
1786
1787     ViceLog(125, ("FSYNC_com_StatsOp: fd %d got command for stats: "
1788                   "{vlru_generation = %lu, hash_bucket = %lu, partName = "
1789                   "%.16s}\n", (int)fd,
1790                   afs_printable_uint32_lu(scom.sop->args.vlru_generation),
1791                   afs_printable_uint32_lu(scom.sop->args.hash_bucket),
1792                   scom.sop->args.partName));
1793
1794     switch (com->hdr.command) {
1795     case FSYNC_VOL_STATS_GENERAL:
1796         code = FSYNC_com_StatsOpGeneral(&scom, res);
1797         break;
1798 #ifdef AFS_DEMAND_ATTACH_FS
1799         /* statistics for the following subsystems are only tracked
1800          * for demand attach fileservers */
1801     case FSYNC_VOL_STATS_VICEP:
1802         code = FSYNC_com_StatsOpViceP(&scom, res);
1803         break;
1804     case FSYNC_VOL_STATS_HASH:
1805         code = FSYNC_com_StatsOpHash(&scom, res);
1806         break;
1807     case FSYNC_VOL_STATS_HDR:
1808         code = FSYNC_com_StatsOpHdr(&scom, res);
1809         break;
1810     case FSYNC_VOL_STATS_VLRU:
1811         code = FSYNC_com_StatsOpVLRU(&scom, res);
1812         break;
1813 #endif /* AFS_DEMAND_ATTACH_FS */
1814     default:
1815         code = SYNC_BAD_COMMAND;
1816     }
1817
1818     return code;
1819 }
1820
1821 static afs_int32
1822 FSYNC_com_StatsOpGeneral(FSSYNC_StatsOp_command * scom, SYNC_response * res)
1823 {
1824     afs_int32 code = SYNC_OK;
1825
1826     memcpy(res->payload.buf, &VStats, sizeof(VStats));
1827     res->hdr.response_len += sizeof(VStats);
1828
1829     return code;
1830 }
1831
1832 #ifdef AFS_DEMAND_ATTACH_FS
1833 static afs_int32
1834 FSYNC_com_StatsOpViceP(FSSYNC_StatsOp_command * scom, SYNC_response * res)
1835 {
1836     afs_int32 code = SYNC_OK;
1837     struct DiskPartition64 * dp;
1838     struct DiskPartitionStats64 * stats;
1839
1840     if (SYNC_verifyProtocolString(scom->sop->args.partName, sizeof(scom->sop->args.partName))) {
1841         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1842         code = SYNC_FAILED;
1843         goto done;
1844     }
1845
1846     dp = VGetPartition_r(scom->sop->args.partName, 0);
1847     if (!dp) {
1848         code = SYNC_FAILED;
1849     } else {
1850         stats = (struct DiskPartitionStats64 *) res->payload.buf;
1851         stats->free = dp->free;
1852         stats->totalUsable = dp->totalUsable;
1853         stats->minFree = dp->minFree;
1854         stats->f_files = dp->f_files;
1855         stats->vol_list_len = dp->vol_list.len;
1856
1857         res->hdr.response_len += sizeof(struct DiskPartitionStats64);
1858     }
1859
1860  done:
1861     return code;
1862 }
1863
1864 static afs_int32
1865 FSYNC_com_StatsOpHash(FSSYNC_StatsOp_command * scom, SYNC_response * res)
1866 {
1867     afs_int32 code = SYNC_OK;
1868     struct VolumeHashChainStats * stats;
1869     struct VolumeHashChainHead * head;
1870
1871     if (scom->sop->args.hash_bucket >= VolumeHashTable.Size) {
1872         return SYNC_FAILED;
1873     }
1874
1875     head = &VolumeHashTable.Table[scom->sop->args.hash_bucket];
1876     stats = (struct VolumeHashChainStats *) res->payload.buf;
1877     stats->table_size = VolumeHashTable.Size;
1878     stats->chain_len = head->len;
1879     stats->chain_cacheCheck = head->cacheCheck;
1880     stats->chain_busy = head->busy;
1881     AssignInt64(head->looks, &stats->chain_looks);
1882     AssignInt64(head->gets, &stats->chain_gets);
1883     AssignInt64(head->reorders, &stats->chain_reorders);
1884
1885     res->hdr.response_len += sizeof(struct VolumeHashChainStats);
1886
1887     return code;
1888 }
1889
1890 static afs_int32
1891 FSYNC_com_StatsOpHdr(FSSYNC_StatsOp_command * scom, SYNC_response * res)
1892 {
1893     afs_int32 code = SYNC_OK;
1894
1895     memcpy(res->payload.buf, &volume_hdr_LRU.stats, sizeof(volume_hdr_LRU.stats));
1896     res->hdr.response_len += sizeof(volume_hdr_LRU.stats);
1897
1898     return code;
1899 }
1900
1901 static afs_int32
1902 FSYNC_com_StatsOpVLRU(FSSYNC_StatsOp_command * scom, SYNC_response * res)
1903 {
1904     afs_int32 code = SYNC_OK;
1905
1906     code = SYNC_BAD_COMMAND;
1907
1908     return code;
1909 }
1910 #endif /* AFS_DEMAND_ATTACH_FS */
1911
1912 /**
1913  * populate an FSSYNC_VolOp_info object from a command packet object.
1914  *
1915  * @param[in]   vcom  pointer to command packet
1916  * @param[out]  info  pointer to info object which will be populated
1917  *
1918  * @note FSSYNC_VolOp_info objects are attached to Volume objects when
1919  *       a volume operation is commenced.
1920  *
1921  * @internal
1922  */
1923 static void
1924 FSYNC_com_to_info(FSSYNC_VolOp_command * vcom, FSSYNC_VolOp_info * info)
1925 {
1926     memcpy(&info->com, vcom->hdr, sizeof(SYNC_command_hdr));
1927     memcpy(&info->vop, vcom->vop, sizeof(FSSYNC_VolOp_hdr));
1928     info->vol_op_state = FSSYNC_VolOpPending;
1929 }
1930
1931 /**
1932  * check whether command packet partition name matches volume
1933  * object's partition name.
1934  *
1935  * @param[in] vcom        pointer to command packet
1936  * @param[in] vp          pointer to volume object
1937  * @param[in] match_anon  anon matching control flag (see note below)
1938  *
1939  * @return whether partitions match
1940  *   @retval 0  partitions do NOT match
1941  *   @retval 1  partitions match
1942  *
1943  * @note if match_anon is non-zero, then this function will return a
1944  *       positive match for a zero-length partition string in the
1945  *       command packet.
1946  *
1947  * @internal
1948  */
1949 static int
1950 FSYNC_partMatch(FSSYNC_VolOp_command * vcom, Volume * vp, int match_anon)
1951 {
1952     return ((match_anon && vcom->vop->partName[0] == 0) ||
1953             (strncmp(vcom->vop->partName, V_partition(vp)->name,
1954                      sizeof(vcom->vop->partName)) == 0));
1955 }
1956
1957
1958 static void
1959 FSYNC_Drop(osi_socket fd)
1960 {
1961     struct offlineInfo *p;
1962     int i;
1963     Error error;
1964     char tvolName[VMAXPATHLEN];
1965
1966     VOL_LOCK;
1967     p = OfflineVolumes[FindHandler(fd)];
1968     for (i = 0; i < MAXOFFLINEVOLUMES; i++) {
1969         if (p[i].volumeID) {
1970
1971             Volume *vp;
1972
1973             tvolName[0] = OS_DIRSEPC;
1974             sprintf(&tvolName[1], VFORMAT, afs_printable_uint32_lu(p[i].volumeID));
1975             vp = VAttachVolumeByName_r(&error, p[i].partName, tvolName,
1976                                        V_VOLUPD);
1977             if (vp)
1978                 VPutVolume_r(vp);
1979             p[i].volumeID = 0;
1980         }
1981     }
1982     VOL_UNLOCK;
1983     RemoveHandler(fd);
1984 #ifdef AFS_NT40_ENV
1985     closesocket(fd);
1986 #else
1987     close(fd);
1988 #endif
1989     AcceptOn();
1990 }
1991
1992 static int AcceptHandler = -1;  /* handler id for accept, if turned on */
1993
1994 static void
1995 AcceptOn(void)
1996 {
1997     if (AcceptHandler == -1) {
1998         osi_Assert(AddHandler(fssync_server_state.fd, FSYNC_newconnection));
1999         AcceptHandler = FindHandler(fssync_server_state.fd);
2000     }
2001 }
2002
2003 static void
2004 AcceptOff(void)
2005 {
2006     if (AcceptHandler != -1) {
2007         osi_Assert(RemoveHandler(fssync_server_state.fd));
2008         AcceptHandler = -1;
2009     }
2010 }
2011
2012 /* The multiple FD handling code. */
2013
2014 static osi_socket HandlerFD[MAXHANDLERS];
2015 static void (*HandlerProc[MAXHANDLERS]) (osi_socket);
2016
2017 static void
2018 InitHandler(void)
2019 {
2020     int i;
2021     ObtainWriteLock(&FSYNC_handler_lock);
2022     for (i = 0; i < MAXHANDLERS; i++) {
2023         HandlerFD[i] = OSI_NULLSOCKET;
2024         HandlerProc[i] = 0;
2025     }
2026     ReleaseWriteLock(&FSYNC_handler_lock);
2027 }
2028
2029 #if defined(HAVE_POLL) && defined(AFS_PTHREAD_ENV)
2030 static void
2031 CallHandler(struct pollfd *fds, int nfds, int mask)
2032 {
2033     int i;
2034     int handler;
2035     ObtainReadLock(&FSYNC_handler_lock);
2036     for (i = 0; i < nfds; i++) {
2037         if (fds[i].revents & mask) {
2038             handler = FindHandler_r(fds[i].fd);
2039             ReleaseReadLock(&FSYNC_handler_lock);
2040             (*HandlerProc[handler]) (fds[i].fd);
2041             ObtainReadLock(&FSYNC_handler_lock);
2042         }
2043     }
2044     ReleaseReadLock(&FSYNC_handler_lock);
2045 }
2046 #else
2047 static void
2048 CallHandler(fd_set * fdsetp)
2049 {
2050     int i;
2051     ObtainReadLock(&FSYNC_handler_lock);
2052     for (i = 0; i < MAXHANDLERS; i++) {
2053         if (HandlerFD[i] >= 0 && FD_ISSET(HandlerFD[i], fdsetp)) {
2054             ReleaseReadLock(&FSYNC_handler_lock);
2055             (*HandlerProc[i]) (HandlerFD[i]);
2056             ObtainReadLock(&FSYNC_handler_lock);
2057         }
2058     }
2059     ReleaseReadLock(&FSYNC_handler_lock);
2060 }
2061 #endif
2062
2063 static int
2064 AddHandler(osi_socket afd, void (*aproc) (osi_socket))
2065 {
2066     int i;
2067     ObtainWriteLock(&FSYNC_handler_lock);
2068     for (i = 0; i < MAXHANDLERS; i++)
2069         if (HandlerFD[i] == OSI_NULLSOCKET)
2070             break;
2071     if (i >= MAXHANDLERS) {
2072         ReleaseWriteLock(&FSYNC_handler_lock);
2073         return 0;
2074     }
2075     HandlerFD[i] = afd;
2076     HandlerProc[i] = aproc;
2077     ReleaseWriteLock(&FSYNC_handler_lock);
2078     return 1;
2079 }
2080
2081 static int
2082 FindHandler(osi_socket afd)
2083 {
2084     int i;
2085     ObtainReadLock(&FSYNC_handler_lock);
2086     for (i = 0; i < MAXHANDLERS; i++)
2087         if (HandlerFD[i] == afd) {
2088             ReleaseReadLock(&FSYNC_handler_lock);
2089             return i;
2090         }
2091     ReleaseReadLock(&FSYNC_handler_lock);       /* just in case */
2092     osi_Assert(1 == 2);
2093     return -1;                  /* satisfy compiler */
2094 }
2095
2096 static int
2097 FindHandler_r(osi_socket afd)
2098 {
2099     int i;
2100     for (i = 0; i < MAXHANDLERS; i++)
2101         if (HandlerFD[i] == afd) {
2102             return i;
2103         }
2104     osi_Assert(1 == 2);
2105     return -1;                  /* satisfy compiler */
2106 }
2107
2108 static int
2109 RemoveHandler(osi_socket afd)
2110 {
2111     ObtainWriteLock(&FSYNC_handler_lock);
2112     HandlerFD[FindHandler_r(afd)] = OSI_NULLSOCKET;
2113     ReleaseWriteLock(&FSYNC_handler_lock);
2114     return 1;
2115 }
2116
2117 #if defined(HAVE_POLL) && defined(AFS_PTHREAD_ENV)
2118 static void
2119 GetHandler(struct pollfd *fds, int maxfds, int events, int *nfds)
2120 {
2121     int i;
2122     int fdi = 0;
2123     ObtainReadLock(&FSYNC_handler_lock);
2124     for (i = 0; i < MAXHANDLERS; i++)
2125         if (HandlerFD[i] != OSI_NULLSOCKET) {
2126             osi_Assert(fdi<maxfds);
2127             fds[fdi].fd = HandlerFD[i];
2128             fds[fdi].events = events;
2129             fds[fdi].revents = 0;
2130             fdi++;
2131         }
2132     *nfds = fdi;
2133     ReleaseReadLock(&FSYNC_handler_lock);
2134 }
2135 #else
2136 static void
2137 GetHandler(fd_set * fdsetp, int *maxfdp)
2138 {
2139     int i;
2140     int maxfd = -1;
2141     FD_ZERO(fdsetp);
2142     ObtainReadLock(&FSYNC_handler_lock);        /* just in case */
2143     for (i = 0; i < MAXHANDLERS; i++)
2144         if (HandlerFD[i] != OSI_NULLSOCKET) {
2145             FD_SET(HandlerFD[i], fdsetp);
2146 #ifndef AFS_NT40_ENV
2147             /* On Windows the nfds parameter to select() is ignored */
2148             if (maxfd < HandlerFD[i] || maxfd == (int)-1)
2149                 maxfd = HandlerFD[i];
2150 #endif /* AFS_NT40_ENV */
2151         }
2152     *maxfdp = maxfd;
2153     ReleaseReadLock(&FSYNC_handler_lock);       /* just in case */
2154 }
2155 #endif /* HAVE_POLL && AFS_PTHREAD_ENV */
2156
2157 #endif /* FSSYNC_BUILD_SERVER */