/*
* 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 <string.h>
+#include <roken.h>
-RCSID
- ("$Header$");
+#include <ctype.h>
#ifndef AFS_NAMEI_ENV
-#if defined(AFS_LINUX20_ENV) || defined(AFS_SUN4_ENV)
+#if defined(AFS_LINUX20_ENV)
/* ListViceInodes
*
* Return codes:
* -2 - Unable to completely write temp file. Produces warning message in log.
*/
int
-ListViceInodes(char *devname, char *mountedOn, char *resultFile,
- int (*judgeInode) (), int judgeParam, int *forcep, int forceR,
+ListViceInodes(char *devname, char *mountedOn, FD_t inodeFile,
+ afs_uint32 (*judgeInode) (), afs_uint32 judgeParam, int *forcep, int forceR,
char *wpath, void *rock)
{
Log("ListViceInodes not implemented for this platform!\n");
return -1;
}
#else
-#include <ctype.h>
-#include <sys/param.h>
-#if defined(AFS_SGI_ENV)
-#else
+#if !defined(AFS_SGI_ENV)
#ifdef AFS_OSF_ENV
#include <ufs/fs.h>
#else /* AFS_OSF_ENV */
#endif
#endif /* AFS_VFSINCL_ENV */
#endif /* AFS_OSF_ENV */
-#include <sys/time.h>
#ifdef AFS_VFSINCL_ENV
#include <sys/vnode.h>
#ifdef AFS_SUN5_ENV
#endif /* AFS_SGI_ENV */
#include <afs/osi_inode.h>
#include <sys/file.h>
-#include <stdio.h>
#include <rx/xdr.h>
#include <afs/afsint.h>
#include "nfs.h"
#include <afs/afssyscalls.h>
#include "viceinode.h"
-#include <sys/stat.h>
#if defined (AFS_AIX_ENV) || defined (AFS_HPUX_ENV)
#include <sys/ino.h>
#endif
-#ifdef AFS_PTHREAD_ENV
-#include <assert.h>
-#else /* AFS_PTHREAD_ENV */
-#include <afs/assert.h>
-#endif /* AFS_PTHREAD_ENV */
-#if defined(AFS_HPUX101_ENV)
-#include <unistd.h>
-#endif
-#include "partition.h"
-/*@+fcnmacros +macrofcndecl@*/
-#ifdef O_LARGEFILE
-#ifdef S_SPLINT_S
-extern off64_t afs_lseek(int FD, off64_t O, int F);
-#endif /*S_SPLINT_S */
-#define afs_lseek(FD, O, F) lseek64(FD, (off64_t) (O), F)
-#define afs_stat stat64
-#define afs_fstat fstat64
-#define afs_open open64
-#define afs_fopen fopen64
-#else /* !O_LARGEFILE */
-#ifdef S_SPLINT_S
-extern off_t afs_lseek(int FD, off_t O, int F);
-#endif /*S_SPLINT_S */
-#define afs_lseek(FD, O, F) lseek(FD, (off_t) (O), F)
-#define afs_stat stat
-#define afs_fstat fstat
-#define afs_open open
-#define afs_fopen fopen
-#endif /* !O_LARGEFILE */
-/*@=fcnmacros =macrofcndecl@*/
+#include "lock.h"
+#include "ihandle.h"
+#include "vnode.h"
+#include "volume.h"
+#include "volinodes.h"
+#include "partition.h"
+#include "fssync.h"
+#include "volume_inline.h"
/* Notice: parts of this module have been cribbed from vfsck.c */
#define ROOTINODE 2
static char *partition;
int Testing=0;
-int pfd;
+FD_t pfd;
#ifdef AFS_AIX32_ENV
#include <jfs/filsys.h>
int
-ListViceInodes(char *devname, char *mountedOn, char *resultFile,
- int (*judgeInode) (), int judgeParam, int *forcep, int forceR,
+ListViceInodes(char *devname, char *mountedOn, FD_t inodeFile,
+ int (*judgeInode) (), afs_uint32 judgeParam, int *forcep, int forceR,
char *wpath, void *rock)
{
- FILE *inodeFile = NULL;
char dev[50], rdev[51];
struct stat status;
struct dinode *p;
struct stat root_inode;
int ninodes = 0, err = 0;
- pfd = -1; /* initialize so we don't close on error output below. */
+ pfd = INVALID_FD; /* initialize so we don't close on error output below. */
*forcep = 0;
sync();
sleep(1); /* simulate operator */
fmax = fs.s_fsize / (FSBSIZE / 512); /* first invalid blk num */
- pfd = afs_open(rdev, O_RDONLY);
- if (pfd < 0) {
+ pfd = OS_OPEN(rdev, O_RDONLY, 0666);
+ if (pfd == INVALID_FD) {
Log("Unable to open `%s' inode for reading\n", rdev);
return -1;
}
- inodeFile = fopen(resultFile, "w");
- if (inodeFile == NULL) {
- Log("Unable to create inode description file %s\n", resultFile);
- goto out;
- }
-
/*
* calculate the maximum number of inodes possible
*/
* LAST_RSVD_I is a vice inode, with dead beef, and
* di_nlink == 2 to indicate the FORCE.
*/
- assert(p = ginode(LAST_RSVD_I));
+ osi_Assert(p = ginode(LAST_RSVD_I));
if (p->di_vicemagic == VICEMAGIC && p->di_vicep1 == 0xdeadbeef
&& p->di_nlink == 2) {
if (judgeInode && (*judgeInode) (&info, judgeParam, rock) == 0)
continue;
- if (fwrite(&info, sizeof info, 1, inodeFile) != 1) {
- Log("Error writing inode file for partition %s\n", partition);
- goto out;
+ if (inodeFile != INVALID_FD) {
+ if (OS_WRITE(inodeFile, &info, sizeof(info)) != sizeof(info)) {
+ Log("Error writing inode file for partition %s\n", partition);
+ goto out;
+ }
}
++ninodes;
}
- if (fflush(inodeFile) == EOF) {
- Log("Unable to successfully flush inode file for %s\n", partition);
- err = -2;
- goto out1;
- }
- if (fsync(fileno(inodeFile)) == -1) {
- Log("Unable to successfully fsync inode file for %s\n", partition);
- err = -2;
- goto out1;
- }
- if (fclose(inodeFile) == EOF) {
- Log("Unable to successfully close inode file for %s\n", partition);
- err = -2;
- goto out1;
- }
+ if (inodeFile != INVALID_FD) {
+ if (OS_SYNC(inodeFile) == -1) {
+ Log("Unable to successfully fsync inode file for %s\n", partition);
+ err = -2;
+ goto out1;
+ }
- /*
- * Paranoia: check that the file is really the right size
- */
- if (stat(resultFile, &status) == -1) {
- Log("Unable to successfully stat inode file for %s\n", partition);
- err = -2;
- goto out1;
- }
- if (status.st_size != ninodes * sizeof(struct ViceInodeInfo)) {
- Log("Wrong size (%d instead of %d) in inode file for %s\n",
- status.st_size, ninodes * sizeof(struct ViceInodeInfo),
- partition);
- err = -2;
- goto out1;
+ /*
+ * Paranoia: check that the file is really the right size
+ */
+ if (OS_SIZE(inodeFile) != ninodes * sizeof(struct ViceInodeInfo)) {
+ Log("Wrong size (%d instead of %d) in inode file for %s\n",
+ status.st_size, ninodes * sizeof(struct ViceInodeInfo),
+ partition);
+ err = -2;
+ goto out1;
+ }
}
- close(pfd);
+ OS_CLOSE(pfd);
return 0;
out:
err = -1;
out1:
- if (pfd >= 0)
- close(pfd);
- if (inodeFile)
- fclose(inodeFile);
+ if (pfd != INVALID_FD)
+ OS_CLOSE(pfd);
return err;
}
int
ReadSuper(struct superblock *fs, char *devName)
{
- int pfd;
+ FD_t pfd;
- pfd = afs_open(devName, O_RDONLY);
- if (pfd < 0) {
+ pfd = OS_OPEN(devName, O_RDONLY, 0666);
+ if (pfd == INVALID_FD) {
Log("Unable to open inode on %s for reading superblock.\n", devName);
return -1;
}
Log("Unable to read superblock on %s.\n", devName);
return -1;
}
- close(pfd);
+ OS_CLOSE(pfd);
return (0);
}
/* xfs_ListViceInodes
*
* xfs_ListViceInodes verifies and correct the XFS namespace as it collects
- * the inode information. The name is required for the idec operation to work.
+ * the inode information. The name is required for the idec operation to work.
* Steps 2 and 3 below are for the AFS_XFS_NAME_VERS == 1. If the name space
- * changes, the algorithm will need to change.
+ * changes, the algorithm will need to change.
* 1) If the parent inode number does not match the directory's inod number,
* change it in the attribute.
* 2) If the unqifier in the attribute does not match the name, rename the
*/
/* xfs_VerifyInode
- *
+ *
* Does the verifications listed above.
* We can't change the names until the readdir is complete, so we set the
* rename flag if the file needs renaming.
char tmpName[32];
b64_string_t stmp;
int tag;
+ afs_ino_str_t stmp;
*rename = 0;
(void)sprintf(path, "%s/%s", dir, name);
if (info->ili_magic != XFS_VICEMAGIC) {
Log("%s magic for %s/%s (inode %s) from %d to %d\n",
Testing ? "Would have changed" : "Changing", dir, name,
- PrintInode(NULL, info->ili_info.inodeNumber), info->ili_magic,
+ PrintInode(stmp, info->ili_info.inodeNumber), info->ili_magic,
XFS_VICEMAGIC);
if (!Testing)
update_chown = 1;
if (info->ili_vno != AFS_XFS_VNO_CLIP(vno)) {
Log("%s volume id for %s/%s (inode %s) from %d to %d\n",
Testing ? "Would have changed" : "Changing", dir, name,
- PrintInode(NULL, info->ili_info.inodeNumber), info->ili_vno,
+ PrintInode(stmp, info->ili_info.inodeNumber), info->ili_vno,
AFS_XFS_VNO_CLIP(vno));
if (!Testing)
update_chown = 1;
if (strncmp(name, tmpName, strlen(tmpName))) {
Log("%s name %s (inode %s) in directory %s, unique=%d, tag=%d\n",
Testing ? "Would have returned bad" : "Bad", name,
- PrintInode(NULL, info->ili_info.inodeNumber), dir,
+ PrintInode(stmp, info->ili_info.inodeNumber), dir,
info->ili_info.param[2], info->ili_tag);
if (!Testing)
*rename = 1;
p = strchr(tmpName + 1, '.');
if (!p) {
Log("No tag found on name %s (inode %s)in directory, %s.\n",
- name, PrintInode(NULL, info->ili_info.inodeNumber), dir,
+ name, PrintInode(stmp, info->ili_info.inodeNumber), dir,
Testing ? "would have renamed" : "will rename");
if (!Testing)
*rename = 1;
tag = base64_to_int(p + 1);
Log("%s the tag for %s (inode %s) from %d to %d.\n",
Testing ? "Would have changed" : "Will change", path,
- PrintInode(NULL, info->ili_info.inodeNumber), dir, tag,
+ PrintInode(stmp, info->ili_info.inodeNumber), dir, tag,
info->ili_tag);
if (!Testing)
update_tag = 1;
int
-xfs_ListViceInodes(char *devname, char *mountedOn, char *resultFile,
- int (*judgeInode) (), int judgeParam, int *forcep,
+xfs_ListViceInodes(char *devname, char *mountedOn, FD_t inodeFile,
+ int (*judgeInode) (), afs_uint32 judgeParam, int *forcep,
int forceR, char *wpath, void *rock)
{
- FILE *inodeFile = NULL;
i_list_inode_t info;
int info_size = sizeof(i_list_inode_t);
int fd;
int n_renames = 0;
int n_avail = 0;
uint64_t pino;
- struct stat status;
int errors = 0;
*forcep = 0;
return -1;
}
- inodeFile = fopen(resultFile, "w");
- if (inodeFile == NULL) {
- Log("Unable to create inode description file %s\n", resultFile);
- return -1;
- }
-
if ((top_dirp = opendir(mountedOn)) == NULL) {
Log("Can't open directory %s to read inodes.\n", mountedOn);
return -1;
n_renames++;
}
- if (fwrite
- (&info.ili_info, sizeof(vice_inode_info_t), 1, inodeFile)
- != 1) {
- Log("Error writing inode file for partition %s\n", mountedOn);
- goto err1_exit;
+ if (inodeFile != INVALID_FD) {
+ if (OS_WRITE
+ (inodeFile, &info.ili_info, sizeof(vice_inode_info_t))
+ != sizeof(vice_inode_info_t)) {
+ Log("Error writing inode file for partition %s\n", mountedOn);
+ goto err1_exit;
+ }
}
ninodes++;
closedir(top_dirp);
if (renames)
free((char *)renames);
- if (fflush(inodeFile) == EOF) {
- ("Unable to successfully flush inode file for %s\n", mountedOn);
- fclose(inodeFile);
- return errors ? -1 : -2;
- }
- if (fsync(fileno(inodeFile)) == -1) {
- Log("Unable to successfully fsync inode file for %s\n", mountedOn);
- fclose(inodeFile);
- return errors ? -1 : -2;
- }
- if (fclose(inodeFile) == EOF) {
- Log("Unable to successfully close inode file for %s\n", mountedOn);
- return errors ? -1 : -2;
- }
- /*
- * Paranoia: check that the file is really the right size
- */
- if (stat(resultFile, &status) == -1) {
- Log("Unable to successfully stat inode file for %s\n", partition);
- return errors ? -1 : -2;
- }
- if (status.st_size != ninodes * sizeof(struct ViceInodeInfo)) {
- Log("Wrong size (%d instead of %d) in inode file for %s\n",
- status.st_size, ninodes * sizeof(struct ViceInodeInfo),
- partition);
- return errors ? -1 : -2;
+ if (inodeFile != INVALID_FD) {
+ if (OS_SYNC(inodeFile) == -1) {
+ Log("Unable to successfully fsync inode file for %s\n", mountedOn);
+ return errors ? -1 : -2;
+ }
+ /*
+ * Paranoia: check that the file is really the right size
+ */
+ if (OS_SIZE(inodeFile) != ninodes * sizeof(struct ViceInodeInfo)) {
+ Log("Wrong size (%d instead of %d) in inode file for %s\n",
+ OS_SIZE(inodeFile), ninodes * sizeof(struct ViceInodeInfo),
+ partition);
+ return errors ? -1 : -2;
+ }
}
if (errors) {
closedir(top_dirp);
if (renames)
free((char *)renames);
- if (inodeFile)
- fclose(inodeFile);
return -1;
}
#endif
int
-ListViceInodes(char *devname, char *mountedOn, char *resultFile,
- int (*judgeInode) (), int judgeParam, int *forcep, int forceR,
+ListViceInodes(char *devname, char *mountedOn, FD_t inodeFile,
+ int (*judgeInode) (), afs_uint32 judgeParam, int *forcep, int forceR,
char *wpath, void *rock)
{
- FILE *inodeFile = NULL;
char dev[50], rdev[51];
struct stat status;
struct efs_dinode *p;
}
#ifdef AFS_SGI_XFS_IOPS_ENV
if (!strcmp("xfs", root_inode.st_fstype)) {
- return xfs_ListViceInodes(devname, mountedOn, resultFile, judgeInode,
+ return xfs_ListViceInodes(devname, mountedOn, inodeFile, judgeInode,
judgeParam, forcep, forceR, wpath, rock);
} else
#endif
extern char *afs_rawname();
int
-ListViceInodes(char *devname, char *mountedOn, char *resultFile,
- int (*judgeInode) (), int judgeParam, int *forcep, int forceR,
+ListViceInodes(char *devname, char *mountedOn, FD_t inodeFile,
+ int (*judgeInode) (), afs_uint32 judgeParam, int *forcep, int forceR,
char *wpath, void *rock)
{
union {
#endif
} super;
int i, c, e, bufsize, code, err = 0;
- FILE *inodeFile = NULL;
char dev[50], rdev[100], err1[512], *ptr1;
struct dinode *inodes = NULL, *einodes, *dptr;
- struct stat status;
int ninodes = 0;
struct dinode *p;
struct ViceInodeInfo info;
sleep(10);
#endif
- pfd = afs_open(rdev, O_RDONLY);
- if (pfd <= 0) {
+ pfd = OS_OPEN(rdev, O_RDONLY, 0666);
+ if (pfd == INVALID_FD) {
sprintf(err1, "Could not open device %s to get inode list\n", rdev);
perror(err1);
return -1;
goto out;
}
- inodeFile = fopen(resultFile, "w");
- if (inodeFile == NULL) {
- Log("Unable to create inode description file %s\n", resultFile);
- goto out;
- }
#ifdef AFS_AIX_ENV
/*
* char *FSlabel(), *fslabel=0;
info.u.param[3] = auxp->aux_param4;
if (judgeInode && (*judgeInode) (&info, judgeParam, rock) == 0)
continue;
- if (fwrite(&info, sizeof info, 1, inodeFile) != 1) {
- Log("Error writing inode file for partition %s\n", partition);
- goto out;
+ if (inodeFile != INVALID_FD) {
+ if (OS_WRITE(inodeFile, &info, sizeof(info)) != sizeof(info)) {
+ Log("Error writing inode file for partition %s\n", partition);
+ goto out;
+ }
}
ninodes++;
}
i = c * sblock.fs_ipg;
e = i + sblock.fs_ipg;
#if defined(AFS_HPUX102_ENV)
- if (afs_lseek(pfd, dbtoo(fsbtodb(&sblock, itod(&sblock, i))), L_SET) ==
+ if (OS_SEEK(pfd, dbtoo(fsbtodb(&sblock, itod(&sblock, i))), L_SET) ==
-1) {
#else
- if (afs_lseek(pfd, dbtob(fsbtodb(&sblock, itod(&sblock, i))), L_SET) ==
+ if (OS_SEEK(pfd, dbtob(fsbtodb(&sblock, itod(&sblock, i))), L_SET) ==
-1) {
#endif
#else
e = i + super.fs.fs_ipg;
#ifdef AFS_OSF_ENV
dblk1 = fsbtodb(&super.fs, itod(&super.fs, i));
- if (afs_lseek(pfd, (off_t) ((off_t) dblk1 * DEV_BSIZE), L_SET) == -1) {
+ if (OS_SEEK(pfd, (off_t) ((off_t) dblk1 * DEV_BSIZE), L_SET) == -1) {
#else
#if defined(AFS_SUN5_ENV) || defined(AFS_DARWIN_ENV)
f1 = fsbtodb(&super.fs, itod(&super.fs, i));
off = (offset_t) f1 << DEV_BSHIFT;
- if (llseek(pfd, off, L_SET) == -1) {
+ if (OS_SEEK(pfd, off, L_SET) == -1) {
#else
- if (afs_lseek(pfd, dbtob(fsbtodb(&super.fs, itod(&super.fs, i))), L_SET)
+ if (OS_SEEK(pfd, dbtob(fsbtodb(&super.fs, itod(&super.fs, i))), L_SET)
== -1) {
#endif /* AFS_SUN5_ENV */
#endif /* AFS_OSF_ENV */
}
while (i < e) {
if (!forceR) {
- if (read(pfd, inodes, bufsize) != bufsize) {
+ if (OS_READ(pfd, inodes, bufsize) != bufsize) {
Log("Error reading inodes for partition %s; run vfsck\n",
partition);
goto out;
}
} else {
- register int bj, bk;
+ int bj, bk;
dptr = inodes;
for (bj = bk = 0; bj < bufsize; bj = bj + 512, bk++) {
- if ((code = read(pfd, dptr, 512)) != 512) {
+ if ((code = OS_READ(pfd, dptr, 512)) != 512) {
Log("Error reading inode %d? for partition %s (errno = %d); run vfsck\n", bk + i, partition, errno);
- if (afs_lseek(pfd, 512, L_SET) == -1) {
- Log("Lseek failed\n");
+ if (OS_SEEK(pfd, 512, L_SET) == -1) {
+ Log("OS_SEEK failed\n");
goto out;
}
dptr->di_mode = 0;
goto out;
}
#else
- assert(0); /* define AFS_3DISPARES in param.h */
+ osi_Panic("Tru64 needs AFS_3DISPARES\n");
#endif
#endif
-#if defined(AFS_SUN56_ENV)
+#if defined(AFS_SUN5_ENV)
/* if this is a pre-sol2.6 unconverted inode, bail out */
{
afs_uint32 p1, p2, p3, p4;
info.linkCount = p->di_nlink;
if (judgeInode && (*judgeInode) (&info, judgeParam, rock) == 0)
continue;
- if (fwrite(&info, sizeof info, 1, inodeFile) != 1) {
- Log("Error writing inode file for partition %s\n",
- partition);
- goto out;
+ if (inodeFile != INVALID_FD) {
+ if (OS_WRITE(inodeFile, &info, sizeof(info)) != sizeof(info)) {
+ Log("Error writing inode file for partition %s\n",
+ partition);
+ goto out;
+ }
}
ninodes++;
}
if (inodes)
free(inodes);
#endif
- if (fflush(inodeFile) == EOF) {
- Log("Unable to successfully flush inode file for %s\n", partition);
- err = -2;
- goto out1;
- }
- if (fsync(fileno(inodeFile)) == -1) {
- Log("Unable to successfully fsync inode file for %s\n", partition);
- err = -2;
- goto out1;
- }
- if (fclose(inodeFile) == EOF) {
- Log("Unable to successfully close inode file for %s\n", partition);
- err = -2;
- goto out1;
- }
+ if (inodeFile != INVALID_FD) {
+ if (OS_SYNC(inodeFile) == -1) {
+ Log("Unable to successfully fsync inode file for %s\n", partition);
+ err = -2;
+ goto out1;
+ }
- /*
- * Paranoia: check that the file is really the right size
- */
- if (stat(resultFile, &status) == -1) {
- Log("Unable to successfully stat inode file for %s\n", partition);
- err = -2;
- goto out1;
- }
- if (status.st_size != ninodes * sizeof(struct ViceInodeInfo)) {
- Log("Wrong size (%d instead of %d) in inode file for %s\n",
- status.st_size, ninodes * sizeof(struct ViceInodeInfo),
- partition);
- err = -2;
- goto out1;
+ /*
+ * Paranoia: check that the file is really the right size
+ */
+ if (OS_SIZE(inodeFile) != ninodes * sizeof(struct ViceInodeInfo)) {
+ Log("Wrong size (%d instead of %d) in inode file for %s\n",
+ OS_SIZE(inodeFile), ninodes * sizeof(struct ViceInodeInfo),
+ partition);
+ err = -2;
+ goto out1;
+ }
}
- close(pfd);
+ OS_CLOSE(pfd);
return 0;
out:
err = -1;
out1:
- close(pfd);
- if (inodeFile)
- fclose(inodeFile);
+ OS_CLOSE(pfd);
if (inodes)
free(inodes);
return err;
#endif
int
-bread(int fd, char *buf, daddr_t blk, afs_int32 size)
+bread(FD_t fd, char *buf, daddr_t blk, afs_int32 size)
{
#ifdef AFS_AIX_ENV
#ifdef AFS_AIX41_ENV
offset_t off = (offset_t) blk << FSBSHIFT;
- if (llseek(fd, off, 0) < 0) {
+ if (OS_SEEK(fd, off, 0) < 0) {
Log("Unable to seek to offset %llu for block %u\n", off, blk);
return -1;
}
#else /* AFS_AIX41_ENV */
- if (afs_lseek(fd, blk * Bsize, 0) < 0) {
+ if (OS_SEEK(fd, blk * Bsize, 0) < 0) {
Log("Unable to seek to offset %u for block %u\n", blk * Bsize, blk);
}
#endif /* AFS_AIX41_ENV */
#else
- if (afs_lseek(fd, (off_t) dbtob(blk), L_SET) < 0) {
+ if (OS_SEEK(fd, (off_t) dbtob(blk), L_SET) < 0) {
Log("Unable to seek to offset %u for block %u\n", dbtob(blk), blk);
}
#endif
- if (read(fd, buf, size) != size) {
+ if (OS_READ(fd, buf, size) != size) {
Log("Unable to read block %d, partition %s\n", blk, partition);
return -1;
}
}
#endif /* AFS_LINUX20_ENV */
+static afs_int32
+convertVolumeInfo(FdHandle_t *fdhr, FdHandle_t *fdhw, afs_uint32 vid)
+{
+ struct VolumeDiskData vd;
+ char *p;
+
+ if (FDH_PREAD(fdhr, &vd, sizeof(struct VolumeDiskData), 0) !=
+ sizeof(struct VolumeDiskData)) {
+ Log("1 convertiVolumeInfo: read failed for %lu with code %d\n", vid,
+ errno);
+ return -1;
+ }
+ vd.restoredFromId = vd.id; /* remember the RO volume here */
+ vd.cloneId = vd.id;
+ vd.id = vd.parentId;
+ vd.type = RWVOL;
+ vd.dontSalvage = 0;
+ vd.inUse = 0;
+ vd.uniquifier += 5000; /* just in case there are still file copies
+ from the old RW volume around */
+
+ /* For ROs, the copyDate contains the time that the RO volume was actually
+ * created, and the creationDate just contains the last time the RO was
+ * copied from the RW data. So, make the new RW creationDate more accurate
+ * by setting it to copyDate, if copyDate is older. Since, we know the
+ * volume is at least as old as copyDate. */
+ if (vd.copyDate < vd.creationDate) {
+ vd.creationDate = vd.copyDate;
+ } else {
+ /* If copyDate is newer, just make copyDate and creationDate the same,
+ * for consistency with other RWs */
+ vd.copyDate = vd.creationDate;
+ }
+
+ p = strrchr(vd.name, '.');
+ if (p && !strcmp(p, ".readonly")) {
+ memset(p, 0, 9);
+ }
+
+ if (FDH_PWRITE(fdhw, &vd, sizeof(struct VolumeDiskData), 0) !=
+ sizeof(struct VolumeDiskData)) {
+ Log("1 convertiVolumeInfo: write failed for %lu with code %d\n", vid,
+ errno);
+ return -1;
+ }
+ return 0;
+}
+
+struct specino {
+ afs_int32 inodeType;
+ Inode inodeNumber;
+ Inode ninodeNumber;
+};
+
+
+int
+UpdateThisVolume(struct ViceInodeInfo *inodeinfo, VolumeId singleVolumeNumber,
+ struct specino *specinos)
+{
+ struct dinode *p;
+ if ((inodeinfo->u.vnode.vnodeNumber == INODESPECIAL) &&
+ (inodeinfo->u.vnode.volumeId == singleVolumeNumber)) {
+ specinos[inodeinfo->u.special.type].inodeNumber =
+ inodeinfo->inodeNumber;
+ }
+ return 0; /* We aren't using a result file, we're caching */
+}
+
+static char *
+getDevName(char *pbuffer, char *wpath)
+{
+ char pbuf[128], *ptr;
+ strcpy(pbuf, pbuffer);
+ ptr = (char *)strrchr(pbuf, OS_DIRSEPC);
+ if (ptr) {
+ *ptr = '\0';
+ strcpy(wpath, pbuf);
+ } else
+ return NULL;
+ ptr = (char *)strrchr(pbuffer, OS_DIRSEPC);
+ if (ptr) {
+ strcpy(pbuffer, ptr + 1);
+ return pbuffer;
+ } else
+ return NULL;
+}
+
+#ifdef FSSYNC_BUILD_CLIENT
+int
+inode_ConvertROtoRWvolume(char *pname, afs_uint32 volumeId)
+{
+ char dir_name[512], oldpath[512], newpath[512];
+ char volname[20];
+ char headername[16];
+ char *name;
+ int fd, err, forcep, j;
+ ssize_t len, nBytes;
+ struct dirent *dp;
+ struct DiskPartition64 *partP;
+ struct ViceInodeInfo info;
+ struct VolumeDiskHeader h;
+ IHandle_t *ih, *ih2;
+ FdHandle_t *fdP, *fdP2;
+ afs_foff_t offset;
+ char wpath[100];
+ char tmpDevName[100];
+ char buffer[128];
+ struct specino specinos[VI_LINKTABLE+1];
+ Inode nearInode = 0;
+# ifdef AFS_DEMAND_ATTACH_FS
+ int locktype = 0;
+# endif /* AFS_DEMAND_ATTACH_FS */
+ int code = 0;
+
+ memset(&specinos, 0, sizeof(specinos));
+
+ /* now do the work */
+
+ for (partP = DiskPartitionList; partP && strcmp(partP->name, pname);
+ partP = partP->next);
+ if (!partP) {
+ Log("1 inode_ConvertROtoRWvolume: Couldn't find DiskPartition for %s\n", pname);
+ code = EIO;
+ goto done;
+ }
+
+#ifdef AFS_DEMAND_ATTACH_FS
+ locktype = VVolLockType(V_VOLUPD, 1);
+ code = VLockVolumeByIdNB(volumeId, partP, locktype);
+ if (code) {
+ locktype = 0;
+ code = EIO;
+ goto done;
+ }
+#endif
+
+ if (VReadVolumeDiskHeader(volumeId, partP, &h)) {
+ Log("1 inode_ConvertROtoRWvolume: Couldn't read header for RO-volume %lu.\n",
+ afs_printable_uint32_lu(volumeId));
+ return EIO;
+ }
+
+ FSYNC_VolOp(volumeId, pname, FSYNC_VOL_BREAKCBKS, 0, NULL);
+
+ strcpy(tmpDevName, partP->devName);
+ name = getDevName(tmpDevName, wpath);
+
+ if ((err = ListViceInodes(name, VPartitionPath(partP),
+ NULL, UpdateThisVolume, volumeId,
+ &forcep, 0, wpath, &specinos)) < 0)
+ {
+ Log("1 inode_ConvertROtoRWvolume: Couldn't get special inodes\n");
+ code = EIO;
+ goto done;
+ }
+
+#if defined(NEARINODE_HINT)
+ nearInodeHash(volumeId, nearInode);
+ nearInode %= partP->f_files;
+#endif
+
+ for (j = VI_VOLINFO; j < VI_LINKTABLE+1; j++) {
+ if (specinos[j].inodeNumber > 0) {
+ specinos[j].ninodeNumber =
+ IH_CREATE(NULL, partP->device, VPartitionPath(partP),
+ nearInode, h.parent, INODESPECIAL, j, h.parent);
+ IH_INIT(ih, partP->device, volumeId,
+ specinos[j].inodeNumber);
+ fdP = IH_OPEN(ih);
+ if (!fdP) {
+ Log("1 inode_ConvertROtoRWvolume: Couldn't find special inode %d for %d\n", j, volumeId);
+ code = -1;
+ goto done;
+ }
+
+ IH_INIT(ih2, partP->device, h.parent, specinos[j].ninodeNumber);
+ fdP2 = IH_OPEN(ih2);
+ if (!fdP2) {
+ Log("1 inode_ConvertROtoRWvolume: Couldn't find special inode %d for %d\n", j, h.parent);
+ code = -1;
+ goto done;
+ }
+
+ if (j == VI_VOLINFO)
+ convertVolumeInfo(fdP, fdP2, ih2->ih_vid);
+ else {
+ offset = 0;
+ while (1) {
+ len = FDH_PREAD(fdP, buffer, sizeof(buffer), offset);
+ if (len < 0)
+ return errno;
+ if (len == 0)
+ break;
+ nBytes = FDH_PWRITE(fdP2, buffer, len, offset);
+ if (nBytes != len) {
+ code = -1;
+ goto done;
+ }
+ offset += len;
+ }
+ }
+
+ FDH_CLOSE(fdP);
+ FDH_CLOSE(fdP2);
+
+ /* Unlink the old special inode; otherwise we will get duplicate
+ * special inodes if we recreate the RO again */
+ if (IH_DEC(ih, specinos[j].inodeNumber, volumeId) == -1) {
+ afs_ino_str_t stmp;
+ Log("IH_DEC failed: %x, %s, %u errno %d\n", ih,
+ PrintInode(stmp, specinos[j].inodeNumber), volumeId, errno);
+ }
+
+ IH_RELEASE(ih);
+ IH_RELEASE(ih2);
+ }
+ }
+
+ h.id = h.parent;
+#ifdef AFS_64BIT_IOPS_ENV
+ h.volumeInfo_lo = (afs_int32)specinos[VI_VOLINFO].ninodeNumber & 0xffffffff;
+ h.volumeInfo_hi = (afs_int32)(specinos[VI_VOLINFO].ninodeNumber >> 32) && 0xffffffff;
+ h.smallVnodeIndex_lo = (afs_int32)specinos[VI_SMALLINDEX].ninodeNumber & 0xffffffff;
+ h.smallVnodeIndex_hi = (afs_int32)(specinos[VI_SMALLINDEX].ninodeNumber >> 32) & 0xffffffff;
+ h.largeVnodeIndex_lo = (afs_int32)specinos[VI_LARGEINDEX].ninodeNumber & 0xffffffff;
+ h.largeVnodeIndex_hi = (afs_int32)(specinos[VI_LARGEINDEX].ninodeNumber >> 32) & 0xffffffff;
+ if (specinos[VI_LINKTABLE].ninodeNumber) {
+ h.linkTable_lo = (afs_int32)specinos[VI_LINKTABLE].ninodeNumber & 0xffffffff;
+ h.linkTable_hi = (afs_int32)specinos[VI_LINKTABLE].ninodeNumber & 0xffffffff;
+ }
+#else
+ h.volumeInfo_lo = specinos[VI_VOLINFO].ninodeNumber;
+ h.smallVnodeIndex_lo = specinos[VI_SMALLINDEX].ninodeNumber;
+ h.largeVnodeIndex_lo = specinos[VI_LARGEINDEX].ninodeNumber;
+ if (specinos[VI_LINKTABLE].ninodeNumber) {
+ h.linkTable_lo = specinos[VI_LINKTABLE].ninodeNumber;
+ }
+#endif
+
+ if (VCreateVolumeDiskHeader(&h, partP)) {
+ Log("1 inode_ConvertROtoRWvolume: Couldn't write header for RW-volume %lu\n",
+ afs_printable_uint32_lu(h.id));
+ code = EIO;
+ goto done;
+ }
+
+ if (VDestroyVolumeDiskHeader(partP, volumeId, h.parent)) {
+ Log("1 inode_ConvertROtoRWvolume: Couldn't unlink header for RO-volume %lu\n",
+ afs_printable_uint32_lu(volumeId));
+ }
+
+ FSYNC_VolOp(volumeId, pname, FSYNC_VOL_DONE, 0, NULL);
+ FSYNC_VolOp(h.id, pname, FSYNC_VOL_ON, 0, NULL);
+
+ done:
+# ifdef AFS_DEMAND_ATTACH_FS
+ if (locktype) {
+ VUnlockVolumeById(volumeId, partP);
+ }
+# endif /* AFS_DEMAND_ATTACH_FS */
+ return code;
+}
+#endif /* FSSYNC_BUILD_CLIENT */
#endif /* AFS_NAMEI_ENV */