2 * Copyright 2006, Sine Nomine Associates and others.
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
10 /* Main program file. Define globals. */
18 #include <afsconfig.h>
19 #include <afs/param.h>
24 #include <WINNT/afsevent.h>
28 #include <afs/afsint.h>
29 #include <afs/afs_assert.h>
33 #include <afs/osi_inode.h>
37 #include <afs/afsutil.h>
38 #include <afs/fileutil.h>
43 #include <afs/ihandle.h>
44 #include <afs/vnode.h>
45 #include <afs/volume.h>
46 #include <afs/partition.h>
47 #include <afs/daemon_com.h>
48 #include <afs/salvsync.h>
53 int VolumeChanged; /* hack to make dir package happy */
56 #ifndef AFS_DEMAND_ATTACH_FS
58 main(int argc, char ** argv)
60 fprintf(stderr, "*** salvsync-debug is only supported for OpenAFS builds with the demand-attach fileserver extension\n");
63 #else /* AFS_DEMAND_ATTACH_FS */
73 struct salv_state * sop;
76 static int common_prolog(struct cmd_syndesc *, struct fssync_state *);
77 static int common_salv_prolog(struct cmd_syndesc *, struct fssync_state *);
79 static int do_salvop(struct fssync_state *, afs_int32 command, SYNC_response * res);
81 static char * response_code_to_string(afs_int32);
82 static char * command_code_to_string(afs_int32);
83 static char * reason_code_to_string(afs_int32);
84 static char * state_code_to_string(afs_int32);
87 static int OpStats(struct cmd_syndesc * as, void * rock);
88 static int OpSalvage(struct cmd_syndesc * as, void * rock);
89 static int OpCancel(struct cmd_syndesc * as, void * rock);
90 static int OpCancelAll(struct cmd_syndesc * as, void * rock);
91 static int OpRaisePrio(struct cmd_syndesc * as, void * rock);
92 static int OpQuery(struct cmd_syndesc * as, void * rock);
96 #include "AFS_component_version_number.c"
100 #define COMMON_PARMS_OFFSET 13
101 #define COMMON_PARMS(ts) \
102 cmd_Seek(ts, COMMON_PARMS_OFFSET); \
103 cmd_AddParm(ts, "-reason", CMD_SINGLE, CMD_OPTIONAL, "sync protocol reason code"); \
104 cmd_AddParm(ts, "-programtype", CMD_SINGLE, CMD_OPTIONAL, "program type code")
106 #define COMMON_SALV_PARMS_OFFSET 10
107 #define COMMON_SALV_PARMS(ts) \
108 cmd_Seek(ts, COMMON_SALV_PARMS_OFFSET); \
109 cmd_AddParm(ts, "-volumeid", CMD_SINGLE, 0, "volume id"); \
110 cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL, "partition name"); \
111 cmd_AddParm(ts, "-priority", CMD_SINGLE, CMD_OPTIONAL, "priority")
113 #define SALV_PARMS_DECL(ts) \
114 COMMON_SALV_PARMS(ts); \
117 #define COMMON_PARMS_DECL(ts) \
121 main(int argc, char **argv)
123 struct cmd_syndesc *ts;
126 /* Initialize directory paths */
127 if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
129 ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
131 fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
137 ts = cmd_CreateSyntax("stats", OpStats, NULL, "get salvageserver statistics (SALVSYNC_NOP opcode)");
138 COMMON_PARMS_DECL(ts);
139 cmd_CreateAlias(ts, "nop");
141 ts = cmd_CreateSyntax("salvage", OpSalvage, NULL, "schedule a salvage (SALVSYNC_SALVAGE opcode)");
144 ts = cmd_CreateSyntax("cancel", OpCancel, NULL, "cancel a salvage (SALVSYNC_CANCEL opcode)");
147 ts = cmd_CreateSyntax("raiseprio", OpRaisePrio, NULL, "raise a salvage priority (SALVSYNC_RAISEPRIO opcode)");
149 cmd_CreateAlias(ts, "rp");
151 ts = cmd_CreateSyntax("query", OpQuery, NULL, "query salvage status (SALVSYNC_QUERY opcode)");
153 cmd_CreateAlias(ts, "qry");
155 ts = cmd_CreateSyntax("kill", OpCancelAll, NULL, "cancel all scheduled salvages (SALVSYNC_CANCELALL opcode)");
156 COMMON_PARMS_DECL(ts);
158 err = cmd_Dispatch(argc, argv);
163 common_prolog(struct cmd_syndesc * as, struct fssync_state * state)
166 VolumePackageOptions opts;
169 if (afs_winsockInit() < 0) {
174 VOptDefaults(debugUtility, &opts);
175 if (VInitVolumePackage2(debugUtility, &opts)) {
176 /* VInitVolumePackage2 can fail on e.g. partition attachment errors,
177 * but we don't really care, since all we're doing is trying to use
179 fprintf(stderr, "errors encountered initializing volume package, but "
180 "trying to continue anyway\n");
184 if ((ti = as->parms[COMMON_PARMS_OFFSET].items)) { /* -reason */
185 state->reason = atoi(ti->data);
187 state->reason = SALVSYNC_REASON_WHATEVER;
190 if ((ti = as->parms[COMMON_PARMS_OFFSET+1].items)) { /* -programtype */
191 if (!strcmp(ti->data, "fileServer")) {
192 programType = fileServer;
193 } else if (!strcmp(ti->data, "volumeUtility")) {
194 programType = volumeUtility;
195 } else if (!strcmp(ti->data, "salvager")) {
196 programType = salvager;
197 } else if (!strcmp(ti->data, "salvageServer")) {
198 programType = salvageServer;
199 } else if (!strcmp(ti->data, "volumeServer")) {
200 programType = volumeServer;
201 } else if (!strcmp(ti->data, "volumeSalvager")) {
202 programType = volumeSalvager;
204 programType = (ProgramType) atoi(ti->data);
214 common_salv_prolog(struct cmd_syndesc * as, struct fssync_state * state)
218 state->sop = (struct salv_state *) calloc(1, sizeof(struct salv_state));
219 assert(state->sop != NULL);
221 if ((ti = as->parms[COMMON_SALV_PARMS_OFFSET].items)) { /* -volumeid */
222 state->sop->volume = atoi(ti->data);
224 fprintf(stderr, "required argument -volumeid not given\n");
227 if ((ti = as->parms[COMMON_SALV_PARMS_OFFSET+1].items)) { /* -partition */
228 strlcpy(state->sop->partName, ti->data, sizeof(state->sop->partName));
230 memset(state->sop->partName, 0, sizeof(state->sop->partName));
233 if ((ti = as->parms[COMMON_SALV_PARMS_OFFSET+2].items)) { /* -prio */
234 state->sop->prio = atoi(ti->data);
236 state->sop->prio = 0;
243 do_salvop(struct fssync_state * state, afs_int32 command, SYNC_response * res)
246 SALVSYNC_response_hdr hdr_l, *hdr;
251 res->payload.len = sizeof(hdr_l);
252 res->payload.buf = hdr = &hdr_l;
254 hdr = (SALVSYNC_response_hdr *) res->payload.buf;
257 fprintf(stderr, "calling SALVSYNC_SalvageVolume with command code %d (%s)\n",
258 command, command_code_to_string(command));
260 code = SALVSYNC_SalvageVolume(state->sop->volume,
261 state->sop->partName,
272 fprintf(stderr, "possible sync protocol error. return code was %d\n", code);
275 fprintf(stderr, "SALVSYNC_SalvageVolume returned %d (%s)\n", code, response_code_to_string(code));
276 fprintf(stderr, "protocol response code was %d (%s)\n",
277 res->hdr.response, response_code_to_string(res->hdr.response));
278 fprintf(stderr, "protocol reason code was %d (%s)\n",
279 res->hdr.reason, reason_code_to_string(res->hdr.reason));
281 printf("state = {\n");
282 if (res->hdr.flags & SALVSYNC_FLAG_VOL_STATS_VALID) {
283 printf("\tstate = %d (%s)\n",
284 hdr->state, state_code_to_string(hdr->state));
285 printf("\tprio = %d\n", hdr->prio);
287 printf("\tsq_len = %d\n", hdr->sq_len);
288 printf("\tpq_len = %d\n", hdr->pq_len);
297 response_code_to_string(afs_int32 response)
303 return "SYNC_DENIED";
305 return "SYNC_COM_ERROR";
306 case SYNC_BAD_COMMAND:
307 return "SYNC_BAD_COMMAND";
309 return "SYNC_FAILED";
311 return "**UNKNOWN**";
316 command_code_to_string(afs_int32 command)
319 case SYNC_COM_CHANNEL_CLOSE:
320 return "SYNC_COM_CHANNEL_CLOSE";
322 return "SALVSYNC_NOP";
323 case SALVSYNC_SALVAGE:
324 return "SALVSYNC_SALVAGE";
325 case SALVSYNC_CANCEL:
326 return "SALVSYNC_CANCEL";
327 case SALVSYNC_RAISEPRIO:
328 return "SALVSYNC_RAISEPRIO";
330 return "SALVSYNC_QUERY";
331 case SALVSYNC_CANCELALL:
332 return "SALVSYNC_CANCELLALL";
334 return "**UNKNOWN**";
339 reason_code_to_string(afs_int32 reason)
342 case SALVSYNC_WHATEVER:
343 return "SALVSYNC_WHATEVER";
345 return "SALVSYNC_ERROR";
346 case SALVSYNC_OPERATOR:
347 return "SALVSYNC_OPERATOR";
348 case SALVSYNC_SHUTDOWN:
349 return "SALVSYNC_SHUTDOWN";
350 case SALVSYNC_NEEDED:
351 return "SALVSYNC_NEEDED";
353 return "**UNKNOWN**";
359 program_type_to_string(afs_int32 type)
361 switch ((ProgramType)type) {
365 return "volumeUtility";
369 return "salvageServer";
371 return "**UNKNOWN**";
377 state_code_to_string(afs_int32 state)
380 case SALVSYNC_STATE_UNKNOWN:
381 return "SALVSYNC_STATE_UNKNOWN";
382 case SALVSYNC_STATE_QUEUED:
383 return "SALVSYNC_STATE_QUEUED";
384 case SALVSYNC_STATE_SALVAGING:
385 return "SALVSYNC_STATE_SALVAGING";
386 case SALVSYNC_STATE_ERROR:
387 return "SALVSYNC_STATE_ERROR";
388 case SALVSYNC_STATE_DONE:
389 return "SALVSYNC_STATE_DONE";
391 return "**UNKNOWN**";
396 OpStats(struct cmd_syndesc * as, void * rock)
398 struct fssync_state state;
400 common_prolog(as, &state);
401 common_salv_prolog(as, &state);
403 do_salvop(&state, SALVSYNC_NOP, NULL);
409 OpSalvage(struct cmd_syndesc * as, void * rock)
411 struct fssync_state state;
413 common_prolog(as, &state);
414 common_salv_prolog(as, &state);
416 do_salvop(&state, SALVSYNC_SALVAGE, NULL);
422 OpCancel(struct cmd_syndesc * as, void * rock)
424 struct fssync_state state;
426 common_prolog(as, &state);
427 common_salv_prolog(as, &state);
429 do_salvop(&state, SALVSYNC_CANCEL, NULL);
435 OpCancelAll(struct cmd_syndesc * as, void * rock)
437 struct fssync_state state;
439 common_prolog(as, &state);
440 common_salv_prolog(as, &state);
442 do_salvop(&state, SALVSYNC_CANCELALL, NULL);
448 OpRaisePrio(struct cmd_syndesc * as, void * rock)
450 struct fssync_state state;
452 common_prolog(as, &state);
453 common_salv_prolog(as, &state);
455 do_salvop(&state, SALVSYNC_RAISEPRIO, NULL);
461 OpQuery(struct cmd_syndesc * as, void * rock)
463 struct fssync_state state;
465 common_prolog(as, &state);
466 common_salv_prolog(as, &state);
468 do_salvop(&state, SALVSYNC_QUERY, NULL);
473 #endif /* AFS_DEMAND_ATTACH_FS */