[hcoop/debian/openafs.git] / src / budb / db_dump.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
 */

/* dump the database
 * Dump is made to a local file. Structures are dumped in network byte order
 * for transportability between hosts
 */

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

#include <roken.h>

#include <afs/opr.h>

#ifdef AFS_PTHREAD_ENV
# include <opr/lock.h>
#endif

#include <ubik.h>
#include <afs/audit.h>

#include "database.h"
#include "budb.h"
#include "globals.h"
#include "error_macros.h"
#include "budb_errs.h"
#include "budb_internal.h"


/* dump ubik database - routines to scan the database and dump all
 * 	the information
 */

/* -----------------------
 * synchronization on pipe
 * -----------------------
 */

/* interlocking for database dump */

dumpSyncT dumpSync;
dumpSyncP dumpSyncPtr = &dumpSync;


/* canWrite
 *	check if we should dump more of the database. Waits for the reader
 *	to drain the information before allowing the writer to proceed.
 * exit:
 *	1 - ok to write
 */

afs_int32
canWrite(int fid)
{
#ifndef AFS_PTHREAD_ENV
    afs_int32 code = 0;
#endif
    extern dumpSyncP dumpSyncPtr;

    ObtainWriteLock(&dumpSyncPtr->ds_lock);

    /* let the pipe drain */
    while (dumpSyncPtr->ds_bytes > 0) {
	if (dumpSyncPtr->ds_readerStatus == DS_WAITING) {
	    dumpSyncPtr->ds_readerStatus = 0;
#ifdef AFS_PTHREAD_ENV
	    opr_cv_broadcast(&dumpSyncPtr->ds_readerStatus_cond);
#else
	    code = LWP_SignalProcess(&dumpSyncPtr->ds_readerStatus);
	    if (code)
		LogError(code, "canWrite: Signal delivery failed\n");
#endif
	}
	dumpSyncPtr->ds_writerStatus = DS_WAITING;
	ReleaseWriteLock(&dumpSyncPtr->ds_lock);
#ifdef AFS_PTHREAD_ENV
	MUTEX_ENTER(&dumpSyncPtr->ds_writerStatus_mutex);
	opr_cv_wait(&dumpSyncPtr->ds_writerStatus_cond, &dumpSyncPtr->ds_writerStatus_mutex);
	MUTEX_EXIT(&dumpSyncPtr->ds_writerStatus_mutex);
#else
	LWP_WaitProcess(&dumpSyncPtr->ds_writerStatus);
#endif
	ObtainWriteLock(&dumpSyncPtr->ds_lock);
    }
    return (1);
}


/* haveWritten
 *	record the fact that nbytes have been written. Signal the reader
 *	to proceed, and unlock.
 * exit:
 *	no return value
 */

void
haveWritten(afs_int32 nbytes)
{
#ifndef AFS_PTHREAD_ENV
    afs_int32 code = 0;
#endif
    extern dumpSyncP dumpSyncPtr;

    dumpSyncPtr->ds_bytes += nbytes;
    if (dumpSyncPtr->ds_readerStatus == DS_WAITING) {
	dumpSyncPtr->ds_readerStatus = 0;
#ifdef AFS_PTHREAD_ENV
	opr_cv_broadcast(&dumpSyncPtr->ds_readerStatus_cond);
#else
	code = LWP_SignalProcess(&dumpSyncPtr->ds_readerStatus);
	if (code)
	    LogError(code, "haveWritten: Signal delivery failed\n");
#endif
    }
    ReleaseWriteLock(&dumpSyncPtr->ds_lock);
}

/* doneWriting
 *	wait for the reader to drain all the information, and then set the
 *	done flag.
 */

void
doneWriting(afs_int32 error)
{
#ifndef AFS_PTHREAD_ENV
    afs_int32 code = 0;
#endif

    /* wait for the reader */
    ObtainWriteLock(&dumpSyncPtr->ds_lock);
    while (dumpSyncPtr->ds_readerStatus != DS_WAITING) {
	LogDebug(4, "doneWriting: waiting for Reader\n");
	dumpSyncPtr->ds_writerStatus = DS_WAITING;
	ReleaseWriteLock(&dumpSyncPtr->ds_lock);
#ifdef AFS_PTHREAD_ENV
	MUTEX_ENTER(&dumpSyncPtr->ds_writerStatus_mutex);
	opr_cv_wait(&dumpSyncPtr->ds_writerStatus_cond, &dumpSyncPtr->ds_writerStatus_mutex);
	MUTEX_EXIT(&dumpSyncPtr->ds_writerStatus_mutex);
#else
	LWP_WaitProcess(&dumpSyncPtr->ds_writerStatus);
#endif
	ObtainWriteLock(&dumpSyncPtr->ds_lock);
    }

    LogDebug(4, "doneWriting: setting done\n");

    /* signal that we are done */
    if (error)
	dumpSyncPtr->ds_writerStatus = DS_DONE_ERROR;
    else
	dumpSyncPtr->ds_writerStatus = DS_DONE;
    dumpSyncPtr->ds_readerStatus = 0;
#ifdef AFS_PTHREAD_ENV
    opr_cv_broadcast(&dumpSyncPtr->ds_readerStatus_cond);
#else
    code = LWP_NoYieldSignal(&dumpSyncPtr->ds_readerStatus);
    if (code)
	LogError(code, "doneWriting: Signal delivery failed\n");
#endif
    ReleaseWriteLock(&dumpSyncPtr->ds_lock);
}

/* notes:
 *	ut - setup and pass down
 */

/* writeStructHeader
 *	write header appropriate for requested structure type
 */

afs_int32
writeStructHeader(int fid, afs_int32 type)
{
    struct structDumpHeader hostDumpHeader, netDumpHeader;

    hostDumpHeader.type = type;
    hostDumpHeader.structversion = 1;


    switch (type) {
    case SD_DBHEADER:
	hostDumpHeader.size = sizeof(struct DbHeader);
	break;

    case SD_DUMP:
	hostDumpHeader.size = sizeof(struct budb_dumpEntry);
	break;

    case SD_TAPE:
	hostDumpHeader.size = sizeof(struct budb_tapeEntry);
	break;

    case SD_VOLUME:
	hostDumpHeader.size = sizeof(struct budb_volumeEntry);
	break;

    case SD_END:
	hostDumpHeader.size = 0;
	break;

    default:
	LogError(0, "writeStructHeader: invalid type %d\n", type);
	BUDB_EXIT(1);
    }

    structDumpHeader_hton(&hostDumpHeader, &netDumpHeader);

    if (canWrite(fid) <= 0)
	return (BUDB_DUMPFAILED);
    if (write(fid, &netDumpHeader, sizeof(netDumpHeader)) !=
	sizeof(netDumpHeader))
	return (BUDB_DUMPFAILED);
    haveWritten(sizeof(netDumpHeader));

    return (0);
}

