#include <afsconfig.h>
#include <afs/param.h>
+#include <roken.h>
-#include <sys/types.h>
#include <ctype.h>
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-#ifdef AFS_NT40_ENV
-#include <fcntl.h>
-#else
-#include <sys/param.h>
-#include <sys/file.h>
-#include <sys/uio.h>
-#include <netinet/in.h>
-#include <unistd.h>
-#endif
-#include <sys/stat.h>
-#ifdef AFS_PTHREAD_ENV
-#include <assert.h>
-#else /* AFS_PTHREAD_ENV */
-#include <afs/assert.h>
-#endif /* AFS_PTHREAD_ENV */
+
+#include <afs/afs_assert.h>
#include <rx/xdr.h>
#include <rx/rx.h>
#include <afs/afsint.h>
#include <afs/vnode.h>
#include <afs/volume.h>
#include <afs/partition.h>
-#include "dump.h"
#include <afs/daemon_com.h>
#include <afs/fssync.h>
#include <afs/acl.h>
#include <afs/com_err.h>
#include <afs/vol_prototypes.h>
+
+#include "dump.h"
#include "volser.h"
#include "volint.h"
#include "dumpstuff.h"
int volid, int vnodeNumber, int dumpEverything);
static int ReadDumpHeader(struct iod *iodp, struct DumpHeader *hp);
static int ReadVnodes(struct iod *iodp, Volume * vp, int incremental,
- afs_int32 * Lbuf, afs_int32 s1, afs_int32 * Sbuf,
+ afs_foff_t * Lbuf, afs_int32 s1, afs_foff_t * Sbuf,
afs_int32 s2, afs_int32 delo);
static afs_fsize_t volser_WriteFile(int vn, struct iod *iodp,
FdHandle_t * handleP, int tag,
int code, i;
int one_success = 0;
- assert((iodp->call && iodp->ncalls == 1 && !iodp->calls)
+ osi_Assert((iodp->call && iodp->ncalls == 1 && !iodp->calls)
|| (!iodp->call && iodp->ncalls >= 1 && iodp->calls));
if (iodp->call) {
return ((iod_Write(iodp, tbuffer, 2) == 2) ? 0 : VOLSERDUMPERROR);
}
-#define putint32(p, v) *p++ = v>>24, *p++ = v>>16, *p++ = v>>8, *p++ = v
-#define putshort(p, v) *p++ = v>>8, *p++ = v
+#define afs_putint32(p, v) *p++ = v>>24, *p++ = v>>16, *p++ = v>>8, *p++ = v
+#define afs_putshort(p, v) *p++ = v>>8, *p++ = v
static int
DumpDouble(struct iod *iodp, char tag, afs_uint32 value1,
char tbuffer[9];
byte *p = (unsigned char *)tbuffer;
*p++ = tag;
- putint32(p, value1);
- putint32(p, value2);
+ afs_putint32(p, value1);
+ afs_putint32(p, value2);
return ((iod_Write(iodp, tbuffer, 9) == 9) ? 0 : VOLSERDUMPERROR);
}
char tbuffer[5];
byte *p = (unsigned char *)tbuffer;
*p++ = tag;
- putint32(p, value);
+ afs_putint32(p, value);
return ((iod_Write(iodp, tbuffer, 5) == 5) ? 0 : VOLSERDUMPERROR);
}
int code = 0;
byte *p = (unsigned char *)tbuffer;
*p++ = tag;
- putshort(p, nelem);
+ afs_putshort(p, nelem);
code = iod_Write(iodp, tbuffer, 3);
if (code != 3)
return VOLSERDUMPERROR;
p = (unsigned char *)tbuffer;
v = *array++; /*this was register */
- putint32(p, v);
+ afs_putint32(p, v);
code = iod_Write(iodp, tbuffer, 4);
if (code != 4)
return VOLSERDUMPERROR;
return VOLSERDUMPERROR;
}
code = iod_Write(iodp, &tag, 1);
+ if (code != 1)
+ return VOLSERDUMPERROR;
return 0;
}
{
int code = 0, error = 0;
afs_int32 pad = 0;
- afs_int32 offset = 0;
+ afs_foff_t offset = 0;
afs_sfsize_t nbytes, howBig;
ssize_t n;
size_t howMany;
- afs_foff_t lcode = 0;
+ afs_foff_t howFar = 0;
byte *p;
afs_uint32 hi, lo;
afs_ino_str_t stmp;
if (nbytes < howMany)
howMany = nbytes;
- /* Read the data - unless we know we can't */
- n = (lcode ? 0 : FDH_READ(handleP, p, howMany));
+ /* Read the data */
+ n = FDH_PREAD(handleP, p, howMany, howFar);
+ howFar += n;
/* If read any good data and we null padded previously, log the
* amount that we had null padded.
*/
if ((n > 0) && pad) {
- Log("1 Volser: DumpFile: Null padding file %d bytes at offset %u\n", pad, offset);
+ Log("1 Volser: DumpFile: Null padding file %d bytes at offset %lld\n", pad, (long long)offset);
pad = 0;
}
/* Now seek over the data we could not get. An error here means we
* can't do the next read.
*/
- lcode = FDH_SEEK(handleP, (size_t)((size - nbytes) + howMany), SEEK_SET);
- if (lcode != ((size - nbytes) + howMany)) {
- if (lcode < 0) {
- Log("1 Volser: DumpFile: Error seeking in inode %s for vnode %d: %s\n", PrintInode(NULL, handleP->fd_ih->ih_ino), vnode, afs_error_message(errno));
- } else {
- Log("1 Volser: DumpFile: Error seeking in inode %s for vnode %d\n", PrintInode(NULL, handleP->fd_ih->ih_ino), vnode);
- lcode = -1;
- }
- } else {
- lcode = 0;
- }
+ howFar = (size_t)((size - nbytes) + howMany);
}
/* Now write the data out */
}
if (pad) { /* Any padding we hadn't reported yet */
- Log("1 Volser: DumpFile: Null padding file: %d bytes at offset %u\n",
- pad, offset);
+ Log("1 Volser: DumpFile: Null padding file: %d bytes at offset %lld\n",
+ pad, (long long)offset);
}
free(p);
int vnodeIndex;
fdP = IH_OPEN(vp->vnodeIndex[class].handle);
- assert(fdP != NULL);
+ osi_Assert(fdP != NULL);
file = FDH_FDOPEN(fdP, "r+");
- assert(file != NULL);
+ osi_Assert(file != NULL);
size = OS_SIZE(fdP->fd_fd);
- assert(size != -1);
+ osi_Assert(size != -1);
nVnodes = (size / vcp->diskSize) - 1;
if (nVnodes > 0) {
- assert((nVnodes + 1) * vcp->diskSize == size);
- assert(STREAM_SEEK(file, vcp->diskSize, 0) == 0);
+ osi_Assert((nVnodes + 1) * vcp->diskSize == size);
+ osi_Assert(STREAM_ASEEK(file, vcp->diskSize) == 0);
} else
nVnodes = 0;
for (vnodeIndex = 0;
int
-ProcessIndex(Volume * vp, VnodeClass class, afs_int32 ** Bufp, int *sizep,
+ProcessIndex(Volume * vp, VnodeClass class, afs_foff_t ** Bufp, int *sizep,
int del)
{
- int i, nVnodes, offset, code;
- afs_int32 *Buf;
+ int i, nVnodes, code;
+ afs_foff_t offset;
+ afs_foff_t *Buf;
int cnt = 0;
afs_sfsize_t size;
StreamHandle_t *afile;
for (i = 0; i < *sizep; i++) {
if (Buf[i]) {
cnt++;
- STREAM_SEEK(afile, Buf[i], 0);
+ STREAM_ASEEK(afile, Buf[i]);
code = STREAM_READ(vnode, vcp->diskSize, 1, afile);
if (code == 1) {
if (vnode->type != vNull && VNDISK_GET_INO(vnode)) {
V_parentId(vp));
DOPOLL;
}
- STREAM_SEEK(afile, Buf[i], 0);
+ STREAM_ASEEK(afile, Buf[i]);
(void)STREAM_WRITE(zero, vcp->diskSize, 1, afile); /* Zero it out */
}
Buf[i] = 0;
OS_SYNC(afile->str_fd);
} else {
size = OS_SIZE(fdP->fd_fd);
- assert(size != -1);
+ osi_Assert(size != -1);
nVnodes =
(size <=
vcp->diskSize ? 0 : size - vcp->diskSize) >> vcp->logSize;
Log("RestoreVolume ProcessIndex: Set up %d inodes for volume %d\n",
nVnodes, V_id(vp));
}
- Buf = (afs_int32 *) malloc(nVnodes * sizeof(afs_int32));
+ Buf = malloc(nVnodes * sizeof(afs_foff_t));
if (Buf == NULL) {
STREAM_CLOSE(afile);
FDH_CLOSE(fdP);
return -1;
}
- memset(Buf, 0, nVnodes * sizeof(afs_int32));
- STREAM_SEEK(afile, offset = vcp->diskSize, 0);
+ memset(Buf, 0, nVnodes * sizeof(afs_foff_t));
+ STREAM_ASEEK(afile, offset = vcp->diskSize);
while (1) {
code = STREAM_READ(vnode, vcp->diskSize, 1, afile);
if (code != 1) {
Volume *vp;
struct iod iod;
struct iod *iodp = &iod;
- afs_int32 *b1 = NULL, *b2 = NULL;
+ afs_foff_t *b1 = NULL, *b2 = NULL;
int s1 = 0, s2 = 0, delo = 0, tdelo;
int tag;
static int
ReadVnodes(struct iod *iodp, Volume * vp, int incremental,
- afs_int32 * Lbuf, afs_int32 s1, afs_int32 * Sbuf, afs_int32 s2,
+ afs_foff_t * Lbuf, afs_int32 s1, afs_foff_t * Sbuf, afs_int32 s2,
afs_int32 delo)
{
afs_int32 vnodeNumber;
if (!VALID_INO(ino)) {
Log("1 Volser: ReadVnodes: IH_CREATE: %s - restore aborted\n",
afs_error_message(errno));
+ V_needsSalvaged(vp) = 1;
return VOLSERREAD_DUMPERROR;
}
nearInode = ino;
Log("1 Volser: ReadVnodes: IH_OPEN: %s - restore aborted\n",
afs_error_message(errno));
IH_RELEASE(tmpH);
+ V_needsSalvaged(vp) = 1;
return VOLSERREAD_DUMPERROR;
}
vnodeLength =
Log("1 Volser: ReadVnodes: IDEC inode %llu\n",
(afs_uintmax_t) ino);
IH_DEC(V_linkHandle(vp), ino, V_parentId(vp));
+ V_needsSalvaged(vp) = 1;
return VOLSERREAD_DUMPERROR;
}
break;
if (fdP == NULL) {
Log("1 Volser: ReadVnodes: Error opening vnode index: %s; restore aborted\n",
afs_error_message(errno));
+ V_needsSalvaged(vp) = 1;
return VOLSERREAD_DUMPERROR;
}
- if (FDH_SEEK(fdP, vnodeIndexOffset(vcp, vnodeNumber), SEEK_SET) <
- 0) {
- Log("1 Volser: ReadVnodes: Error seeking into vnode index: %s; restore aborted\n",
- afs_error_message(errno));
- FDH_REALLYCLOSE(fdP);
- return VOLSERREAD_DUMPERROR;
- }
- if (FDH_READ(fdP, &oldvnode, sizeof(oldvnode)) ==
+ if (FDH_PREAD(fdP, &oldvnode, sizeof(oldvnode), vnodeIndexOffset(vcp, vnodeNumber)) ==
sizeof(oldvnode)) {
if (oldvnode.type != vNull && VNDISK_GET_INO(&oldvnode)) {
IH_DEC(V_linkHandle(vp), VNDISK_GET_INO(&oldvnode),
}
}
vnode->vnodeMagic = vcp->magic;
- if (FDH_SEEK(fdP, vnodeIndexOffset(vcp, vnodeNumber), SEEK_SET) <
- 0) {
- Log("1 Volser: ReadVnodes: Error seeking into vnode index: %s; restore aborted\n",
- afs_error_message(errno));
- FDH_REALLYCLOSE(fdP);
- return VOLSERREAD_DUMPERROR;
- }
- if (FDH_WRITE(fdP, vnode, vcp->diskSize) != vcp->diskSize) {
+ if (FDH_PWRITE(fdP, vnode, vcp->diskSize, vnodeIndexOffset(vcp, vnodeNumber)) != vcp->diskSize) {
Log("1 Volser: ReadVnodes: Error writing vnode index: %s; restore aborted\n",
afs_error_message(errno));
FDH_REALLYCLOSE(fdP);
+ V_needsSalvaged(vp) = 1;
return VOLSERREAD_DUMPERROR;
}
FDH_CLOSE(fdP);
*status = 0;
-#ifdef AFS_64BIT_ENV
{
afs_uint32 filesize_high = 0L, filesize_low = 0L;
if (tag == 'h') {
}
FillInt64(filesize, filesize_high, filesize_low);
}
-#else /* !AFS_64BIT_ENV */
- if (!ReadInt32(iodp, &filesize)) {
- *status = 1;
- return (0);
- }
-#endif /* !AFS_64BIT_ENV */
p = (unsigned char *)malloc(size);
if (p == NULL) {
*status = 2;
break;
}
if (handleP) {
- nBytes = FDH_WRITE(handleP, p, size);
+ nBytes = FDH_PWRITE(handleP, p, size, written);
if (nBytes > 0)
written += nBytes;
if (nBytes != size) {
int vnodeIndex;
fdP = IH_OPEN(vp->vnodeIndex[class].handle);
- assert(fdP != NULL);
+ osi_Assert(fdP != NULL);
file = FDH_FDOPEN(fdP, "r+");
- assert(file != NULL);
+ osi_Assert(file != NULL);
size = OS_SIZE(fdP->fd_fd);
- assert(size != -1);
+ osi_Assert(size != -1);
nVnodes = (size / vcp->diskSize) - 1;
if (nVnodes > 0) {
- assert((nVnodes + 1) * vcp->diskSize == size);
- assert(STREAM_SEEK(file, vcp->diskSize, 0) == 0);
+ osi_Assert((nVnodes + 1) * vcp->diskSize == size);
+ osi_Assert(STREAM_ASEEK(file, vcp->diskSize) == 0);
} else
nVnodes = 0;
for (vnodeIndex = 0;