0edcb8cb699fbe07f8be3dcc9fab58a6f00ba573
[openafs.git] / src / vol / salvsync-server.c
1 /*
2  * Copyright 2006-2008, Sine Nomine Associates and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * salvsync-server.c
12  *
13  * OpenAFS demand attach fileserver
14  * Salvage server synchronization with fileserver.
15  */
16
17 /* This controls the size of an fd_set; it must be defined early before
18  * the system headers define that type and the macros that operate on it.
19  * Its value should be as large as the maximum file descriptor limit we
20  * are likely to run into on any platform.  Right now, that is 65536
21  * which is the default hard fd limit on Solaris 9 */
22 #ifndef _WIN32
23 #define FD_SETSIZE 65536
24 #endif
25
26 #include <afsconfig.h>
27 #include <afs/param.h>
28
29
30 #include <sys/types.h>
31 #include <stdio.h>
32 #ifdef AFS_NT40_ENV
33 #include <winsock2.h>
34 #include <time.h>
35 #else
36 #include <sys/param.h>
37 #include <sys/socket.h>
38 #include <netinet/in.h>
39 #include <netdb.h>
40 #include <sys/time.h>
41 #endif
42 #include <errno.h>
43 #include <assert.h>
44 #include <signal.h>
45 #include <string.h>
46
47
48 #include <rx/xdr.h>
49 #include <afs/afsint.h>
50 #include "nfs.h"
51 #include <afs/errors.h>
52 #include "salvsync.h"
53 #include "lwp.h"
54 #include "lock.h"
55 #include <afs/afssyscalls.h>
56 #include "ihandle.h"
57 #include "vnode.h"
58 #include "volume.h"
59 #include "partition.h"
60 #include <rx/rx_queue.h>
61 #include <afs/procmgmt.h>
62
63 #if !defined(offsetof)
64 #include <stddef.h>
65 #endif
66
67 #ifdef USE_UNIX_SOCKETS
68 #include <afs/afsutil.h>
69 #include <sys/un.h>
70 #endif
71
72
73 /*@printflike@*/ extern void Log(const char *format, ...);
74
75 #define MAXHANDLERS     4       /* Up to 4 clients; must be at least 2, so that
76                                  * move = dump+restore can run on single server */
77
78
79 /*
80  * This lock controls access to the handler array.
81  */
82 struct Lock SALVSYNC_handler_lock;
83
84
85 #ifdef AFS_DEMAND_ATTACH_FS
86 /*
87  * SALVSYNC is a feature specific to the demand attach fileserver
88  */
89
90 /* Forward declarations */
91 static void * SALVSYNC_syncThread(void *);
92 static void SALVSYNC_newconnection(osi_socket fd);
93 static void SALVSYNC_com(osi_socket fd);
94 static void SALVSYNC_Drop(osi_socket fd);
95 static void AcceptOn(void);
96 static void AcceptOff(void);
97 static void InitHandler(void);
98 static void CallHandler(fd_set * fdsetp);
99 static int AddHandler(osi_socket afd, void (*aproc) (int));
100 static int FindHandler(register osi_socket afd);
101 static int FindHandler_r(register osi_socket afd);
102 static int RemoveHandler(register osi_socket afd);
103 static void GetHandler(fd_set * fdsetp, int *maxfdp);
104
105 static int AllocNode(struct SalvageQueueNode ** node);
106
107 static int AddToSalvageQueue(struct SalvageQueueNode * node);
108 static void DeleteFromSalvageQueue(struct SalvageQueueNode * node);
109 static void AddToPendingQueue(struct SalvageQueueNode * node);
110 static void DeleteFromPendingQueue(struct SalvageQueueNode * node);
111 static struct SalvageQueueNode * LookupPendingCommand(SALVSYNC_command_hdr * qry);
112 static struct SalvageQueueNode * LookupPendingCommandByPid(int pid);
113 static void UpdateCommandPrio(struct SalvageQueueNode * node);
114 static void HandlePrio(struct SalvageQueueNode * clone, 
115                        struct SalvageQueueNode * parent,
116                        afs_uint32 new_prio);
117
118 static int LinkNode(struct SalvageQueueNode * parent,
119                     struct SalvageQueueNode * clone);
120
121 static struct SalvageQueueNode * LookupNode(VolumeId vid, char * partName, 
122                                             struct SalvageQueueNode ** parent);
123 static struct SalvageQueueNode * LookupNodeByCommand(SALVSYNC_command_hdr * qry,
124                                                      struct SalvageQueueNode ** parent);
125 static void AddNodeToHash(struct SalvageQueueNode * node);
126 static void DeleteNodeFromHash(struct SalvageQueueNode * node);
127
128 static afs_int32 SALVSYNC_com_Salvage(SALVSYNC_command * com, SALVSYNC_response * res);
129 static afs_int32 SALVSYNC_com_Cancel(SALVSYNC_command * com, SALVSYNC_response * res);
130 static afs_int32 SALVSYNC_com_Query(SALVSYNC_command * com, SALVSYNC_response * res);
131 static afs_int32 SALVSYNC_com_CancelAll(SALVSYNC_command * com, SALVSYNC_response * res);
132 static afs_int32 SALVSYNC_com_Link(SALVSYNC_command * com, SALVSYNC_response * res);
133
134
135 extern int LogLevel;
136 extern int VInit;
137 extern pthread_mutex_t vol_salvsync_mutex;
138
139 /**
140  * salvsync server socket handle.
141  */
142 static SYNC_server_state_t salvsync_server_state = 
143     { -1,                       /* file descriptor */
144       SALVSYNC_ENDPOINT_DECL,   /* server endpoint */
145       SALVSYNC_PROTO_VERSION,   /* protocol version */
146       5,                        /* bind() retry limit */
147       100,                      /* listen() queue depth */
148       "SALVSYNC",               /* protocol name string */
149     };
150
151
152 /**
153  * queue of all volumes waiting to be salvaged.
154  */
155 struct SalvageQueue {
156     volatile int total_len;
157     volatile afs_int32 last_insert;    /**< id of last partition to have a salvage node inserted */
158     volatile int len[VOLMAXPARTS+1];
159     volatile struct rx_queue part[VOLMAXPARTS+1]; /**< per-partition queues of pending salvages */
160     pthread_cond_t cv;
161 };
162 static struct SalvageQueue salvageQueue;  /* volumes waiting to be salvaged */
163
164 /**
165  * queue of all volumes currently being salvaged.
166  */
167 struct QueueHead {
168     volatile struct rx_queue q;  /**< queue of salvages in progress */
169     volatile int len;            /**< length of in-progress queue */
170     pthread_cond_t queue_change_cv;
171 };
172 static struct QueueHead pendingQueue;  /* volumes being salvaged */
173
174 /* XXX
175  * whether a partition has a salvage in progress
176  *
177  * the salvager code only permits one salvage per partition at a time
178  *
179  * the following hack tries to keep salvaged parallelism high by
180  * only permitting one salvage dispatch per partition at a time
181  *
182  * unfortunately, the parallel salvager currently
183  * has a rather braindead routine that won't permit
184  * multiple salvages on the same "device".  this
185  * function happens to break pretty badly on lvm, raid luns, etc.
186  *
187  * this hack isn't good enough to stop the device limiting code from
188  * crippling performance.  someday that code needs to be rewritten
189  */
190 static int partition_salvaging[VOLMAXPARTS+1];
191
192 static int HandlerFD[MAXHANDLERS];
193 static void (*HandlerProc[MAXHANDLERS]) (int);
194
195 #define VSHASH_SIZE 64
196 #define VSHASH_MASK (VSHASH_SIZE-1)
197 #define VSHASH(vid) ((vid)&VSHASH_MASK)
198
199 static struct QueueHead  SalvageHashTable[VSHASH_SIZE];
200
201 static struct SalvageQueueNode *
202 LookupNode(afs_uint32 vid, char * partName,
203            struct SalvageQueueNode ** parent)
204 {
205     struct rx_queue *qp, *nqp;
206     struct SalvageQueueNode *vsp;
207     int idx = VSHASH(vid);
208
209     for (queue_Scan(&SalvageHashTable[idx], qp, nqp, rx_queue)) {
210         vsp = (struct SalvageQueueNode *)((char *)qp - offsetof(struct SalvageQueueNode, hash_chain));
211         if ((vsp->command.sop.volume == vid) &&
212             !strncmp(vsp->command.sop.partName, partName, sizeof(vsp->command.sop.partName))) {
213             break;
214         }
215     }
216
217     if (queue_IsEnd(&SalvageHashTable[idx], qp)) {
218         vsp = NULL;
219     }
220
221     if (parent) {
222         if (vsp) {
223             *parent = (vsp->type == SALVSYNC_VOLGROUP_CLONE) ?
224                 vsp->volgroup.parent : vsp;
225         } else {
226             *parent = NULL;
227         }
228     }
229
230     return vsp;
231 }
232
233 static struct SalvageQueueNode *
234 LookupNodeByCommand(SALVSYNC_command_hdr * qry,
235                     struct SalvageQueueNode ** parent)
236 {
237     return LookupNode(qry->volume, qry->partName, parent);
238 }
239
240 static void
241 AddNodeToHash(struct SalvageQueueNode * node)
242 {
243     int idx = VSHASH(node->command.sop.volume);
244
245     if (queue_IsOnQueue(&node->hash_chain)) {
246         return;
247     }
248
249     queue_Append(&SalvageHashTable[idx], &node->hash_chain);
250     SalvageHashTable[idx].len++;
251 }
252
253 static void
254 DeleteNodeFromHash(struct SalvageQueueNode * node)
255 {
256     int idx = VSHASH(node->command.sop.volume);
257
258     if (queue_IsNotOnQueue(&node->hash_chain)) {
259         return;
260     }
261
262     queue_Remove(&node->hash_chain);
263     SalvageHashTable[idx].len--;
264 }
265
266 void
267 SALVSYNC_salvInit(void)
268 {
269     int i;
270     pthread_t tid;
271     pthread_attr_t tattr;
272
273     /* initialize the queues */
274     Lock_Init(&SALVSYNC_handler_lock);
275     assert(pthread_cond_init(&salvageQueue.cv, NULL) == 0);
276     for (i = 0; i <= VOLMAXPARTS; i++) {
277         queue_Init(&salvageQueue.part[i]);
278         salvageQueue.len[i] = 0;
279     }
280     assert(pthread_cond_init(&pendingQueue.queue_change_cv, NULL) == 0);
281     queue_Init(&pendingQueue);
282     salvageQueue.total_len = pendingQueue.len = 0;
283     salvageQueue.last_insert = -1;
284     memset(partition_salvaging, 0, sizeof(partition_salvaging));
285
286     for (i = 0; i < VSHASH_SIZE; i++) {
287         assert(pthread_cond_init(&SalvageHashTable[i].queue_change_cv, NULL) == 0);
288         SalvageHashTable[i].len = 0;
289         queue_Init(&SalvageHashTable[i]);
290     }
291
292     /* start the salvsync thread */
293     assert(pthread_attr_init(&tattr) == 0);
294     assert(pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED) == 0);
295     assert(pthread_create(&tid, &tattr, SALVSYNC_syncThread, NULL) == 0);
296 }
297
298 static void
299 CleanFDs(void)
300 {
301     int i;
302     for (i = 0; i < MAXHANDLERS; ++i) {
303         if (HandlerFD[i] >= 0) {
304             SALVSYNC_Drop(HandlerFD[i]);
305         }
306     }
307
308     /* just in case we were in AcceptOff mode, and thus this fd wouldn't
309      * have a handler */
310     close(salvsync_server_state.fd);
311     salvsync_server_state.fd = -1;
312 }
313
314 static fd_set SALVSYNC_readfds;
315
316 static void *
317 SALVSYNC_syncThread(void * args)
318 {
319     int on = 1;
320     int code;
321     int numTries;
322     int tid;
323     SYNC_server_state_t * state = &salvsync_server_state;
324
325     /* when we fork, the child needs to close the salvsync server sockets,
326      * otherwise, it may get salvsync requests, instead of the parent
327      * salvageserver */
328     assert(pthread_atfork(NULL, NULL, CleanFDs) == 0);
329
330     SYNC_getAddr(&state->endpoint, &state->addr);
331     SYNC_cleanupSock(state);
332
333 #ifndef AFS_NT40_ENV
334     (void)signal(SIGPIPE, SIG_IGN);
335 #endif
336
337     state->fd = SYNC_getSock(&state->endpoint);
338     code = SYNC_bindSock(state);
339     assert(!code);
340
341     InitHandler();
342     AcceptOn();
343
344     for (;;) {
345         int maxfd;
346         GetHandler(&SALVSYNC_readfds, &maxfd);
347         /* Note: check for >= 1 below is essential since IOMGR_select
348          * doesn't have exactly same semantics as select.
349          */
350         if (select(maxfd + 1, &SALVSYNC_readfds, NULL, NULL, NULL) >= 1)
351             CallHandler(&SALVSYNC_readfds);
352     }
353
354     return NULL;
355 }
356
357 static void
358 SALVSYNC_newconnection(int afd)
359 {
360 #ifdef USE_UNIX_SOCKETS
361     struct sockaddr_un other;
362 #else  /* USE_UNIX_SOCKETS */
363     struct sockaddr_in other;
364 #endif
365     int junk, fd;
366     junk = sizeof(other);
367     fd = accept(afd, (struct sockaddr *)&other, &junk);
368     if (fd == -1) {
369         Log("SALVSYNC_newconnection:  accept failed, errno==%d\n", errno);
370         assert(1 == 2);
371     } else if (!AddHandler(fd, SALVSYNC_com)) {
372         AcceptOff();
373         assert(AddHandler(fd, SALVSYNC_com));
374     }
375 }
376
377 /* this function processes commands from an salvsync file descriptor (fd) */
378 static afs_int32 SALV_cnt = 0;
379 static void
380 SALVSYNC_com(osi_socket fd)
381 {
382     SYNC_command com;
383     SYNC_response res;
384     SALVSYNC_response_hdr sres_hdr;
385     SALVSYNC_command scom;
386     SALVSYNC_response sres;
387     SYNC_PROTO_BUF_DECL(buf);
388
389     memset(&com, 0, sizeof(com));
390     memset(&res, 0, sizeof(res));
391     memset(&scom, 0, sizeof(scom));
392     memset(&sres, 0, sizeof(sres));
393     memset(&sres_hdr, 0, sizeof(sres_hdr));
394     
395     com.payload.buf = (void *)buf;
396     com.payload.len = SYNC_PROTO_MAX_LEN;
397     res.payload.buf = (void *) &sres_hdr;
398     res.payload.len = sizeof(sres_hdr);
399     res.hdr.response_len = sizeof(res.hdr) + sizeof(sres_hdr);
400     res.hdr.proto_version = SALVSYNC_PROTO_VERSION;
401
402     scom.hdr = &com.hdr;
403     scom.sop = (SALVSYNC_command_hdr *) buf;
404     scom.com = &com;
405     sres.hdr = &res.hdr;
406     sres.sop = &sres_hdr;
407     sres.res = &res;
408
409     SALV_cnt++;
410     if (SYNC_getCom(&salvsync_server_state, fd, &com)) {
411         Log("SALVSYNC_com:  read failed; dropping connection (cnt=%d)\n", SALV_cnt);
412         SALVSYNC_Drop(fd);
413         return;
414     }
415
416     if (com.recv_len < sizeof(com.hdr)) {
417         Log("SALVSYNC_com:  invalid protocol message length (%u)\n", com.recv_len);
418         res.hdr.response = SYNC_COM_ERROR;
419         res.hdr.reason = SYNC_REASON_MALFORMED_PACKET;
420         res.hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
421         goto respond;
422     }
423
424     if (com.hdr.proto_version != SALVSYNC_PROTO_VERSION) {
425         Log("SALVSYNC_com:  invalid protocol version (%u)\n", com.hdr.proto_version);
426         res.hdr.response = SYNC_COM_ERROR;
427         res.hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
428         goto respond;
429     }
430
431     if (com.hdr.command == SYNC_COM_CHANNEL_CLOSE) {
432         res.hdr.response = SYNC_OK;
433         res.hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
434
435         /* don't respond, just drop; senders of SYNC_COM_CHANNEL_CLOSE
436          * never wait for a response. */
437         goto done;
438     }
439
440     if (com.recv_len != (sizeof(com.hdr) + sizeof(SALVSYNC_command_hdr))) {
441         Log("SALVSYNC_com:  invalid protocol message length (%u)\n", com.recv_len);
442         res.hdr.response = SYNC_COM_ERROR;
443         res.hdr.reason = SYNC_REASON_MALFORMED_PACKET;
444         res.hdr.flags |= SYNC_FLAG_CHANNEL_SHUTDOWN;
445         goto respond;
446     }
447
448     res.hdr.com_seq = com.hdr.com_seq;
449
450     VOL_LOCK;
451     switch (com.hdr.command) {
452     case SALVSYNC_NOP:
453         break;
454     case SALVSYNC_SALVAGE:
455     case SALVSYNC_RAISEPRIO:
456         res.hdr.response = SALVSYNC_com_Salvage(&scom, &sres);
457         break;
458     case SALVSYNC_CANCEL:
459         /* cancel a salvage */
460         res.hdr.response = SALVSYNC_com_Cancel(&scom, &sres);
461         break;
462     case SALVSYNC_CANCELALL:
463         /* cancel all queued salvages */
464         res.hdr.response = SALVSYNC_com_CancelAll(&scom, &sres);
465         break;
466     case SALVSYNC_QUERY:
467         /* query whether a volume is done salvaging */
468         res.hdr.response = SALVSYNC_com_Query(&scom, &sres);
469         break;
470     case SALVSYNC_OP_LINK:
471         /* link a clone to its parent in the scheduler */
472         res.hdr.response = SALVSYNC_com_Link(&scom, &sres);
473         break;
474     default:
475         res.hdr.response = SYNC_BAD_COMMAND;
476         break;
477     }
478
479     sres_hdr.sq_len = salvageQueue.total_len;
480     sres_hdr.pq_len = pendingQueue.len;
481     VOL_UNLOCK;
482
483  respond:
484     SYNC_putRes(&salvsync_server_state, fd, &res);
485
486  done:
487     if (res.hdr.flags & SYNC_FLAG_CHANNEL_SHUTDOWN) {
488         SALVSYNC_Drop(fd);
489     }
490 }
491
492 /**
493  * request that a volume be salvaged.
494  *
495  * @param[in]  com  inbound command object
496  * @param[out] res  outbound response object
497  *
498  * @return operation status
499  *    @retval SYNC_OK success
500  *    @retval SYNC_DENIED failed to enqueue request
501  *    @retval SYNC_FAILED malformed command packet
502  *
503  * @note this is a SALVSYNC protocol rpc handler
504  *
505  * @internal
506  *
507  * @post the volume is enqueued in the to-be-salvaged queue.  
508  *       if the volume was already in the salvage queue, its 
509  *       priority (and thus its location in the queue) are 
510  *       updated.
511  */
512 static afs_int32
513 SALVSYNC_com_Salvage(SALVSYNC_command * com, SALVSYNC_response * res)
514 {
515     afs_int32 code = SYNC_OK;
516     struct SalvageQueueNode * node, * clone;
517     int hash = 0;
518
519     if (SYNC_verifyProtocolString(com->sop->partName, sizeof(com->sop->partName))) {
520         code = SYNC_FAILED;
521         res->hdr->reason = SYNC_REASON_MALFORMED_PACKET;
522         goto done;
523     }
524
525     clone = LookupNodeByCommand(com->sop, &node);
526
527     if (node == NULL) {
528         if (AllocNode(&node)) {
529             code = SYNC_DENIED;
530             res->hdr->reason = SYNC_REASON_NOMEM;
531             goto done;
532         }
533         clone = node;
534         hash = 1;
535     }
536
537     HandlePrio(clone, node, com->sop->prio);
538
539     switch (node->state) {
540     case SALVSYNC_STATE_QUEUED:
541         UpdateCommandPrio(node);
542         break;
543
544     case SALVSYNC_STATE_ERROR:
545     case SALVSYNC_STATE_DONE:
546     case SALVSYNC_STATE_UNKNOWN:
547         memcpy(&clone->command.com, com->hdr, sizeof(SYNC_command_hdr));
548         memcpy(&clone->command.sop, com->sop, sizeof(SALVSYNC_command_hdr));
549
550         /* 
551          * make sure volgroup parent partition path is kept coherent
552          *
553          * If we ever want to support non-COW clones on a machine holding
554          * the RW site, please note that this code does not work under the
555          * conditions where someone zaps a COW clone on partition X, and
556          * subsequently creates a full clone on partition Y -- we'd need
557          * an inverse to SALVSYNC_com_Link.
558          *  -- tkeiser 11/28/2007
559          */
560         strcpy(node->command.sop.partName, com->sop->partName);
561
562         if (AddToSalvageQueue(node)) {
563             code = SYNC_DENIED;
564         }
565         break;
566
567     default:
568         break;
569     }
570
571     if (hash) {
572         AddNodeToHash(node);
573     }
574
575     res->hdr->flags |= SALVSYNC_FLAG_VOL_STATS_VALID;
576     res->sop->state = node->state;
577     res->sop->prio = node->command.sop.prio;
578
579  done:
580     return code;
581 }
582
583 /**
584  * cancel a pending salvage request.
585  *
586  * @param[in]  com  inbound command object
587  * @param[out] res  outbound response object
588  *
589  * @return operation status
590  *    @retval SYNC_OK success
591  *    @retval SYNC_FAILED malformed command packet
592  *
593  * @note this is a SALVSYNC protocol rpc handler
594  *
595  * @internal
596  */
597 static afs_int32
598 SALVSYNC_com_Cancel(SALVSYNC_command * com, SALVSYNC_response * res)
599 {
600     afs_int32 code = SYNC_OK;
601     struct SalvageQueueNode * node;
602
603     if (SYNC_verifyProtocolString(com->sop->partName, sizeof(com->sop->partName))) {
604         code = SYNC_FAILED;
605         res->hdr->reason = SYNC_REASON_MALFORMED_PACKET;
606         goto done;
607     }
608
609     node = LookupNodeByCommand(com->sop, NULL);
610
611     if (node == NULL) {
612         res->sop->state = SALVSYNC_STATE_UNKNOWN;
613         res->sop->prio = 0;
614     } else {
615         res->hdr->flags |= SALVSYNC_FLAG_VOL_STATS_VALID;
616         res->sop->prio = node->command.sop.prio;
617         res->sop->state = node->state;
618         if ((node->type == SALVSYNC_VOLGROUP_PARENT) && 
619             (node->state == SALVSYNC_STATE_QUEUED)) {
620             DeleteFromSalvageQueue(node);
621         }
622     }
623
624  done:
625     return code;
626 }
627
628 /**
629  * cancel all pending salvage requests.
630  *
631  * @param[in]  com  incoming command object
632  * @param[out] res  outbound response object
633  *
634  * @return operation status
635  *    @retval SYNC_OK success
636  *
637  * @note this is a SALVSYNC protocol rpc handler
638  *
639  * @internal
640  */
641 static afs_int32
642 SALVSYNC_com_CancelAll(SALVSYNC_command * com, SALVSYNC_response * res)
643 {
644     struct SalvageQueueNode * np, *nnp;
645     struct DiskPartition64 * dp;
646
647     for (dp = DiskPartitionList ; dp ; dp = dp->next) {
648         for (queue_Scan(&salvageQueue.part[dp->index], np, nnp, SalvageQueueNode)) {
649             DeleteFromSalvageQueue(np);
650         }
651     }
652
653     return SYNC_OK;
654 }
655
656 /**
657  * link a queue node for a clone to its parent volume.
658  *
659  * @param[in]  com   inbound command object
660  * @param[out] res   outbound response object
661  *
662  * @return operation status
663  *    @retval SYNC_OK success
664  *    @retval SYNC_FAILED malformed command packet
665  *    @retval SYNC_DENIED the request could not be completed
666  *
667  * @note this is a SALVSYNC protocol rpc handler
668  *
669  * @post the requested volume is marked as a child of another volume.
670  *       thus, future salvage requests for this volume will result in the
671  *       parent of the volume group being scheduled for salvage instead
672  *       of this clone.
673  *
674  * @internal
675  */
676 static afs_int32
677 SALVSYNC_com_Link(SALVSYNC_command * com, SALVSYNC_response * res)
678 {
679     afs_int32 code = SYNC_OK;
680     struct SalvageQueueNode * clone, * parent;
681
682     if (SYNC_verifyProtocolString(com->sop->partName, sizeof(com->sop->partName))) {
683         code = SYNC_FAILED;
684         res->hdr->reason = SYNC_REASON_MALFORMED_PACKET;
685         goto done;
686     }
687
688     /* lookup clone's salvage scheduling node */
689     clone = LookupNodeByCommand(com->sop, NULL);
690     if (clone == NULL) {
691         code = SYNC_DENIED;
692         res->hdr->reason = SALVSYNC_REASON_ERROR;
693         goto done;
694     }
695
696     /* lookup parent's salvage scheduling node */
697     parent = LookupNode(com->sop->parent, com->sop->partName, NULL);
698     if (parent == NULL) {
699         if (AllocNode(&parent)) {
700             code = SYNC_DENIED;
701             res->hdr->reason = SYNC_REASON_NOMEM;
702             goto done;
703         }
704         memcpy(&parent->command.com, com->hdr, sizeof(SYNC_command_hdr));
705         memcpy(&parent->command.sop, com->sop, sizeof(SALVSYNC_command_hdr));
706         parent->command.sop.volume = parent->command.sop.parent = com->sop->parent;
707         AddNodeToHash(parent);
708     }
709
710     if (LinkNode(parent, clone)) {
711         code = SYNC_DENIED;
712         goto done;
713     }
714
715  done:
716     return code;
717 }
718
719 /**
720  * query the status of a volume salvage request.
721  *
722  * @param[in]  com   inbound command object
723  * @param[out] res   outbound response object
724  *
725  * @return operation status
726  *    @retval SYNC_OK success
727  *    @retval SYNC_FAILED malformed command packet
728  *
729  * @note this is a SALVSYNC protocol rpc handler
730  *
731  * @internal
732  */
733 static afs_int32
734 SALVSYNC_com_Query(SALVSYNC_command * com, SALVSYNC_response * res)
735 {
736     afs_int32 code = SYNC_OK;
737     struct SalvageQueueNode * node;
738
739     if (SYNC_verifyProtocolString(com->sop->partName, sizeof(com->sop->partName))) {
740         code = SYNC_FAILED;
741         res->hdr->reason = SYNC_REASON_MALFORMED_PACKET;
742         goto done;
743     }
744
745     LookupNodeByCommand(com->sop, &node);
746
747     /* query whether a volume is done salvaging */
748     if (node == NULL) {
749         res->sop->state = SALVSYNC_STATE_UNKNOWN;
750         res->sop->prio = 0;
751     } else {
752         res->hdr->flags |= SALVSYNC_FLAG_VOL_STATS_VALID;
753         res->sop->state = node->state;
754         res->sop->prio = node->command.sop.prio;
755     }
756
757  done:
758     return code;
759 }
760
761 static void
762 SALVSYNC_Drop(osi_socket fd)
763 {
764     RemoveHandler(fd);
765 #ifdef AFS_NT40_ENV
766     closesocket(fd);
767 #else
768     close(fd);
769 #endif
770     AcceptOn();
771 }
772
773 static int AcceptHandler = -1;  /* handler id for accept, if turned on */
774
775 static void
776 AcceptOn(void)
777 {
778     if (AcceptHandler == -1) {
779         assert(AddHandler(salvsync_server_state.fd, SALVSYNC_newconnection));
780         AcceptHandler = FindHandler(salvsync_server_state.fd);
781     }
782 }
783
784 static void
785 AcceptOff(void)
786 {
787     if (AcceptHandler != -1) {
788         assert(RemoveHandler(salvsync_server_state.fd));
789         AcceptHandler = -1;
790     }
791 }
792
793 /* The multiple FD handling code. */
794
795 static void
796 InitHandler(void)
797 {
798     register int i;
799     ObtainWriteLock(&SALVSYNC_handler_lock);
800     for (i = 0; i < MAXHANDLERS; i++) {
801         HandlerFD[i] = -1;
802         HandlerProc[i] = NULL;
803     }
804     ReleaseWriteLock(&SALVSYNC_handler_lock);
805 }
806
807 static void
808 CallHandler(fd_set * fdsetp)
809 {
810     register int i;
811     ObtainReadLock(&SALVSYNC_handler_lock);
812     for (i = 0; i < MAXHANDLERS; i++) {
813         if (HandlerFD[i] >= 0 && FD_ISSET(HandlerFD[i], fdsetp)) {
814             ReleaseReadLock(&SALVSYNC_handler_lock);
815             (*HandlerProc[i]) (HandlerFD[i]);
816             ObtainReadLock(&SALVSYNC_handler_lock);
817         }
818     }
819     ReleaseReadLock(&SALVSYNC_handler_lock);
820 }
821
822 static int
823 AddHandler(osi_socket afd, void (*aproc) (int))
824 {
825     register int i;
826     ObtainWriteLock(&SALVSYNC_handler_lock);
827     for (i = 0; i < MAXHANDLERS; i++)
828         if (HandlerFD[i] == -1)
829             break;
830     if (i >= MAXHANDLERS) {
831         ReleaseWriteLock(&SALVSYNC_handler_lock);
832         return 0;
833     }
834     HandlerFD[i] = afd;
835     HandlerProc[i] = aproc;
836     ReleaseWriteLock(&SALVSYNC_handler_lock);
837     return 1;
838 }
839
840 static int
841 FindHandler(register osi_socket afd)
842 {
843     register int i;
844     ObtainReadLock(&SALVSYNC_handler_lock);
845     for (i = 0; i < MAXHANDLERS; i++)
846         if (HandlerFD[i] == afd) {
847             ReleaseReadLock(&SALVSYNC_handler_lock);
848             return i;
849         }
850     ReleaseReadLock(&SALVSYNC_handler_lock);    /* just in case */
851     assert(1 == 2);
852     return -1;                  /* satisfy compiler */
853 }
854
855 static int
856 FindHandler_r(register osi_socket afd)
857 {
858     register int i;
859     for (i = 0; i < MAXHANDLERS; i++)
860         if (HandlerFD[i] == afd) {
861             return i;
862         }
863     assert(1 == 2);
864     return -1;                  /* satisfy compiler */
865 }
866
867 static int
868 RemoveHandler(register osi_socket afd)
869 {
870     ObtainWriteLock(&SALVSYNC_handler_lock);
871     HandlerFD[FindHandler_r(afd)] = -1;
872     ReleaseWriteLock(&SALVSYNC_handler_lock);
873     return 1;
874 }
875
876 static void
877 GetHandler(fd_set * fdsetp, int *maxfdp)
878 {
879     register int i;
880     register int maxfd = -1;
881     FD_ZERO(fdsetp);
882     ObtainReadLock(&SALVSYNC_handler_lock);     /* just in case */
883     for (i = 0; i < MAXHANDLERS; i++)
884         if (HandlerFD[i] != -1) {
885             FD_SET(HandlerFD[i], fdsetp);
886             if (maxfd < HandlerFD[i])
887                 maxfd = HandlerFD[i];
888         }
889     *maxfdp = maxfd;
890     ReleaseReadLock(&SALVSYNC_handler_lock);    /* just in case */
891 }
892
893 /**
894  * allocate a salvage queue node.
895  *
896  * @param[out] node_out  address in which to store new node pointer
897  *
898  * @return operation status
899  *    @retval 0 success
900  *    @retval 1 failed to allocate node
901  *
902  * @internal
903  */
904 static int
905 AllocNode(struct SalvageQueueNode ** node_out)
906 {
907     int code = 0;
908     struct SalvageQueueNode * node;
909
910     *node_out = node = (struct SalvageQueueNode *) 
911         malloc(sizeof(struct SalvageQueueNode));
912     if (node == NULL) {
913         code = 1;
914         goto done;
915     }
916
917     memset(node, 0, sizeof(struct SalvageQueueNode));
918     node->type = SALVSYNC_VOLGROUP_PARENT;
919     node->state = SALVSYNC_STATE_UNKNOWN;
920
921  done:
922     return code;
923 }
924
925 /**
926  * link a salvage queue node to its parent.
927  *
928  * @param[in] parent  pointer to queue node for parent of volume group
929  * @param[in] clone   pointer to queue node for a clone
930  *
931  * @return operation status
932  *    @retval 0 success
933  *    @retval 1 failure
934  *
935  * @internal
936  */
937 static int
938 LinkNode(struct SalvageQueueNode * parent,
939          struct SalvageQueueNode * clone)
940 {
941     int code = 0;
942     int idx;
943
944     /* check for attaching a clone to a clone */
945     if (parent->type != SALVSYNC_VOLGROUP_PARENT) {
946         code = 1;
947         goto done;
948     }
949
950     /* check for pre-existing registration and openings */
951     for (idx = 0; idx < VOLMAXTYPES; idx++) {
952         if (parent->volgroup.children[idx] == clone) {
953             goto linked;
954         }
955         if (parent->volgroup.children[idx] == NULL) {
956             break;
957         }
958     }
959     if (idx == VOLMAXTYPES) {
960         code = 1;
961         goto done;
962     }
963
964     /* link parent and child */
965     parent->volgroup.children[idx] = clone;
966     clone->type = SALVSYNC_VOLGROUP_CLONE;
967     clone->volgroup.parent = parent;
968
969
970  linked:
971     switch (clone->state) {
972     case SALVSYNC_STATE_QUEUED:
973         DeleteFromSalvageQueue(clone);
974
975     case SALVSYNC_STATE_SALVAGING:
976         switch (parent->state) {
977         case SALVSYNC_STATE_UNKNOWN:
978         case SALVSYNC_STATE_ERROR:
979         case SALVSYNC_STATE_DONE:
980             parent->command.sop.prio = clone->command.sop.prio;
981             AddToSalvageQueue(parent);
982             break;
983
984         case SALVSYNC_STATE_QUEUED:
985             if (clone->command.sop.prio) {
986                 parent->command.sop.prio += clone->command.sop.prio;
987                 UpdateCommandPrio(parent);
988             }
989             break;
990
991         default:
992             break;
993         }
994         break;
995
996     default:
997         break;
998     }
999
1000  done:
1001     return code;
1002 }
1003
1004 static void
1005 HandlePrio(struct SalvageQueueNode * clone, 
1006            struct SalvageQueueNode * node,
1007            afs_uint32 new_prio)
1008 {
1009     afs_uint32 delta;
1010
1011     switch (node->state) {
1012     case SALVSYNC_STATE_ERROR:
1013     case SALVSYNC_STATE_DONE:
1014     case SALVSYNC_STATE_UNKNOWN:
1015         node->command.sop.prio = 0;
1016         break;
1017     }
1018
1019     if (new_prio < clone->command.sop.prio) {
1020         /* strange. let's just set our delta to 1 */
1021         delta = 1;
1022     } else {
1023         delta = new_prio - clone->command.sop.prio;
1024     }
1025
1026     if (clone->type == SALVSYNC_VOLGROUP_CLONE) {
1027         clone->command.sop.prio = new_prio;
1028     }
1029
1030     node->command.sop.prio += delta;
1031 }
1032
1033 static int
1034 AddToSalvageQueue(struct SalvageQueueNode * node)
1035 {
1036     afs_int32 id;
1037     struct SalvageQueueNode * last = NULL;
1038
1039     id = volutil_GetPartitionID(node->command.sop.partName);
1040     if (id < 0 || id > VOLMAXPARTS) {
1041         return 1;
1042     }
1043     if (!VGetPartitionById_r(id, 0)) {
1044         /* don't enqueue salvage requests for unmounted partitions */
1045         return 1;
1046     }
1047     if (queue_IsOnQueue(node)) {
1048         return 0;
1049     }
1050
1051     if (queue_IsNotEmpty(&salvageQueue.part[id])) {
1052         last = queue_Last(&salvageQueue.part[id], SalvageQueueNode);
1053     }
1054     queue_Append(&salvageQueue.part[id], node);
1055     salvageQueue.len[id]++;
1056     salvageQueue.total_len++;
1057     salvageQueue.last_insert = id;
1058     node->partition_id = id;
1059     node->state = SALVSYNC_STATE_QUEUED;
1060
1061     /* reorder, if necessary */
1062     if (last && last->command.sop.prio < node->command.sop.prio) {
1063         UpdateCommandPrio(node);
1064     }
1065
1066     assert(pthread_cond_broadcast(&salvageQueue.cv) == 0);
1067     return 0;
1068 }
1069
1070 static void
1071 DeleteFromSalvageQueue(struct SalvageQueueNode * node)
1072 {
1073     if (queue_IsOnQueue(node)) {
1074         queue_Remove(node);
1075         salvageQueue.len[node->partition_id]--;
1076         salvageQueue.total_len--;
1077         node->state = SALVSYNC_STATE_UNKNOWN;
1078         assert(pthread_cond_broadcast(&salvageQueue.cv) == 0);
1079     }
1080 }
1081
1082 static void
1083 AddToPendingQueue(struct SalvageQueueNode * node)
1084 {
1085     queue_Append(&pendingQueue, node);
1086     pendingQueue.len++;
1087     node->state = SALVSYNC_STATE_SALVAGING;
1088     assert(pthread_cond_broadcast(&pendingQueue.queue_change_cv) == 0);
1089 }
1090
1091 static void
1092 DeleteFromPendingQueue(struct SalvageQueueNode * node)
1093 {
1094     if (queue_IsOnQueue(node)) {
1095         queue_Remove(node);
1096         pendingQueue.len--;
1097         node->state = SALVSYNC_STATE_UNKNOWN;
1098         assert(pthread_cond_broadcast(&pendingQueue.queue_change_cv) == 0);
1099     }
1100 }
1101
1102 static struct SalvageQueueNode *
1103 LookupPendingCommand(SALVSYNC_command_hdr * qry)
1104 {
1105     struct SalvageQueueNode * np, * nnp;
1106
1107     for (queue_Scan(&pendingQueue, np, nnp, SalvageQueueNode)) {
1108         if ((np->command.sop.volume == qry->volume) && 
1109             !strncmp(np->command.sop.partName, qry->partName,
1110                      sizeof(qry->partName)))
1111             break;
1112     }
1113
1114     if (queue_IsEnd(&pendingQueue, np))
1115         np = NULL;
1116     return np;
1117 }
1118
1119 static struct SalvageQueueNode *
1120 LookupPendingCommandByPid(int pid)
1121 {
1122     struct SalvageQueueNode * np, * nnp;
1123
1124     for (queue_Scan(&pendingQueue, np, nnp, SalvageQueueNode)) {
1125         if (np->pid == pid)
1126             break;
1127     }
1128
1129     if (queue_IsEnd(&pendingQueue, np))
1130         np = NULL;
1131     return np;
1132 }
1133
1134
1135 /* raise the priority of a previously scheduled salvage */
1136 static void
1137 UpdateCommandPrio(struct SalvageQueueNode * node)
1138 {
1139     struct SalvageQueueNode *np, *nnp;
1140     afs_int32 id;
1141     afs_uint32 prio;
1142
1143     assert(queue_IsOnQueue(node));
1144
1145     prio = node->command.sop.prio;
1146     id = node->partition_id;
1147     if (queue_First(&salvageQueue.part[id], SalvageQueueNode)->command.sop.prio < prio) {
1148         queue_Remove(node);
1149         queue_Prepend(&salvageQueue.part[id], node);
1150     } else {
1151         for (queue_ScanBackwardsFrom(&salvageQueue.part[id], node, np, nnp, SalvageQueueNode)) {
1152             if (np->command.sop.prio > prio)
1153                 break;
1154         }
1155         if (queue_IsEnd(&salvageQueue.part[id], np)) {
1156             queue_Remove(node);
1157             queue_Prepend(&salvageQueue.part[id], node);
1158         } else if (node != np) {
1159             queue_Remove(node);
1160             queue_InsertAfter(np, node);
1161         }
1162     }
1163 }
1164
1165 /* this will need to be rearchitected if we ever want more than one thread
1166  * to wait for new salvage nodes */
1167 struct SalvageQueueNode * 
1168 SALVSYNC_getWork(void)
1169 {
1170     int i, ret;
1171     struct DiskPartition64 * dp = NULL, * fdp;
1172     static afs_int32 next_part_sched = 0;
1173     struct SalvageQueueNode *node = NULL, *np;
1174
1175     VOL_LOCK;
1176
1177     /*
1178      * wait for work to be scheduled
1179      * if there are no disk partitions, just sit in this wait loop forever
1180      */
1181     while (!salvageQueue.total_len || !DiskPartitionList) {
1182         VOL_CV_WAIT(&salvageQueue.cv);
1183     }
1184
1185     /* 
1186      * short circuit for simple case where only one partition has
1187      * scheduled salvages
1188      */
1189     if (salvageQueue.last_insert >= 0 && salvageQueue.last_insert <= VOLMAXPARTS &&
1190         (salvageQueue.total_len == salvageQueue.len[salvageQueue.last_insert])) {
1191         node = queue_First(&salvageQueue.part[salvageQueue.last_insert], SalvageQueueNode);
1192         goto have_node;
1193     }
1194
1195
1196     /* 
1197      * ok, more than one partition has scheduled salvages.
1198      * now search for partitions with scheduled salvages, but no pending salvages. 
1199      */
1200     dp = VGetPartitionById_r(next_part_sched, 0);
1201     if (!dp) {
1202         dp = DiskPartitionList;
1203     }
1204     fdp = dp;
1205
1206     for (i=0 ; 
1207          !i || dp != fdp ; 
1208          dp = (dp->next) ? dp->next : DiskPartitionList, i++ ) {
1209         if (!partition_salvaging[dp->index] && salvageQueue.len[dp->index]) {
1210             node = queue_First(&salvageQueue.part[dp->index], SalvageQueueNode);
1211             goto have_node;
1212         }
1213     }
1214
1215
1216     /*
1217      * all partitions with scheduled salvages have at least one pending.
1218      * now do an exhaustive search for a scheduled salvage.
1219      */
1220     dp = fdp;
1221
1222     for (i=0 ; 
1223          !i || dp != fdp ; 
1224          dp = (dp->next) ? dp->next : DiskPartitionList, i++ ) {
1225         if (salvageQueue.len[dp->index]) {
1226             node = queue_First(&salvageQueue.part[dp->index], SalvageQueueNode);
1227             goto have_node;
1228         }
1229     }
1230
1231     /* we should never reach this line */
1232     assert(1==2);
1233
1234  have_node:
1235     assert(node != NULL);
1236     node->pid = 0;
1237     partition_salvaging[node->partition_id]++;
1238     DeleteFromSalvageQueue(node);
1239     AddToPendingQueue(node);
1240
1241     if (dp) {
1242         /* update next_part_sched field */
1243         if (dp->next) {
1244             next_part_sched = dp->next->index;
1245         } else if (DiskPartitionList) {
1246             next_part_sched = DiskPartitionList->index;
1247         } else {
1248             next_part_sched = -1;
1249         }
1250     }
1251
1252  bail:
1253     VOL_UNLOCK;
1254     return node;
1255 }
1256
1257 /**
1258  * update internal scheduler state to reflect completion of a work unit.
1259  *
1260  * @param[in]  node    salvage queue node object pointer
1261  * @param[in]  result  worker process result code
1262  *
1263  * @post scheduler state is updated.
1264  *
1265  * @internal
1266  */
1267 static void
1268 SALVSYNC_doneWork_r(struct SalvageQueueNode * node, int result)
1269 {
1270     afs_int32 partid;
1271     int idx;
1272
1273     DeleteFromPendingQueue(node);
1274     partid = node->partition_id;
1275     if (partid >=0 && partid <= VOLMAXPARTS) {
1276         partition_salvaging[partid]--;
1277     }
1278     if (result == 0) {
1279         node->state = SALVSYNC_STATE_DONE;
1280     } else if (result != SALSRV_EXIT_VOLGROUP_LINK) {
1281         node->state = SALVSYNC_STATE_ERROR;
1282     }
1283
1284     if (node->type == SALVSYNC_VOLGROUP_PARENT) {
1285         for (idx = 0; idx < VOLMAXTYPES; idx++) {
1286             if (node->volgroup.children[idx]) {
1287                 node->volgroup.children[idx]->state = node->state;
1288             }
1289         }
1290     }
1291 }
1292
1293 /**
1294  * check whether worker child failed.
1295  *
1296  * @param[in] status  status bitfield return by wait()
1297  *
1298  * @return boolean failure code
1299  *    @retval 0 child succeeded
1300  *    @retval 1 child failed
1301  *
1302  * @internal
1303  */
1304 static int
1305 ChildFailed(int status)
1306 {
1307     return (WCOREDUMP(status) || 
1308             WIFSIGNALED(status) || 
1309             ((WEXITSTATUS(status) != 0) && 
1310              (WEXITSTATUS(status) != SALSRV_EXIT_VOLGROUP_LINK)));
1311 }
1312
1313
1314 /**
1315  * notify salvsync scheduler of node completion, by child pid.
1316  *
1317  * @param[in]  pid     pid of worker child
1318  * @param[in]  status  worker status bitfield from wait()
1319  *
1320  * @post scheduler state is updated.
1321  *       if status code is a failure, fileserver notification was attempted
1322  *
1323  * @see SALVSYNC_doneWork_r
1324  */
1325 void
1326 SALVSYNC_doneWorkByPid(int pid, int status)
1327 {
1328     struct SalvageQueueNode * node;
1329     char partName[16];
1330     afs_uint32 volids[VOLMAXTYPES+1];
1331     unsigned int idx;
1332
1333     memset(volids, 0, sizeof(volids));
1334
1335     VOL_LOCK;
1336     node = LookupPendingCommandByPid(pid);
1337     if (node != NULL) {
1338         SALVSYNC_doneWork_r(node, status);
1339
1340         if (ChildFailed(status)) {
1341             /* populate volume id list for later processing outside the glock */
1342             volids[0] = node->command.sop.volume;
1343             strcpy(partName, node->command.sop.partName);
1344             if (node->type == SALVSYNC_VOLGROUP_PARENT) {
1345                 for (idx = 0; idx < VOLMAXTYPES; idx++) {
1346                     if (node->volgroup.children[idx]) {
1347                         volids[idx+1] = node->volgroup.children[idx]->command.sop.volume;
1348                     }
1349                 }
1350             }
1351         }
1352     }
1353     VOL_UNLOCK;
1354
1355     /*
1356      * if necessary, notify fileserver of
1357      * failure to salvage volume group
1358      * [we cannot guarantee that the child made the
1359      *  appropriate notifications (e.g. SIGSEGV)]
1360      *  -- tkeiser 11/28/2007
1361      */
1362     if (ChildFailed(status)) {
1363         for (idx = 0; idx <= VOLMAXTYPES; idx++) {
1364             if (volids[idx]) {
1365                 FSYNC_VolOp(volids[idx],
1366                             partName,
1367                             FSYNC_VOL_FORCE_ERROR,
1368                             FSYNC_WHATEVER,
1369                             NULL);
1370             }
1371         }
1372     }
1373 }
1374
1375 #endif /* AFS_DEMAND_ATTACH_FS */