[hcoop/debian/openafs.git] / src / vlserver / sascnvldb.c

/*
 * Copyright 2000, International Business Machines Corporation and others.
 * All Rights Reserved.
 *
 * This software has been released under the terms of the IBM Public
 * License.  For details, see the LICENSE file in the top-level source
 * directory or online at http://www.openafs.org/dl/license10.html
 */

#include <afsconfig.h>
#include <afs/param.h>
#include <afs/stds.h>

#include <sys/file.h>
#include <afs/venus.h>
#include <afs/cmd.h>
#include <afs/afs_consts.h>

#include "cnvldb.h"		/* CHANGEME! */

static char pn[] = "cnvldb";
static char tempname[] = "XXnewvldb";
static char space[AFS_PIOCTL_MAXSIZE];
static int MaxServers[2] = { 30, 254 };	/* max server # permitted in this version */

#ifdef notdef			/* postpone this... */
static int
saferead(fd, addr, osize)
     int fd, osize;
     char *addr;
{
    int rc, size;
    char *ptr;

    if (size == EOF)
	return (EOF);

    ptr = addr;
    rc = osize = size;

    while (rc != EOF) {
	rc = read(fd, ptr, size)) {
	    if (rc == size)
		return osize;
	    else {
		if (errno != EINTR) {
		    perror(pn);
		    exit(-1);
		}
	    }
	}
    }


    static int
      saferead(fd, addr, osize)
    int fd, osize;
    char *addr;
    {
	int rc;

	rc = read(fd, addr, osize);
	if (rc != osize && rc != EOF) {
	    perror(pn);
	    exit(-1);
	}
	return (rc);
    }
#else
#define saferead(fd,addr,siz) read((fd),(addr),(siz))
#endif

static char tspace[1024];	/* chdir can't handle anything bigger, anyway */
/* return a static pointer to a buffer */
static char *
Parent(apath)
     char *apath;
{
    char *tp;
    strcpy(tspace, apath);
    tp = strrchr(tspace, '/');
    if (tp) {
	*tp = 0;
    } else
	strcpy(tspace, ".");
    return tspace;
}

#ifdef notdef

/* this function returns TRUE (1) if the file is in AFS, otherwise false (0) */
static int
InAFS(apath)
     char *apath;
{
    struct ViceIoctl blob;
    afs_int32 code;

    blob.in_size = 0;
    blob.out_size = AFS_PIOCTL_MAXSIZE;
    blob.out = space;

    code = pioctl(apath, VIOC_FILE_CELL_NAME, &blob, 1);
    if (code) {
	if ((errno == EINVAL) || (errno == ENOENT))
	    return 0;
    }
    return 1;
}

QuickPrintStatus(status, name)
     struct VolumeStatus *status;
     char *name;
{
    double QuotaUsed = 0.0;
    double PartUsed = 0.0;
    int WARN = 0;

    if (status->MaxQuota != 0) {
	QuotaUsed =
	    ((((double)status->BlocksInUse) / status->MaxQuota) * 100.0);
    } else {
	/* no limit */
    }
    PartUsed =
	(100.0 -
	 ((((double)status->PartBlocksAvail) / status->PartMaxBlocks) *
	  100.0));
}


static int
ListQuotaCmd(struct cmd_syndesc *as, void *arock)
{
    afs_int32 code;
    struct ViceIoctl blob;
    struct cmd_item *ti;
    struct VolumeStatus *status;
    char *name;

    for (ti = as->parms[0].items; ti; ti = ti->next) {
	/* once per file */
	blob.out_size = AFS_PIOCTL_MAXSIZE;
	blob.in_size = 0;
	blob.out = space;
	code = pioctl(ti->data, VIOCGETVOLSTAT, &blob, 1);
	if (code) {
	    Die(code, ti->data);
	    continue;
	}
	status = (struct VolumeStatus *)space;
	name = (char *)status + sizeof(*status);
	QuickPrintStatus(status, name);
    }
    return 0;
}
#endif /* notdef */

int gc = 1, fromvers = 1, tovers = 2;
char *pathname = NULL, *defaultpath = "/usr/afs/db/vl.DB0";

usage()
{
    fprintf(stderr, "usage: %s ", pn);
    fprintf(stderr, "[-name <pathname>] [-help]\n");
}

getargs(argc, argv)
     int argc;
     char **argv;
{
    int pos, i;
    pos = 0;

    for (i = 1; i < argc; i++) {
	if (!argv[i])
	    break;
	else if (*(argv[i]) != '-') {	/* positional params */
	    if (!pathname)
		pathname = argv[i];
	    else {
		fprintf(stderr, "%s: Too many parameters!\n");
		usage();
		exit(-1);
	    }
	} else			/* keyword params */
	    switch (argv[i][1]) {

	    case 't':		/* -to */
		fprintf(stderr, "%s: can't specify version with this tool!\n",
			pn);
		exit(-1);
		break;

	    case 'f':		/* -from */
		fprintf(stderr, "%s: can't specify version with this tool!\n",
			pn);
		break;

	    case 'n':		/* -name */
		if (pathname) {
		    fprintf(stderr,
			    "%s: -name specified (or implied) twice!\n", pn);
		    exit(-1);
		}
		pathname = argv[++i];
		break;

	    case 'h':		/* -help */
		usage();
		exit(0);
		break;

	    case 'g':		/* -gc == No GC */
		gc = 0;
		break;

	    default:
		usage();
		exit(EINVAL);
	    }
    }

    if (!pathname)
	pathname = defaultpath;
}