/* writeTextHeader
 *	write header appropriate for requested structure type
 */

afs_int32
writeTextHeader(int fid, afs_int32 type)
{
    struct structDumpHeader hostDumpHeader, netDumpHeader;

    hostDumpHeader.structversion = 1;

    switch (type) {
    case TB_DUMPSCHEDULE:
	hostDumpHeader.type = SD_TEXT_DUMPSCHEDULE;
	break;

    case TB_VOLUMESET:
	hostDumpHeader.type = SD_TEXT_VOLUMESET;
	break;

    case TB_TAPEHOSTS:
	hostDumpHeader.type = SD_TEXT_TAPEHOSTS;
	break;

    default:
	LogError(0, "writeTextHeader: invalid type %d\n", type);
	BUDB_EXIT(1);
    }

    hostDumpHeader.size = ntohl(db.h.textBlock[type].size);
    structDumpHeader_hton(&hostDumpHeader, &netDumpHeader);

    if (canWrite(fid) <= 0)
	return (BUDB_DUMPFAILED);

    if (write(fid, &netDumpHeader, sizeof(netDumpHeader)) !=
	sizeof(netDumpHeader))
	return (BUDB_DUMPFAILED);

    haveWritten(sizeof(netDumpHeader));

    return (0);
}

afs_int32
writeDbHeader(int fid)
{
    struct DbHeader header;
    afs_int32 curtime;
    afs_int32 code = 0, tcode;

    extern struct memoryDB db;

    /* check the memory database header for integrity */
    if (db.h.version != db.h.checkVersion)
	ERROR(BUDB_DATABASEINCONSISTENT);

    curtime = time(0);

    /* copy selected fields. Source is in xdr format. */
    header.dbversion = db.h.version;
    header.created = htonl(curtime);
    strcpy(header.cell, "");
    header.lastDumpId = db.h.lastDumpId;
    header.lastInstanceId = db.h.lastInstanceId;
    header.lastTapeId = db.h.lastTapeId;

    tcode = writeStructHeader(fid, SD_DBHEADER);
    if (tcode)
	ERROR(tcode);

    if (canWrite(fid) <= 0)
	ERROR(BUDB_DUMPFAILED);

    if (write(fid, &header, sizeof(header)) != sizeof(header))
	ERROR(BUDB_DUMPFAILED);

    haveWritten(sizeof(header));

  error_exit:
    return (code);
}

/* writeDump
 *	write out a dump entry structure
 */

afs_int32
writeDump(int fid, dbDumpP dumpPtr)
{
    struct budb_dumpEntry dumpEntry;
    afs_int32 code = 0, tcode;

    tcode = dumpToBudbDump(dumpPtr, &dumpEntry);
    if (tcode)
	ERROR(tcode);

    writeStructHeader(fid, SD_DUMP);

    if (canWrite(fid) <= 0)
	ERROR(BUDB_DUMPFAILED);

    if (write(fid, &dumpEntry, sizeof(dumpEntry)) != sizeof(dumpEntry))
	ERROR(BUDB_DUMPFAILED);
    haveWritten(sizeof(dumpEntry));

  error_exit:
    return (code);
}

afs_int32
writeTape(int fid, struct tape *tapePtr, afs_int32 dumpid)
{
    struct budb_tapeEntry tapeEntry;
    afs_int32 code = 0, tcode;

    tcode = writeStructHeader(fid, SD_TAPE);
    if (tcode)
	ERROR(tcode);

    tapeToBudbTape(tapePtr, &tapeEntry);

    tapeEntry.dump = htonl(dumpid);

    if (canWrite(fid) <= 0)
	ERROR(BUDB_DUMPFAILED);

    if (write(fid, &tapeEntry, sizeof(tapeEntry)) != sizeof(tapeEntry))
	ERROR(BUDB_DUMPFAILED);

    haveWritten(sizeof(tapeEntry));

  error_exit:
    return (code);
}

/* combines volFragment and volInfo */

afs_int32
writeVolume(struct ubik_trans *ut, int fid, struct volFragment *volFragmentPtr,
	    struct volInfo *volInfoPtr, afs_int32 dumpid, char *tapeName)
{
    struct budb_volumeEntry budbVolume;
    afs_int32 code = 0;

    volsToBudbVol(volFragmentPtr, volInfoPtr, &budbVolume);

    budbVolume.dump = htonl(dumpid);
    strcpy(budbVolume.tape, tapeName);

    writeStructHeader(fid, SD_VOLUME);

    if (canWrite(fid) <= 0)
	ERROR(BUDB_DUMPFAILED);

    if (write(fid, &budbVolume, sizeof(budbVolume)) != sizeof(budbVolume))
	ERROR(BUDB_DUMPFAILED);

    haveWritten(sizeof(budbVolume));

  error_exit:
    return (code);
}

/* -------------------
 * handlers for the text blocks
 * -------------------
 */

/* checkLock
 *	make sure a text lock is NOT held
 * exit:
 *	0 - not held
 *	n - error
 */

afs_int32
checkLock(afs_int32 textType)
{
    db_lockP lockPtr;

    if ((textType < 0) || (textType > TB_NUM - 1))
	return (BUDB_BADARGUMENT);

    lockPtr = &db.h.textLocks[textType];

    if (lockPtr->lockState != 0)
	return (BUDB_LOCKED);
    return (0);
}

/* checkText
 *	check the integrity of the specified text type
 */

int
checkText(struct ubik_trans *ut, afs_int32 textType)
{
    struct textBlock *tbPtr;
    afs_int32 nBytes = 0;	/* accumulated actual size */
    afs_int32 size;
    struct block block;
    dbadr blockAddr;

    afs_int32 code = 0;

    tbPtr = &db.h.textBlock[textType];
    blockAddr = ntohl(tbPtr->textAddr);
    size = ntohl(tbPtr->size);

    while (blockAddr != 0) {
	/* read the block */
	code =
	    cdbread(ut, text_BLOCK, blockAddr, (char *)&block, sizeof(block));
	if (code)
	    ERROR(code);

	/* check its type */
	if (block.h.type != text_BLOCK)
	    ERROR(BUDB_DATABASEINCONSISTENT);

	/* add up the size */
	nBytes += BLOCK_DATA_SIZE;

	blockAddr = ntohl(block.h.next);
    }

    /* ensure that we have at least the expected amount of text */
    if (nBytes < size)
	ERROR(BUDB_DATABASEINCONSISTENT);

  error_exit:
    return (code);
}

