Log binding ip address and port during startup
[openafs.git] / src / vlserver / sascnvldb.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12 #include <afs/stds.h>
13
14 #include <sys/file.h>
15 #include <afs/venus.h>
16 #include <afs/cmd.h>
17 #include <afs/afs_consts.h>
18
19 #include "cnvldb.h"             /* CHANGEME! */
20
21 static char pn[] = "cnvldb";
22 static char tempname[] = "XXnewvldb";
23 static char space[AFS_PIOCTL_MAXSIZE];
24 static int MaxServers[2] = { 30, 254 }; /* max server # permitted in this version */
25
26 #ifdef notdef                   /* postpone this... */
27 static int
28 saferead(fd, addr, osize)
29      int fd, osize;
30      char *addr;
31 {
32     int rc, size;
33     char *ptr;
34
35     if (size == EOF)
36         return (EOF);
37
38     ptr = addr;
39     rc = osize = size;
40
41     while (rc != EOF) {
42         rc = read(fd, ptr, size)) {
43             if (rc == size)
44                 return osize;
45             else {
46                 if (errno != EINTR) {
47                     perror(pn);
48                     exit(-1);
49                 }
50             }
51         }
52     }
53
54
55     static int
56       saferead(fd, addr, osize)
57     int fd, osize;
58     char *addr;
59     {
60         int rc;
61
62         rc = read(fd, addr, osize);
63         if (rc != osize && rc != EOF) {
64             perror(pn);
65             exit(-1);
66         }
67         return (rc);
68     }
69 #else
70 #define saferead(fd,addr,siz) read((fd),(addr),(siz))
71 #endif
72
73 static char tspace[1024];       /* chdir can't handle anything bigger, anyway */
74 /* return a static pointer to a buffer */
75 static char *
76 Parent(apath)
77      char *apath;
78 {
79     char *tp;
80     strcpy(tspace, apath);
81     tp = strrchr(tspace, '/');
82     if (tp) {
83         *tp = 0;
84     } else
85         strcpy(tspace, ".");
86     return tspace;
87 }
88
89 #ifdef notdef
90
91 /* this function returns TRUE (1) if the file is in AFS, otherwise false (0) */
92 static int
93 InAFS(apath)
94      char *apath;
95 {
96     struct ViceIoctl blob;
97     afs_int32 code;
98
99     blob.in_size = 0;
100     blob.out_size = AFS_PIOCTL_MAXSIZE;
101     blob.out = space;
102
103     code = pioctl(apath, VIOC_FILE_CELL_NAME, &blob, 1);
104     if (code) {
105         if ((errno == EINVAL) || (errno == ENOENT))
106             return 0;
107     }
108     return 1;
109 }
110
111 QuickPrintStatus(status, name)
112      struct VolumeStatus *status;
113      char *name;
114 {
115     double QuotaUsed = 0.0;
116     double PartUsed = 0.0;
117     int WARN = 0;
118
119     if (status->MaxQuota != 0) {
120         QuotaUsed =
121             ((((double)status->BlocksInUse) / status->MaxQuota) * 100.0);
122     } else {
123         /* no limit */
124     }
125     PartUsed =
126         (100.0 -
127          ((((double)status->PartBlocksAvail) / status->PartMaxBlocks) *
128           100.0));
129 }
130
131
132 static int
133 ListQuotaCmd(struct cmd_syndesc *as, void *arock)
134 {
135     afs_int32 code;
136     struct ViceIoctl blob;
137     struct cmd_item *ti;
138     struct VolumeStatus *status;
139     char *name;
140
141     for (ti = as->parms[0].items; ti; ti = ti->next) {
142         /* once per file */
143         blob.out_size = AFS_PIOCTL_MAXSIZE;
144         blob.in_size = 0;
145         blob.out = space;
146         code = pioctl(ti->data, VIOCGETVOLSTAT, &blob, 1);
147         if (code) {
148             Die(code, ti->data);
149             continue;
150         }
151         status = (struct VolumeStatus *)space;
152         name = (char *)status + sizeof(*status);
153         QuickPrintStatus(status, name);
154     }
155     return 0;
156 }
157 #endif /* notdef */
158
159 int gc = 1, fromvers = 1, tovers = 2;
160 char *pathname = NULL, *defaultpath = "/usr/afs/db/vl.DB0";
161
162 usage()
163 {
164     fprintf(stderr, "usage: %s ", pn);
165     fprintf(stderr, "[-name <pathname>] [-help]\n");
166 }
167
168 getargs(argc, argv)
169      int argc;
170      char **argv;
171 {
172     int pos, i;
173     pos = 0;
174
175     for (i = 1; i < argc; i++) {
176         if (!argv[i])
177             break;
178         else if (*(argv[i]) != '-') {   /* positional params */
179             if (!pathname)
180                 pathname = argv[i];
181             else {
182                 fprintf(stderr, "%s: Too many parameters!\n");
183                 usage();
184                 exit(-1);
185             }
186         } else                  /* keyword params */
187             switch (argv[i][1]) {
188
189             case 't':           /* -to */
190                 fprintf(stderr, "%s: can't specify version with this tool!\n",
191                         pn);
192                 exit(-1);
193                 break;
194
195             case 'f':           /* -from */
196                 fprintf(stderr, "%s: can't specify version with this tool!\n",
197                         pn);
198                 break;
199
200             case 'n':           /* -name */
201                 if (pathname) {
202                     fprintf(stderr,
203                             "%s: -name specified (or implied) twice!\n", pn);
204                     exit(-1);
205                 }
206                 pathname = argv[++i];
207                 break;
208
209             case 'h':           /* -help */
210                 usage();
211                 exit(0);
212                 break;
213
214             case 'g':           /* -gc == No GC */
215                 gc = 0;
216                 break;
217
218             default:
219                 usage();
220                 exit(EINVAL);
221             }
222     }
223
224     if (!pathname)
225         pathname = defaultpath;
226 }
227
228 #include "AFS_component_version_number.c"
229
230 main(argc, argv)
231      int argc;
232      char **argv;
233 {
234     afs_int32 code;
235     int old, new, rc;
236     short uvers;
237     char ubik[80];              /* space for some ubik header */
238
239     union {
240         struct vlheader_1 header1;
241         struct vlheader_2 header2;
242     } oldheader, newheader;     /* large enough for either */
243
244     union {
245         struct vlentry_1 entry1;
246         struct vlentry_2 entry2;
247     } vlentry;
248
249
250     getargs(argc, argv);
251
252     /* should stat() the old vldb, get its size, and see if there's */
253     /* room for another.  It might be in AFS, so check the quota, too */
254     if (!(old = open(pathname, O_RDONLY))) {
255         perror(pn);
256         exit(-1);
257     }
258
259     if (chdir(Parent(pathname))) {
260         perror(pn);
261         exit(-1);
262     }
263
264     if (!(new = open(tempname, O_WRONLY | O_CREAT | O_TRUNC, 0600))) {
265         perror(pn);
266         exit(-1);
267     }
268
269     if (fromvers == 0) {        /* not set */
270         lseek(old, 64, L_SET);
271         read(old, &fromvers, sizeof(int));
272         fromvers = ntohl(fromvers);
273         lseek(old, 0, L_SET);   /* go back to beginning */
274     }
275
276     /* skip the UBIK data */
277     read(old, ubik, 64);
278 #ifdef notdef
279     uvers = ntohs(uvers);
280     uvers += 10;                /* hey, if you screw with the VLDB, you lose */
281     uvers = htons(uvers);
282 #endif
283     write(new, ubik, 64);
284
285     readheader(old, fromvers, &oldheader);
286     convert_header(new, fromvers, tovers, &oldheader, &newheader);
287     while ((rc = read(old, &vlentry, sizeof(struct vlentry_1))) && rc != EOF) {
288         convert_vlentry(new, fromvers, tovers, &oldheader, &newheader,
289                         &vlentry);
290     }
291
292
293     if (gc)
294         rewrite_header(new, tovers, &newheader);
295
296     close(old);
297     if (fsync(new)) {
298         perror(pn);
299         exit(-1);
300     }
301
302     close(new);
303     rename(tempname, pathname);
304     exit(0);
305 }
306
307 readheader(fd, version, addr)
308      int fd;
309      int version;
310      char *addr;
311 {
312     if (version == 1) {
313         read(fd, addr, sizeof(struct vlheader_2));      /* it's not a bug, it's SAS */
314     } else if (version == 2) {
315         read(fd, addr, sizeof(struct vlheader_2));
316     } else
317         return EINVAL;
318
319     return 0;
320 }
321
322 /* SAS special */
323 convert_header(fd, fromv, tov, fromaddr, toaddr)
324      int fd, fromv, tov;
325      char *fromaddr, *toaddr;
326 {
327     struct vlheader_2 *tvp1;
328     struct vlheader_2 *tvp2;
329     int i, j, diff;
330
331     memcpy(toaddr, fromaddr, sizeof(struct vlheader_2));
332     tvp2 = (struct vlheader_2 *)toaddr;
333     tvp2->vital_header.vldbversion = htonl(2);
334
335     write(fd, tvp2, sizeof(struct vlheader_2));
336
337     /* for garbage-collecting... */
338     if (gc)
339         for (i = 0; i < 254; i++)
340             tvp2->IpMappedAddr[i] = 0;
341
342     return 0;
343 }
344
345 static int
346 convert_vlentry(new, fromvers, tovers, oldheader, newheader, vlentry)
347      int new, fromvers, tovers;
348      struct vlheader_1 *oldheader, *newheader;  /* close enough */
349      struct vlentry_1 *vlentry; /* 1 and 2 are identical */
350 {
351     int diff, i, s;
352
353 #ifndef DEBUG
354     if (fromvers != tovers) {   /* only supports 1 and 2 currently */
355 #endif
356
357         diff =
358             (tovers ==
359              1 ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2))
360             - (fromvers ==
361                1 ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2));
362
363         for (i = 0; i < 3; i++)
364             vlentry->nextIdHash[i] =
365                 htonl(ntohl(vlentry->nextIdHash[i]) + diff);
366
367         vlentry->nextNameHash = htonl(ntohl(vlentry->nextNameHash) + diff);
368
369 #ifndef DEBUG
370     } else {
371         ;                       /* no change, we're just in it for the GC */
372     }
373 #endif
374
375     for (i = 0; i < 8; i++) {
376         s = vlentry->serverNumber[i];
377         if (s != 255) {
378             if (s > 254) {
379                 fprintf(stderr,
380                         "%s: Too Many Servers (%d) for this version!\n", pn,
381                         s + 1);
382                 exit(-1);
383             } else {
384                 newheader->IpMappedAddr[s] = oldheader->IpMappedAddr[s];
385             }
386         }
387     }
388     write(new, vlentry, sizeof(struct vlentry_2));
389
390     return;
391 }
392
393 static int
394 rewrite_header(new, tovers, newheader)
395      int new, tovers;
396      char *newheader;
397 {
398     int pos;
399
400     pos = lseek(new, 64, L_SET);        /* leave room for ubik */
401
402     if (pos == -1) {
403         perror(pn);
404         fprintf(stderr, "%s: no garbage collection\n", pn);
405         return;
406     } else if (pos != 64) {
407         fprintf(stderr, "%s: Can't rewind: no garbage collection\n", pn);
408         return;
409     }
410
411     if (tovers = 1) {
412         write(new, newheader, sizeof(struct vlheader_1));
413     } else {
414         write(new, newheader, sizeof(struct vlheader_2));
415     }
416
417     return;
418 }