#include "AFS_component_version_number.c"

main(argc, argv)
     int argc;
     char **argv;
{
    afs_int32 code;
    int old, new, rc;
    short uvers;
    char ubik[80];		/* space for some ubik header */

    union {
	struct vlheader_1 header1;
	struct vlheader_2 header2;
    } oldheader, newheader;	/* large enough for either */

    union {
	struct vlentry_1 entry1;
	struct vlentry_2 entry2;
    } vlentry;


    getargs(argc, argv);

    /* should stat() the old vldb, get its size, and see if there's */
    /* room for another.  It might be in AFS, so check the quota, too */
    if (!(old = open(pathname, O_RDONLY))) {
	perror(pn);
	exit(-1);
    }

    if (chdir(Parent(pathname))) {
	perror(pn);
	exit(-1);
    }

    if (!(new = open(tempname, O_WRONLY | O_CREAT | O_TRUNC, 0600))) {
	perror(pn);
	exit(-1);
    }

    if (fromvers == 0) {	/* not set */
	lseek(old, 64, L_SET);
	read(old, &fromvers, sizeof(int));
	fromvers = ntohl(fromvers);
	lseek(old, 0, L_SET);	/* go back to beginning */
    }

    /* skip the UBIK data */
    read(old, ubik, 64);
#ifdef notdef
    uvers = ntohs(uvers);
    uvers += 10;		/* hey, if you screw with the VLDB, you lose */
    uvers = htons(uvers);
#endif
    write(new, ubik, 64);

    readheader(old, fromvers, &oldheader);
    convert_header(new, fromvers, tovers, &oldheader, &newheader);
    while ((rc = read(old, &vlentry, sizeof(struct vlentry_1))) && rc != EOF) {
	convert_vlentry(new, fromvers, tovers, &oldheader, &newheader,
			&vlentry);
    }


    if (gc)
	rewrite_header(new, tovers, &newheader);

    close(old);
    if (fsync(new)) {
	perror(pn);
	exit(-1);
    }

    close(new);
    rename(tempname, pathname);
    exit(0);
}

readheader(fd, version, addr)
     int fd;
     int version;
     char *addr;
{
    if (version == 1) {
	read(fd, addr, sizeof(struct vlheader_2));	/* it's not a bug, it's SAS */
    } else if (version == 2) {
	read(fd, addr, sizeof(struct vlheader_2));
    } else
	return EINVAL;

    return 0;
}

/* SAS special */
convert_header(fd, fromv, tov, fromaddr, toaddr)
     int fd, fromv, tov;
     char *fromaddr, *toaddr;
{
    struct vlheader_2 *tvp1;
    struct vlheader_2 *tvp2;
    int i, j, diff;

    memcpy(toaddr, fromaddr, sizeof(struct vlheader_2));
    tvp2 = (struct vlheader_2 *)toaddr;
    tvp2->vital_header.vldbversion = htonl(2);

    write(fd, tvp2, sizeof(struct vlheader_2));

    /* for garbage-collecting... */
    if (gc)
	for (i = 0; i < 254; i++)
	    tvp2->IpMappedAddr[i] = 0;

    return 0;
}

static int
convert_vlentry(new, fromvers, tovers, oldheader, newheader, vlentry)
     int new, fromvers, tovers;
     struct vlheader_1 *oldheader, *newheader;	/* close enough */
     struct vlentry_1 *vlentry;	/* 1 and 2 are identical */
{
    int diff, i, s;

#ifndef DEBUG
    if (fromvers != tovers) {	/* only supports 1 and 2 currently */
#endif

	diff =
	    (tovers ==
	     1 ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2))
	    - (fromvers ==
	       1 ? sizeof(struct vlheader_1) : sizeof(struct vlheader_2));

	for (i = 0; i < 3; i++)
	    vlentry->nextIdHash[i] =
		htonl(ntohl(vlentry->nextIdHash[i]) + diff);

	vlentry->nextNameHash = htonl(ntohl(vlentry->nextNameHash) + diff);

#ifndef DEBUG
    } else {
	;			/* no change, we're just in it for the GC */
    }
#endif

    for (i = 0; i < 8; i++) {
	s = vlentry->serverNumber[i];
	if (s != 255) {
	    if (s > 254) {
		fprintf(stderr,
			"%s: Too Many Servers (%d) for this version!\n", pn,
			s + 1);
		exit(-1);
	    } else {
		newheader->IpMappedAddr[s] = oldheader->IpMappedAddr[s];
	    }
	}
    }
    write(new, vlentry, sizeof(struct vlentry_2));

    return;
}

static int
rewrite_header(new, tovers, newheader)
     int new, tovers;
     char *newheader;
{
    int pos;

    pos = lseek(new, 64, L_SET);	/* leave room for ubik */

    if (pos == -1) {
	perror(pn);
	fprintf(stderr, "%s: no garbage collection\n", pn);
	return;
    } else if (pos != 64) {
	fprintf(stderr, "%s: Can't rewind: no garbage collection\n", pn);
	return;
    }

    if (tovers = 1) {
	write(new, newheader, sizeof(struct vlheader_1));
    } else {
	write(new, newheader, sizeof(struct vlheader_2));
    }

    return;
}
Commit	Line	Data
805e021f CE	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	}