/* writeText
 * entry:
 *	textType - type of text block, e.g. TB_DUMPSCHEDULE
 */

afs_int32
writeText(struct ubik_trans *ut, int fid, int textType)
{
    struct textBlock *tbPtr;
    afs_int32 textSize, writeSize;
    dbadr dbAddr;
    struct block block;
    afs_int32 code = 0;

    /* check lock is free */
    code = checkLock(textType);
    if (code)
	ERROR(code);

    /* ensure that this block has the correct type */
    code = checkText(ut, textType);
    if (code) {
	LogError(0, "writeText: text type %d damaged\n", textType);
	ERROR(code);
    }

    tbPtr = &db.h.textBlock[textType];
    textSize = ntohl(tbPtr->size);
    dbAddr = ntohl(tbPtr->textAddr);

    if (!dbAddr)
	goto error_exit;	/* Don't save anything if no blocks */

    writeTextHeader(fid, textType);

    while (dbAddr) {
	code = cdbread(ut, text_BLOCK, dbAddr, (char *)&block, sizeof(block));
	if (code)
	    ERROR(code);

	writeSize = min(textSize, BLOCK_DATA_SIZE);
	if (!writeSize)
	    break;

	if (canWrite(fid) <= 0)
	    ERROR(BUDB_DUMPFAILED);

	if (write(fid, &block.a[0], writeSize) != writeSize)
	    ERROR(BUDB_IO);

	haveWritten(writeSize);
	textSize -= writeSize;

	dbAddr = ntohl(block.h.next);
    }

  error_exit:
    return (code);
}

#define MAXAPPENDS 200

