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 {
1258                 code = SYNC_DENIED;
1259                 res->hdr.reason = FSYNC_BAD_STATE;
1260             }
1261
1262             VCancelReservation_r(vp);
1263             vp = NULL;
1264 #else /* AFS_DEMAND_ATTACH_FS */
1265             if (!vp->specialStatus) {
1266                 vp->specialStatus = VNOVOL;
1267             }
1268             code = SYNC_OK;
1269 #endif /* !AFS_DEMAND_ATTACH_FS */
1270         } else {
1271             code = SYNC_OK; /* XXX is this really a good idea? */
1272             res->hdr.reason = FSYNC_WRONG_PART;
1273         }
1274     } else {
1275         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1276     }
1277
1278  done:
1279     return code;
1280 }
1281
1282 #ifdef AFS_DEMAND_ATTACH_FS
1283 /**
1284  * service an FSYNC request to transition a volume to the hard error state.
1285  *
1286  * @param[in]   vcom  pointer command object
1287  * @param[out]  res   object in which to store response packet
1288  *
1289  * @return operation status
1290  *   @retval SYNC_OK volume transitioned to hard error state
1291  *   @retval SYNC_FAILED invalid command protocol message
1292  *   @retval SYNC_DENIED (see note)
1293  *
1294  * @note this is an FSYNC RPC server stub
1295  *
1296  * @note this procedure handles the following FSSYNC command codes:
1297  *       - FSYNC_VOL_FORCE_ERROR
1298  *
1299  * @note SYNC_DENIED is returned in the following cases:
1300  *        - no partition name is specified (reason field set to
1301  *          FSYNC_WRONG_PART).
1302  *        - volume id not known to fileserver (reason field set
1303  *          to FSYNC_UNKNOWN_VOLID).
1304  *
1305  * @note demand attach fileserver only
1306  *
1307  * @internal
1308  */
1309 static afs_int32
1310 FSYNC_com_VolError(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1311 {
1312     Error error;
1313     Volume * vp;
1314     afs_int32 code = SYNC_FAILED;
1315
1316     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
1317         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1318         goto done;
1319     }
1320
1321     vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
1322
1323     if (!vp && vcom->hdr->reason == FSYNC_SALVAGE) {
1324         /* The requested volume doesn't seem to exist. However, it is possible
1325          * that this is triggered by trying to create or clone a volume that
1326          * was prevented from succeeding by a half-created volume in the way.
1327          * (e.g. we tried to create volume X, but volume X exists except that
1328          * its .vol header was deleted for some reason) So, still try to
1329          * a salvage for that volume ID. */
1330
1331         Log("FSYNC_com_VolError: attempting to schedule salvage for unknown "
1332             "volume %lu part %s\n", afs_printable_uint32_lu(vcom->vop->volume),
1333             vcom->vop->partName);
1334         vp = VPreAttachVolumeById_r(&error, vcom->vop->partName,
1335                                     vcom->vop->volume);
1336     }
1337
1338     if (vp) {
1339         if (FSYNC_partMatch(vcom, vp, 0)) {
1340             /* null out salvsync control state, as it's no longer relevant */
1341             memset(&vp->salvage, 0, sizeof(vp->salvage));
1342
1343             VCreateReservation_r(vp);
1344             VWaitExclusiveState_r(vp);
1345             VDeregisterVolOp_r(vp);
1346
1347             if (vcom->hdr->reason == FSYNC_SALVAGE) {
1348                 FSYNC_backgroundSalvage(vp);
1349             } else {
1350                 VChangeState_r(vp, VOL_STATE_ERROR);
1351             }
1352
1353             VCancelReservation_r(vp);
1354             vp = NULL;
1355
1356             code = SYNC_OK;
1357         } else {
1358             res->hdr.reason = FSYNC_WRONG_PART;
1359         }
1360     } else {
1361         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1362     }
1363
1364  done:
1365     return code;
1366 }
1367 #endif /* AFS_DEMAND_ATTACH_FS */
1368
1369 /**
1370  * service an FSYNC request to break all callbacks for this volume.
1371  *
1372  * @param[in]   vcom  pointer command object
1373  * @param[out]  res   object in which to store response packet
1374  *
1375  * @return operation status
1376  *   @retval SYNC_OK callback breaks scheduled for volume
1377  *
1378  * @note this is an FSYNC RPC server stub
1379  *
1380  * @note this procedure handles the following FSSYNC command codes:
1381  *       - FSYNC_VOL_BREAKCBKS
1382  *
1383  * @note demand attach fileserver only
1384  *
1385  * @todo should do partition matching
1386  *
1387  * @internal
1388  */
1389 static afs_int32
1390 FSYNC_com_VolBreakCBKs(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1391 {
1392     /* if the volume is being restored, break all callbacks on it */
1393     if (V_BreakVolumeCallbacks) {
1394         Log("fssync: breaking all call backs for volume %u\n",
1395             vcom->vop->volume);
1396         VOL_UNLOCK;
1397         (*V_BreakVolumeCallbacks) (vcom->vop->volume);
1398         VOL_LOCK;
1399     }
1400     return SYNC_OK;
1401 }
1402
1403 /**
1404  * service an FSYNC request to return the Volume object.
1405  *
1406  * @param[in]   vcom  pointer command object
1407  * @param[out]  res   object in which to store response packet
1408  *
1409  * @return operation status
1410  *   @retval SYNC_OK      volume object returned to caller
1411  *   @retval SYNC_FAILED  bad command packet, or failed to locate volume object
1412  *
1413  * @note this is an FSYNC RPC server stub
1414  *
1415  * @note this procedure handles the following FSSYNC command codes:
1416  *       - FSYNC_VOL_QUERY
1417  *
1418  * @internal
1419  */
1420 static afs_int32
1421 FSYNC_com_VolQuery(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1422 {
1423     afs_int32 code = SYNC_FAILED;
1424     Error error;
1425     Volume * vp;
1426
1427     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
1428         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1429         goto done;
1430     }
1431
1432 #ifdef AFS_DEMAND_ATTACH_FS
1433     vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
1434 #else /* !AFS_DEMAND_ATTACH_FS */
1435     vp = VGetVolume_r(&error, vcom->vop->volume);
1436 #endif /* !AFS_DEMAND_ATTACH_FS */
1437
1438     if (vp) {
1439         if (FSYNC_partMatch(vcom, vp, 1)) {
1440             if (res->payload.len >= sizeof(Volume)) {
1441                 memcpy(res->payload.buf, vp, sizeof(Volume));
1442                 res->hdr.response_len += sizeof(Volume);
1443                 code = SYNC_OK;
1444             } else {
1445                 res->hdr.reason = SYNC_REASON_PAYLOAD_TOO_BIG;
1446             }
1447         } else {
1448             res->hdr.reason = FSYNC_WRONG_PART;
1449         }
1450 #ifndef AFS_DEMAND_ATTACH_FS
1451         VPutVolume_r(vp);
1452 #endif
1453     } else {
1454         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1455     }
1456
1457  done:
1458     return code;
1459 }
1460
1461 /**
1462  * service an FSYNC request to return the Volume header.
1463  *
1464  * @param[in]   vcom  pointer command object
1465  * @param[out]  res   object in which to store response packet
1466  *
1467  * @return operation status
1468  *   @retval SYNC_OK volume header returned to caller
1469  *   @retval SYNC_FAILED  bad command packet, or failed to locate volume header
1470  *
1471  * @note this is an FSYNC RPC server stub
1472  *
1473  * @note this procedure handles the following FSSYNC command codes:
1474  *       - FSYNC_VOL_QUERY_HDR
1475  *
1476  * @internal
1477  */
1478 static afs_int32
1479 FSYNC_com_VolHdrQuery(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1480 {
1481     afs_int32 code = SYNC_FAILED;
1482     Error error;
1483     Volume * vp;
1484
1485     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
1486         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1487         goto done;
1488     }
1489     if (res->payload.len < sizeof(VolumeDiskData)) {
1490         res->hdr.reason = SYNC_REASON_PAYLOAD_TOO_BIG;
1491         goto done;
1492     }
1493
1494 #ifdef AFS_DEMAND_ATTACH_FS
1495     vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
1496 #else /* !AFS_DEMAND_ATTACH_FS */
1497     vp = VGetVolume_r(&error, vcom->vop->volume);
1498 #endif
1499
1500     if (vp) {
1501         if (FSYNC_partMatch(vcom, vp, 1)) {
1502 #ifdef AFS_DEMAND_ATTACH_FS
1503             if ((vp->header == NULL) ||
1504                 !(V_attachFlags(vp) & VOL_HDR_ATTACHED) ||
1505                 !(V_attachFlags(vp) & VOL_HDR_LOADED)) {
1506                 res->hdr.reason = FSYNC_HDR_NOT_ATTACHED;
1507                 goto cleanup;
1508             }
1509 #else /* !AFS_DEMAND_ATTACH_FS */
1510             if (!vp || !vp->header) {
1511                 res->hdr.reason = FSYNC_HDR_NOT_ATTACHED;
1512                 goto cleanup;
1513             }
1514 #endif /* !AFS_DEMAND_ATTACH_FS */
1515         } else {
1516             res->hdr.reason = FSYNC_WRONG_PART;
1517             goto cleanup;
1518         }
1519     } else {
1520         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1521         goto done;
1522     }
1523
1524     memcpy(res->payload.buf, &V_disk(vp), sizeof(VolumeDiskData));
1525     res->hdr.response_len += sizeof(VolumeDiskData);
1526     code = SYNC_OK;
1527
1528  cleanup:
1529 #ifndef AFS_DEMAND_ATTACH_FS
1530     VPutVolume_r(vp);
1531 #endif
1532
1533  done:
1534     return code;
1535 }
1536
1537 #ifdef AFS_DEMAND_ATTACH_FS
1538 static afs_int32
1539 FSYNC_com_VolOpQuery(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1540 {
1541     afs_int32 code = SYNC_OK;
1542     Error error;
1543     Volume * vp;
1544
1545     vp = VLookupVolume_r(&error, vcom->vop->volume, NULL);
1546
1547     if (vp && vp->pending_vol_op) {
1548         osi_Assert(sizeof(FSSYNC_VolOp_info) <= res->payload.len);
1549         memcpy(res->payload.buf, vp->pending_vol_op, sizeof(FSSYNC_VolOp_info));
1550         res->hdr.response_len += sizeof(FSSYNC_VolOp_info);
1551     } else {
1552         if (!vp || V_attachState(vp) == VOL_STATE_DELETED) {
1553             res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1554         } else if (!FSYNC_partMatch(vcom, vp, 1)) {
1555             res->hdr.reason = FSYNC_WRONG_PART;
1556         } else {
1557             res->hdr.reason = FSYNC_NO_PENDING_VOL_OP;
1558         }
1559         code = SYNC_FAILED;
1560     }
1561     return code;
1562 }
1563
1564 static afs_int32
1565 FSYNC_com_VGQuery(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1566 {
1567     afs_int32 code = SYNC_FAILED;
1568     int rc;
1569     struct DiskPartition64 * dp;
1570
1571     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
1572         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1573         goto done;
1574     }
1575
1576     dp = VGetPartition_r(vcom->vop->partName, 0);
1577     if (dp == NULL) {
1578         res->hdr.reason = FSYNC_BAD_PART;
1579         goto done;
1580     }
1581
1582     osi_Assert(sizeof(FSSYNC_VGQry_response_t) <= res->payload.len);
1583
1584     rc = VVGCache_query_r(dp, vcom->vop->volume, res->payload.buf);
1585     switch (rc) {
1586     case 0:
1587         res->hdr.response_len += sizeof(FSSYNC_VGQry_response_t);
1588         code = SYNC_OK;
1589         break;
1590     case EAGAIN:
1591         res->hdr.reason = FSYNC_PART_SCANNING;
1592         break;
1593     case ENOENT:
1594         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1595         break;
1596     default:
1597         break;
1598     }
1599
1600  done:
1601     return code;
1602 }
1603
1604 static afs_int32
1605 FSYNC_com_VGUpdate(osi_socket fd, SYNC_command * com, SYNC_response * res)
1606 {
1607     afs_int32 code = SYNC_FAILED;
1608     struct DiskPartition64 * dp;
1609     FSSYNC_VGUpdate_command_t * vgucom;
1610     int rc;
1611
1612     if (com->recv_len != (sizeof(com->hdr) + sizeof(*vgucom))) {
1613         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1614         res->hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
1615         code = SYNC_COM_ERROR;
1616         goto done;
1617     }
1618
1619     vgucom = com->payload.buf;
1620
1621     ViceLog(125, ("FSYNC_com_VGUpdate: fd %d got command for parent %lu child "
1622                   "%lu partName %.16s\n", (int)fd,
1623                   afs_printable_uint32_lu(vgucom->parent),
1624                   afs_printable_uint32_lu(vgucom->child),
1625                   vgucom->partName));
1626
1627     if (SYNC_verifyProtocolString(vgucom->partName, sizeof(vgucom->partName))) {
1628         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1629         goto done;
1630     }
1631
1632     dp = VGetPartition_r(vgucom->partName, 0);
1633     if (dp == NULL) {
1634         res->hdr.reason = FSYNC_BAD_PART;
1635         goto done;
1636     }
1637
1638     switch(com->hdr.command) {
1639     case FSYNC_VG_ADD:
1640         rc = VVGCache_entry_add_r(dp, vgucom->parent, vgucom->child, NULL);
1641         break;
1642
1643     case FSYNC_VG_DEL:
1644         rc = VVGCache_entry_del_r(dp, vgucom->parent, vgucom->child);
1645         break;
1646
1647     default:
1648         Log("FSYNC_com_VGUpdate called improperly\n");
1649         rc = -1;
1650         break;
1651     }
1652
1653     /* EINVAL means the partition VGC doesn't exist at all; not really
1654      * an error */
1655     if (rc == 0 || rc == EINVAL) {
1656         code = SYNC_OK;
1657     }
1658
1659     if (rc == ENOENT) {
1660         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1661     } else {
1662         res->hdr.reason = FSYNC_WHATEVER;
1663     }
1664
1665  done:
1666     return code;
1667 }
1668
1669 static afs_int32
1670 FSYNC_com_VGScan(FSSYNC_VolOp_command * vcom, SYNC_response * res)
1671 {
1672     afs_int32 code = SYNC_FAILED;
1673     struct DiskPartition64 * dp;
1674
1675     if (SYNC_verifyProtocolString(vcom->vop->partName, sizeof(vcom->vop->partName))) {
1676         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1677         goto done;
1678     }
1679
1680     dp = VGetPartition_r(vcom->vop->partName, 0);
1681     if (dp == NULL) {
1682         res->hdr.reason = FSYNC_BAD_PART;
1683         goto done;
1684     }
1685
1686     if (VVGCache_scanStart_r(dp) == 0) {
1687         code = SYNC_OK;
1688     }
1689
1690  done:
1691     return code;
1692 }
1693
1694 static afs_int32
1695 FSYNC_com_VGScanAll(FSSYNC_VolOp_command * com, SYNC_response * res)
1696 {
1697     afs_int32 code = SYNC_FAILED;
1698
1699     if (VVGCache_scanStart_r(NULL) == 0) {
1700         code = SYNC_OK;
1701     }
1702
1703     return code;
1704 }
1705 #endif /* AFS_DEMAND_ATTACH_FS */
1706
1707 static afs_int32
1708 FSYNC_com_VnQry(osi_socket fd, SYNC_command * com, SYNC_response * res)
1709 {
1710     afs_int32 code = SYNC_OK;
1711     FSSYNC_VnQry_hdr * qry = com->payload.buf;
1712     Volume * vp;
1713     Vnode * vnp;
1714     Error error;
1715
1716     if (com->recv_len != (sizeof(com->hdr) + sizeof(FSSYNC_VnQry_hdr))) {
1717         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1718         res->hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
1719         return SYNC_COM_ERROR;
1720     }
1721
1722     ViceLog(125, ("FSYNC_com_VnQry: fd %d got command for vol %lu vnode %lu "
1723                   "uniq %lu spare %lu partName %.16s\n", (int)fd,
1724                   afs_printable_uint32_lu(qry->volume),
1725                   afs_printable_uint32_lu(qry->vnode),
1726                   afs_printable_uint32_lu(qry->unique),
1727                   afs_printable_uint32_lu(qry->spare),
1728                   qry->partName));
1729
1730 #ifdef AFS_DEMAND_ATTACH_FS
1731     vp = VLookupVolume_r(&error, qry->volume, NULL);
1732 #else /* !AFS_DEMAND_ATTACH_FS */
1733     vp = VGetVolume_r(&error, qry->volume);
1734 #endif /* !AFS_DEMAND_ATTACH_FS */
1735
1736     if (!vp) {
1737         res->hdr.reason = FSYNC_UNKNOWN_VOLID;
1738         code = SYNC_FAILED;
1739         goto done;
1740     }
1741
1742     vnp = VLookupVnode(vp, qry->vnode);
1743     if (!vnp) {
1744         res->hdr.reason = FSYNC_UNKNOWN_VNID;
1745         code = SYNC_FAILED;
1746         goto cleanup;
1747     }
1748
1749     if (Vn_class(vnp)->residentSize > res->payload.len) {
1750         res->hdr.reason = SYNC_REASON_ENCODING_ERROR;
1751         code = SYNC_FAILED;
1752         goto cleanup;
1753     }
1754
1755     memcpy(res->payload.buf, vnp, Vn_class(vnp)->residentSize);
1756     res->hdr.response_len += Vn_class(vnp)->residentSize;
1757
1758  cleanup:
1759 #ifndef AFS_DEMAND_ATTACH_FS
1760     VPutVolume_r(vp);
1761 #endif
1762
1763  done:
1764     return code;
1765 }
1766
1767 static afs_int32
1768 FSYNC_com_StatsOp(osi_socket fd, SYNC_command * com, SYNC_response * res)
1769 {
1770     afs_int32 code = SYNC_OK;
1771     FSSYNC_StatsOp_command scom;
1772
1773     if (com->recv_len != (sizeof(com->hdr) + sizeof(FSSYNC_StatsOp_hdr))) {
1774         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1775         res->hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
1776         return SYNC_COM_ERROR;
1777     }
1778
1779     scom.hdr = &com->hdr;
1780     scom.sop = (FSSYNC_StatsOp_hdr *) com->payload.buf;
1781     scom.com = com;
1782
1783     ViceLog(125, ("FSYNC_com_StatsOp: fd %d got command for stats: "
1784                   "{vlru_generation = %lu, hash_bucket = %lu, partName = "
1785                   "%.16s}\n", (int)fd,
1786                   afs_printable_uint32_lu(scom.sop->args.vlru_generation),
1787                   afs_printable_uint32_lu(scom.sop->args.hash_bucket),
1788                   scom.sop->args.partName));
1789
1790     switch (com->hdr.command) {
1791     case FSYNC_VOL_STATS_GENERAL:
1792         code = FSYNC_com_StatsOpGeneral(&scom, res);
1793         break;
1794 #ifdef AFS_DEMAND_ATTACH_FS
1795         /* statistics for the following subsystems are only tracked
1796          * for demand attach fileservers */
1797     case FSYNC_VOL_STATS_VICEP:
1798         code = FSYNC_com_StatsOpViceP(&scom, res);
1799         break;
1800     case FSYNC_VOL_STATS_HASH:
1801         code = FSYNC_com_StatsOpHash(&scom, res);
1802         break;
1803     case FSYNC_VOL_STATS_HDR:
1804         code = FSYNC_com_StatsOpHdr(&scom, res);
1805         break;
1806     case FSYNC_VOL_STATS_VLRU:
1807         code = FSYNC_com_StatsOpVLRU(&scom, res);
1808         break;
1809 #endif /* AFS_DEMAND_ATTACH_FS */
1810     default:
1811         code = SYNC_BAD_COMMAND;
1812     }
1813
1814     return code;
1815 }
1816
1817 static afs_int32
1818 FSYNC_com_StatsOpGeneral(FSSYNC_StatsOp_command * scom, SYNC_response * res)
1819 {
1820     afs_int32 code = SYNC_OK;
1821
1822     memcpy(res->payload.buf, &VStats, sizeof(VStats));
1823     res->hdr.response_len += sizeof(VStats);
1824
1825     return code;
1826 }
1827
1828 #ifdef AFS_DEMAND_ATTACH_FS
1829 static afs_int32
1830 FSYNC_com_StatsOpViceP(FSSYNC_StatsOp_command * scom, SYNC_response * res)
1831 {
1832     afs_int32 code = SYNC_OK;
1833     struct DiskPartition64 * dp;
1834     struct DiskPartitionStats64 * stats;
1835
1836     if (SYNC_verifyProtocolString(scom->sop->args.partName, sizeof(scom->sop->args.partName))) {
1837         res->hdr.reason = SYNC_REASON_MALFORMED_PACKET;
1838         code = SYNC_FAILED;
1839         goto done;
1840     }
1841
1842     dp = VGetPartition_r(scom->sop->args.partName, 0);
1843     if (!dp) {
1844         code = SYNC_FAILED;
1845     } else {
1846         stats = (struct DiskPartitionStats64 *) res->payload.buf;
1847         stats->free = dp->free;
1848         stats->totalUsable = dp->totalUsable;
1849         stats->minFree = dp->minFree;
1850         stats->f_files = dp->f_files;
1851         stats->vol_list_len = dp->vol_list.len;
1852
1853         res->hdr.response_len += sizeof(struct DiskPartitionStats64);
1854     }
1855
1856  done:
1857     return code;
1858 }
1859
1860 static afs_int32
1861 FSYNC_com_StatsOpHash(FSSYNC_StatsOp_command * scom, SYNC_response * res)
1862 {
1863     afs_int32 code = SYNC_OK;
1864     struct VolumeHashChainStats * stats;
1865     struct VolumeHashChainHead * head;
1866
1867     if (scom->sop->args.hash_bucket >= VolumeHashTable.Size) {
1868         return SYNC_FAILED;
1869     }
1870
1871     head = &VolumeHashTable.Table[scom->sop->args.hash_bucket];
1872     stats = (struct VolumeHashChainStats *) res->payload.buf;
1873     stats->table_size = VolumeHashTable.Size;
1874     stats->chain_len = head->len;
1875     stats->chain_cacheCheck = head->cacheCheck;
1876     stats->chain_busy = head->busy;
1877     AssignInt64(head->looks, &stats->chain_looks);
1878     AssignInt64(head->gets, &stats->chain_gets);
1879     AssignInt64(head->reorders, &stats->chain_reorders);
1880
1881     res->hdr.response_len += sizeof(struct VolumeHashChainStats);
1882
1883     return code;
1884 }
1885
1886 static afs_int32
1887 FSYNC_com_StatsOpHdr(FSSYNC_StatsOp_command * scom, SYNC_response * res)
1888 {
1889     afs_int32 code = SYNC_OK;
1890
1891     memcpy(res->payload.buf, &volume_hdr_LRU.stats, sizeof(volume_hdr_LRU.stats));
1892     res->hdr.response_len += sizeof(volume_hdr_LRU.stats);
1893
1894     return code;
1895 }
1896
1897 static afs_int32
1898 FSYNC_com_StatsOpVLRU(FSSYNC_StatsOp_command * scom, SYNC_response * res)
1899 {
1900     afs_int32 code = SYNC_OK;
1901
1902     code = SYNC_BAD_COMMAND;
1903
1904     return code;
1905 }
1906 #endif /* AFS_DEMAND_ATTACH_FS */
1907
1908 /**
1909  * populate an FSSYNC_VolOp_info object from a command packet object.
1910  *
1911  * @param[in]   vcom  pointer to command packet
1912  * @param[out]  info  pointer to info object which will be populated
1913  *
1914  * @note FSSYNC_VolOp_info objects are attached to Volume objects when
1915  *       a volume operation is commenced.
1916  *
1917  * @internal
1918  */
1919 static void
1920 FSYNC_com_to_info(FSSYNC_VolOp_command * vcom, FSSYNC_VolOp_info * info)
1921 {
1922     memcpy(&info->com, vcom->hdr, sizeof(SYNC_command_hdr));
1923     memcpy(&info->vop, vcom->vop, sizeof(FSSYNC_VolOp_hdr));
1924     info->vol_op_state = FSSYNC_VolOpPending;
1925 }
1926
1927 /**
1928  * check whether command packet partition name matches volume
1929  * object's partition name.
1930  *
1931  * @param[in] vcom        pointer to command packet
1932  * @param[in] vp          pointer to volume object
1933  * @param[in] match_anon  anon matching control flag (see note below)
1934  *
1935  * @return whether partitions match
1936  *   @retval 0  partitions do NOT match
1937  *   @retval 1  partitions match
1938  *
1939  * @note if match_anon is non-zero, then this function will return a
1940  *       positive match for a zero-length partition string in the
1941  *       command packet.
1942  *
1943  * @internal
1944  */
1945 static int
1946 FSYNC_partMatch(FSSYNC_VolOp_command * vcom, Volume * vp, int match_anon)
1947 {
1948     return ((match_anon && vcom->vop->partName[0] == 0) ||
1949             (strncmp(vcom->vop->partName, V_partition(vp)->name,
1950                      sizeof(vcom->vop->partName)) == 0));
1951 }
1952
1953
1954 static void
1955 FSYNC_Drop(osi_socket fd)
1956 {
1957     struct offlineInfo *p;
1958     int i;
1959     Error error;
1960     char tvolName[VMAXPATHLEN];
1961
1962     VOL_LOCK;
1963     p = OfflineVolumes[FindHandler(fd)];
1964     for (i = 0; i < MAXOFFLINEVOLUMES; i++) {
1965         if (p[i].volumeID) {
1966
1967             Volume *vp;
1968
1969             tvolName[0] = OS_DIRSEPC;
1970             sprintf(&tvolName[1], VFORMAT, afs_printable_uint32_lu(p[i].volumeID));
1971             vp = VAttachVolumeByName_r(&error, p[i].partName, tvolName,
1972                                        V_VOLUPD);
1973             if (vp)
1974                 VPutVolume_r(vp);
1975             p[i].volumeID = 0;
1976         }
1977     }
1978     VOL_UNLOCK;
1979     RemoveHandler(fd);
1980 #ifdef AFS_NT40_ENV
1981     closesocket(fd);
1982 #else
1983     close(fd);
1984 #endif
1985     AcceptOn();
1986 }
1987
1988 static int AcceptHandler = -1;  /* handler id for accept, if turned on */
1989
1990 static void
1991 AcceptOn(void)
1992 {
1993     if (AcceptHandler == -1) {
1994         osi_Assert(AddHandler(fssync_server_state.fd, FSYNC_newconnection));
1995         AcceptHandler = FindHandler(fssync_server_state.fd);
1996     }
1997 }
1998
1999 static void
2000 AcceptOff(void)
2001 {
2002     if (AcceptHandler != -1) {
2003         osi_Assert(RemoveHandler(fssync_server_state.fd));
2004         AcceptHandler = -1;
2005     }
2006 }
2007
2008 /* The multiple FD handling code. */
2009
2010 static osi_socket HandlerFD[MAXHANDLERS];
2011 static void (*HandlerProc[MAXHANDLERS]) (osi_socket);
2012
2013 static void
2014 InitHandler(void)
2015 {
2016     int i;
2017     ObtainWriteLock(&FSYNC_handler_lock);
2018     for (i = 0; i < MAXHANDLERS; i++) {
2019         HandlerFD[i] = OSI_NULLSOCKET;
2020         HandlerProc[i] = 0;
2021     }
2022     ReleaseWriteLock(&FSYNC_handler_lock);
2023 }
2024
2025 #if defined(HAVE_POLL) && defined(AFS_PTHREAD_ENV)
2026 static void
2027 CallHandler(struct pollfd *fds, int nfds, int mask)
2028 {
2029     int i;
2030     int handler;
2031     ObtainReadLock(&FSYNC_handler_lock);
2032     for (i = 0; i < nfds; i++) {
2033         if (fds[i].revents & mask) {
2034             handler = FindHandler_r(fds[i].fd);
2035             ReleaseReadLock(&FSYNC_handler_lock);
2036             (*HandlerProc[handler]) (fds[i].fd);
2037             ObtainReadLock(&FSYNC_handler_lock);
2038         }
2039     }
2040     ReleaseReadLock(&FSYNC_handler_lock);
2041 }
2042 #else
2043 static void
2044 CallHandler(fd_set * fdsetp)
2045 {
2046     int i;
2047     ObtainReadLock(&FSYNC_handler_lock);
2048     for (i = 0; i < MAXHANDLERS; i++) {
2049         if (HandlerFD[i] >= 0 && FD_ISSET(HandlerFD[i], fdsetp)) {
2050             ReleaseReadLock(&FSYNC_handler_lock);
2051             (*HandlerProc[i]) (HandlerFD[i]);
2052             ObtainReadLock(&FSYNC_handler_lock);
2053         }
2054     }
2055     ReleaseReadLock(&FSYNC_handler_lock);
2056 }
2057 #endif
2058
2059 static int
2060 AddHandler(osi_socket afd, void (*aproc) (osi_socket))
2061 {
2062     int i;
2063     ObtainWriteLock(&FSYNC_handler_lock);
2064     for (i = 0; i < MAXHANDLERS; i++)
2065         if (HandlerFD[i] == OSI_NULLSOCKET)
2066             break;
2067     if (i >= MAXHANDLERS) {
2068         ReleaseWriteLock(&FSYNC_handler_lock);
2069         return 0;
2070     }
2071     HandlerFD[i] = afd;
2072     HandlerProc[i] = aproc;
2073     ReleaseWriteLock(&FSYNC_handler_lock);
2074     return 1;
2075 }
2076
2077 static int
2078 FindHandler(osi_socket afd)
2079 {
2080     int i;
2081     ObtainReadLock(&FSYNC_handler_lock);
2082     for (i = 0; i < MAXHANDLERS; i++)
2083         if (HandlerFD[i] == afd) {
2084             ReleaseReadLock(&FSYNC_handler_lock);
2085             return i;
2086         }
2087     ReleaseReadLock(&FSYNC_handler_lock);       /* just in case */
2088     osi_Assert(1 == 2);
2089     return -1;                  /* satisfy compiler */
2090 }
2091
2092 static int
2093 FindHandler_r(osi_socket afd)
2094 {
2095     int i;
2096     for (i = 0; i < MAXHANDLERS; i++)
2097         if (HandlerFD[i] == afd) {
2098             return i;
2099         }
2100     osi_Assert(1 == 2);
2101     return -1;                  /* satisfy compiler */
2102 }
2103
2104 static int
2105 RemoveHandler(osi_socket afd)
2106 {
2107     ObtainWriteLock(&FSYNC_handler_lock);
2108     HandlerFD[FindHandler_r(afd)] = OSI_NULLSOCKET;
2109     ReleaseWriteLock(&FSYNC_handler_lock);
2110     return 1;
2111 }
2112
2113 #if defined(HAVE_POLL) && defined(AFS_PTHREAD_ENV)
2114 static void
2115 GetHandler(struct pollfd *fds, int maxfds, int events, int *nfds)
2116 {
2117     int i;
2118     int fdi = 0;
2119     ObtainReadLock(&FSYNC_handler_lock);
2120     for (i = 0; i < MAXHANDLERS; i++)
2121         if (HandlerFD[i] != OSI_NULLSOCKET) {
2122             osi_Assert(fdi<maxfds);
2123             fds[fdi].fd = HandlerFD[i];
2124             fds[fdi].events = events;
2125             fds[fdi].revents = 0;
2126             fdi++;
2127         }
2128     *nfds = fdi;
2129     ReleaseReadLock(&FSYNC_handler_lock);
2130 }
2131 #else
2132 static void
2133 GetHandler(fd_set * fdsetp, int *maxfdp)
2134 {
2135     int i;
2136     int maxfd = -1;
2137     FD_ZERO(fdsetp);
2138     ObtainReadLock(&FSYNC_handler_lock);        /* just in case */
2139     for (i = 0; i < MAXHANDLERS; i++)
2140         if (HandlerFD[i] != OSI_NULLSOCKET) {
2141             FD_SET(HandlerFD[i], fdsetp);
2142 #ifndef AFS_NT40_ENV
2143             /* On Windows the nfds parameter to select() is ignored */
2144             if (maxfd < HandlerFD[i] || maxfd == (int)-1)
2145                 maxfd = HandlerFD[i];
2146 #endif /* AFS_NT40_ENV */
2147         }
2148     *maxfdp = maxfd;
2149     ReleaseReadLock(&FSYNC_handler_lock);       /* just in case */
2150 }
2151 #endif /* HAVE_POLL && AFS_PTHREAD_ENV */
2152
2153 #endif /* FSSYNC_BUILD_SERVER */