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