afs_int32
writeDatabase(struct ubik_trans *ut, int fid)
{
    dbadr dbAddr, dbAppAddr;
    struct dump diskDump, apDiskDump;
    dbadr tapeAddr;
    struct tape diskTape;
    dbadr volFragAddr;
    struct volFragment diskVolFragment;
    struct volInfo diskVolInfo;
    int length, hash;
    int old = 0;
    int entrySize;
    afs_int32 code = 0, tcode;
    afs_int32 appDumpAddrs[MAXAPPENDS], numaddrs, appcount, j;

    struct memoryHashTable *mht;

    LogDebug(4, "writeDatabase:\n");

    /* write out a header identifying this database etc */
    tcode = writeDbHeader(fid);
    if (tcode) {
	LogError(tcode, "writeDatabase: Can't write Header\n");
	ERROR(tcode);
    }

    /* write out the tree of dump structures */

    mht = ht_GetType(HT_dumpIden_FUNCTION, &entrySize);
    if (!mht) {
	LogError(tcode, "writeDatabase: Can't get dump type\n");
	ERROR(BUDB_BADARGUMENT);
    }

    for (old = 0; old <= 1; old++) {
	/*oldnew */
	/* only two states, old or not old */
	length = (old ? mht->oldLength : mht->length);
	if (!length)
	    continue;

	for (hash = 0; hash < length; hash++) {
	    /*hashBuckets */
	    /* dump all the dumps in this hash bucket
	     */
	    for (dbAddr = ht_LookupBucket(ut, mht, hash, old); dbAddr; dbAddr = ntohl(diskDump.idHashChain)) {	/*initialDumps */
		/* now check if this dump had any errors/inconsistencies.
		 * If so, don't dump it
		 */
		if (badEntry(dbAddr)) {
		    LogError(0,
			     "writeDatabase: Damaged dump entry at addr 0x%x\n",
			     dbAddr);
		    Log("     Skipping remainder of dumps on hash chain %d\n",
			hash);
		    break;
		}

		tcode =
		    cdbread(ut, dump_BLOCK, dbAddr, &diskDump,
			    sizeof(diskDump));
		if (tcode) {
		    LogError(tcode,
			     "writeDatabase: Can't read dump entry (addr 0x%x)\n",
			     dbAddr);
		    Log("     Skipping remainder of dumps on hash chain %d\n",
			hash);
		    break;
		}

		/* Skip appended dumps, only start with initial dumps */
		if (diskDump.initialDumpID != 0)
		    continue;

		/* Skip appended dumps, only start with initial dumps. Then
		 * follow the appended dump chain so they are in order for restore.
		 */
		appcount = numaddrs = 0;
		for (dbAppAddr = dbAddr; dbAppAddr;
		     dbAppAddr = ntohl(apDiskDump.appendedDumpChain)) {
		    /*appendedDumps */
		    /* Check to see if we have a circular loop of appended dumps */
		    for (j = 0; j < numaddrs; j++) {
			if (appDumpAddrs[j] == dbAppAddr)
			    break;	/* circular loop */
		    }
		    if (j < numaddrs) {	/* circular loop */
			Log("writeDatabase: Circular loop found in appended dumps\n");
			Log("Skipping rest of appended dumps of dumpID %u\n",
			    ntohl(diskDump.id));
			break;
		    }
		    if (numaddrs >= MAXAPPENDS)
			numaddrs = MAXAPPENDS - 1;	/* don't overflow */
		    appDumpAddrs[numaddrs] = dbAppAddr;
		    numaddrs++;

		    /* If we dump a 1000 appended dumps, assume a loop */
		    if (appcount >= 5 * MAXAPPENDS) {
			Log("writeDatabase: Potential circular loop of appended dumps\n");
			Log("Skipping rest of appended dumps of dumpID %u. Dumped %d\n", ntohl(diskDump.id), appcount);
			break;
		    }
		    appcount++;

		    /* Read the dump entry */
		    if (dbAddr == dbAppAddr) {
			/* First time through, don't need to read the dump entry again */
			memcpy(&apDiskDump, &diskDump, sizeof(diskDump));
		    } else {
			if (badEntry(dbAppAddr)) {
			    LogError(0,
				     "writeDatabase: Damaged appended dump entry at addr 0x%x\n",
				     dbAddr);
			    Log("     Skipping this and remainder of appended dumps of initial DumpID %u\n", ntohl(diskDump.id));
			    break;
			}

			tcode =
			    cdbread(ut, dump_BLOCK, dbAppAddr, &apDiskDump,
				    sizeof(apDiskDump));
			if (tcode) {
			    LogError(tcode,
				     "writeDatabase: Can't read appended dump entry (addr 0x%x)\n",
				     dbAppAddr);
			    Log("     Skipping this and remainder of appended dumps of initial DumpID %u\n", ntohl(diskDump.id));
			    break;
			}

			/* Verify that this appended dump points to the initial dump */
			if (ntohl(apDiskDump.initialDumpID) !=
			    ntohl(diskDump.id)) {
			    LogError(0,
				     "writeDatabase: Appended dumpID %u does not reference initial dumpID %u\n",
				     ntohl(apDiskDump.id),
				     ntohl(diskDump.id));
			    Log("     Skipping this appended dump\n");
			    continue;
			}
		    }

		    /* Save the dump entry */
		    tcode = writeDump(fid, &apDiskDump);
		    if (tcode) {
			LogError(tcode,
				 "writeDatabase: Can't write dump entry\n");
			ERROR(tcode);
		    }

		    /* For each tape on this dump
		     */
		    for (tapeAddr = ntohl(apDiskDump.firstTape); tapeAddr; tapeAddr = ntohl(diskTape.nextTape)) {	/*tapes */
			/* read the tape entry */
			tcode =
			    cdbread(ut, tape_BLOCK, tapeAddr, &diskTape,
				    sizeof(diskTape));
			if (tcode) {
			    LogError(tcode,
				     "writeDatabase: Can't read tape entry (addr 0x%x) of dumpID %u\n",
				     tapeAddr, ntohl(apDiskDump.id));
			    Log("     Skipping this and remaining tapes in the dump (and all their volumes)\n");
			    break;
			}

			/* Save the tape entry */
			tcode =
			    writeTape(fid, &diskTape, ntohl(apDiskDump.id));
			if (tcode) {
			    LogError(tcode,
				     "writeDatabase: Can't write tape entry\n");
			    ERROR(tcode);
			}

			/* For each volume on this tape.
			 */
			for (volFragAddr = ntohl(diskTape.firstVol); volFragAddr; volFragAddr = ntohl(diskVolFragment.sameTapeChain)) {	/*volumes */
			    /* Read the volume Fragment entry */
			    tcode =
				cdbread(ut, volFragment_BLOCK, volFragAddr,
					&diskVolFragment,
					sizeof(diskVolFragment));
			    if (tcode) {
				LogError(tcode,
					 "writeDatabase: Can't read volfrag entry (addr 0x%x) of dumpID %u\n",
					 volFragAddr, ntohl(apDiskDump.id));
				Log("     Skipping this and remaining volumes on tape '%s'\n", diskTape.name);
				break;
			    }

			    /* Read the volume Info entry */
			    tcode =
				cdbread(ut, volInfo_BLOCK,
					ntohl(diskVolFragment.vol),
					&diskVolInfo, sizeof(diskVolInfo));
			    if (tcode) {
				LogError(tcode,
					 "writeDatabase: Can't read volinfo entry (addr 0x%x) of dumpID %u\n",
					 ntohl(diskVolFragment.vol),
					 ntohl(apDiskDump.id));
				Log("     Skipping volume on tape '%s'\n",
				    diskTape.name);
				continue;
			    }

			    /* Save the volume entry */
			    tcode =
				writeVolume(ut, fid, &diskVolFragment,
					    &diskVolInfo,
					    ntohl(apDiskDump.id),
					    diskTape.name);
			    if (tcode) {
				LogError(tcode,
					 "writeDatabase: Can't write volume entry\n");
				ERROR(tcode);
			    }
			}	/*volumes */
		    }		/*tapes */
		}		/*appendedDumps */
	    }			/*initialDumps */
	}			/*hashBuckets */
    }				/*oldnew */

    /* write out the textual configuration information */
    tcode = writeText(ut, fid, TB_DUMPSCHEDULE);
    if (tcode) {
	LogError(tcode, "writeDatabase: Can't write dump schedule\n");
	ERROR(tcode);
    }
    tcode = writeText(ut, fid, TB_VOLUMESET);
    if (tcode) {
	LogError(tcode, "writeDatabase: Can't write volume set\n");
	ERROR(tcode);
    }
    tcode = writeText(ut, fid, TB_TAPEHOSTS);
    if (tcode) {
	LogError(tcode, "writeDatabase: Can't write tape hosts\n");
	ERROR(tcode);
    }

    tcode = writeStructHeader(fid, SD_END);
    if (tcode) {
	LogError(tcode, "writeDatabase: Can't write end savedb\n");
	ERROR(tcode);
    }

  error_exit:
    doneWriting(code);
    return (code);
}


#ifdef notdef

afs_int32
canWrite(int fid)
{
    afs_int32 in, out, except;
    struct timeval tp;
    afs_int32 code;

    tp.tv_sec = 0;
    tp.tv_usec = 0;

    out = (1 << fid);
    in = 0;
    except = 0;

    code = IOMGR_Select(32, &in, &out, &except, &tp);
    return (code);
}

