Windows: build tsalvaged on Windows
[openafs.git] / src / tsalvaged / salvsync-debug.c
1 /*
2  * Copyright 2006, 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  * salvsync debug 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/afs_assert.h>
42 #include <afs/dir.h>
43
44 #include <fcntl.h>
45
46 #ifndef AFS_NT40_ENV
47 #include <afs/osi_inode.h>
48 #endif
49
50 #include <afs/cmd.h>
51 #include <afs/afsutil.h>
52 #include <afs/fileutil.h>
53
54 #include <afs/nfs.h>
55 #include <lwp.h>
56 #include <lock.h>
57 #include <afs/ihandle.h>
58 #include <afs/vnode.h>
59 #include <afs/volume.h>
60 #include <afs/partition.h>
61 #include <afs/daemon_com.h>
62 #include <afs/salvsync.h>
63 #ifdef AFS_NT40_ENV
64 #include <pthread.h>
65 #endif
66
67 int VolumeChanged; /* hack to make dir package happy */
68
69
70 #ifndef AFS_DEMAND_ATTACH_FS
71 int
72 main(int argc, char ** argv)
73 {
74     fprintf(stderr, "*** salvsync-debug is only supported for OpenAFS builds with the demand-attach fileserver extension\n");
75     return -1;
76 }
77 #else /* AFS_DEMAND_ATTACH_FS */
78
79 struct salv_state {
80     afs_uint32 prio;
81     afs_uint32 volume;
82     char partName[16];
83 };
84
85 struct state {
86     afs_int32 reason;
87     struct salv_state * sop;
88 };
89
90 static int common_prolog(struct cmd_syndesc *, struct state *);
91 static int common_salv_prolog(struct cmd_syndesc *, struct state *);
92
93 static int do_salvop(struct state *, afs_int32 command, SYNC_response * res);
94
95 static char * response_code_to_string(afs_int32);
96 static char * command_code_to_string(afs_int32);
97 static char * reason_code_to_string(afs_int32);
98 static char * state_code_to_string(afs_int32);
99
100
101 static int OpStats(struct cmd_syndesc * as, void * rock);
102 static int OpSalvage(struct cmd_syndesc * as, void * rock);
103 static int OpCancel(struct cmd_syndesc * as, void * rock);
104 static int OpCancelAll(struct cmd_syndesc * as, void * rock);
105 static int OpRaisePrio(struct cmd_syndesc * as, void * rock);
106 static int OpQuery(struct cmd_syndesc * as, void * rock);
107
108
109 #ifndef AFS_NT40_ENV
110 #include "AFS_component_version_number.c"
111 #endif
112 #define MAX_ARGS 128
113
114 #define COMMON_PARMS_OFFSET    13
115 #define COMMON_PARMS(ts) \
116     cmd_Seek(ts, COMMON_PARMS_OFFSET); \
117     cmd_AddParm(ts, "-reason", CMD_SINGLE, CMD_OPTIONAL, "sync protocol reason code"); \
118     cmd_AddParm(ts, "-programtype", CMD_SINGLE, CMD_OPTIONAL, "program type code")
119
120 #define COMMON_SALV_PARMS_OFFSET    10
121 #define COMMON_SALV_PARMS(ts) \
122     cmd_Seek(ts, COMMON_SALV_PARMS_OFFSET); \
123     cmd_AddParm(ts, "-volumeid", CMD_SINGLE, 0, "volume id"); \
124     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL, "partition name"); \
125     cmd_AddParm(ts, "-priority", CMD_SINGLE, CMD_OPTIONAL, "priority")
126
127 #define SALV_PARMS_DECL(ts) \
128     COMMON_SALV_PARMS(ts); \
129     COMMON_PARMS(ts)
130
131 #define COMMON_PARMS_DECL(ts) \
132     COMMON_PARMS(ts)
133
134 int
135 main(int argc, char **argv)
136 {
137     struct cmd_syndesc *ts;
138     int err = 0;
139
140     /* Initialize directory paths */
141     if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
142 #ifdef AFS_NT40_ENV
143         ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
144 #endif
145         fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
146                 argv[0]);
147         exit(2);
148     }
149
150
151     ts = cmd_CreateSyntax("stats", OpStats, NULL, "get salvageserver statistics (SALVSYNC_NOP opcode)");
152     COMMON_PARMS_DECL(ts);
153     cmd_CreateAlias(ts, "nop");
154
155     ts = cmd_CreateSyntax("salvage", OpSalvage, NULL, "schedule a salvage (SALVSYNC_SALVAGE opcode)");
156     SALV_PARMS_DECL(ts);
157
158     ts = cmd_CreateSyntax("cancel", OpCancel, NULL, "cancel a salvage (SALVSYNC_CANCEL opcode)");
159     SALV_PARMS_DECL(ts);
160
161     ts = cmd_CreateSyntax("raiseprio", OpRaisePrio, NULL, "raise a salvage priority (SALVSYNC_RAISEPRIO opcode)");
162     SALV_PARMS_DECL(ts);
163     cmd_CreateAlias(ts, "rp");
164
165     ts = cmd_CreateSyntax("query", OpQuery, NULL, "query salvage status (SALVSYNC_QUERY opcode)");
166     SALV_PARMS_DECL(ts);
167     cmd_CreateAlias(ts, "qry");
168
169     ts = cmd_CreateSyntax("kill", OpCancelAll, NULL, "cancel all scheduled salvages (SALVSYNC_CANCELALL opcode)");
170     COMMON_PARMS_DECL(ts);
171
172     err = cmd_Dispatch(argc, argv);
173     exit(err);
174 }
175
176 static int
177 common_prolog(struct cmd_syndesc * as, struct state * state)
178 {
179     struct cmd_item *ti;
180     VolumePackageOptions opts;
181
182 #ifdef AFS_NT40_ENV
183     if (afs_winsockInit() < 0) {
184         Exit(1);
185     }
186 #endif
187
188     VOptDefaults(debugUtility, &opts);
189     if (VInitVolumePackage2(debugUtility, &opts)) {
190         /* VInitVolumePackage2 can fail on e.g. partition attachment errors,
191          * but we don't really care, since all we're doing is trying to use
192          * SALVSYNC */
193         fprintf(stderr, "errors encountered initializing volume package, but "
194                         "trying to continue anyway\n");
195     }
196     DInit(1);
197
198     if ((ti = as->parms[COMMON_PARMS_OFFSET].items)) {  /* -reason */
199         state->reason = atoi(ti->data);
200     }
201     if ((ti = as->parms[COMMON_PARMS_OFFSET+1].items)) {        /* -programtype */
202         if (!strcmp(ti->data, "fileServer")) {
203             programType = fileServer;
204         } else if (!strcmp(ti->data, "volumeUtility")) {
205             programType = volumeUtility;
206         } else if (!strcmp(ti->data, "salvager")) {
207             programType = salvager;
208         } else if (!strcmp(ti->data, "salvageServer")) {
209             programType = salvageServer;
210         } else if (!strcmp(ti->data, "volumeServer")) {
211             programType = volumeServer;
212         } else if (!strcmp(ti->data, "volumeSalvager")) {
213             programType = volumeSalvager;
214         } else {
215             programType = (ProgramType) atoi(ti->data);
216         }
217     }
218
219     VConnectSALV();
220
221     return 0;
222 }
223
224 static int
225 common_salv_prolog(struct cmd_syndesc * as, struct state * state)
226 {
227     struct cmd_item *ti;
228
229     state->sop = (struct salv_state *) calloc(1, sizeof(struct salv_state));
230     assert(state->sop != NULL);
231
232     if ((ti = as->parms[COMMON_SALV_PARMS_OFFSET].items)) {     /* -volumeid */
233         state->sop->volume = atoi(ti->data);
234     } else {
235         fprintf(stderr, "required argument -volumeid not given\n");
236     }
237
238     if ((ti = as->parms[COMMON_SALV_PARMS_OFFSET+1].items)) {   /* -partition */
239         strlcpy(state->sop->partName, ti->data, sizeof(state->sop->partName));
240     } else {
241         memset(state->sop->partName, 0, sizeof(state->sop->partName));
242     }
243
244     if ((ti = as->parms[COMMON_SALV_PARMS_OFFSET+2].items)) {   /* -prio */
245         state->sop->prio = atoi(ti->data);
246     } else {
247         state->sop->prio = 0;
248     }
249
250     return 0;
251 }
252
253 static int
254 do_salvop(struct state * state, afs_int32 command, SYNC_response * res)
255 {
256     afs_int32 code;
257     SALVSYNC_response_hdr hdr_l, *hdr;
258     SYNC_response res_l;
259
260     if (!res) {
261         res = &res_l;
262         res->payload.len = sizeof(hdr_l);
263         res->payload.buf = hdr = &hdr_l;
264     } else {
265         hdr = (SALVSYNC_response_hdr *) res->payload.buf;
266     }
267
268     fprintf(stderr, "calling SALVSYNC_SalvageVolume with command code %d (%s)\n",
269             command, command_code_to_string(command));
270
271     code = SALVSYNC_SalvageVolume(state->sop->volume,
272                                   state->sop->partName,
273                                   command,
274                                   state->reason,
275                                   state->sop->prio,
276                                   res);
277
278     switch (code) {
279     case SYNC_OK:
280     case SYNC_DENIED:
281         break;
282     default:
283         fprintf(stderr, "possible sync protocol error. return code was %d\n", code);
284     }
285
286     fprintf(stderr, "SALVSYNC_SalvageVolume returned %d (%s)\n", code, response_code_to_string(code));
287     fprintf(stderr, "protocol response code was %d (%s)\n",
288             res->hdr.response, response_code_to_string(res->hdr.response));
289     fprintf(stderr, "protocol reason code was %d (%s)\n",
290             res->hdr.reason, reason_code_to_string(res->hdr.reason));
291
292     printf("state = {\n");
293     if (res->hdr.flags & SALVSYNC_FLAG_VOL_STATS_VALID) {
294         printf("\tstate = %d (%s)\n",
295                hdr->state, state_code_to_string(hdr->state));
296         printf("\tprio = %d\n", hdr->prio);
297     }
298     printf("\tsq_len = %d\n", hdr->sq_len);
299     printf("\tpq_len = %d\n", hdr->pq_len);
300     printf("}\n");
301
302     VDisconnectSALV();
303
304     return 0;
305 }
306
307 static char *
308 response_code_to_string(afs_int32 response)
309 {
310     switch (response) {
311     case SYNC_OK:
312         return "SYNC_OK";
313     case SYNC_DENIED:
314         return "SYNC_DENIED";
315     case SYNC_COM_ERROR:
316         return "SYNC_COM_ERROR";
317     case SYNC_BAD_COMMAND:
318         return "SYNC_BAD_COMMAND";
319     case SYNC_FAILED:
320         return "SYNC_FAILED";
321     default:
322         return "**UNKNOWN**";
323     }
324 }
325
326 static char *
327 command_code_to_string(afs_int32 command)
328 {
329     switch (command) {
330     case SYNC_COM_CHANNEL_CLOSE:
331         return "SYNC_COM_CHANNEL_CLOSE";
332     case SALVSYNC_NOP:
333         return "SALVSYNC_NOP";
334     case SALVSYNC_SALVAGE:
335         return "SALVSYNC_SALVAGE";
336     case SALVSYNC_CANCEL:
337         return "SALVSYNC_CANCEL";
338     case SALVSYNC_RAISEPRIO:
339         return "SALVSYNC_RAISEPRIO";
340     case SALVSYNC_QUERY:
341         return "SALVSYNC_QUERY";
342     case SALVSYNC_CANCELALL:
343         return "SALVSYNC_CANCELLALL";
344     default:
345         return "**UNKNOWN**";
346     }
347 }
348
349 static char *
350 reason_code_to_string(afs_int32 reason)
351 {
352     switch (reason) {
353     case SALVSYNC_WHATEVER:
354         return "SALVSYNC_WHATEVER";
355     case SALVSYNC_ERROR:
356         return "SALVSYNC_ERROR";
357     case SALVSYNC_OPERATOR:
358         return "SALVSYNC_OPERATOR";
359     case SALVSYNC_SHUTDOWN:
360         return "SALVSYNC_SHUTDOWN";
361     case SALVSYNC_NEEDED:
362         return "SALVSYNC_NEEDED";
363     default:
364         return "**UNKNOWN**";
365     }
366 }
367
368 #if 0
369 static char *
370 program_type_to_string(afs_int32 type)
371 {
372     switch ((ProgramType)type) {
373     case fileServer:
374         return "fileServer";
375     case volumeUtility:
376         return "volumeUtility";
377     case salvager:
378         return "salvager";
379     case salvageServer:
380         return "salvageServer";
381     default:
382         return "**UNKNOWN**";
383     }
384 }
385 #endif
386
387 static char *
388 state_code_to_string(afs_int32 state)
389 {
390     switch (state) {
391     case SALVSYNC_STATE_UNKNOWN:
392         return "SALVSYNC_STATE_UNKNOWN";
393     case SALVSYNC_STATE_QUEUED:
394         return "SALVSYNC_STATE_QUEUED";
395     case SALVSYNC_STATE_SALVAGING:
396         return "SALVSYNC_STATE_SALVAGING";
397     case SALVSYNC_STATE_ERROR:
398         return "SALVSYNC_STATE_ERROR";
399     case SALVSYNC_STATE_DONE:
400         return "SALVSYNC_STATE_DONE";
401     default:
402         return "**UNKNOWN**";
403     }
404 }
405
406 static int
407 OpStats(struct cmd_syndesc * as, void * rock)
408 {
409     struct state state;
410
411     common_prolog(as, &state);
412     common_salv_prolog(as, &state);
413
414     do_salvop(&state, SALVSYNC_NOP, NULL);
415
416     return 0;
417 }
418
419 static int
420 OpSalvage(struct cmd_syndesc * as, void * rock)
421 {
422     struct state state;
423
424     common_prolog(as, &state);
425     common_salv_prolog(as, &state);
426
427     do_salvop(&state, SALVSYNC_SALVAGE, NULL);
428
429     return 0;
430 }
431
432 static int
433 OpCancel(struct cmd_syndesc * as, void * rock)
434 {
435     struct state state;
436
437     common_prolog(as, &state);
438     common_salv_prolog(as, &state);
439
440     do_salvop(&state, SALVSYNC_CANCEL, NULL);
441
442     return 0;
443 }
444
445 static int
446 OpCancelAll(struct cmd_syndesc * as, void * rock)
447 {
448     struct state state;
449
450     common_prolog(as, &state);
451     common_salv_prolog(as, &state);
452
453     do_salvop(&state, SALVSYNC_CANCELALL, NULL);
454
455     return 0;
456 }
457
458 static int
459 OpRaisePrio(struct cmd_syndesc * as, void * rock)
460 {
461     struct state state;
462
463     common_prolog(as, &state);
464     common_salv_prolog(as, &state);
465
466     do_salvop(&state, SALVSYNC_RAISEPRIO, NULL);
467
468     return 0;
469 }
470
471 static int
472 OpQuery(struct cmd_syndesc * as, void * rock)
473 {
474     struct state state;
475
476     common_prolog(as, &state);
477     common_salv_prolog(as, &state);
478
479     do_salvop(&state, SALVSYNC_QUERY, NULL);
480
481     return 0;
482 }
483
484 #endif /* AFS_DEMAND_ATTACH_FS */