fssync-debug: exec DAFS version if DAFS detected
[openafs.git] / src / vol / fssync-debug.c
1 /*
2  * Copyright 2006-2010, 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 /* Main program file. Define globals. */
11 #define MAIN 1
12
13 /*
14  * fssync administration tool
15  */
16
17
18 #include <afsconfig.h>
19 #include <afs/param.h>
20
21
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <dirent.h>
26 #include <sys/stat.h>
27 #include <time.h>
28 #include <errno.h>
29 #ifdef AFS_NT40_ENV
30 #include <io.h>
31 #include <WINNT/afsevent.h>
32 #else
33 #include <sys/param.h>
34 #include <sys/file.h>
35 #ifndef ITIMER_REAL
36 #include <sys/time.h>
37 #endif /* ITIMER_REAL */
38 #endif
39 #include <rx/xdr.h>
40 #include <afs/afsint.h>
41 #include <afs/assert.h>
42
43 #include <fcntl.h>
44
45 #ifndef AFS_NT40_ENV
46 #include <afs/osi_inode.h>
47 #endif
48
49 #include <afs/cmd.h>
50 #include <afs/dir.h>
51 #include <afs/afsutil.h>
52 #include <afs/fileutil.h>
53
54 #include "nfs.h"
55 #include "lwp.h"
56 #include "lock.h"
57 #include "ihandle.h"
58 #include "vnode.h"
59 #include "volume.h"
60 #include "volume_inline.h"
61 #include "partition.h"
62 #include "daemon_com.h"
63 #include "daemon_com_inline.h"
64 #include "fssync.h"
65 #include "fssync_inline.h"
66 #include "vg_cache.h"
67 #ifdef AFS_NT40_ENV
68 #include <pthread.h>
69 #endif
70
71 int VolumeChanged; /* hack to make dir package happy */
72
73
74 struct volop_state {
75     afs_uint32 volume;
76     afs_uint32 vnode;
77     afs_uint32 unique;
78     char partName[16];
79 };
80
81 struct state {
82     afs_int32 reason;
83     struct volop_state * vop;
84 };
85
86 #ifndef AFS_DEMAND_ATTACH_FS
87 /* remember argv/argc for later, if we need to re-exec */
88 static char **fssd_argv;
89 static int fssd_argc;
90 #endif
91
92 static int common_prolog(struct cmd_syndesc *, struct state *);
93 static int common_volop_prolog(struct cmd_syndesc *, struct state *);
94
95 static int do_volop(struct state *, afs_int32 command, SYNC_response * res);
96
97 static int VolOnline(struct cmd_syndesc * as, void * rock);
98 static int VolOffline(struct cmd_syndesc * as, void * rock);
99 static int VolMode(struct cmd_syndesc * as, void * rock);
100 static int VolDetach(struct cmd_syndesc * as, void * rock);
101 static int VolBreakCBKs(struct cmd_syndesc * as, void * rock);
102 static int VolMove(struct cmd_syndesc * as, void * rock);
103 static int VolList(struct cmd_syndesc * as, void * rock);
104 static int VolLeaveOff(struct cmd_syndesc * as, void * rock);
105 static int VolForceAttach(struct cmd_syndesc * as, void * rock);
106 static int VolForceError(struct cmd_syndesc * as, void * rock);
107 static int VolQuery(struct cmd_syndesc * as, void * rock);
108 static int VolHdrQuery(struct cmd_syndesc * as, void * rock);
109 static int VolOpQuery(struct cmd_syndesc * as, void * rock);
110 static int StatsQuery(struct cmd_syndesc * as, void * rock);
111 static int VnQuery(struct cmd_syndesc * as, void * rock);
112
113 static int VGCQuery(struct cmd_syndesc * as, void * rock);
114 static int VGCAdd(struct cmd_syndesc * as, void * rock);
115 static int VGCDel(struct cmd_syndesc * as, void * rock);
116 static int VGCScan(struct cmd_syndesc * as, void * rock);
117 static int VGCScanAll(struct cmd_syndesc * as, void * rock);
118
119 static void print_vol_stats_general(VolPkgStats * stats);
120 static void print_vol_stats_viceP(struct DiskPartitionStats64 * stats);
121 static void print_vol_stats_hash(struct VolumeHashChainStats * stats);
122 #ifdef AFS_DEMAND_ATTACH_FS
123 static void print_vol_stats_hdr(struct volume_hdr_LRU_stats * stats);
124 #endif
125
126 #ifndef AFS_NT40_ENV
127 #include "AFS_component_version_number.c"
128 #endif
129 #define MAX_ARGS 128
130
131 #define COMMON_PARMS_OFFSET    12
132 #define COMMON_PARMS(ts) \
133     cmd_Seek(ts, COMMON_PARMS_OFFSET); \
134     cmd_AddParm(ts, "-reason", CMD_SINGLE, CMD_OPTIONAL, "sync protocol reason code"); \
135     cmd_AddParm(ts, "-programtype", CMD_SINGLE, CMD_OPTIONAL, "program type code")
136
137 #define COMMON_VOLOP_PARMS_OFFSET    10
138 #define COMMON_VOLOP_PARMS(ts) \
139     cmd_Seek(ts, COMMON_VOLOP_PARMS_OFFSET); \
140     cmd_AddParm(ts, "-volumeid", CMD_SINGLE, 0, "volume id"); \
141     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL, "partition name")
142
143 #define CUSTOM_PARMS_OFFSET 1
144
145
146 #define VOLOP_PARMS_DECL(ts) \
147     COMMON_VOLOP_PARMS(ts); \
148     COMMON_PARMS(ts)
149 #define COMMON_PARMS_DECL(ts) \
150     COMMON_PARMS(ts)
151
152 int
153 main(int argc, char **argv)
154 {
155     struct cmd_syndesc *ts;
156     int err = 0;
157
158     /* Initialize directory paths */
159     if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
160 #ifdef AFS_NT40_ENV
161         ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
162 #endif
163         fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
164                 argv[0]);
165         exit(2);
166     }
167
168 #ifndef AFS_DEMAND_ATTACH_FS
169     fssd_argv = argv;
170     fssd_argc = argc;
171 #endif
172
173     ts = cmd_CreateSyntax("online", VolOnline, NULL, "bring a volume online (FSYNC_VOL_ON opcode)");
174     VOLOP_PARMS_DECL(ts);
175
176     ts = cmd_CreateSyntax("offline", VolOffline, NULL, "take a volume offline (FSYNC_VOL_OFF opcode)");
177     VOLOP_PARMS_DECL(ts);
178
179     ts = cmd_CreateSyntax("mode", VolMode, NULL, "change volume attach mode (FSYNC_VOL_NEEDVOLUME opcode)");
180     VOLOP_PARMS_DECL(ts);
181     cmd_CreateAlias(ts, "needvolume");
182
183     ts = cmd_CreateSyntax("detach", VolDetach, NULL, "detach a volume (FSYNC_VOL_DONE opcode)");
184     VOLOP_PARMS_DECL(ts);
185
186     ts = cmd_CreateSyntax("callback", VolBreakCBKs, NULL, "break callbacks for volume (FSYNC_VOL_BREAKCBKS opcode)");
187     VOLOP_PARMS_DECL(ts);
188     cmd_CreateAlias(ts, "cbk");
189
190     ts = cmd_CreateSyntax("move", VolMove, NULL, "set volume moved flag (FSYNC_VOL_MOVE opcode)");
191     VOLOP_PARMS_DECL(ts);
192
193     ts = cmd_CreateSyntax("list", VolList, NULL, "sync local volume list (FSYNC_VOL_LISTVOLUMES opcode)");
194     VOLOP_PARMS_DECL(ts);
195     cmd_CreateAlias(ts, "ls");
196
197     ts = cmd_CreateSyntax("leaveoff", VolLeaveOff, 0, "leave volume offline (FSYNC_VOL_LEAVE_OFF opcode)");
198     VOLOP_PARMS_DECL(ts);
199
200     ts = cmd_CreateSyntax("attach", VolForceAttach, 0, "force full attachment (FSYNC_VOL_ATTACH opcode)");
201     VOLOP_PARMS_DECL(ts);
202
203     ts = cmd_CreateSyntax("error", VolForceError, 0, "force into hard error state (FSYNC_VOL_FORCE_ERROR opcode)");
204     VOLOP_PARMS_DECL(ts);
205
206     ts = cmd_CreateSyntax("query", VolQuery, NULL, "get volume structure (FSYNC_VOL_QUERY opcode)");
207     VOLOP_PARMS_DECL(ts);
208     cmd_CreateAlias(ts, "qry");
209
210     ts = cmd_CreateSyntax("header", VolHdrQuery, NULL, "get volume disk data structure (FSYNC_VOL_QUERY_HDR opcode)");
211     VOLOP_PARMS_DECL(ts);
212     cmd_CreateAlias(ts, "hdr");
213
214     ts = cmd_CreateSyntax("volop", VolOpQuery, NULL, "get pending volume operation info (FSYNC_VOL_QUERY_VOP opcode)");
215     VOLOP_PARMS_DECL(ts);
216     cmd_CreateAlias(ts, "vop");
217
218     ts = cmd_CreateSyntax("vnode", VnQuery, NULL, "get vnode structure (FSYNC_VOL_QUERY_VNODE opcode)");
219     cmd_Seek(ts, CUSTOM_PARMS_OFFSET);
220     cmd_AddParm(ts, "-volumeid", CMD_SINGLE, 0, "volume id");
221     cmd_AddParm(ts, "-vnodeid", CMD_SINGLE, 0, "vnode id");
222     cmd_AddParm(ts, "-unique", CMD_SINGLE, 0, "uniquifier");
223     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
224     COMMON_PARMS_DECL(ts);
225
226     ts = cmd_CreateSyntax("stats", StatsQuery, NULL, "see 'stats help' for more information");
227     cmd_Seek(ts, CUSTOM_PARMS_OFFSET);
228     cmd_AddParm(ts, "-cmd", CMD_SINGLE, 0, "subcommand");
229     cmd_AddParm(ts, "-arg1", CMD_SINGLE, CMD_OPTIONAL, "arg1");
230     cmd_AddParm(ts, "-arg2", CMD_SINGLE, CMD_OPTIONAL, "arg2");
231     COMMON_PARMS_DECL(ts);
232
233     ts = cmd_CreateSyntax("vgcquery", VGCQuery, 0, "query volume group cache (FSYNC_VG_QUERY opcode)");
234     cmd_Seek(ts, CUSTOM_PARMS_OFFSET);
235     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
236     cmd_AddParm(ts, "-volumeid", CMD_SINGLE, 0, "volume id");
237     COMMON_PARMS_DECL(ts);
238     cmd_CreateAlias(ts, "vgcqry");
239
240     ts = cmd_CreateSyntax("vgcadd", VGCAdd, 0, "add entry to volume group cache (FSYNC_VG_ADD opcode)");
241     cmd_Seek(ts, CUSTOM_PARMS_OFFSET);
242     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
243     cmd_AddParm(ts, "-parent", CMD_SINGLE, 0, "parent volume id");
244     cmd_AddParm(ts, "-child", CMD_SINGLE, 0, "child volume id");
245     COMMON_PARMS_DECL(ts);
246
247     ts = cmd_CreateSyntax("vgcdel", VGCDel, 0, "delete entry from volume group cache (FSYNC_VG_DEL opcode)");
248     cmd_Seek(ts, CUSTOM_PARMS_OFFSET);
249     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
250     cmd_AddParm(ts, "-parent", CMD_SINGLE, 0, "parent volume id");
251     cmd_AddParm(ts, "-child", CMD_SINGLE, 0, "child volume id");
252     COMMON_PARMS_DECL(ts);
253
254     ts = cmd_CreateSyntax("vgcscan", VGCScan, 0,
255                           "start volume group cache re-scan"
256                           " (FSYNC_VG_SCAN opcode)");
257     cmd_Seek(ts, CUSTOM_PARMS_OFFSET);
258     cmd_AddParm(ts, "-partition", CMD_SINGLE, 0, "partition name");
259     COMMON_PARMS_DECL(ts);
260
261     ts = cmd_CreateSyntax("vgcscanall", VGCScanAll, 0,
262                           "start whole-server volume group cache re-scan"
263                           " (FSYNC_VG_SCAN_ALL opcode)");
264     COMMON_PARMS_DECL(ts);
265
266     err = cmd_Dispatch(argc, argv);
267     exit(err);
268 }
269
270 #ifdef AFS_DEMAND_ATTACH_FS
271 # define dafs_prolog()
272 #else
273 /* Try to detect if the fileserver is DAFS, and if so, re-exec as the
274  * DAFS-enabled fssync-debug (dafssync_debug). If we fail to detect or
275  * exec, just try to proceed anyway as if the server is not DAFS */
276 static void
277 dafs_prolog(void)
278 {
279     SYNC_response res;
280     SYNC_PROTO_BUF_DECL(res_buf);
281     afs_int32 code;
282     char *dfssd;
283
284     res.payload.len = SYNC_PROTO_MAX_LEN;
285     res.payload.buf = res_buf;
286
287     /* LISTVOLUMES is a no-op; we just want to get the response header flags
288      * to see if the server reports itself as DAFS or not */
289     code = FSYNC_VolOp(0, NULL, FSYNC_VOL_LISTVOLUMES, FSYNC_WHATEVER, &res);
290     if (code) {
291         /* probably failed to contact the fileserver; later code will provide
292          * some warning/error indication */
293         return;
294     }
295
296     if (!(res.hdr.flags & SYNC_FLAG_DAFS_EXTENSIONS)) {
297         /* fileserver is not DAFS, so we don't need to do anything */
298         return;
299     }
300
301     dfssd = afs_exec_alt(fssd_argc, fssd_argv, "da", NULL);
302
303     fprintf(stderr, "\n*** server asserted demand attach extensions, but we failed\n"
304                     "*** to exec a DAFS-enabled fssync-debug '%s' (errno=%d);\n"
305                     "*** attempting to proceed without it.\n\n", dfssd, errno);
306
307     free(dfssd);
308 }
309 #endif /* !AFS_DEMAND_ATTACH_FS */
310
311 static int
312 common_prolog(struct cmd_syndesc * as, struct state * state)
313 {
314     struct cmd_item *ti;
315     VolumePackageOptions opts;
316
317 #ifdef AFS_NT40_ENV
318     if (afs_winsockInit() < 0) {
319         Exit(1);
320     }
321 #endif
322
323     VOptDefaults(debugUtility, &opts);
324     if (VInitVolumePackage2(debugUtility, &opts)) {
325         /* VInitVolumePackage2 can fail on e.g. partition attachment errors,
326          * but we don't really care, since all we're doing is trying to use
327          * FSSYNC */
328         fprintf(stderr, "errors encountered initializing volume package, but "
329                         "trying to continue anyway\n");
330     }
331     DInit(1);
332
333     if ((ti = as->parms[COMMON_PARMS_OFFSET].items)) {  /* -reason */
334         state->reason = atoi(ti->data);
335     }
336     if ((ti = as->parms[COMMON_PARMS_OFFSET+1].items)) {        /* -programtype */
337         if (!strcmp(ti->data, "fileServer")) {
338             programType = fileServer;
339         } else if (!strcmp(ti->data, "volumeUtility")) {
340             programType = volumeUtility;
341         } else if (!strcmp(ti->data, "salvager")) {
342             programType = salvager;
343         } else if (!strcmp(ti->data, "salvageServer")) {
344             programType = salvageServer;
345         } else if (!strcmp(ti->data, "volumeServer")) {
346             programType = volumeServer;
347         } else if (!strcmp(ti->data, "volumeSalvager")) {
348             programType = volumeSalvager;
349         } else {
350             programType = (ProgramType) atoi(ti->data);
351         }
352     }
353
354     VConnectFS();
355
356     return 0;
357 }
358
359 static int
360 common_volop_prolog(struct cmd_syndesc * as, struct state * state)
361 {
362     struct cmd_item *ti;
363
364     state->vop = (struct volop_state *) calloc(1, sizeof(struct volop_state));
365     assert(state->vop != NULL);
366
367     if ((ti = as->parms[COMMON_VOLOP_PARMS_OFFSET].items)) {    /* -volumeid */
368         state->vop->volume = atoi(ti->data);
369     } else {
370         fprintf(stderr, "required argument -volumeid not given\n");
371     }
372
373     if ((ti = as->parms[COMMON_VOLOP_PARMS_OFFSET+1].items)) {  /* -partition */
374         strlcpy(state->vop->partName, ti->data, sizeof(state->vop->partName));
375     } else {
376         memset(state->vop->partName, 0, sizeof(state->vop->partName));
377     }
378
379     return 0;
380 }
381
382 static int
383 debug_response(afs_int32 code, SYNC_response * res)
384 {
385     switch (code) {
386     case SYNC_OK:
387     case SYNC_DENIED:
388         break;
389     default:
390         fprintf(stderr, "warning: response code indicates possible protocol error.\n");
391     }
392
393     fprintf(stderr, "FSSYNC service returned %d (%s)\n", code, SYNC_res2string(code));
394
395     if (res) {
396         fprintf(stderr, "protocol header response code was %d (%s)\n",
397                 res->hdr.response, SYNC_res2string(res->hdr.response));
398         fprintf(stderr, "protocol reason code was %d (%s)\n",
399                 res->hdr.reason, FSYNC_reason2string(res->hdr.reason));
400     }
401
402     return 0;
403 }
404
405 static int
406 do_volop(struct state * state, afs_int32 command, SYNC_response * res)
407 {
408     afs_int32 code;
409     SYNC_PROTO_BUF_DECL(res_buf);
410     SYNC_response res_l;
411
412     if (!res) {
413         res = &res_l;
414         res->payload.len = SYNC_PROTO_MAX_LEN;
415         res->payload.buf = res_buf;
416     }
417
418     fprintf(stderr, "calling FSYNC_VolOp with command code %d (%s)\n",
419             command, FSYNC_com2string(command));
420
421     code = FSYNC_VolOp(state->vop->volume,
422                        state->vop->partName,
423                        command,
424                        state->reason,
425                        res);
426
427     debug_response(code, res);
428
429     VDisconnectFS();
430
431     return 0;
432
433 }
434
435
436 #define ENUMTOSTRING(en)  #en
437 #define ENUMCASE(en) \
438     case en: \
439         return ENUMTOSTRING(en); \
440         break
441
442 #define FLAGTOSTRING(fl)  #fl
443 #define FLAGCASE(bitstr, fl, str, count) \
444     do { \
445         if ((bitstr) & (fl)) { \
446             if (count) \
447                 strlcat((str), " | ", sizeof(str)); \
448             strlcat((str), FLAGTOSTRING(fl), sizeof(str)); \
449             (count)++; \
450         } \
451     } while (0)
452
453 static int
454 VolOnline(struct cmd_syndesc * as, void * rock)
455 {
456     struct state state;
457
458     common_prolog(as, &state);
459     common_volop_prolog(as, &state);
460
461     do_volop(&state, FSYNC_VOL_ON, NULL);
462
463     return 0;
464 }
465
466 static int
467 VolOffline(struct cmd_syndesc * as, void * rock)
468 {
469     struct state state;
470
471     common_prolog(as, &state);
472     common_volop_prolog(as, &state);
473
474     do_volop(&state, FSYNC_VOL_OFF, NULL);
475
476     return 0;
477 }
478
479 static int
480 VolMode(struct cmd_syndesc * as, void * rock)
481 {
482     struct state state;
483
484     common_prolog(as, &state);
485     common_volop_prolog(as, &state);
486
487     do_volop(&state, FSYNC_VOL_NEEDVOLUME, NULL);
488
489     return 0;
490 }
491
492 static int
493 VolDetach(struct cmd_syndesc * as, void * rock)
494 {
495     struct state state;
496
497     common_prolog(as, &state);
498     common_volop_prolog(as, &state);
499
500     do_volop(&state, FSYNC_VOL_DONE, NULL);
501
502     return 0;
503 }
504
505 static int
506 VolBreakCBKs(struct cmd_syndesc * as, void * rock)
507 {
508     struct state state;
509
510     common_prolog(as, &state);
511     common_volop_prolog(as, &state);
512
513     do_volop(&state, FSYNC_VOL_BREAKCBKS, NULL);
514
515     return 0;
516 }
517
518 static int
519 VolMove(struct cmd_syndesc * as, void * rock)
520 {
521     struct state state;
522
523     common_prolog(as, &state);
524     common_volop_prolog(as, &state);
525
526     do_volop(&state, FSYNC_VOL_MOVE, NULL);
527
528     return 0;
529 }
530
531 static int
532 VolList(struct cmd_syndesc * as, void * rock)
533 {
534     struct state state;
535
536     common_prolog(as, &state);
537     common_volop_prolog(as, &state);
538
539     do_volop(&state, FSYNC_VOL_LISTVOLUMES, NULL);
540
541     return 0;
542 }
543
544 static int
545 VolLeaveOff(struct cmd_syndesc * as, void * rock)
546 {
547     struct state state;
548
549     common_prolog(as, &state);
550     common_volop_prolog(as, &state);
551
552     do_volop(&state, FSYNC_VOL_LEAVE_OFF, NULL);
553
554     return 0;
555 }
556
557 static int
558 VolForceAttach(struct cmd_syndesc * as, void * rock)
559 {
560     struct state state;
561
562     common_prolog(as, &state);
563     common_volop_prolog(as, &state);
564
565     do_volop(&state, FSYNC_VOL_ATTACH, NULL);
566
567     return 0;
568 }
569
570 static int
571 VolForceError(struct cmd_syndesc * as, void * rock)
572 {
573     struct state state;
574
575     common_prolog(as, &state);
576     common_volop_prolog(as, &state);
577
578     do_volop(&state, FSYNC_VOL_FORCE_ERROR, NULL);
579
580     return 0;
581 }
582
583 #ifdef AFS_DEMAND_ATTACH_FS
584 static char *
585 vol_state_to_string(VolState state)
586 {
587     switch (state) {
588         ENUMCASE(VOL_STATE_UNATTACHED);
589         ENUMCASE(VOL_STATE_PREATTACHED);
590         ENUMCASE(VOL_STATE_ATTACHING);
591         ENUMCASE(VOL_STATE_ATTACHED);
592         ENUMCASE(VOL_STATE_UPDATING);
593         ENUMCASE(VOL_STATE_GET_BITMAP);
594         ENUMCASE(VOL_STATE_HDR_LOADING);
595         ENUMCASE(VOL_STATE_HDR_ATTACHING);
596         ENUMCASE(VOL_STATE_SHUTTING_DOWN);
597         ENUMCASE(VOL_STATE_GOING_OFFLINE);
598         ENUMCASE(VOL_STATE_OFFLINING);
599         ENUMCASE(VOL_STATE_DETACHING);
600         ENUMCASE(VOL_STATE_SALVSYNC_REQ);
601         ENUMCASE(VOL_STATE_SALVAGING);
602         ENUMCASE(VOL_STATE_ERROR);
603         ENUMCASE(VOL_STATE_VNODE_ALLOC);
604         ENUMCASE(VOL_STATE_VNODE_GET);
605         ENUMCASE(VOL_STATE_VNODE_CLOSE);
606         ENUMCASE(VOL_STATE_VNODE_RELEASE);
607         ENUMCASE(VOL_STATE_VLRU_ADD);
608         ENUMCASE(VOL_STATE_DELETED);
609         ENUMCASE(VOL_STATE_FREED);
610     default:
611         return "**UNKNOWN**";
612     }
613 }
614
615 static char *
616 vol_flags_to_string(afs_uint16 flags)
617 {
618     static char str[128];
619     int count = 0;
620     str[0]='\0';
621
622     FLAGCASE(flags, VOL_HDR_ATTACHED, str, count);
623     FLAGCASE(flags, VOL_HDR_LOADED, str, count);
624     FLAGCASE(flags, VOL_HDR_IN_LRU, str, count);
625     FLAGCASE(flags, VOL_IN_HASH, str, count);
626     FLAGCASE(flags, VOL_ON_VBYP_LIST, str, count);
627     FLAGCASE(flags, VOL_IS_BUSY, str, count);
628     FLAGCASE(flags, VOL_ON_VLRU, str, count);
629     FLAGCASE(flags, VOL_HDR_DONTSALV, str, count);
630
631     return str;
632 }
633
634 static char *
635 vlru_idx_to_string(int idx)
636 {
637     switch (idx) {
638         ENUMCASE(VLRU_QUEUE_NEW);
639         ENUMCASE(VLRU_QUEUE_MID);
640         ENUMCASE(VLRU_QUEUE_OLD);
641         ENUMCASE(VLRU_QUEUE_CANDIDATE);
642         ENUMCASE(VLRU_QUEUE_HELD);
643         ENUMCASE(VLRU_QUEUE_INVALID);
644     default:
645         return "**UNKNOWN**";
646     }
647 }
648
649
650 static char *
651 vn_state_to_string(VnState state)
652 {
653     switch (state) {
654         ENUMCASE(VN_STATE_INVALID);
655         ENUMCASE(VN_STATE_RELEASING);
656         ENUMCASE(VN_STATE_CLOSING);
657         ENUMCASE(VN_STATE_ALLOC);
658         ENUMCASE(VN_STATE_ONLINE);
659         ENUMCASE(VN_STATE_LOAD);
660         ENUMCASE(VN_STATE_EXCLUSIVE);
661         ENUMCASE(VN_STATE_STORE);
662         ENUMCASE(VN_STATE_READ);
663         ENUMCASE(VN_STATE_ERROR);
664     default:
665         return "**UNKNOWN**";
666     }
667 }
668
669 static char *
670 vn_flags_to_string(afs_uint32 flags)
671 {
672     static char str[128];
673     int count = 0;
674     str[0]='\0';
675
676     FLAGCASE(flags, VN_ON_HASH, str, count);
677     FLAGCASE(flags, VN_ON_LRU, str, count);
678     FLAGCASE(flags, VN_ON_VVN, str, count);
679
680     return str;
681 }
682 #endif
683
684 static int
685 VolQuery(struct cmd_syndesc * as, void * rock)
686 {
687     struct state state;
688     SYNC_PROTO_BUF_DECL(res_buf);
689     SYNC_response res;
690     Volume v;
691 #ifdef AFS_DEMAND_ATTACH_FS
692     int hi, lo;
693 #endif
694
695     dafs_prolog();
696
697     res.hdr.response_len = sizeof(res.hdr);
698     res.payload.buf = res_buf;
699     res.payload.len = SYNC_PROTO_MAX_LEN;
700
701     common_prolog(as, &state);
702     common_volop_prolog(as, &state);
703
704     do_volop(&state, FSYNC_VOL_QUERY, &res);
705
706     if (res.hdr.response == SYNC_OK) {
707         memcpy(&v, res.payload.buf, sizeof(Volume));
708
709         printf("volume = {\n");
710         printf("\thashid          = %u\n", v.hashid);
711         printf("\theader          = %p\n", v.header);
712         printf("\tdevice          = %d\n", v.device);
713         printf("\tpartition       = %p\n", v.partition);
714         printf("\tlinkHandle      = %p\n", v.linkHandle);
715         printf("\tnextVnodeUnique = %u\n", v.nextVnodeUnique);
716         printf("\tdiskDataHandle  = %p\n", v.diskDataHandle);
717         printf("\tvnodeHashOffset = %u\n", v.vnodeHashOffset);
718         printf("\tshuttingDown    = %d\n", v.shuttingDown);
719         printf("\tgoingOffline    = %d\n", v.goingOffline);
720         printf("\tcacheCheck      = %u\n", v.cacheCheck);
721         printf("\tnUsers          = %d\n", v.nUsers);
722         printf("\tneedsPutBack    = %d\n", v.needsPutBack);
723         printf("\tspecialStatus   = %d\n", v.specialStatus);
724         printf("\tupdateTime      = %u\n", v.updateTime);
725
726         printf("\tvnodeIndex[vSmall] = {\n");
727         printf("\t\thandle       = %p\n", v.vnodeIndex[vSmall].handle);
728         printf("\t\tbitmap       = %p\n", v.vnodeIndex[vSmall].bitmap);
729         printf("\t\tbitmapSize   = %u\n", v.vnodeIndex[vSmall].bitmapSize);
730         printf("\t\tbitmapOffset = %u\n", v.vnodeIndex[vSmall].bitmapOffset);
731         printf("\t}\n");
732         printf("\tvnodeIndex[vLarge] = {\n");
733         printf("\t\thandle       = %p\n", v.vnodeIndex[vLarge].handle);
734         printf("\t\tbitmap       = %p\n", v.vnodeIndex[vLarge].bitmap);
735         printf("\t\tbitmapSize   = %u\n", v.vnodeIndex[vLarge].bitmapSize);
736         printf("\t\tbitmapOffset = %u\n", v.vnodeIndex[vLarge].bitmapOffset);
737         printf("\t}\n");
738 #ifdef AFS_DEMAND_ATTACH_FS
739         if (res.hdr.flags & SYNC_FLAG_DAFS_EXTENSIONS) {
740             printf("\tupdateTime      = %u\n", v.updateTime);
741             printf("\tattach_state    = %s\n", vol_state_to_string(v.attach_state));
742             printf("\tattach_flags    = %s\n", vol_flags_to_string(v.attach_flags));
743             printf("\tnWaiters        = %d\n", v.nWaiters);
744             printf("\tchainCacheCheck = %d\n", v.chainCacheCheck);
745
746             /* online salvage structure */
747             printf("\tsalvage = {\n");
748             printf("\t\tprio      = %u\n", v.salvage.prio);
749             printf("\t\treason    = %d\n", v.salvage.reason);
750             printf("\t\trequested = %d\n", v.salvage.requested);
751             printf("\t\tscheduled = %d\n", v.salvage.scheduled);
752             printf("\t}\n");
753
754             /* statistics structure */
755             printf("\tstats = {\n");
756
757             printf("\t\thash_lookups = {\n");
758             SplitInt64(v.stats.hash_lookups,hi,lo);
759             printf("\t\t\thi = %u\n", hi);
760             printf("\t\t\tlo = %u\n", lo);
761             printf("\t\t}\n");
762
763             printf("\t\thash_short_circuits = {\n");
764             SplitInt64(v.stats.hash_short_circuits,hi,lo);
765             printf("\t\t\thi = %u\n", hi);
766             printf("\t\t\tlo = %u\n", lo);
767             printf("\t\t}\n");
768
769             printf("\t\thdr_loads = {\n");
770             SplitInt64(v.stats.hdr_loads,hi,lo);
771             printf("\t\t\thi = %u\n", hi);
772             printf("\t\t\tlo = %u\n", lo);
773             printf("\t\t}\n");
774
775             printf("\t\thdr_gets = {\n");
776             SplitInt64(v.stats.hdr_gets,hi,lo);
777             printf("\t\t\thi = %u\n", hi);
778             printf("\t\t\tlo = %u\n", lo);
779             printf("\t\t}\n");
780
781             printf("\t\tattaches         = %u\n", v.stats.attaches);
782             printf("\t\tsoft_detaches    = %u\n", v.stats.soft_detaches);
783             printf("\t\tsalvages         = %u\n", v.stats.salvages);
784             printf("\t\tvol_ops          = %u\n", v.stats.vol_ops);
785
786             printf("\t\tlast_attach      = %u\n", v.stats.last_attach);
787             printf("\t\tlast_get         = %u\n", v.stats.last_get);
788             printf("\t\tlast_promote     = %u\n", v.stats.last_promote);
789             printf("\t\tlast_hdr_get     = %u\n", v.stats.last_hdr_get);
790             printf("\t\tlast_hdr_load    = %u\n", v.stats.last_hdr_load);
791             printf("\t\tlast_salvage     = %u\n", v.stats.last_salvage);
792             printf("\t\tlast_salvage_req = %u\n", v.stats.last_salvage_req);
793             printf("\t\tlast_vol_op      = %u\n", v.stats.last_vol_op);
794             printf("\t}\n");
795
796             /* VLRU state */
797             printf("\tvlru = {\n");
798             printf("\t\tidx = %d (%s)\n",
799                    v.vlru.idx, vlru_idx_to_string(v.vlru.idx));
800             printf("\t}\n");
801
802             /* volume op state */
803             printf("\tpending_vol_op  = %p\n", v.pending_vol_op);
804         }
805 #else /* !AFS_DEMAND_ATTACH_FS */
806         if (res.hdr.flags & SYNC_FLAG_DAFS_EXTENSIONS) {
807             printf("*** server asserted demand attach extensions. this fssync-debug\n"
808                    "*** is not built to recognize those extensions. please use an\n"
809                    "*** fssync-debug with demand attach if you need to dump dafs\n"
810                    "*** extended state.\n");
811         }
812 #endif /* !AFS_DEMAND_ATTACH_FS */
813         printf("}\n");
814     }
815
816     return 0;
817 }
818
819 static int
820 VolHdrQuery(struct cmd_syndesc * as, void * rock)
821 {
822     struct state state;
823     SYNC_PROTO_BUF_DECL(res_buf);
824     SYNC_response res;
825     VolumeDiskData v;
826     int i;
827
828     res.hdr.response_len = sizeof(res.hdr);
829     res.payload.buf = res_buf;
830     res.payload.len = SYNC_PROTO_MAX_LEN;
831
832     common_prolog(as, &state);
833     common_volop_prolog(as, &state);
834
835     do_volop(&state, FSYNC_VOL_QUERY_HDR, &res);
836
837     if (res.hdr.response == SYNC_OK) {
838         memcpy(&v, res.payload.buf, sizeof(VolumeDiskData));
839
840         printf("VolumeDiskData = {\n");
841         printf("\tstamp = {\n");
842         printf("\t\tmagic   = 0x%x\n", v.stamp.magic);
843         printf("\t\tversion = %u\n", v.stamp.version);
844         printf("\t}\n");
845
846         printf("\tid               = %u\n", v.id);
847         printf("\tname             = '%s'\n", v.name);
848         if (v.inUse != 0) {
849             printf("\tinUse            = %d (%s)\n", v.inUse, VPTypeToString(v.inUse));
850         } else {
851             printf("\tinUse            = %d (no)\n", v.inUse);
852         }
853         printf("\tinService        = %d\n", v.inService);
854         printf("\tblessed          = %d\n", v.blessed);
855         printf("\tneedsSalvaged    = %d\n", v.needsSalvaged);
856         printf("\tuniquifier       = %u\n", v.uniquifier);
857         printf("\ttype             = %d\n", v.type);
858         printf("\tparentId         = %u\n", v.parentId);
859         printf("\tcloneId          = %u\n", v.cloneId);
860         printf("\tbackupId         = %u\n", v.backupId);
861         printf("\trestoredFromId   = %u\n", v.restoredFromId);
862         printf("\tneedsCallback    = %d\n", v.needsCallback);
863         printf("\tdestroyMe        = %d\n", v.destroyMe);
864         printf("\tdontSalvage      = %d\n", v.dontSalvage);
865         printf("\tmaxquota         = %d\n", v.maxquota);
866         printf("\tminquota         = %d\n", v.minquota);
867         printf("\tmaxfiles         = %d\n", v.maxfiles);
868         printf("\taccountNumber    = %u\n", v.accountNumber);
869         printf("\towner            = %u\n", v.owner);
870         printf("\tfilecount        = %d\n", v.filecount);
871         printf("\tdiskused         = %d\n", v.diskused);
872         printf("\tdayUse           = %d\n", v.dayUse);
873         for (i = 0; i < 7; i++) {
874             printf("\tweekUse[%d]       = %d\n", i, v.weekUse[i]);
875         }
876         printf("\tdayUseDate       = %u\n", v.dayUseDate);
877         printf("\tcreationDate     = %u\n", v.creationDate);
878         printf("\taccessDate       = %u\n", v.accessDate);
879         printf("\tupdateDate       = %u\n", v.updateDate);
880         printf("\texpirationDate   = %u\n", v.expirationDate);
881         printf("\tbackupDate       = %u\n", v.backupDate);
882         printf("\tcopyDate         = %u\n", v.copyDate);
883 #ifdef OPENAFS_VOL_STATS
884         printf("\tstat_initialized = %d\n", v.stat_initialized);
885 #else
886         printf("\tmtd              = '%s'\n", v.motd);
887 #endif
888         printf("}\n");
889     }
890
891     return 0;
892 }
893
894 static int
895 VolOpQuery(struct cmd_syndesc * as, void * rock)
896 {
897     struct state state;
898     SYNC_PROTO_BUF_DECL(res_buf);
899     SYNC_response res;
900     FSSYNC_VolOp_info vop;
901
902     res.hdr.response_len = sizeof(res.hdr);
903     res.payload.buf = res_buf;
904     res.payload.len = SYNC_PROTO_MAX_LEN;
905
906     common_prolog(as, &state);
907     common_volop_prolog(as, &state);
908
909     do_volop(&state, FSYNC_VOL_QUERY_VOP, &res);
910
911     if (!(res.hdr.flags & SYNC_FLAG_DAFS_EXTENSIONS)) {
912         printf("*** file server not compiled with demand attach extensions.\n");
913         printf("*** pending volume operation metadata not available.\n");
914     }
915
916     if (res.hdr.response == SYNC_OK) {
917         memcpy(&vop, res.payload.buf, sizeof(FSSYNC_VolOp_info));
918
919         printf("pending_vol_op = {\n");
920
921         printf("\tcom = {\n");
922         printf("\t\tproto_version  = %u\n", vop.com.proto_version);
923         printf("\t\tpkt_seq        = %u\n", vop.com.pkt_seq);
924         printf("\t\tcom_seq        = %u\n", vop.com.com_seq);
925         printf("\t\tprogramType    = %d (%s)\n",
926                vop.com.programType, VPTypeToString(vop.com.programType));
927         printf("\t\tpid            = %d\n", vop.com.pid);
928         printf("\t\ttid            = %d\n", vop.com.tid);
929         printf("\t\tcommand        = %d (%s)\n",
930                vop.com.command, FSYNC_com2string(vop.com.command));
931         printf("\t\treason         = %d (%s)\n",
932                vop.com.reason, FSYNC_reason2string(vop.com.reason));
933         printf("\t\tcommand_len    = %u\n", vop.com.command_len);
934         printf("\t\tflags          = 0x%lux\n", afs_printable_uint32_lu(vop.com.flags));
935         printf("\t}\n");
936
937         printf("\tvop = {\n");
938         printf("\t\tvolume         = %u\n", vop.vop.volume);
939         if (afs_strnlen(vop.vop.partName, sizeof(vop.vop.partName)) <
940             sizeof(vop.vop.partName)) {
941             printf("\t\tpartName       = '%s'\n", vop.vop.partName);
942         } else {
943             printf("\t\tpartName       = (illegal string)\n");
944         }
945         printf("\t}\n");
946
947         printf("}\n");
948     }
949
950     return 0;
951 }
952
953 static int
954 vn_prolog(struct cmd_syndesc * as, struct state * state)
955 {
956     struct cmd_item *ti;
957
958     state->vop = (struct volop_state *) calloc(1, sizeof(struct volop_state));
959     assert(state->vop != NULL);
960
961     if ((ti = as->parms[CUSTOM_PARMS_OFFSET].items)) {  /* -volumeid */
962         state->vop->volume = atoi(ti->data);
963     } else {
964         fprintf(stderr, "required argument -volumeid not given\n");
965     }
966
967     if ((ti = as->parms[CUSTOM_PARMS_OFFSET+1].items)) {        /* -vnodeid */
968         state->vop->vnode = atoi(ti->data);
969     } else {
970         fprintf(stderr, "required argument -vnodeid not given\n");
971     }
972
973     if ((ti = as->parms[CUSTOM_PARMS_OFFSET+2].items)) {        /* -unique */
974         state->vop->unique = atoi(ti->data);
975     } else {
976         state->vop->unique = 0;
977     }
978
979     if ((ti = as->parms[COMMON_VOLOP_PARMS_OFFSET+3].items)) {  /* -partition */
980         strlcpy(state->vop->partName, ti->data, sizeof(state->vop->partName));
981     } else {
982         memset(state->vop->partName, 0, sizeof(state->vop->partName));
983     }
984
985     return 0;
986 }
987
988 static int
989 do_vnqry(struct state * state, SYNC_response * res)
990 {
991     afs_int32 code;
992     int command = FSYNC_VOL_QUERY_VNODE;
993     FSSYNC_VnQry_hdr qry;
994
995     qry.volume = state->vop->volume;
996     qry.vnode = state->vop->vnode;
997     qry.unique = state->vop->unique;
998     qry.spare = 0;
999     strlcpy(qry.partName, state->vop->partName, sizeof(qry.partName));
1000
1001     fprintf(stderr, "calling FSYNC_GenericOp with command code %d (%s)\n",
1002             command, FSYNC_com2string(command));
1003
1004     code = FSYNC_GenericOp(&qry, sizeof(qry), command, FSYNC_OPERATOR, res);
1005
1006     debug_response(code, res);
1007
1008     VDisconnectFS();
1009
1010     return 0;
1011 }
1012
1013 static int
1014 VnQuery(struct cmd_syndesc * as, void * rock)
1015 {
1016     struct state state;
1017     SYNC_PROTO_BUF_DECL(res_buf);
1018     SYNC_response res;
1019     Vnode v;
1020
1021     dafs_prolog();
1022
1023     res.hdr.response_len = sizeof(res.hdr);
1024     res.payload.buf = res_buf;
1025     res.payload.len = SYNC_PROTO_MAX_LEN;
1026
1027     common_prolog(as, &state);
1028     vn_prolog(as, &state);
1029
1030     do_vnqry(&state, &res);
1031
1032     if (res.hdr.response == SYNC_OK) {
1033         memcpy(&v, res.payload.buf, sizeof(Vnode));
1034
1035         printf("vnode = {\n");
1036
1037         printf("\tvid_hash = {\n");
1038         printf("\t\tnext = %p\n", v.vid_hash.next);
1039         printf("\t\tprev = %p\n", v.vid_hash.prev);
1040         printf("\t}\n");
1041
1042         printf("\thashNext        = %p\n", v.hashNext);
1043         printf("\tlruNext         = %p\n", v.lruNext);
1044         printf("\tlruPrev         = %p\n", v.lruPrev);
1045         printf("\thashIndex       = %hu\n", v.hashIndex);
1046         printf("\tchanged_newTime = %u\n", (unsigned int) v.changed_newTime);
1047         printf("\tchanged_oldTime = %u\n", (unsigned int) v.changed_oldTime);
1048         printf("\tdelete          = %u\n", (unsigned int) v.delete);
1049         printf("\tvnodeNumber     = %u\n", v.vnodeNumber);
1050         printf("\tvolumePtr       = %p\n", v.volumePtr);
1051         printf("\tnUsers          = %u\n", v.nUsers);
1052         printf("\tcacheCheck      = %u\n", v.cacheCheck);
1053
1054 #ifdef AFS_DEMAND_ATTACH_FS
1055         if (!(res.hdr.flags & SYNC_FLAG_DAFS_EXTENSIONS)) {
1056             printf("*** this fssync-debug is built to expect demand attach extensions.\n"
1057                    "*** server asserted that is was not compiled with demand attach.\n"
1058                    "*** please use an fssync-debug without demand attach to match your\n"
1059                    "*** server.\n");
1060             goto done;
1061         }
1062
1063         printf("\tnReaders        = %u\n", v.nReaders);
1064         printf("\tvn_state_flags  = %s\n", vn_flags_to_string(v.vn_state_flags));
1065         printf("\tvn_state        = %s\n", vn_state_to_string(v.vn_state));
1066 #else
1067         if (res.hdr.flags & SYNC_FLAG_DAFS_EXTENSIONS) {
1068             printf("*** server asserted demand attach extensions. this fssync-debug is not\n"
1069                    "*** built to recognize those extensions. please use an fssync-debug\n"
1070                    "*** with demand attach to match your server.\n");
1071             goto done;
1072         }
1073 #endif /* !AFS_DEMAND_ATTACH_FS */
1074
1075         printf("\tvcp             = %p\n", v.vcp);
1076         printf("\thandle          = %p\n", v.handle);
1077
1078         printf("\tdisk = {\n");
1079         printf("\t\ttype              = %u\n", v.disk.type);
1080         printf("\t\tcloned            = %u\n", v.disk.cloned);
1081         printf("\t\tmodeBits          = %u\n", v.disk.modeBits);
1082         printf("\t\tlinkCount         = %d\n", v.disk.linkCount);
1083         printf("\t\tlength            = %u\n", v.disk.length);
1084         printf("\t\tuniquifier        = %u\n", v.disk.uniquifier);
1085         printf("\t\tdataVersion       = %u\n", v.disk.dataVersion);
1086         printf("\t\tvn_ino_lo         = %u\n", v.disk.vn_ino_lo);
1087         printf("\t\tunixModifyTime    = %u\n", v.disk.unixModifyTime);
1088         printf("\t\tauthor            = %u\n", v.disk.author);
1089         printf("\t\towner             = %u\n", v.disk.owner);
1090         printf("\t\tparent            = %u\n", v.disk.parent);
1091         printf("\t\tvnodeMagic        = %u\n", v.disk.vnodeMagic);
1092
1093         printf("\t\tlock = {\n");
1094         printf("\t\t\tlockCount   = %d\n", v.disk.lock.lockCount);
1095         printf("\t\t\tlockTime    = %d\n", v.disk.lock.lockTime);
1096         printf("\t\t}\n");
1097
1098         printf("\t\tserverModifyTime  = %u\n", v.disk.serverModifyTime);
1099         printf("\t\tgroup             = %d\n", v.disk.group);
1100         printf("\t\tvn_ino_hi         = %d\n", v.disk.vn_ino_hi);
1101         printf("\t\tvn_length_hi      = %u\n", v.disk.vn_length_hi);
1102         printf("\t}\n");
1103
1104         printf("}\n");
1105     }
1106
1107  done:
1108     return 0;
1109 }
1110
1111
1112 static int
1113 StatsQuery(struct cmd_syndesc * as, void * rock)
1114 {
1115     afs_int32 code;
1116     int command;
1117     struct cmd_item *ti;
1118     struct state state;
1119     SYNC_PROTO_BUF_DECL(res_buf);
1120     SYNC_response res;
1121     FSSYNC_StatsOp_hdr scom;
1122
1123     res.hdr.response_len = sizeof(res.hdr);
1124     res.payload.buf = res_buf;
1125     res.payload.len = SYNC_PROTO_MAX_LEN;
1126
1127     if ((ti = as->parms[CUSTOM_PARMS_OFFSET].items)) {  /* -subcommand */
1128         if (!strcasecmp(ti->data, "vicep")) {
1129             command = FSYNC_VOL_STATS_VICEP;
1130         } else if (!strcasecmp(ti->data, "hash")) {
1131             command = FSYNC_VOL_STATS_HASH;
1132 #ifdef AFS_DEMAND_ATTACH_FS
1133         } else if (!strcasecmp(ti->data, "hdr")) {
1134             command = FSYNC_VOL_STATS_HDR;
1135         } else if (!strcasecmp(ti->data, "vlru")) {
1136             command = FSYNC_VOL_STATS_VLRU;
1137 #endif
1138         } else if (!strcasecmp(ti->data, "pkg")) {
1139             command = FSYNC_VOL_STATS_GENERAL;
1140         } else if (!strcasecmp(ti->data, "help")) {
1141             fprintf(stderr, "fssync-debug stats subcommands:\n");
1142             fprintf(stderr, "\tpkg\tgeneral volume package stats\n");
1143             fprintf(stderr, "\tvicep\tvice partition stats\n");
1144             fprintf(stderr, "\thash\tvolume hash chain stats\n");
1145 #ifdef AFS_DEMAND_ATTACH_FS
1146             fprintf(stderr, "\thdr\tvolume header cache stats\n");
1147             fprintf(stderr, "\tvlru\tvlru generation stats\n");
1148 #endif
1149             exit(0);
1150         } else {
1151             fprintf(stderr, "invalid stats subcommand");
1152             exit(1);
1153         }
1154     } else {
1155         command = FSYNC_VOL_STATS_GENERAL;
1156     }
1157
1158     if ((ti = as->parms[CUSTOM_PARMS_OFFSET+1].items)) {        /* -arg1 */
1159         switch (command) {
1160         case FSYNC_VOL_STATS_VICEP:
1161             strlcpy(scom.args.partName, ti->data, sizeof(state.vop->partName));
1162             break;
1163         case FSYNC_VOL_STATS_HASH:
1164             scom.args.hash_bucket = atoi(ti->data);
1165             break;
1166         case FSYNC_VOL_STATS_VLRU:
1167             scom.args.vlru_generation = atoi(ti->data);
1168             break;
1169         default:
1170             fprintf(stderr, "unrecognized arguments\n");
1171             exit(1);
1172         }
1173     } else {
1174         switch (command) {
1175         case FSYNC_VOL_STATS_VICEP:
1176         case FSYNC_VOL_STATS_HASH:
1177         case FSYNC_VOL_STATS_VLRU:
1178             fprintf(stderr, "this subcommand requires more parameters\n");
1179             exit(1);
1180         }
1181     }
1182
1183     common_prolog(as, &state);
1184
1185     fprintf(stderr, "calling FSYNC_askfs with command code %d (%s)\n",
1186             command, FSYNC_com2string(command));
1187
1188     code = FSYNC_StatsOp(&scom, command, FSYNC_WHATEVER, &res);
1189
1190     switch (code) {
1191     case SYNC_OK:
1192     case SYNC_DENIED:
1193         break;
1194     default:
1195         fprintf(stderr, "possible sync protocol error. return code was %d\n", code);
1196     }
1197
1198     fprintf(stderr, "FSYNC_VolOp returned %d (%s)\n", code, SYNC_res2string(code));
1199     fprintf(stderr, "protocol response code was %d (%s)\n",
1200             res.hdr.response, SYNC_res2string(res.hdr.response));
1201     fprintf(stderr, "protocol reason code was %d (%s)\n",
1202             res.hdr.reason, FSYNC_reason2string(res.hdr.reason));
1203
1204     VDisconnectFS();
1205
1206     if (res.hdr.response == SYNC_OK) {
1207         switch (command) {
1208         case FSYNC_VOL_STATS_GENERAL:
1209             {
1210                 struct VolPkgStats vol_stats;
1211                 memcpy(&vol_stats, res_buf, sizeof(vol_stats));
1212                 print_vol_stats_general(&vol_stats);
1213                 break;
1214             }
1215         case FSYNC_VOL_STATS_VICEP:
1216             {
1217                 struct DiskPartitionStats64 vicep_stats;
1218                 memcpy(&vicep_stats, res_buf, sizeof(vicep_stats));
1219                 print_vol_stats_viceP(&vicep_stats);
1220                 break;
1221             }
1222         case FSYNC_VOL_STATS_HASH:
1223             {
1224                 struct VolumeHashChainStats hash_stats;
1225                 memcpy(&hash_stats, res_buf, sizeof(hash_stats));
1226                 print_vol_stats_hash(&hash_stats);
1227                 break;
1228             }
1229 #ifdef AFS_DEMAND_ATTACH_FS
1230         case FSYNC_VOL_STATS_HDR:
1231             {
1232                 struct volume_hdr_LRU_stats hdr_stats;
1233                 memcpy(&hdr_stats, res_buf, sizeof(hdr_stats));
1234                 print_vol_stats_hdr(&hdr_stats);
1235                 break;
1236             }
1237 #endif /* AFS_DEMAND_ATTACH_FS */
1238         }
1239     }
1240
1241     return 0;
1242 }
1243
1244 static void
1245 print_vol_stats_general(VolPkgStats * stats)
1246 {
1247 #ifdef AFS_DEMAND_ATTACH_FS
1248     int i;
1249 #endif
1250     afs_uint32 hi, lo;
1251
1252     printf("VolPkgStats = {\n");
1253 #ifdef AFS_DEMAND_ATTACH_FS
1254     for (i = 0; i < VOL_STATE_COUNT; i++) {
1255         printf("\tvol_state_count[%s] = %d\n",
1256                vol_state_to_string(i),
1257                stats->state_levels[i]);
1258     }
1259
1260     SplitInt64(stats->hash_looks, hi, lo);
1261     printf("\thash_looks = {\n");
1262     printf("\t\thi = %u\n", hi);
1263     printf("\t\tlo = %u\n", lo);
1264     printf("\t}\n");
1265
1266     SplitInt64(stats->hash_reorders, hi, lo);
1267     printf("\thash_reorders = {\n");
1268     printf("\t\thi = %u\n", hi);
1269     printf("\t\tlo = %u\n", lo);
1270     printf("\t}\n");
1271
1272     SplitInt64(stats->salvages, hi, lo);
1273     printf("\tsalvages = {\n");
1274     printf("\t\thi = %u\n", hi);
1275     printf("\t\tlo = %u\n", lo);
1276     printf("\t}\n");
1277
1278     SplitInt64(stats->vol_ops, hi, lo);
1279     printf("\tvol_ops = {\n");
1280     printf("\t\thi = %u\n", hi);
1281     printf("\t\tlo = %u\n", lo);
1282     printf("\t}\n");
1283 #endif
1284     SplitInt64(stats->hdr_loads, hi, lo);
1285     printf("\thdr_loads = {\n");
1286     printf("\t\thi = %u\n", hi);
1287     printf("\t\tlo = %u\n", lo);
1288     printf("\t}\n");
1289
1290     SplitInt64(stats->hdr_gets, hi, lo);
1291     printf("\thdr_gets = {\n");
1292     printf("\t\thi = %u\n", hi);
1293     printf("\t\tlo = %u\n", lo);
1294     printf("\t}\n");
1295
1296     SplitInt64(stats->attaches, hi, lo);
1297     printf("\tattaches = {\n");
1298     printf("\t\thi = %u\n", hi);
1299     printf("\t\tlo = %u\n", lo);
1300     printf("\t}\n");
1301
1302     SplitInt64(stats->soft_detaches, hi, lo);
1303     printf("\tsoft_detaches = {\n");
1304     printf("\t\thi = %u\n", hi);
1305     printf("\t\tlo = %u\n", lo);
1306     printf("\t}\n");
1307
1308     printf("\thdr_cache_size = %d\n", stats->hdr_cache_size);
1309
1310     printf("}\n");
1311 }
1312
1313 static void
1314 print_vol_stats_viceP(struct DiskPartitionStats64 * stats)
1315 {
1316     printf("DiskPartitionStats64 = {\n");
1317     printf("\tfree = %" AFS_INT64_FMT "\n", stats->free);
1318     printf("\tminFree = %" AFS_INT64_FMT "\n", stats->minFree);
1319     printf("\ttotalUsable = %" AFS_INT64_FMT "\n", stats->totalUsable);
1320     printf("\tf_files = %" AFS_INT64_FMT "\n", stats->f_files);
1321 #ifdef AFS_DEMAND_ATTACH_FS
1322     printf("\tvol_list_len = %d\n", stats->vol_list_len);
1323 #endif
1324     printf("}\n");
1325 }
1326
1327 static void
1328 print_vol_stats_hash(struct VolumeHashChainStats * stats)
1329 {
1330 #ifdef AFS_DEMAND_ATTACH_FS
1331     afs_uint32 hi, lo;
1332 #endif
1333
1334     printf("DiskPartitionStats = {\n");
1335     printf("\ttable_size = %d\n", stats->table_size);
1336     printf("\tchain_len = %d\n", stats->chain_len);
1337
1338 #ifdef AFS_DEMAND_ATTACH_FS
1339     printf("\tchain_cacheCheck = %d\n", stats->chain_cacheCheck);
1340     printf("\tchain_busy = %d\n", stats->chain_busy);
1341
1342     SplitInt64(stats->chain_looks, hi, lo);
1343     printf("\tchain_looks = {\n");
1344     printf("\t\thi = %u\n", hi);
1345     printf("\t\tlo = %u\n", lo);
1346     printf("\t}\n");
1347
1348     SplitInt64(stats->chain_gets, hi, lo);
1349     printf("\tchain_gets = {\n");
1350     printf("\t\thi = %u\n", hi);
1351     printf("\t\tlo = %u\n", lo);
1352     printf("\t}\n");
1353
1354     SplitInt64(stats->chain_reorders, hi, lo);
1355     printf("\tchain_reorders = {\n");
1356     printf("\t\thi = %u\n", hi);
1357     printf("\t\tlo = %u\n", lo);
1358     printf("\t}\n");
1359 #endif /* AFS_DEMAND_ATTACH_FS */
1360
1361     printf("}\n");
1362 }
1363
1364
1365 #ifdef AFS_DEMAND_ATTACH_FS
1366 static void
1367 print_vol_stats_hdr(struct volume_hdr_LRU_stats * stats)
1368 {
1369     printf("volume_hdr_LRU_stats = {\n");
1370     printf("\tfree = %d\n", stats->free);
1371     printf("\tused = %d\n", stats->used);
1372     printf("\tattached = %d\n", stats->attached);
1373     printf("}\n");
1374 }
1375 #endif /* AFS_DEMAND_ATTACH_FS */
1376
1377
1378 /**
1379  * query VGC.
1380  *
1381  * @notes args:
1382  *    - CUSTOM_PARMS_OFFSET+0 is partition string
1383  *    - CUSTOM_PARMS_OFFSET+1 is volume id
1384  *
1385  * @return operation status
1386  *    @retval 0 success
1387  */
1388 static int
1389 VGCQuery(struct cmd_syndesc * as, void * rock)
1390 {
1391     afs_int32 code;
1392     struct state state;
1393     char * partName;
1394     VolumeId volid;
1395     FSSYNC_VGQry_response_t q_res;
1396     SYNC_response res;
1397     int i;
1398     struct cmd_item *ti;
1399
1400     if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+0].items)) {       /* -partition */
1401         return -1;
1402     }
1403     partName = ti->data;
1404
1405     if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+1].items)) {       /* -volumeid */
1406         return -1;
1407     }
1408     volid = atoi(ti->data);
1409
1410     common_prolog(as, &state);
1411
1412     fprintf(stderr, "calling FSYNC_VCGQuery\n");
1413
1414     code = FSYNC_VGCQuery(partName, volid, &q_res, &res);
1415
1416     debug_response(code, &res);
1417
1418     if (code == SYNC_OK) {
1419         printf("VG = {\n");
1420         printf("\trw\t=\t%u\n", q_res.rw);
1421         printf("\tchildren\t= (\n");
1422         for (i = 0; i < VOL_VG_MAX_VOLS; i++) {
1423             if (q_res.children[i]) {
1424                 printf("\t\t%u\n", q_res.children[i]);
1425             }
1426         }
1427         printf("\t)\n");
1428     }
1429
1430     VDisconnectFS();
1431
1432     return 0;
1433 }
1434
1435 static int
1436 VGCAdd(struct cmd_syndesc * as, void * rock)
1437 {
1438     afs_int32 code;
1439     struct state state;
1440     char * partName;
1441     VolumeId parent, child;
1442     struct cmd_item *ti;
1443     SYNC_response res;
1444
1445     if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+0].items)) {       /* -partition */
1446         return -1;
1447     }
1448     partName = ti->data;
1449
1450     if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+1].items)) {       /* -parent */
1451         return -1;
1452     }
1453     parent = atoi(ti->data);
1454
1455     if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+2].items)) {       /* -child */
1456         return -1;
1457     }
1458     child = atoi(ti->data);
1459
1460     common_prolog(as, &state);
1461     fprintf(stderr, "calling FSYNC_VCGAdd\n");
1462     code = FSYNC_VGCAdd(partName, parent, child, state.reason, &res);
1463     debug_response(code, &res);
1464
1465     VDisconnectFS();
1466
1467     return 0;
1468 }
1469
1470 static int
1471 VGCDel(struct cmd_syndesc * as, void * rock)
1472 {
1473     afs_int32 code;
1474     struct state state;
1475     char * partName;
1476     VolumeId parent, child;
1477     struct cmd_item *ti;
1478     SYNC_response res;
1479
1480     if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+0].items)) {       /* -partition */
1481         return -1;
1482     }
1483     partName = ti->data;
1484
1485     if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+1].items)) {       /* -parent */
1486         return -1;
1487     }
1488     parent = atoi(ti->data);
1489
1490     if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+2].items)) {       /* -child */
1491         return -1;
1492     }
1493     child = atoi(ti->data);
1494
1495     state.reason = FSYNC_WHATEVER;
1496
1497     common_prolog(as, &state);
1498     fprintf(stderr, "calling FSYNC_VCGDel\n");
1499     code = FSYNC_VGCDel(partName, parent, child, state.reason, &res);
1500     debug_response(code, &res);
1501
1502     VDisconnectFS();
1503
1504     return 0;
1505 }
1506
1507 static int
1508 VGCScan(struct cmd_syndesc * as, void * rock)
1509 {
1510     afs_int32 code;
1511     struct state state;
1512     char * partName;
1513     struct cmd_item *ti;
1514
1515     if (!(ti = as->parms[CUSTOM_PARMS_OFFSET+0].items)) {       /* -partition */
1516         return -1;
1517     }
1518     partName = ti->data;
1519
1520     common_prolog(as, &state);
1521     fprintf(stderr, "calling FSYNC_VCGScan\n");
1522     code = FSYNC_VGCScan(partName, state.reason);
1523     debug_response(code, NULL);
1524
1525     VDisconnectFS();
1526
1527     return 0;
1528 }
1529
1530 static int
1531 VGCScanAll(struct cmd_syndesc * as, void * rock)
1532 {
1533     afs_int32 code;
1534     struct state state;
1535
1536     common_prolog(as, &state);
1537     fprintf(stderr, "calling FSYNC_VCGScanAll\n");
1538     code = FSYNC_VGCScan(NULL, state.reason);
1539     debug_response(code, NULL);
1540
1541     VDisconnectFS();
1542
1543     return 0;
1544 }