#endif /* notdef */
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	/* dump the database
	11	* Dump is made to a local file. Structures are dumped in network byte order
	12	* for transportability between hosts
	13	*/
	14
	15	#include <afsconfig.h>
	16	#include <afs/param.h>
	17	#include <afs/stds.h>
	18
	19	#include <roken.h>
	20
	21	#include <afs/opr.h>
	22
	23	#ifdef AFS_PTHREAD_ENV
	24	# include <opr/lock.h>
	25	#endif
	26
	27	#include <ubik.h>
	28	#include <afs/audit.h>
	29
	30	#include "database.h"
	31	#include "budb.h"
	32	#include "globals.h"
	33	#include "error_macros.h"
	34	#include "budb_errs.h"
	35	#include "budb_internal.h"
	36
	37
	38	/* dump ubik database - routines to scan the database and dump all
	39	* the information
	40	*/
	41
	42	/* -----------------------
	43	* synchronization on pipe
	44	* -----------------------
	45	*/
	46
	47	/* interlocking for database dump */
	48
	49	dumpSyncT dumpSync;
	50	dumpSyncP dumpSyncPtr = &dumpSync;
	51
	52
	53	/* canWrite
	54	* check if we should dump more of the database. Waits for the reader
	55	* to drain the information before allowing the writer to proceed.
	56	* exit:
	57	* 1 - ok to write
	58	*/
	59
	60	afs_int32
	61	canWrite(int fid)
	62	{
	63	#ifndef AFS_PTHREAD_ENV
	64	afs_int32 code = 0;
65	#endif
66	extern dumpSyncP dumpSyncPtr;
67
68	ObtainWriteLock(&dumpSyncPtr->ds_lock);
69
70	/* let the pipe drain */
71	while (dumpSyncPtr->ds_bytes > 0) {
72	if (dumpSyncPtr->ds_readerStatus == DS_WAITING) {
73	dumpSyncPtr->ds_readerStatus = 0;
74	#ifdef AFS_PTHREAD_ENV
75	opr_cv_broadcast(&dumpSyncPtr->ds_readerStatus_cond);
76	#else
77	code = LWP_SignalProcess(&dumpSyncPtr->ds_readerStatus);
78	if (code)
79	LogError(code, "canWrite: Signal delivery failed\n");
80	#endif
81	}
82	dumpSyncPtr->ds_writerStatus = DS_WAITING;
83	ReleaseWriteLock(&dumpSyncPtr->ds_lock);
84	#ifdef AFS_PTHREAD_ENV
85	MUTEX_ENTER(&dumpSyncPtr->ds_writerStatus_mutex);
86	opr_cv_wait(&dumpSyncPtr->ds_writerStatus_cond, &dumpSyncPtr->ds_writerStatus_mutex);
87	MUTEX_EXIT(&dumpSyncPtr->ds_writerStatus_mutex);
88	#else
89	LWP_WaitProcess(&dumpSyncPtr->ds_writerStatus);
90	#endif
91	ObtainWriteLock(&dumpSyncPtr->ds_lock);
92	}
93	return (1);
94	}
95
96
97	/* haveWritten
98	* record the fact that nbytes have been written. Signal the reader
99	* to proceed, and unlock.
100	* exit:
101	* no return value
102	*/
103
104	void
105	haveWritten(afs_int32 nbytes)
106	{
107	#ifndef AFS_PTHREAD_ENV
108	afs_int32 code = 0;
109	#endif
110	extern dumpSyncP dumpSyncPtr;
111
112	dumpSyncPtr->ds_bytes += nbytes;
113	if (dumpSyncPtr->ds_readerStatus == DS_WAITING) {
114	dumpSyncPtr->ds_readerStatus = 0;
115	#ifdef AFS_PTHREAD_ENV
116	opr_cv_broadcast(&dumpSyncPtr->ds_readerStatus_cond);
117	#else
118	code = LWP_SignalProcess(&dumpSyncPtr->ds_readerStatus);
119	if (code)
120	LogError(code, "haveWritten: Signal delivery failed\n");
121	#endif
122	}
123	ReleaseWriteLock(&dumpSyncPtr->ds_lock);
124	}
125
126	/* doneWriting
127	* wait for the reader to drain all the information, and then set the
128	* done flag.
129	*/
130
131	void
132	doneWriting(afs_int32 error)
133	{
134	#ifndef AFS_PTHREAD_ENV
135	afs_int32 code = 0;
136	#endif
137
138	/* wait for the reader */
139	ObtainWriteLock(&dumpSyncPtr->ds_lock);
140	while (dumpSyncPtr->ds_readerStatus != DS_WAITING) {
141	LogDebug(4, "doneWriting: waiting for Reader\n");
142	dumpSyncPtr->ds_writerStatus = DS_WAITING;
143	ReleaseWriteLock(&dumpSyncPtr->ds_lock);
144	#ifdef AFS_PTHREAD_ENV
145	MUTEX_ENTER(&dumpSyncPtr->ds_writerStatus_mutex);
146	opr_cv_wait(&dumpSyncPtr->ds_writerStatus_cond, &dumpSyncPtr->ds_writerStatus_mutex);
147	MUTEX_EXIT(&dumpSyncPtr->ds_writerStatus_mutex);
148	#else
149	LWP_WaitProcess(&dumpSyncPtr->ds_writerStatus);
150	#endif
151	ObtainWriteLock(&dumpSyncPtr->ds_lock);
152	}
153
154	LogDebug(4, "doneWriting: setting done\n");
155
156	/* signal that we are done */
157	if (error)
158	dumpSyncPtr->ds_writerStatus = DS_DONE_ERROR;
159	else
160	dumpSyncPtr->ds_writerStatus = DS_DONE;
161	dumpSyncPtr->ds_readerStatus = 0;
162	#ifdef AFS_PTHREAD_ENV
163	opr_cv_broadcast(&dumpSyncPtr->ds_readerStatus_cond);
164	#else
165	code = LWP_NoYieldSignal(&dumpSyncPtr->ds_readerStatus);
166	if (code)
167	LogError(code, "doneWriting: Signal delivery failed\n");
168	#endif
169	ReleaseWriteLock(&dumpSyncPtr->ds_lock);
170	}
171
172	/* notes:
173	* ut - setup and pass down
174	*/
175
176	/* writeStructHeader
177	* write header appropriate for requested structure type
178	*/
179
180	afs_int32
181	writeStructHeader(int fid, afs_int32 type)
182	{
183	struct structDumpHeader hostDumpHeader, netDumpHeader;
184
185	hostDumpHeader.type = type;
186	hostDumpHeader.structversion = 1;
187
188
189	switch (type) {
190	case SD_DBHEADER:
191	hostDumpHeader.size = sizeof(struct DbHeader);
192	break;
193
194	case SD_DUMP:
195	hostDumpHeader.size = sizeof(struct budb_dumpEntry);
196	break;
197
198	case SD_TAPE:
199	hostDumpHeader.size = sizeof(struct budb_tapeEntry);
200	break;
201
202	case SD_VOLUME:
203	hostDumpHeader.size = sizeof(struct budb_volumeEntry);
204	break;
205
206	case SD_END:
207	hostDumpHeader.size = 0;
208	break;
209
210	default:
211	LogError(0, "writeStructHeader: invalid type %d\n", type);
212	BUDB_EXIT(1);
213	}
214
215	structDumpHeader_hton(&hostDumpHeader, &netDumpHeader);
216
217	if (canWrite(fid) <= 0)
218	return (BUDB_DUMPFAILED);
219	if (write(fid, &netDumpHeader, sizeof(netDumpHeader)) !=
220	sizeof(netDumpHeader))
221	return (BUDB_DUMPFAILED);
222	haveWritten(sizeof(netDumpHeader));
223
224	return (0);
225	}
226
227	/* writeTextHeader
228	* write header appropriate for requested structure type
229	*/
230
231	afs_int32
232	writeTextHeader(int fid, afs_int32 type)
233	{
234	struct structDumpHeader hostDumpHeader, netDumpHeader;
235
236	hostDumpHeader.structversion = 1;
237
238	switch (type) {
239	case TB_DUMPSCHEDULE:
240	hostDumpHeader.type = SD_TEXT_DUMPSCHEDULE;
241	break;
242
243	case TB_VOLUMESET:
244	hostDumpHeader.type = SD_TEXT_VOLUMESET;
245	break;
246
247	case TB_TAPEHOSTS:
248	hostDumpHeader.type = SD_TEXT_TAPEHOSTS;
249	break;
250
251	default:
252	LogError(0, "writeTextHeader: invalid type %d\n", type);
253	BUDB_EXIT(1);
254	}
255
256	hostDumpHeader.size = ntohl(db.h.textBlock[type].size);
257	structDumpHeader_hton(&hostDumpHeader, &netDumpHeader);
258
259	if (canWrite(fid) <= 0)
260	return (BUDB_DUMPFAILED);
261
262	if (write(fid, &netDumpHeader, sizeof(netDumpHeader)) !=
263	sizeof(netDumpHeader))
264	return (BUDB_DUMPFAILED);
265
266	haveWritten(sizeof(netDumpHeader));
267
268	return (0);
269	}
270
271	afs_int32
272	writeDbHeader(int fid)
273	{
274	struct DbHeader header;
275	afs_int32 curtime;
276	afs_int32 code = 0, tcode;
277
278	extern struct memoryDB db;
279
280	/* check the memory database header for integrity */
281	if (db.h.version != db.h.checkVersion)
282	ERROR(BUDB_DATABASEINCONSISTENT);
283
284	curtime = time(0);
285
286	/* copy selected fields. Source is in xdr format. */
287	header.dbversion = db.h.version;
288	header.created = htonl(curtime);
289	strcpy(header.cell, "");
290	header.lastDumpId = db.h.lastDumpId;
291	header.lastInstanceId = db.h.lastInstanceId;
292	header.lastTapeId = db.h.lastTapeId;
293
294	tcode = writeStructHeader(fid, SD_DBHEADER);
295	if (tcode)
296	ERROR(tcode);
297
298	if (canWrite(fid) <= 0)
299	ERROR(BUDB_DUMPFAILED);
300
301	if (write(fid, &header, sizeof(header)) != sizeof(header))
302	ERROR(BUDB_DUMPFAILED);
303
304	haveWritten(sizeof(header));
305
306	error_exit:
307	return (code);
308	}
309
310	/* writeDump
311	* write out a dump entry structure
312	*/
313
314	afs_int32
315	writeDump(int fid, dbDumpP dumpPtr)
316	{
317	struct budb_dumpEntry dumpEntry;
318	afs_int32 code = 0, tcode;
319
320	tcode = dumpToBudbDump(dumpPtr, &dumpEntry);
321	if (tcode)
322	ERROR(tcode);
323
324	writeStructHeader(fid, SD_DUMP);
325
326	if (canWrite(fid) <= 0)
327	ERROR(BUDB_DUMPFAILED);
328
329	if (write(fid, &dumpEntry, sizeof(dumpEntry)) != sizeof(dumpEntry))
330	ERROR(BUDB_DUMPFAILED);
331	haveWritten(sizeof(dumpEntry));
332
333	error_exit:
334	return (code);
335	}
336
337	afs_int32
338	writeTape(int fid, struct tape *tapePtr, afs_int32 dumpid)
339	{
340	struct budb_tapeEntry tapeEntry;
341	afs_int32 code = 0, tcode;
342
343	tcode = writeStructHeader(fid, SD_TAPE);
344	if (tcode)
345	ERROR(tcode);
346
347	tapeToBudbTape(tapePtr, &tapeEntry);
348
349	tapeEntry.dump = htonl(dumpid);
350
351	if (canWrite(fid) <= 0)
352	ERROR(BUDB_DUMPFAILED);
353
354	if (write(fid, &tapeEntry, sizeof(tapeEntry)) != sizeof(tapeEntry))
355	ERROR(BUDB_DUMPFAILED);
356
357	haveWritten(sizeof(tapeEntry));
358
359	error_exit:
360	return (code);
361	}
362
363	/* combines volFragment and volInfo */
364
365	afs_int32
366	writeVolume(struct ubik_trans ut, int fid, struct volFragment volFragmentPtr,
367	struct volInfo volInfoPtr, afs_int32 dumpid, char tapeName)
368	{
369	struct budb_volumeEntry budbVolume;
370	afs_int32 code = 0;
371
372	volsToBudbVol(volFragmentPtr, volInfoPtr, &budbVolume);
373
374	budbVolume.dump = htonl(dumpid);
375	strcpy(budbVolume.tape, tapeName);
376
377	writeStructHeader(fid, SD_VOLUME);
378
379	if (canWrite(fid) <= 0)
380	ERROR(BUDB_DUMPFAILED);
381
382	if (write(fid, &budbVolume, sizeof(budbVolume)) != sizeof(budbVolume))
383	ERROR(BUDB_DUMPFAILED);
384
385	haveWritten(sizeof(budbVolume));
386
387	error_exit:
388	return (code);
389	}
390
391	/* -------------------
392	* handlers for the text blocks
393	* -------------------
394	*/
395
396	/* checkLock
397	* make sure a text lock is NOT held
398	* exit:
399	* 0 - not held
400	* n - error
401	*/
402
403	afs_int32
404	checkLock(afs_int32 textType)
405	{
406	db_lockP lockPtr;
407
408	if ((textType < 0) \|\| (textType > TB_NUM - 1))
409	return (BUDB_BADARGUMENT);
410
411	lockPtr = &db.h.textLocks[textType];
412
413	if (lockPtr->lockState != 0)
414	return (BUDB_LOCKED);
415	return (0);
416	}
417
418	/* checkText
419	* check the integrity of the specified text type
420	*/
421
422	int
423	checkText(struct ubik_trans *ut, afs_int32 textType)
424	{
425	struct textBlock *tbPtr;
426	afs_int32 nBytes = 0; /* accumulated actual size */
427	afs_int32 size;
428	struct block block;
429	dbadr blockAddr;
430
431	afs_int32 code = 0;
432
433	tbPtr = &db.h.textBlock[textType];
434	blockAddr = ntohl(tbPtr->textAddr);
435	size = ntohl(tbPtr->size);
436
437	while (blockAddr != 0) {
438	/* read the block */
439	code =
440	cdbread(ut, text_BLOCK, blockAddr, (char *)&block, sizeof(block));
441	if (code)
442	ERROR(code);
443
444	/* check its type */
445	if (block.h.type != text_BLOCK)
446	ERROR(BUDB_DATABASEINCONSISTENT);
447
448	/* add up the size */
449	nBytes += BLOCK_DATA_SIZE;
450
451	blockAddr = ntohl(block.h.next);
452	}
453
454	/* ensure that we have at least the expected amount of text */
455	if (nBytes < size)
456	ERROR(BUDB_DATABASEINCONSISTENT);
457
458	error_exit:
459	return (code);
460	}
461
462	/* writeText
463	* entry:
464	* textType - type of text block, e.g. TB_DUMPSCHEDULE
465	*/
466
467	afs_int32
468	writeText(struct ubik_trans *ut, int fid, int textType)
469	{
470	struct textBlock *tbPtr;
471	afs_int32 textSize, writeSize;
472	dbadr dbAddr;
473	struct block block;
474	afs_int32 code = 0;
475
476	/* check lock is free */
477	code = checkLock(textType);
478	if (code)
479	ERROR(code);
480
481	/* ensure that this block has the correct type */
482	code = checkText(ut, textType);
483	if (code) {
484	LogError(0, "writeText: text type %d damaged\n", textType);
485	ERROR(code);
486	}
487
488	tbPtr = &db.h.textBlock[textType];
489	textSize = ntohl(tbPtr->size);
490	dbAddr = ntohl(tbPtr->textAddr);
491
492	if (!dbAddr)
493	goto error_exit; /* Don't save anything if no blocks */
494
495	writeTextHeader(fid, textType);
496
497	while (dbAddr) {
498	code = cdbread(ut, text_BLOCK, dbAddr, (char *)&block, sizeof(block));
499	if (code)
500	ERROR(code);
501
502	writeSize = min(textSize, BLOCK_DATA_SIZE);
503	if (!writeSize)
504	break;
505
506	if (canWrite(fid) <= 0)
507	ERROR(BUDB_DUMPFAILED);
508
509	if (write(fid, &block.a[0], writeSize) != writeSize)
510	ERROR(BUDB_IO);
511
512	haveWritten(writeSize);
513	textSize -= writeSize;
514
515	dbAddr = ntohl(block.h.next);
516	}
517
518	error_exit:
519	return (code);
520	}
521
522	#define MAXAPPENDS 200
523
524	afs_int32
525	writeDatabase(struct ubik_trans *ut, int fid)
526	{
527	dbadr dbAddr, dbAppAddr;
528	struct dump diskDump, apDiskDump;
529	dbadr tapeAddr;
530	struct tape diskTape;
531	dbadr volFragAddr;
532	struct volFragment diskVolFragment;
533	struct volInfo diskVolInfo;
534	int length, hash;
535	int old = 0;
536	int entrySize;
537	afs_int32 code = 0, tcode;
538	afs_int32 appDumpAddrs[MAXAPPENDS], numaddrs, appcount, j;
539
540	struct memoryHashTable *mht;
541
542	LogDebug(4, "writeDatabase:\n");
543
544	/* write out a header identifying this database etc */
545	tcode = writeDbHeader(fid);
546	if (tcode) {
547	LogError(tcode, "writeDatabase: Can't write Header\n");
548	ERROR(tcode);
549	}
550
551	/* write out the tree of dump structures */
552
553	mht = ht_GetType(HT_dumpIden_FUNCTION, &entrySize);
554	if (!mht) {
555	LogError(tcode, "writeDatabase: Can't get dump type\n");
556	ERROR(BUDB_BADARGUMENT);
557	}
558
559	for (old = 0; old <= 1; old++) {
560	/oldnew /
561	/* only two states, old or not old */
562	length = (old ? mht->oldLength : mht->length);
563	if (!length)
564	continue;
565
566	for (hash = 0; hash < length; hash++) {
567	/hashBuckets /
568	/* dump all the dumps in this hash bucket
569	*/
570	for (dbAddr = ht_LookupBucket(ut, mht, hash, old); dbAddr; dbAddr = ntohl(diskDump.idHashChain)) { /initialDumps /
571	/* now check if this dump had any errors/inconsistencies.
572	* If so, don't dump it
573	*/
574	if (badEntry(dbAddr)) {
575	LogError(0,
576	"writeDatabase: Damaged dump entry at addr 0x%x\n",
577	dbAddr);
578	Log(" Skipping remainder of dumps on hash chain %d\n",
579	hash);
580	break;
581	}
582
583	tcode =
584	cdbread(ut, dump_BLOCK, dbAddr, &diskDump,
585	sizeof(diskDump));
586	if (tcode) {
587	LogError(tcode,
588	"writeDatabase: Can't read dump entry (addr 0x%x)\n",
589	dbAddr);
590	Log(" Skipping remainder of dumps on hash chain %d\n",
591	hash);
592	break;
593	}
594
595	/* Skip appended dumps, only start with initial dumps */
596	if (diskDump.initialDumpID != 0)
597	continue;
598
599	/* Skip appended dumps, only start with initial dumps. Then
600	* follow the appended dump chain so they are in order for restore.
601	*/
602	appcount = numaddrs = 0;
603	for (dbAppAddr = dbAddr; dbAppAddr;
604	dbAppAddr = ntohl(apDiskDump.appendedDumpChain)) {
605	/appendedDumps /
606	/* Check to see if we have a circular loop of appended dumps */
607	for (j = 0; j < numaddrs; j++) {
608	if (appDumpAddrs[j] == dbAppAddr)
609	break; /* circular loop */
610	}
611	if (j < numaddrs) { /* circular loop */
612	Log("writeDatabase: Circular loop found in appended dumps\n");
613	Log("Skipping rest of appended dumps of dumpID %u\n",
614	ntohl(diskDump.id));
615	break;
616	}
617	if (numaddrs >= MAXAPPENDS)
618	numaddrs = MAXAPPENDS - 1; /* don't overflow */
619	appDumpAddrs[numaddrs] = dbAppAddr;
620	numaddrs++;
621
622	/* If we dump a 1000 appended dumps, assume a loop */
623	if (appcount >= 5 * MAXAPPENDS) {
624	Log("writeDatabase: Potential circular loop of appended dumps\n");
625	Log("Skipping rest of appended dumps of dumpID %u. Dumped %d\n", ntohl(diskDump.id), appcount);
626	break;
627	}
628	appcount++;
629
630	/* Read the dump entry */
631	if (dbAddr == dbAppAddr) {
632	/* First time through, don't need to read the dump entry again */
633	memcpy(&apDiskDump, &diskDump, sizeof(diskDump));
634	} else {
635	if (badEntry(dbAppAddr)) {
636	LogError(0,
637	"writeDatabase: Damaged appended dump entry at addr 0x%x\n",
638	dbAddr);
639	Log(" Skipping this and remainder of appended dumps of initial DumpID %u\n", ntohl(diskDump.id));
640	break;
641	}
642
643	tcode =
644	cdbread(ut, dump_BLOCK, dbAppAddr, &apDiskDump,
645	sizeof(apDiskDump));
646	if (tcode) {
647	LogError(tcode,
648	"writeDatabase: Can't read appended dump entry (addr 0x%x)\n",
649	dbAppAddr);
650	Log(" Skipping this and remainder of appended dumps of initial DumpID %u\n", ntohl(diskDump.id));
651	break;
652	}
653
654	/* Verify that this appended dump points to the initial dump */
655	if (ntohl(apDiskDump.initialDumpID) !=
656	ntohl(diskDump.id)) {
657	LogError(0,
658	"writeDatabase: Appended dumpID %u does not reference initial dumpID %u\n",
659	ntohl(apDiskDump.id),
660	ntohl(diskDump.id));
661	Log(" Skipping this appended dump\n");
662	continue;
663	}
664	}
665
666	/* Save the dump entry */
667	tcode = writeDump(fid, &apDiskDump);
668	if (tcode) {
669	LogError(tcode,
670	"writeDatabase: Can't write dump entry\n");
671	ERROR(tcode);
672	}
673
674	/* For each tape on this dump
675	*/
676	for (tapeAddr = ntohl(apDiskDump.firstTape); tapeAddr; tapeAddr = ntohl(diskTape.nextTape)) { /tapes /
677	/* read the tape entry */
678	tcode =
679	cdbread(ut, tape_BLOCK, tapeAddr, &diskTape,
680	sizeof(diskTape));
681	if (tcode) {
682	LogError(tcode,
683	"writeDatabase: Can't read tape entry (addr 0x%x) of dumpID %u\n",
684	tapeAddr, ntohl(apDiskDump.id));
685	Log(" Skipping this and remaining tapes in the dump (and all their volumes)\n");
686	break;
687	}
688
689	/* Save the tape entry */
690	tcode =
691	writeTape(fid, &diskTape, ntohl(apDiskDump.id));
692	if (tcode) {
693	LogError(tcode,
694	"writeDatabase: Can't write tape entry\n");
695	ERROR(tcode);
696	}
697
698	/* For each volume on this tape.
699	*/
700	for (volFragAddr = ntohl(diskTape.firstVol); volFragAddr; volFragAddr = ntohl(diskVolFragment.sameTapeChain)) { /volumes /
701	/* Read the volume Fragment entry */
702	tcode =
703	cdbread(ut, volFragment_BLOCK, volFragAddr,
704	&diskVolFragment,
705	sizeof(diskVolFragment));
706	if (tcode) {
707	LogError(tcode,
708	"writeDatabase: Can't read volfrag entry (addr 0x%x) of dumpID %u\n",
709	volFragAddr, ntohl(apDiskDump.id));
710	Log(" Skipping this and remaining volumes on tape '%s'\n", diskTape.name);
711	break;
712	}
713
714	/* Read the volume Info entry */
715	tcode =
716	cdbread(ut, volInfo_BLOCK,
717	ntohl(diskVolFragment.vol),
718	&diskVolInfo, sizeof(diskVolInfo));
719	if (tcode) {
720	LogError(tcode,
721	"writeDatabase: Can't read volinfo entry (addr 0x%x) of dumpID %u\n",
722	ntohl(diskVolFragment.vol),
723	ntohl(apDiskDump.id));
724	Log(" Skipping volume on tape '%s'\n",
725	diskTape.name);
726	continue;
727	}
728
729	/* Save the volume entry */
730	tcode =
731	writeVolume(ut, fid, &diskVolFragment,
732	&diskVolInfo,
733	ntohl(apDiskDump.id),
734	diskTape.name);
735	if (tcode) {
736	LogError(tcode,
737	"writeDatabase: Can't write volume entry\n");
738	ERROR(tcode);
739	}
740	} /volumes /
741	} /tapes /
742	} /appendedDumps /
743	} /initialDumps /
744	} /hashBuckets /
745	} /oldnew /
746
747	/* write out the textual configuration information */
748	tcode = writeText(ut, fid, TB_DUMPSCHEDULE);
749	if (tcode) {
750	LogError(tcode, "writeDatabase: Can't write dump schedule\n");
751	ERROR(tcode);
752	}
753	tcode = writeText(ut, fid, TB_VOLUMESET);
754	if (tcode) {
755	LogError(tcode, "writeDatabase: Can't write volume set\n");
756	ERROR(tcode);
757	}
758	tcode = writeText(ut, fid, TB_TAPEHOSTS);
759	if (tcode) {
760	LogError(tcode, "writeDatabase: Can't write tape hosts\n");
761	ERROR(tcode);
762	}
763
764	tcode = writeStructHeader(fid, SD_END);
765	if (tcode) {
766	LogError(tcode, "writeDatabase: Can't write end savedb\n");
767	ERROR(tcode);
768	}
769
770	error_exit:
771	doneWriting(code);
772	return (code);
773	}
774
775
776	#ifdef notdef
777
778	afs_int32
779	canWrite(int fid)
780	{
781	afs_int32 in, out, except;
782	struct timeval tp;
783	afs_int32 code;
784
785	tp.tv_sec = 0;
786	tp.tv_usec = 0;
787
788	out = (1 << fid);
789	in = 0;
790	except = 0;
791
792	code = IOMGR_Select(32, &in, &out, &except, &tp);
793	return (code);
794	}
795
796	#endif /* notdef */