/*
* 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>
-RCSID
- ("$Header$");
+#ifdef IGNORE_SOME_GCC_WARNINGS
+# pragma GCC diagnostic warning "-Wimplicit-function-declaration"
+#endif
#include <sys/types.h>
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
#ifdef AFS_NT40_ENV
#include <winsock2.h>
#include <io.h>
#include <rx/rx.h>
#include <afs/afsint.h>
#include <stdio.h>
+#include <string.h>
#include <afs/procmgmt.h>
#include <afs/assert.h>
#include <afs/prs_fs.h>
#include <afs/nfs.h>
#include <lwp.h>
#include <lock.h>
-#include <afs/auth.h>
#include <afs/cellconfig.h>
#include <afs/keys.h>
#include <ubik.h>
#include <afs/acl.h>
+#include <afs/volser.h>
+#include <afs/vlserver.h>
#include <afs/tcdata.h>
#include <afs/budb.h>
#include <afs/budb_client.h>
#include <afs/bubasics.h>
+#include <afs/bucoord_prototypes.h>
+#include <afs/butm_prototypes.h>
+#include <afs/budb_prototypes.h>
+#include <afs/afsutil.h>
+#include "butc_internal.h"
#include "error_macros.h"
/* GLOBAL CONFIGURATION PARAMETERS */
extern int dump_namecheck;
extern int autoQuery;
+struct rstTapeInfo {
+ afs_int32 taskId;
+ afs_int32 tapeSeq;
+ afs_uint32 dumpid;
+};
+
+static void initTapeBuffering(void);
+static int writeDbDump(struct butm_tapeInfo *, afs_uint32, Date, afs_uint32);
+static int restoreDbEntries(struct butm_tapeInfo *, struct rstTapeInfo *);
+
+int getTapeData(struct butm_tapeInfo *, struct rstTapeInfo *, void *,
+ afs_int32);
+int restoreDbHeader(struct butm_tapeInfo *, struct rstTapeInfo *,
+ struct structDumpHeader *);
+int restoreDbDump(struct butm_tapeInfo *, struct rstTapeInfo *,
+ struct structDumpHeader *);
+int restoreText(struct butm_tapeInfo *, struct rstTapeInfo *,
+ struct structDumpHeader *);
+
+
+
+void * KeepAlive(void *);
/* CreateDBDump
- * create a dump entry for a saved database
+ * create a dump entry for a saved database
*/
afs_int32
-CreateDBDump(dumpEntryPtr)
- struct budb_dumpEntry *dumpEntryPtr;
+CreateDBDump(struct budb_dumpEntry *dumpEntryPtr)
{
afs_int32 code = 0;
* Leave the tape mounted.
*/
afs_int32
-GetDBTape(taskId, expires, tapeInfoPtr, dumpid, sequence, queryFlag,
- wroteLabel)
- afs_int32 taskId;
- Date expires;
- struct butm_tapeInfo *tapeInfoPtr;
- afs_uint32 dumpid;
- afs_int32 sequence;
- int queryFlag;
- int *wroteLabel;
+GetDBTape(afs_int32 taskId, Date expires, struct butm_tapeInfo *tapeInfoPtr,
+ afs_uint32 dumpid, afs_int32 sequence, int queryFlag,
+ int *wroteLabel)
{
afs_int32 code = 0;
int interactiveFlag;
struct butm_tapeLabel oldTapeLabel, newLabel;
struct tapeEntryList *endList;
- extern struct tapeConfig globalTapeConfig;
/* construct the name of the tape */
sprintf(tapeName, "%s.%-d", DUMP_TAPE_NAME, sequence);
goto getNewTape;
}
- /* On first tape, the savedb has not started yet, so the database is not locked
+ /* On first tape, the savedb has not started yet, so the database is not locked
* and we can therefore, access information from it. This is easier to do because
* database dumps don't have appended dumps (nor appended).
*/
struct budb_dumpEntry de, de2;
/* Verify the tape has not expired
- * Early database dumps don't have a dumpid
+ * Early database dumps don't have a dumpid
*/
if (!tapeExpired(&oldTapeLabel)) {
TLog(taskId, "This tape has not expired\n");
}
/* Otherwise, the savedb is in progress and we can't
- * access the database (it's locked). So we rely on the
+ * access the database (it's locked). So we rely on the
* information available (and not the backup database).
*/
else {
*/
afs_int32
-freeTapeList()
+freeTapeList(void)
{
struct tapeEntryList *next;
}
/* addTapesToDb
- * With the list of tapes, add them to the database.
+ * With the list of tapes, add them to the database.
* Also delete any olddumpids that are around.
*/
afs_int32
-addTapesToDb(taskId)
- afs_int32 taskId;
+addTapesToDb(afs_int32 taskId)
{
afs_int32 code = 0;
afs_int32 i, new;
* the blocksize on writes
*/
-static
-writeDbDump(tapeInfoPtr, taskId, expires, dumpid)
- struct butm_tapeInfo *tapeInfoPtr;
- afs_uint32 taskId;
- Date expires;
- afs_uint32 dumpid;
+static int
+writeDbDump(struct butm_tapeInfo *tapeInfoPtr, afs_uint32 taskId,
+ Date expires, afs_uint32 dumpid)
{
afs_int32 blockSize;
afs_int32 writeBufNbytes = 0;
char *writeBufPtr;
afs_int32 transferSize;
- char *readBufPtr;
+ char *readBufPtr = NULL;
afs_int32 maxReadSize;
charListT charList;
extern struct tapeConfig globalTapeConfig;
extern struct udbHandleS udbHandle;
- extern int KeepAlive();
-
blockSize = BUTM_BLKSIZE;
writeBlock = (char *)malloc(BUTM_BLOCKSIZE);
if (!writeBlock)
memset(writeBuffer, 0, BUTM_BLKSIZE);
maxReadSize = 1024;
- /*
- * The margin of space to check for end of tape is set to the
- * amount of space used to write an end-of-tape multiplied by 2.
+ /*
+ * The margin of space to check for end of tape is set to the
+ * amount of space used to write an end-of-tape multiplied by 2.
* The amount of space is size of a 16K EODump marker, its EOF
* marker, and up to two EOF markers done on close (1 16K blocks +
- * 3 EOF * markers).
+ * 3 EOF * markers).
*/
tc_EndMargin = (16384 + 3 * globalTapeConfig.fileMarkSize) * 2;
tc_KEndMargin = tc_EndMargin / 1024;
* dump backup database to tape
*/
-afs_int32
-saveDbToTape(saveDbIfPtr)
- struct saveDbIf *saveDbIfPtr;
+void *
+saveDbToTape(void *param)
{
+ struct saveDbIf *saveDbIfPtr = (struct saveDbIf *)param;
afs_int32 code = 0;
afs_int32 i;
int wroteLabel;
&wroteLabel);
/*
- * If did not write the label, remove created dump
+ * If did not write the label, remove created dump
* Else if wrote the label, remove old dump from db so it's not saved.
*/
if (!wroteLabel) {
free(saveDbIfPtr);
LeaveDeviceQueue(deviceLatch);
- return (code);
+ return (void *)(intptr_t)(code);
}
-struct rstTapeInfo {
- afs_int32 taskId;
- afs_int32 tapeSeq;
- afs_uint32 dumpid;
-};
/* makeDbDumpEntry()
* Make a database dump entry given a tape label.
*/
afs_int32
-makeDbDumpEntry(tapeEntPtr, dumpEntryPtr)
- struct budb_tapeEntry *tapeEntPtr;
- struct budb_dumpEntry *dumpEntryPtr;
+makeDbDumpEntry(struct budb_tapeEntry *tapeEntPtr,
+ struct budb_dumpEntry *dumpEntryPtr)
{
memset(dumpEntryPtr, 0, sizeof(struct budb_dumpEntry));
*/
afs_int32
-readDbTape(tapeInfoPtr, rstTapeInfoPtr, query)
- struct butm_tapeInfo *tapeInfoPtr;
- struct rstTapeInfo *rstTapeInfoPtr;
- int query;
+readDbTape(struct butm_tapeInfo *tapeInfoPtr,
+ struct rstTapeInfo *rstTapeInfoPtr, int query)
{
afs_int32 code = 0;
int interactiveFlag;
}
static afs_int32 nbytes = 0; /* # bytes left in buffer */
-static
-initTapeBuffering()
+static void
+initTapeBuffering(void)
{
nbytes = 0;
}
* tape positioned after tape label
*/
-static
-restoreDbEntries(tapeInfoPtr, rstTapeInfoPtr)
- struct butm_tapeInfo *tapeInfoPtr;
- struct rstTapeInfo *rstTapeInfoPtr;
+static int
+restoreDbEntries(struct butm_tapeInfo *tapeInfoPtr,
+ struct rstTapeInfo *rstTapeInfoPtr)
{
struct structDumpHeader netItemHeader, hostItemHeader;
afs_int32 more = 1;
* restore the backup database from tape.
*/
-afs_int32
-restoreDbFromTape(taskId)
- afs_uint32 taskId;
+void *
+restoreDbFromTape(void *param)
{
+ afs_uint32 taskId = (intptr_t) param;
afs_int32 code = 0;
afs_int32 i;
struct butm_tapeInfo tapeInfo;
LeaveDeviceQueue(deviceLatch);
setStatus(taskId, TASK_DONE);
- return (code);
+ return (void *)(intptr_t)(code);
}
/* KeepAlive
- *
- * While dumping the database, keeps the connection alive.
+ *
+ * While dumping the database, keeps the connection alive.
* Every 10 seconds, wake up and ask to read 0 bytes of the database.
- * This resets the database's internal timer so that it does not
+ * This resets the database's internal timer so that it does not
* prematuraly quit (on asking for new tapes and such).
- *
+ *
* Use the same udbHandle as writeDbDump so we go to the same server.
*/
-int
-KeepAlive()
+void *
+KeepAlive(void *unused)
{
charListT charList;
afs_int32 code;
* restore special items in the header
*/
-restoreDbHeader(tapeInfo, rstTapeInfoPtr, nextHeader)
- struct butm_tapeInfo *tapeInfo;
- struct rstTapeInfo *rstTapeInfoPtr;
- struct structDumpHeader *nextHeader;
+int
+restoreDbHeader(struct butm_tapeInfo *tapeInfo,
+ struct rstTapeInfo *rstTapeInfoPtr,
+ struct structDumpHeader *nextHeader)
{
struct structDumpHeader netItemHeader;
struct DbHeader netDbHeader, hostDbHeader;
/* Add the database header to the database */
code =
- ubik_Call(BUDB_RestoreDbHeader, udbHandle.uh_client, 0,
+ ubik_BUDB_RestoreDbHeader(udbHandle.uh_client, 0,
&hostDbHeader);
if (code) {
ErrorLog(0, rstTapeInfoPtr->taskId, code, 0,
* nextHeader - ptr to structure for return value
* exit:
* nextHeader - next structure header from tape
- * notes:
+ * notes:
* upon entry, the dump structure header has been read confirming that
* a database dump tree exists on the tape
*/
-restoreDbDump(tapeInfo, rstTapeInfoPtr, nextHeader)
- struct butm_tapeInfo *tapeInfo;
- struct rstTapeInfo *rstTapeInfoPtr;
- struct structDumpHeader *nextHeader;
+int
+restoreDbDump(struct butm_tapeInfo *tapeInfo,
+ struct rstTapeInfo *rstTapeInfoPtr,
+ struct structDumpHeader *nextHeader)
{
struct budb_dumpEntry netDumpEntry, hostDumpEntry;
struct budb_tapeEntry netTapeEntry, hostTapeEntry;
struct budb_volumeEntry netVolumeEntry, hostVolumeEntry;
struct structDumpHeader netItemHeader;
- afs_int32 taskId;
int restoreThisDump = 1;
afs_int32 code = 0;
extern struct udbHandleS udbHandle;
- taskId = rstTapeInfoPtr->taskId;
-
/* read dump entry */
memset(&netDumpEntry, 0, sizeof(netDumpEntry));
code =
*/
afs_int32
-saveTextFile(taskId, textType, fileName)
- afs_int32 taskId;
- afs_int32 textType;
- char *fileName;
+saveTextFile(afs_int32 taskId, afs_int32 textType, char *fileName)
{
udbClientTextP ctPtr = 0;
afs_int32 code = 0;
* nextHeader - struct header for next item on the tape
*/
-restoreText(tapeInfo, rstTapeInfoPtr, nextHeader)
- struct butm_tapeInfo *tapeInfo;
- struct rstTapeInfo *rstTapeInfoPtr;
- struct structDumpHeader *nextHeader;
+int
+restoreText(struct butm_tapeInfo *tapeInfo,
+ struct rstTapeInfo *rstTapeInfoPtr,
+ struct structDumpHeader *nextHeader)
{
char filename[64];
afs_int32 nbytes;
/* getTapeData
* Read information from tape, and place the requested number of bytes
- * in the buffer supplied
+ * in the buffer supplied
* entry:
* tapeInfo
* rstTapeInfoPtr - Info about the dump being restored.
* fn retn - 0, ok, n, error
*/
-getTapeData(tapeInfoPtr, rstTapeInfoPtr, buffer, requestedBytes)
- struct butm_tapeInfo *tapeInfoPtr;
- struct rstTapeInfo *rstTapeInfoPtr;
- char *buffer;
- afs_int32 requestedBytes;
+int
+getTapeData(struct butm_tapeInfo *tapeInfoPtr,
+ struct rstTapeInfo *rstTapeInfoPtr,
+ void *out, afs_int32 requestedBytes)
{
- afs_int32 taskId, transferBytes, new;
+ char *buffer = (char *) out;
+ afs_int32 taskId, transferBytes;
afs_int32 code = 0;
- afs_uint32 dumpid;
taskId = rstTapeInfoPtr->taskId;
git://git.openafs.org / openafs.git / blobdiff