void
CloneVolume(Error * error, Volume * original, Volume * new, Volume * old)
{
- VOL_LOCK CloneVolume_r(error, original, new, old);
-VOL_UNLOCK}
+ VOL_LOCK;
+ CloneVolume_r(error, original, new, old);
+ VOL_UNLOCK;
+}
void
CloneVolume_r(Error * rerror, Volume * original, Volume * new, Volume * old)
#define MAXHANDLERS 4 /* Up to 4 clients; must be at least 2, so that
* move = dump+restore can run on single server */
-#define MAXOFFLINEVOLUMES 128 /* This needs to be as big as the maximum
+#define MAXOFFLINEVOLUMES 128 /* This needs to be as big as the maximum
* number that would be offline for 1 operation.
* Current winner is salvage, which needs all
* cloned read-only copies offline when salvaging
else
command.partName[0] = 0;
assert(FS_sd != -1);
- VFSYNC_LOCK
+ VFSYNC_LOCK;
#ifdef AFS_NT40_ENV
if (send(FS_sd, (char *)&command, sizeof(command), 0) != sizeof(command)) {
printf("FSYNC_askfs: write to file server failed\n");
("FSYNC_askfs: negative response from file server; volume %u, command %d\n",
command.volume, (int)command.command);
}
- done:
- VFSYNC_UNLOCK
-
+ done:
+ VFSYNC_UNLOCK;
return response;
}
FSYNC_Drop(fd);
return;
}
- VATTACH_LOCK VOL_LOCK volumes = OfflineVolumes[FindHandler(fd)];
+ VATTACH_LOCK;
+ VOL_LOCK;
+ volumes = OfflineVolumes[FindHandler(fd)];
for (v = 0, i = 0; i < MAXOFFLINEVOLUMES; i++) {
if (volumes[i].volumeID == command.volume
&& strcmp(volumes[i].partName, command.partName) == 0) {
if (V_BreakVolumeCallbacks) {
Log("fssync: volume %u moved to %x; breaking all call backs\n",
command.volume, command.reason);
- VOL_UNLOCK VATTACH_UNLOCK(*V_BreakVolumeCallbacks) (command.
- volume);
- VATTACH_LOCK VOL_LOCK}
+ VOL_UNLOCK;
+ VATTACH_UNLOCK;
+ (*V_BreakVolumeCallbacks) (command.volume);
+ VATTACH_LOCK;
+ VOL_LOCK;
+ }
break;
case FSYNC_RESTOREVOLUME:
/* if the volume is being restored, break all callbacks on it */
if (V_BreakVolumeCallbacks) {
Log("fssync: volume %u restored; breaking all call backs\n",
command.volume);
- VOL_UNLOCK VATTACH_UNLOCK(*V_BreakVolumeCallbacks) (command.
- volume);
- VATTACH_LOCK VOL_LOCK}
+ VOL_UNLOCK;
+ VATTACH_UNLOCK;
+ (*V_BreakVolumeCallbacks) (command.volume);
+ VATTACH_LOCK;
+ VOL_LOCK;
+ }
break;
default:
rc = FSYNC_DENIED;
break;
}
- VOL_UNLOCK VATTACH_UNLOCK
+ VOL_UNLOCK;
+ VATTACH_UNLOCK;
#ifdef AFS_NT40_ENV
- (void) send(fd, &rc, 1, 0);
+ (void)send(fd, &rc, 1, 0);
#else
- (void) write(fd, &rc, 1);
+ (void)write(fd, &rc, 1);
#endif
}
Error error;
char tvolName[VMAXPATHLEN];
- VATTACH_LOCK VOL_LOCK p = OfflineVolumes[FindHandler(fd)];
+ VATTACH_LOCK;
+ VOL_LOCK;
+ p = OfflineVolumes[FindHandler(fd)];
for (i = 0; i < MAXOFFLINEVOLUMES; i++) {
if (p[i].volumeID) {
Volume *vp;
p[i].volumeID = 0;
}
}
- VOL_UNLOCK VATTACH_UNLOCK RemoveHandler(fd);
+ VOL_UNLOCK;
+ VATTACH_UNLOCK;
+ RemoveHandler(fd);
#ifdef AFS_NT40_ENV
closesocket(fd);
#else
static
fstabscan()
{
- if(_fs_count <= 0)
- return(0);
- _fs_fstab.fs_spec = _fs_ptr->f_mntfromname;
- _fs_fstab.fs_file = _fs_ptr->f_mntonname;
- _fs_fstab.fs_vfstype = _fs_ptr->f_fstypename;
- _fs_fstab.fs_mntops = _fs_ptr->f_fstypename; // no mount options given
- _fs_fstab.fs_type = (_fs_ptr->f_flags & MNT_RDONLY) ? FSTAB_RO : FSTAB_RW;
- _fs_fstab.fs_freq = 0;
- _fs_fstab.fs_passno = 0;
-
- _fs_ptr++;
- _fs_count--;
- return(1);
+ if (_fs_count <= 0)
+ return (0);
+ _fs_fstab.fs_spec = _fs_ptr->f_mntfromname;
+ _fs_fstab.fs_file = _fs_ptr->f_mntonname;
+ _fs_fstab.fs_vfstype = _fs_ptr->f_fstypename;
+ _fs_fstab.fs_mntops = _fs_ptr->f_fstypename; // no mount options given
+ _fs_fstab.fs_type = (_fs_ptr->f_flags & MNT_RDONLY) ? FSTAB_RO : FSTAB_RW;
+ _fs_fstab.fs_freq = 0;
+ _fs_fstab.fs_passno = 0;
+
+ _fs_ptr++;
+ _fs_count--;
+ return (1);
}
struct fstab *
getfsent()
{
- if (!_fs_buf && !setfsent() || !fstabscan())
- return((struct fstab *)NULL);
- return(&_fs_fstab);
+ if (!_fs_buf && !setfsent() || !fstabscan())
+ return ((struct fstab *)NULL);
+ return (&_fs_fstab);
}
struct fstab *
getfsspec(name)
- register const char *name;
+ register const char *name;
{
- if (setfsent())
- while (fstabscan())
- if (!strcmp(_fs_fstab.fs_spec, name))
- return(&_fs_fstab);
- return((struct fstab *)NULL);
+ if (setfsent())
+ while (fstabscan())
+ if (!strcmp(_fs_fstab.fs_spec, name))
+ return (&_fs_fstab);
+ return ((struct fstab *)NULL);
}
struct fstab *
getfsfile(name)
- register const char *name;
+ register const char *name;
{
- if (setfsent())
- while (fstabscan())
- if (!strcmp(_fs_fstab.fs_file, name))
- return(&_fs_fstab);
- return((struct fstab *)NULL);
+ if (setfsent())
+ while (fstabscan())
+ if (!strcmp(_fs_fstab.fs_file, name))
+ return (&_fs_fstab);
+ return ((struct fstab *)NULL);
}
setfsent()
{
- long bufsize;
-
- if (_fs_buf) {
- free(_fs_buf);
- _fs_buf = NULL;
- }
- if((_fs_count = getfsstat(NULL, 0, MNT_WAIT)) < 0) {
- error(errno);
- return(0);
- }
- bufsize = (long)_fs_count * sizeof(struct statfs);
- if((_fs_buf = malloc(bufsize)) == NULL) {
- error(errno);
- return(0);
- }
- if(getfsstat(_fs_buf, bufsize, MNT_WAIT) < 0) {
- error(errno);
- return(0);
- }
- _fs_ptr = _fs_buf;
- return(1);
+ long bufsize;
+
+ if (_fs_buf) {
+ free(_fs_buf);
+ _fs_buf = NULL;
+ }
+ if ((_fs_count = getfsstat(NULL, 0, MNT_WAIT)) < 0) {
+ error(errno);
+ return (0);
+ }
+ bufsize = (long)_fs_count *sizeof(struct statfs);
+ if ((_fs_buf = malloc(bufsize)) == NULL) {
+ error(errno);
+ return (0);
+ }
+ if (getfsstat(_fs_buf, bufsize, MNT_WAIT) < 0) {
+ error(errno);
+ return (0);
+ }
+ _fs_ptr = _fs_buf;
+ return (1);
}
void
endfsent()
{
- if (_fs_buf) {
- free(_fs_buf);
- _fs_buf = NULL;
- }
- _fs_count = 0;
+ if (_fs_buf) {
+ free(_fs_buf);
+ _fs_buf = NULL;
+ }
+ _fs_count = 0;
}
static
error(err)
- int err;
+ int err;
{
- char *p;
-
- (void)write(STDERR_FILENO, "fstab: ", 7);
- (void)write(STDERR_FILENO, _PATH_FSTAB, sizeof(_PATH_FSTAB) - 1);
- (void)write(STDERR_FILENO, ": ", 1);
- p = strerror(err);
- (void)write(STDERR_FILENO, p, strlen(p));
- (void)write(STDERR_FILENO, "\n", 1);
+ char *p;
+
+ (void)write(STDERR_FILENO, "fstab: ", 7);
+ (void)write(STDERR_FILENO, _PATH_FSTAB, sizeof(_PATH_FSTAB) - 1);
+ (void)write(STDERR_FILENO, ": ", 1);
+ p = strerror(err);
+ (void)write(STDERR_FILENO, p, strlen(p));
+ (void)write(STDERR_FILENO, "\n", 1);
}
#endif /* defined(AFS_DARWIN_ENV) */
DLL_DELETE(fdP, fdLruHead, fdLruTail, fd_next, fd_prev);
ihP->ih_refcnt++;
IH_UNLOCK;
- (void) FDH_SEEK(fdP, 0, SEEK_SET);
+ (void)FDH_SEEK(fdP, 0, SEEK_SET);
return fdP;
}
}
extern void ih_glock_init(void);
#define IH_LOCK \
assert(pthread_once(&ih_glock_once, ih_glock_init) == 0 && \
- pthread_mutex_lock(&ih_glock_mutex) == 0);
+ pthread_mutex_lock(&ih_glock_mutex) == 0)
#define IH_UNLOCK \
- assert(pthread_mutex_unlock(&ih_glock_mutex) == 0);
+ assert(pthread_mutex_unlock(&ih_glock_mutex) == 0)
#else /* AFS_PTHREAD_ENV */
#define IH_LOCK
#define IH_UNLOCK
if (count == 0) {
IHandle_t *th;
IH_INIT(th, ih->ih_dev, ih->ih_vid, ino);
-#if 0
+#if 0
/* This triggers in the fileserver on the volume index vnodes */
- if (th->ih_refcnt > 1)
- Log("Warning: Leaked ref on ihandle dev %d vid %d ino %lld\n",
+ if (th->ih_refcnt > 1)
+ Log("Warning: Leaked ref on ihandle dev %d vid %d ino %lld\n",
th->ih_dev, th->ih_vid, (int64_t) th->ih_ino);
#endif
- namei_HandleToName(&name, th);
- IH_RELEASE(th);
+ namei_HandleToName(&name, th);
+ IH_RELEASE(th);
code = unlink(name.n_path);
}
FDH_CLOSE(fdP);
*lastDevComp = toupper(*lastDevComp);
#else
{
- char *tfile = vol_DevName(tstat.st_dev, wpath);
- if (!tfile) {
- printf("volnuke: can't find %s's device.\n", aname);
- return 1;
- }
- strcpy(devName, tfile); /* save this from the static buffer */
+ char *tfile = vol_DevName(tstat.st_dev, wpath);
+ if (!tfile) {
+ printf("volnuke: can't find %s's device.\n", aname);
+ return 1;
+ }
+ strcpy(devName, tfile); /* save this from the static buffer */
}
/* aim lastDevComp at the 'foo' of '/dev/foo' */
lastDevComp = strrchr(devName, '/');
}
#else /* AFS_NAMEI_ENV */
IH_INIT(fileH, (int)tstat.st_dev, avolid, ti->inode[i]);
- {
- int j;
- for (j = 0; j < ti->count[i]; j++) {
- code = IH_DEC(fileH, ti->inode[i], avolid);
- }
- }
+ {
+ int j;
+ for (j = 0; j < ti->count[i]; j++) {
+ code = IH_DEC(fileH, ti->inode[i], avolid);
+ }
+ }
IH_RELEASE(fileH);
#endif /* AFS_NAMEI_ENV */
}
static void
VInitPartition(char *path, char *devname, Device dev)
{
- VOL_LOCK VInitPartition_r(path, devname, dev);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VInitPartition_r(path, devname, dev);
+ VOL_UNLOCK;
+}
#ifndef AFS_NT40_ENV
/* VAttachPartitions() finds the vice partitions on this server. Calls
VGetPartition(char *name, int abortp)
{
struct DiskPartition *retVal;
- VOL_LOCK retVal = VGetPartition_r(name, abortp);
- VOL_UNLOCK return retVal;
+ VOL_LOCK;
+ retVal = VGetPartition_r(name, abortp);
+ VOL_UNLOCK;
+ return retVal;
}
#ifdef AFS_NT40_ENV
void
VSetPartitionDiskUsage(register struct DiskPartition *dp)
{
- VOL_LOCK VSetPartitionDiskUsage_r(dp);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VSetPartitionDiskUsage_r(dp);
+ VOL_UNLOCK;
+}
void
VResetDiskUsage_r(void)
void
VResetDiskUsage(void)
{
- VOL_LOCK VResetDiskUsage_r();
-VOL_UNLOCK}
+ VOL_LOCK;
+ VResetDiskUsage_r();
+ VOL_UNLOCK;
+}
void
VAdjustDiskUsage_r(Error * ec, Volume * vp, afs_sfsize_t blocks,
VAdjustDiskUsage(Error * ec, Volume * vp, afs_sfsize_t blocks,
afs_sfsize_t checkBlocks)
{
- VOL_LOCK VAdjustDiskUsage_r(ec, vp, blocks, checkBlocks);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VAdjustDiskUsage_r(ec, vp, blocks, checkBlocks);
+ VOL_UNLOCK;
+}
int
VDiskUsage_r(Volume * vp, afs_sfsize_t blocks)
VDiskUsage(Volume * vp, afs_sfsize_t blocks)
{
int retVal;
- VOL_LOCK retVal = VDiskUsage_r(vp, blocks);
- VOL_UNLOCK return retVal;
+ VOL_LOCK;
+ retVal = VDiskUsage_r(vp, blocks);
+ VOL_UNLOCK;
+ return retVal;
}
void
void
VPrintDiskStats(void)
{
- VOL_LOCK VPrintDiskStats_r();
-VOL_UNLOCK}
+ VOL_LOCK;
+ VPrintDiskStats_r();
+ VOL_UNLOCK;
+}
#ifdef AFS_NT40_ENV
/* Need a separate lock file on NT, since NT only has mandatory file locks. */
void
VLockPartition(char *name)
{
- VOL_LOCK VLockPartition_r(name);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VLockPartition_r(name);
+ VOL_UNLOCK;
+}
void
VUnlockPartition(char *name)
{
- VOL_LOCK VUnlockPartition_r(name);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VUnlockPartition_r(name);
+ VOL_UNLOCK;
+}
void
VPurgeVolume(Error * ec, Volume * vp)
{
- VOL_LOCK VPurgeVolume_r(ec, vp);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VPurgeVolume_r(ec, vp);
+ VOL_UNLOCK;
+}
#define MAXOBLITATONCE 200
/* delete a portion of an index, adjusting offset appropriately. Returns 0 if
void
PurgeIndex(Volume * vp, VnodeClass class)
{
- VOL_LOCK PurgeIndex_r(vp, class);
-VOL_UNLOCK}
+ VOL_LOCK;
+ PurgeIndex_r(vp, class);
+ VOL_UNLOCK;
+}
void
PurgeIndex_r(Volume * vp, VnodeClass class)
void
PurgeHeader(Volume * vp)
{
- VOL_LOCK PurgeHeader_r(vp);
-VOL_UNLOCK}
+ VOL_LOCK;
+ PurgeHeader_r(vp);
+ VOL_UNLOCK;
+}
void
PurgeHeader_r(Volume * vp)
VAllocVnode(Error * ec, Volume * vp, VnodeType type)
{
Vnode *retVal;
- VOL_LOCK retVal = VAllocVnode_r(ec, vp, type);
- VOL_UNLOCK return retVal;
+ VOL_LOCK;
+ retVal = VAllocVnode_r(ec, vp, type);
+ VOL_UNLOCK;
+ return retVal;
}
Vnode *
ObtainWriteLock(&vnp->lock);
} else {
/* follow locking hierarchy */
- VOL_UNLOCK ObtainWriteLock(&vnp->lock);
- VOL_LOCK}
+ VOL_UNLOCK;
+ ObtainWriteLock(&vnp->lock);
+ VOL_LOCK;
+ }
#ifdef AFS_PTHREAD_ENV
vnp->writer = pthread_self();
#else /* AFS_PTHREAD_ENV */
FdHandle_t *fdP;
off_t off = vnodeIndexOffset(vcp, vnodeNumber);
- VOL_UNLOCK fdP = IH_OPEN(ihP);
+ VOL_UNLOCK;
+ fdP = IH_OPEN(ihP);
if (fdP == NULL)
Abort("VAllocVnode: can't open index file!\n");
if ((size = FDH_SIZE(fdP)) < 0)
free(buf);
}
FDH_CLOSE(fdP);
- VOL_LOCK}
+ VOL_LOCK;
+ }
VNLog(4, 2, vnodeNumber, (afs_int32) vnp);
}
VGetVnode(Error * ec, Volume * vp, VnodeId vnodeNumber, int locktype)
{ /* READ_LOCK or WRITE_LOCK, as defined in lock.h */
Vnode *retVal;
- VOL_LOCK retVal = VGetVnode_r(ec, vp, vnodeNumber, locktype);
- VOL_UNLOCK return retVal;
+ VOL_LOCK;
+ retVal = VGetVnode_r(ec, vp, vnodeNumber, locktype);
+ VOL_UNLOCK;
+ return retVal;
}
Vnode *
#endif /* AFS_PTHREAD_ENV */
/* Read vnode from volume index */
- VOL_UNLOCK fdP = IH_OPEN(ihP);
+ VOL_UNLOCK;
+ fdP = IH_OPEN(ihP);
if (fdP == NULL) {
Log("VGetVnode: can't open index dev=%u, i=%s\n", vp->device,
PrintInode(NULL, vp->vnodeIndex[class].handle->ih_ino));
/* Don't take volume off line if the inumber is out of range
* or the inode table is full. */
FDH_REALLYCLOSE(fdP);
- VOL_LOCK if (n == BAD_IGET) {
+ VOL_LOCK;
+ if (n == BAD_IGET) {
Log("VGetVnode: bad inumber %s\n",
PrintInode(NULL, vp->vnodeIndex[class].handle->ih_ino));
*ec = VIO;
return NULL;
}
FDH_CLOSE(fdP);
- VOL_LOCK
- /* Quick check to see that the data is reasonable */
- if (vnp->disk.vnodeMagic != vcp->magic || vnp->disk.type == vNull) {
+ VOL_LOCK;
+ /* Quick check to see that the data is reasonable */
+ if (vnp->disk.vnodeMagic != vcp->magic || vnp->disk.type == vNull) {
if (vnp->disk.type == vNull) {
*ec = VNOVNODE;
mlkReason = 6;
vnp->lruNext->lruPrev = vnp->lruPrev;
}
}
- VOL_UNLOCK if (locktype == READ_LOCK)
+ VOL_UNLOCK;
+ if (locktype == READ_LOCK)
ObtainReadLock(&vnp->lock);
else {
ObtainWriteLock(&vnp->lock);
LWP_CurrentProcess(&vnp->writer);
#endif /* AFS_PTHREAD_ENV */
}
- VOL_LOCK
- /* Check that the vnode hasn't been removed while we were obtaining
- * the lock */
- VNLog(102, 2, vnodeNumber, (afs_int32) vnp);
+ VOL_LOCK;
+ /* Check that the vnode hasn't been removed while we were obtaining
+ * the lock */
+ VNLog(102, 2, vnodeNumber, (afs_int32) vnp);
if ((vnp->disk.type == vNull) || (vnp->cacheCheck == 0)) {
if (vnp->nUsers-- == 1)
StickOnLruChain_r(vnp, vcp);
void
VPutVnode(Error * ec, register Vnode * vnp)
{
- VOL_LOCK VPutVnode_r(ec, vnp);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VPutVnode_r(ec, vnp);
+ VOL_UNLOCK;
+}
void
VPutVnode_r(Error * ec, register Vnode * vnp)
} else {
IHandle_t *ihP = vp->vnodeIndex[class].handle;
FdHandle_t *fdP;
- VOL_UNLOCK fdP = IH_OPEN(ihP);
+ VOL_UNLOCK;
+ fdP = IH_OPEN(ihP);
if (fdP == NULL)
Abort("VPutVnode: can't open index file!\n");
offset = vnodeIndexOffset(vcp, vnp->vnodeNumber);
/* Don't force volume offline if the inumber is out of
* range or the inode table is full.
*/
- VOL_LOCK if (code == BAD_IGET) {
+ VOL_LOCK;
+ if (code == BAD_IGET) {
Log("VPutVnode: bad inumber %s\n",
PrintInode(NULL,
vp->vnodeIndex[class].handle->ih_ino));
VForceOffline_r(vp);
*ec = VSALVAGE;
}
- VOL_UNLOCK FDH_REALLYCLOSE(fdP);
+ VOL_UNLOCK;
+ FDH_REALLYCLOSE(fdP);
} else {
FDH_CLOSE(fdP);
}
- VOL_LOCK
- /* If the vnode is to be deleted, and we wrote the vnode out,
- * free its bitmap entry. Do after the vnode is written so we
- * don't allocate from bitmap before the vnode is written
- * (doing so could cause a "addled bitmap" message).
- */
- if (vnp->delete && !*ec) {
+ VOL_LOCK;
+ /* If the vnode is to be deleted, and we wrote the vnode out,
+ * free its bitmap entry. Do after the vnode is written so we
+ * don't allocate from bitmap before the vnode is written
+ * (doing so could cause a "addled bitmap" message).
+ */
+ if (vnp->delete && !*ec) {
VFreeBitMapEntry_r(ec, &vp->vnodeIndex[class],
vnodeIdToBitNumber(vnp->vnodeNumber));
}
VVnodeWriteToRead(Error * ec, register Vnode * vnp)
{
int retVal;
- VOL_LOCK retVal = VVnodeWriteToRead_r(ec, vnp);
- VOL_UNLOCK return retVal;
+ VOL_LOCK;
+ retVal = VVnodeWriteToRead_r(ec, vnp);
+ VOL_UNLOCK;
+ return retVal;
}
int
changed_oldTime) << 1) | vnp->
delete);
if (thisProcess != vnp->writer)
- Abort("VPutVnode: Vnode at 0x%x locked by another process!\n", (int)vnp);
+ Abort("VPutVnode: Vnode at 0x%x locked by another process!\n",
+ (int)vnp);
if (vnp->delete) {
return 0;
}
IHandle_t *ihP = vp->vnodeIndex[class].handle;
FdHandle_t *fdP;
off_t off = vnodeIndexOffset(vcp, vnp->vnodeNumber);
- VOL_UNLOCK fdP = IH_OPEN(ihP);
+ VOL_UNLOCK;
+ fdP = IH_OPEN(ihP);
if (fdP == NULL)
Abort("VPutVnode: can't open index file!\n");
code = FDH_SEEK(fdP, off, SEEK_SET);
* Don't force volume offline if the inumber is out of
* range or the inode table is full.
*/
- VOL_LOCK if (code == BAD_IGET) {
+ VOL_LOCK;
+ if (code == BAD_IGET) {
Log("VPutVnode: bad inumber %s\n",
- PrintInode(NULL, vp->vnodeIndex[class].handle->ih_ino));
+ PrintInode(NULL,
+ vp->vnodeIndex[class].handle->ih_ino));
*ec = VIO;
} else {
Log("VPutVnode: Couldn't write vnode %u, volume %u (%s)\n", vnp->vnodeNumber, V_id(vnp->volumePtr), V_name(vnp->volumePtr));
VForceOffline_r(vp);
*ec = VSALVAGE;
}
- VOL_UNLOCK}
+ VOL_UNLOCK;
+ }
FDH_CLOSE(fdP);
- VOL_LOCK}
+ VOL_LOCK;
+ }
vcp->writes++;
vnp->changed_newTime = vnp->changed_oldTime = 0;
}
if (saveinodes)
printf
("Volume-Id\t Volsize Auxsize Inodesize AVolsize SizeDiff (VolName)\n");
- printf("%u\t%9d%9d%10d%10d%9d\t%24s\n", V_id(vp), Vdiskused, Vauxsize_k,
- Vvnodesize_k, totvolsize, totvolsize - Vdiskused, V_name(vp));
+ printf("%u\t%9d%9d%10d%10d%9d\t%24s\n", V_id(vp), Vdiskused,
+ Vauxsize_k, Vvnodesize_k, totvolsize, totvolsize - Vdiskused,
+ V_name(vp));
}
}
#ifdef FAST_RESTART
{
- afs_int32 i;
- for (i = 0; i < CMD_MAXPARMS; i++) {
- if (as->parms[i].items) {
- seenany = 1;
- break;
+ afs_int32 i;
+ for (i = 0; i < CMD_MAXPARMS; i++) {
+ if (as->parms[i].items) {
+ seenany = 1;
+ break;
+ }
}
}
- }
if (!seenany) {
char *msg =
"Exiting immediately without salvage. Look into the FileLog to find volumes which really need to be salvaged!";
GetVolumeSummary(singleVolumeNumber);
- for (i = 0,vsp = volumeSummaryp; i < nVolumes; i++) {
+ for (i = 0, vsp = volumeSummaryp; i < nVolumes; i++) {
if (vsp->fileName)
DeleteExtraVolumeHeaderFile(vsp);
}
if (dirOrphaned) {
Log("dir vnode %u: %s/%s parent vnode is %u (vnode %u, unique %u) -- %sdeleted\n", dir->vnodeNumber, (dir->name ? dir->name : "??"), name, vnodeEssence->parent, vnodeNumber, unique, (Testing ? "would have been " : ""));
} else if (vnodeNumber == 1) {
- Log("dir vnode %d: %s/%s is invalid (vnode %d, unique %d) -- %sdeleted\n", dir->vnodeNumber, (dir->name ? dir->name : "??"), name, vnodeNumber, unique, (Testing?"would have been ":""));
+ Log("dir vnode %d: %s/%s is invalid (vnode %d, unique %d) -- %sdeleted\n", dir->vnodeNumber, (dir->name ? dir->name : "??"), name, vnodeNumber, unique, (Testing ? "would have been " : ""));
} else {
Log("dir vnode %u: %s/%s already claimed by directory vnode %u (vnode %u, unique %u) -- %sdeleted\n", dir->vnodeNumber, (dir->name ? dir->name : "??"), name, vnodeEssence->parent, vnodeNumber, unique, (Testing ? "would have been " : ""));
}
VConnectFS(void)
{
int retVal;
- VOL_LOCK retVal = VConnectFS_r();
- VOL_UNLOCK return retVal;
+ VOL_LOCK;
+ retVal = VConnectFS_r();
+ VOL_UNLOCK;
+ return retVal;
}
int
void
VDisconnectFS(void)
{
- VOL_LOCK VDisconnectFS_r();
-VOL_UNLOCK}
+ VOL_LOCK;
+ VDisconnectFS_r();
+ VOL_UNLOCK;
+}
void
VShutdown_r(void)
void
VShutdown(void)
{
- VOL_LOCK VShutdown_r();
-VOL_UNLOCK}
+ VOL_LOCK;
+ VShutdown_r();
+ VOL_UNLOCK;
+}
static void
VAttachVolumeByName(Error * ec, char *partition, char *name, int mode)
{
Volume *retVal;
- VATTACH_LOCK VOL_LOCK retVal =
- VAttachVolumeByName_r(ec, partition, name, mode);
- VOL_UNLOCK VATTACH_UNLOCK return retVal;
+ VATTACH_LOCK;
+ VOL_LOCK;
+ retVal = VAttachVolumeByName_r(ec, partition, name, mode);
+ VOL_UNLOCK;
+ VATTACH_UNLOCK;
+ return retVal;
}
Volume *
strcpy(path, VPartitionPath(partp));
strcat(path, "/");
strcat(path, name);
- VOL_UNLOCK if ((fd = afs_open(path, O_RDONLY)) == -1
- || afs_fstat(fd, &status) == -1) {
+ VOL_UNLOCK;
+ if ((fd = afs_open(path, O_RDONLY)) == -1 || afs_fstat(fd, &status) == -1) {
Log("VAttachVolume: Failed to open %s (errno %d)\n", path, errno);
if (fd > -1)
close(fd);
- VOL_LOCK *ec = VNOVOL;
+ VOL_LOCK;
+ *ec = VNOVOL;
goto done;
}
n = read(fd, &diskHeader, sizeof(diskHeader));
close(fd);
- VOL_LOCK if (n != sizeof(diskHeader)
- || diskHeader.stamp.magic != VOLUMEHEADERMAGIC) {
+ VOL_LOCK;
+ if (n != sizeof(diskHeader)
+ || diskHeader.stamp.magic != VOLUMEHEADERMAGIC) {
Log("VAttachVolume: Error reading volume header %s\n", path);
*ec = VSALVAGE;
goto done;
{
register Volume *vp;
- VOL_UNLOCK vp = (Volume *) calloc(1, sizeof(Volume));
+ VOL_UNLOCK;
+ vp = (Volume *) calloc(1, sizeof(Volume));
assert(vp != NULL);
vp->specialStatus = (byte) (isbusy ? VBUSY : 0);
vp->device = partp->device;
vp->shuttingDown = 0;
vp->goingOffline = 0;
vp->nUsers = 1;
- VOL_LOCK GetVolumeHeader(vp);
- VOL_UNLOCK(void) ReadHeader(ec, V_diskDataHandle(vp), (char *)&V_disk(vp),
- sizeof(V_disk(vp)), VOLUMEINFOMAGIC,
- VOLUMEINFOVERSION);
- VOL_LOCK if (*ec) {
+ VOL_LOCK;
+ GetVolumeHeader(vp);
+ VOL_UNLOCK;
+ (void)ReadHeader(ec, V_diskDataHandle(vp), (char *)&V_disk(vp),
+ sizeof(V_disk(vp)), VOLUMEINFOMAGIC, VOLUMEINFOVERSION);
+ VOL_LOCK;
+ if (*ec) {
Log("VAttachVolume: Error reading diskDataHandle vol header %s; error=%u\n", path, *ec);
}
if (!*ec) {
V_stat_initialized(vp) = 1;
}
#endif /* OPENAFS_VOL_STATS */
- VOL_UNLOCK(void) ReadHeader(ec, vp->vnodeIndex[vSmall].handle,
- (char *)&iHead, sizeof(iHead),
- SMALLINDEXMAGIC, SMALLINDEXVERSION);
- VOL_LOCK if (*ec) {
+ VOL_UNLOCK;
+ (void)ReadHeader(ec, vp->vnodeIndex[vSmall].handle,
+ (char *)&iHead, sizeof(iHead),
+ SMALLINDEXMAGIC, SMALLINDEXVERSION);
+ VOL_LOCK;
+ if (*ec) {
Log("VAttachVolume: Error reading smallVnode vol header %s; error=%u\n", path, *ec);
}
}
if (!*ec) {
struct IndexFileHeader iHead;
- VOL_UNLOCK(void) ReadHeader(ec, vp->vnodeIndex[vLarge].handle,
- (char *)&iHead, sizeof(iHead),
- LARGEINDEXMAGIC, LARGEINDEXVERSION);
- VOL_LOCK if (*ec) {
+ VOL_UNLOCK;
+ (void)ReadHeader(ec, vp->vnodeIndex[vLarge].handle,
+ (char *)&iHead, sizeof(iHead),
+ LARGEINDEXMAGIC, LARGEINDEXVERSION);
+ VOL_LOCK;
+ if (*ec) {
Log("VAttachVolume: Error reading largeVnode vol header %s; error=%u\n", path, *ec);
}
}
#ifdef AFS_NAMEI_ENV
if (!*ec) {
struct versionStamp stamp;
- VOL_UNLOCK(void) ReadHeader(ec, V_linkHandle(vp), (char *)&stamp,
- sizeof(stamp), LINKTABLEMAGIC,
- LINKTABLEVERSION);
- VOL_LOCK if (*ec) {
+ VOL_UNLOCK;
+ (void)ReadHeader(ec, V_linkHandle(vp), (char *)&stamp,
+ sizeof(stamp), LINKTABLEMAGIC, LINKTABLEVERSION);
+ VOL_LOCK;
+ if (*ec) {
Log("VAttachVolume: Error reading namei vol header %s; error=%u\n", path, *ec);
}
}
if (programType == fileServer && VolumeWriteable(vp)) {
int i;
for (i = 0; i < nVNODECLASSES; i++) {
- VOL_UNLOCK GetBitmap(ec, vp, i);
- VOL_LOCK if (*ec) {
+ VOL_UNLOCK;
+ GetBitmap(ec, vp, i);
+ VOL_LOCK;
+ if (*ec) {
FreeVolume(vp);
Log("VAttachVolume: error getting bitmap for volume (%s)\n",
path);
VAttachVolume(Error * ec, VolumeId volumeId, int mode)
{
Volume *retVal;
- VATTACH_LOCK VOL_LOCK retVal = VAttachVolume_r(ec, volumeId, mode);
- VOL_UNLOCK VATTACH_UNLOCK return retVal;
+ VATTACH_LOCK;
+ VOL_LOCK;
+ retVal = VAttachVolume_r(ec, volumeId, mode);
+ VOL_UNLOCK;
+ VATTACH_UNLOCK;
+ return retVal;
}
Volume *
VHold(register Volume * vp)
{
int retVal;
- VOL_LOCK retVal = VHold_r(vp);
- VOL_UNLOCK return retVal;
+ VOL_LOCK;
+ retVal = VHold_r(vp);
+ VOL_UNLOCK;
+ return retVal;
}
void
void
VTakeOffline(register Volume * vp)
{
- VOL_LOCK VTakeOffline_r(vp);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VTakeOffline_r(vp);
+ VOL_UNLOCK;
+}
void
VPutVolume_r(register Volume * vp)
void
VPutVolume(register Volume * vp)
{
- VOL_LOCK VPutVolume_r(vp);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VPutVolume_r(vp);
+ VOL_UNLOCK;
+}
/* Get a pointer to an attached volume. The pointer is returned regardless
of whether or not the volume is in service or on/off line. An error
VGetVolume(Error * ec, VolId volumeId)
{
Volume *retVal;
- VOL_LOCK retVal = VGetVolume_r(ec, volumeId);
- VOL_UNLOCK return retVal;
+ VOL_LOCK;
+ retVal = VGetVolume_r(ec, volumeId);
+ VOL_UNLOCK;
+ return retVal;
}
Volume *
void
VForceOffline(Volume * vp)
{
- VOL_LOCK VForceOffline_r(vp);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VForceOffline_r(vp);
+ VOL_UNLOCK;
+}
/* The opposite of VAttachVolume. The volume header is written to disk, with
the inUse bit turned off. A copy of the header is maintained in memory,
void
VOffline(Volume * vp, char *message)
{
- VOL_LOCK VOffline_r(vp, message);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VOffline_r(vp, message);
+ VOL_UNLOCK;
+}
/* For VDetachVolume, we close all cached file descriptors, but keep
* the Inode handles in case we need to read from a busy volume.
void
VDetachVolume(Error * ec, Volume * vp)
{
- VOL_LOCK VDetachVolume_r(ec, vp);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VDetachVolume_r(ec, vp);
+ VOL_UNLOCK;
+}
VnodeId
* from AddNewReadableResidency */
wasVBUSY = 1;
} else {
- VOL_UNLOCK while (vp->specialStatus == VBUSY)
+ VOL_UNLOCK;
+ while (vp->specialStatus == VBUSY)
#ifdef AFS_PTHREAD_ENV
sleep(2);
#else /* AFS_PTHREAD_ENV */
IOMGR_Sleep(2);
#endif /* AFS_PTHREAD_ENV */
- VOL_LOCK}
+ VOL_LOCK;
+ }
}
if (!index->bitmap) {
vp->specialStatus = VBUSY; /* Stop anyone else from using it. */
for (i = 0; i < nVNODECLASSES; i++) {
- VOL_UNLOCK GetBitmap(ec, vp, i);
- VOL_LOCK if (*ec) {
+ VOL_UNLOCK;
+ GetBitmap(ec, vp, i);
+ VOL_LOCK;
+ if (*ec) {
vp->specialStatus = 0;
vp->shuttingDown = 1; /* Let who has it free it. */
return NULL;
VAllocBitmapEntry(Error * ec, Volume * vp, register struct vnodeIndex * index)
{
VnodeId retVal;
- VOL_LOCK retVal = VAllocBitmapEntry_r(ec, vp, index);
- VOL_UNLOCK return retVal;
+ VOL_LOCK;
+ retVal = VAllocBitmapEntry_r(ec, vp, index);
+ VOL_UNLOCK;
+ return retVal;
}
void
VFreeBitMapEntry(Error * ec, register struct vnodeIndex *index,
unsigned bitNumber)
{
- VOL_LOCK VFreeBitMapEntry_r(ec, index, bitNumber);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VFreeBitMapEntry_r(ec, index, bitNumber);
+ VOL_UNLOCK;
+}
void
VUpdateVolume_r(Error * ec, Volume * vp)
void
VUpdateVolume(Error * ec, Volume * vp)
{
- VOL_LOCK VUpdateVolume_r(ec, vp);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VUpdateVolume_r(ec, vp);
+ VOL_UNLOCK;
+}
void
VSyncVolume_r(Error * ec, Volume * vp)
void
VSyncVolume(Error * ec, Volume * vp)
{
- VOL_LOCK VSyncVolume_r(ec, vp);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VSyncVolume_r(ec, vp);
+ VOL_UNLOCK;
+}
static void
FreeVolume(Volume * vp)
VAdjustVolumeStatistics(register Volume * vp)
{
int retVal;
- VOL_LOCK retVal = VAdjustVolumeStatistics_r(vp);
- VOL_UNLOCK return retVal;
+ VOL_LOCK;
+ retVal = VAdjustVolumeStatistics_r(vp);
+ VOL_UNLOCK;
+ return retVal;
}
void
void
VBumpVolumeUsage(register Volume * vp)
{
- VOL_LOCK VBumpVolumeUsage_r(vp);
-VOL_UNLOCK}
+ VOL_LOCK;
+ VBumpVolumeUsage_r(vp);
+ VOL_UNLOCK;
+}
void
VSetDiskUsage_r(void)
void
VSetDiskUsage(void)
{
- VOL_LOCK VSetDiskUsage_r();
-VOL_UNLOCK}
+ VOL_LOCK;
+ VSetDiskUsage_r();
+ VOL_UNLOCK;
+}
/* The number of minutes that a volume hasn't been updated before the
* "Dont salvage" flag in the volume header will be turned on */
void
VPrintCacheStats(void)
{
- VOL_LOCK VPrintCacheStats_r();
-VOL_UNLOCK}
+ VOL_LOCK;
+ VPrintCacheStats_r();
+ VOL_UNLOCK;
+}
extern pthread_cond_t vol_put_volume_cond;
extern pthread_cond_t vol_sleep_cond;
#define VATTACH_LOCK \
- assert(pthread_mutex_lock(&vol_attach_mutex) == 0);
+ assert(pthread_mutex_lock(&vol_attach_mutex) == 0)
#define VATTACH_UNLOCK \
- assert(pthread_mutex_unlock(&vol_attach_mutex) == 0);
+ assert(pthread_mutex_unlock(&vol_attach_mutex) == 0)
#define VOL_LOCK \
- assert(pthread_mutex_lock(&vol_glock_mutex) == 0);
+ assert(pthread_mutex_lock(&vol_glock_mutex) == 0)
#define VOL_UNLOCK \
- assert(pthread_mutex_unlock(&vol_glock_mutex) == 0);
+ assert(pthread_mutex_unlock(&vol_glock_mutex) == 0)
#define VFSYNC_LOCK \
- assert(pthread_mutex_lock(&vol_fsync_mutex) == 0);
+ assert(pthread_mutex_lock(&vol_fsync_mutex) == 0)
#define VFSYNC_UNLOCK \
- assert(pthread_mutex_unlock(&vol_fsync_mutex) == 0);
+ assert(pthread_mutex_unlock(&vol_fsync_mutex) == 0)
#define VTRANS_LOCK \
- assert(pthread_mutex_lock(&vol_trans_mutex) == 0);
+ assert(pthread_mutex_lock(&vol_trans_mutex) == 0)
#define VTRANS_UNLOCK \
- assert(pthread_mutex_unlock(&vol_trans_mutex) == 0);
+ assert(pthread_mutex_unlock(&vol_trans_mutex) == 0)
#else /* AFS_PTHREAD_ENV */
#define VATTACH_LOCK
#define VATTACH_UNLOCK
{ /* Should be the same as volumeId if there is
* no parent */
Volume *retVal;
- VOL_LOCK retVal = VCreateVolume_r(ec, partname, volumeId, parentId);
- VOL_UNLOCK return retVal;
+ VOL_LOCK;
+ retVal = VCreateVolume_r(ec, partname, volumeId, parentId);
+ VOL_UNLOCK;
+ return retVal;
}
Volume *
void
AssignVolumeName(register VolumeDiskData * vol, char *name, char *ext)
{
- VOL_LOCK AssignVolumeName_r(vol, name, ext);
-VOL_UNLOCK}
+ VOL_LOCK;
+ AssignVolumeName_r(vol, name, ext);
+ VOL_UNLOCK;
+}
void
AssignVolumeName_r(register VolumeDiskData * vol, char *name, char *ext)
{
afs_int32 code;
- VOL_LOCK code = CopyVolumeHeader_r(from, to);
- VOL_UNLOCK return (code);
+ VOL_LOCK;
+ code = CopyVolumeHeader_r(from, to);
+ VOL_UNLOCK;
+ return (code);
}
void
ClearVolumeStats(register VolumeDiskData * vol)
{
- VOL_LOCK ClearVolumeStats_r(vol);
-VOL_UNLOCK}
+ VOL_LOCK;
+ ClearVolumeStats_r(vol);
+ VOL_UNLOCK;
+}
void
ClearVolumeStats_r(register VolumeDiskData * vol)
git://git.openafs.org / openafs.git / commitdiff