/*
* 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 <roken.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <errno.h>
-#ifdef AFS_NT40_ENV
-#include <time.h>
-#include <fcntl.h>
-#else
-#include <sys/time.h>
+#ifdef HAVE_SYS_FILE_H
#include <sys/file.h>
-#include <unistd.h>
#endif
-#include <dirent.h>
-#include <sys/stat.h>
-#ifdef AFS_PTHREAD_ENV
-#include <assert.h>
-#else /* AFS_PTHREAD_ENV */
-#include <afs/assert.h>
-#endif /* AFS_PTHREAD_ENV */
+
+#ifdef HAVE_SYS_LOCKF_H
+#include <sys/lockf.h>
+#endif
#include <rx/xdr.h>
#include <afs/afsint.h>
#include <afs/afsutil.h>
#ifdef AFS_NT40_ENV
#include "ntops.h"
-#include <io.h>
#endif
#include "vnode.h"
#include "volume.h"
+#include "volume_inline.h"
#include "partition.h"
#include "viceinode.h"
#include "volinodes.h"
#include "vol_prototypes.h"
-
-#ifdef AFS_AIX_ENV
-#include <sys/lockf.h>
-#endif
-#if defined(AFS_SUN5_ENV) || defined(AFS_NT40_ENV) || defined(AFS_LINUX20_ENV)
-#include <string.h>
-#else
-#include <strings.h>
+#include "common.h"
+
+#ifndef AFS_NT40_ENV
+# ifdef O_LARGEFILE
+# define AFS_SETLKW F_SETLKW64
+# define AFS_SETLK F_SETLK64
+# define afs_st_flock flock64
+# else
+# define AFS_SETLKW F_SETLKW
+# define AFS_SETLK F_SETLK
+# define afs_st_flock flock
+# endif
#endif
-#ifdef O_LARGEFILE
-#define afs_open open64
-#else /* !O_LARGEFILE */
-#define afs_open open
-#endif /* !O_LARGEFILE */
-
-/*@printflike@*/ extern void Log(const char *format, ...);
-
-#define nFILES (sizeof (stuff)/sizeof(struct stuff))
-
/* Note: the volume creation functions herein leave the destroyMe flag in the
volume header ON: this means that the volumes will not be attached by the
file server and WILL BE DESTROYED the next time a system salvage is performed */
#ifdef FSSYNC_BUILD_CLIENT
static void
-RemoveInodes(Device dev, VolumeId vid)
+RemoveInodes(struct afs_inode_info *stuff, Device dev, VolumeId parent,
+ VolumeId vid)
{
- register int i;
+ int i;
IHandle_t *handle;
/* This relies on the fact that IDEC only needs the device and NT only
* needs the dev and vid to decrement volume special files.
*/
- IH_INIT(handle, dev, vid, -1);
- for (i = 0; i < nFILES; i++) {
+ IH_INIT(handle, dev, parent, -1);
+ for (i = 0; i < MAXINODETYPE; i++) {
Inode inode = *stuff[i].inode;
- if (VALID_INO(inode))
- IH_DEC(handle, inode, vid);
+ if (VALID_INO(inode)) {
+ if (stuff[i].inodeType == VI_LINKTABLE) {
+ IH_DEC(handle, inode, parent);
+ } else {
+ IH_DEC(handle, inode, vid);
+ }
+ }
}
IH_RELEASE(handle);
}
struct VolumeDiskHeader diskHeader;
IHandle_t *handle;
FdHandle_t *fdP;
- Inode nearInode = 0;
+ Inode nearInode AFS_UNUSED = 0;
char *part, *name;
struct stat st;
+ struct VolumeHeader tempHeader;
+ struct afs_inode_info stuff[MAXINODETYPE];
+ afs_ino_str_t stmp;
+# ifdef AFS_DEMAND_ATTACH_FS
+ int locktype = 0;
+# endif /* AFS_DEMAND_ATTACH_FS */
+
+ init_inode_info(&tempHeader, stuff);
*ec = 0;
memset(&vol, 0, sizeof(vol));
}
}
*ec = 0;
+
+# ifdef AFS_DEMAND_ATTACH_FS
+ /* volume doesn't exist yet, but we must lock it to try to prevent something
+ * else from reading it when we're e.g. half way through creating it (or
+ * something tries to create the same volume at the same time) */
+ locktype = VVolLockType(V_VOLUPD, 1);
+ rc = VLockVolumeByIdNB(volumeId, partition, locktype);
+ if (rc) {
+ Log("VCreateVolume: vol %lu already locked by someone else\n",
+ afs_printable_uint32_lu(volumeId));
+ *ec = VNOVOL;
+ return NULL;
+ }
+# else /* AFS_DEMAND_ATTACH_FS */
VLockPartition_r(partname);
+# endif /* !AFS_DEMAND_ATTACH_FS */
+
memset(&tempHeader, 0, sizeof(tempHeader));
tempHeader.stamp.magic = VOLUMEHEADERMAGIC;
tempHeader.stamp.version = VOLUMEHEADERVERSION;
vol.stamp.magic = VOLUMEINFOMAGIC;
vol.stamp.version = VOLUMEINFOVERSION;
vol.destroyMe = DESTROY_ME;
- (void)afs_snprintf(headerName, sizeof headerName, VFORMAT, afs_printable_uint32_lu(vol.id));
- (void)afs_snprintf(volumePath, sizeof volumePath, "%s/%s",
- VPartitionPath(partition), headerName);
+ snprintf(headerName, sizeof headerName, VFORMAT,
+ afs_printable_uint32_lu(vol.id));
+ snprintf(volumePath, sizeof volumePath, "%s" OS_DIRSEP "%s",
+ VPartitionPath(partition), headerName);
rc = stat(volumePath, &st);
if (rc == 0 || errno != ENOENT) {
if (rc == 0) {
errno, volumePath);
*ec = VNOVOL;
}
- return NULL;
+ goto bad_noheader;
}
device = partition->device;
- for (i = 0; i < nFILES; i++) {
- register struct stuff *p = &stuff[i];
+ for (i = 0; i < MAXINODETYPE; i++) {
+ struct afs_inode_info *p = &stuff[i];
if (p->obsolete)
continue;
#ifdef AFS_NAMEI_ENV
(p->inodeType == VI_LINKTABLE) ? vol.parentId : vol.id,
INODESPECIAL, p->inodeType, vol.parentId);
if (!(VALID_INO(*(p->inode)))) {
- if (errno == EEXIST) {
+ if (errno == EEXIST && (p->inodeType == VI_LINKTABLE)) {
/* Increment the reference count instead. */
IHandle_t *lh;
int code;
-#ifdef AFS_NT40_ENV
- *(p->inode) = nt_MakeSpecIno(VI_LINKTABLE);
-#else
*(p->inode) = namei_MakeSpecIno(vol.parentId, VI_LINKTABLE);
-#endif
IH_INIT(lh, device, parentId, *(p->inode));
fdP = IH_OPEN(lh);
if (fdP == NULL) {
bad:
if (handle)
IH_RELEASE(handle);
- RemoveInodes(device, vol.id);
+ RemoveInodes(stuff, device, vol.parentId, vol.id);
if (!*ec) {
*ec = VNOVOL;
}
VDestroyVolumeDiskHeader(partition, volumeId, parentId);
+ bad_noheader:
+# ifdef AFS_DEMAND_ATTACH_FS
+ if (locktype) {
+ VUnlockVolumeById(volumeId, partition);
+ }
+# endif /* AFS_DEMAND_ATTACH_FS */
return NULL;
}
IH_INIT(handle, device, vol.parentId, *(p->inode));
fdP = IH_OPEN(handle);
if (fdP == NULL) {
Log("VCreateVolume: Problem iopen inode %s (err=%d)\n",
- PrintInode(NULL, *(p->inode)), errno);
+ PrintInode(stmp, *(p->inode)), errno);
goto bad;
}
- if (FDH_SEEK(fdP, 0, SEEK_SET) < 0) {
- Log("VCreateVolume: Problem lseek inode %s (err=%d)\n",
- PrintInode(NULL, *(p->inode)), errno);
- FDH_REALLYCLOSE(fdP);
- goto bad;
- }
- if (FDH_WRITE(fdP, (char *)&p->stamp, sizeof(p->stamp)) !=
+ if (FDH_PWRITE(fdP, (char *)&p->stamp, sizeof(p->stamp), 0) !=
sizeof(p->stamp)) {
- Log("VCreateVolume: Problem writing to inode %s (err=%d)\n",
- PrintInode(NULL, *(p->inode)), errno);
+ Log("VCreateVolume: Problem writing to inode %s (err=%d)\n",
+ PrintInode(stmp, *(p->inode)), errno);
FDH_REALLYCLOSE(fdP);
goto bad;
}
fdP = IH_OPEN(handle);
if (fdP == NULL) {
Log("VCreateVolume: Problem iopen inode %s (err=%d)\n",
- PrintInode(NULL, tempHeader.volumeInfo), errno);
+ PrintInode(stmp, tempHeader.volumeInfo), errno);
goto bad;
}
- if (FDH_SEEK(fdP, 0, SEEK_SET) < 0) {
- Log("VCreateVolume: Problem lseek inode %s (err=%d)\n",
- PrintInode(NULL, tempHeader.volumeInfo), errno);
- FDH_REALLYCLOSE(fdP);
- goto bad;
- }
- if (FDH_WRITE(fdP, (char *)&vol, sizeof(vol)) != sizeof(vol)) {
+ if (FDH_PWRITE(fdP, (char *)&vol, sizeof(vol), 0) != sizeof(vol)) {
Log("VCreateVolume: Problem writing to inode %s (err=%d)\n",
- PrintInode(NULL, tempHeader.volumeInfo), errno);
+ PrintInode(stmp, tempHeader.volumeInfo), errno);
FDH_REALLYCLOSE(fdP);
goto bad;
}
goto bad;
}
+# ifdef AFS_DEMAND_ATTACH_FS
+ if (locktype) {
+ VUnlockVolumeById(volumeId, partition);
+ }
+# endif /* AFS_DEMAND_ATTACH_FS */
return (VAttachVolumeByName_r(ec, partname, headerName, V_SECRETLY));
}
#endif /* FSSYNC_BUILD_CLIENT */
void
-AssignVolumeName(register VolumeDiskData * vol, char *name, char *ext)
+AssignVolumeName(VolumeDiskData * vol, char *name, char *ext)
{
VOL_LOCK;
AssignVolumeName_r(vol, name, ext);
}
void
-AssignVolumeName_r(register VolumeDiskData * vol, char *name, char *ext)
+AssignVolumeName_r(VolumeDiskData * vol, char *name, char *ext)
{
- register char *dot;
+ char *dot;
strncpy(vol->name, name, VNAMESIZE - 1);
vol->name[VNAMESIZE - 1] = '\0';
dot = strrchr(vol->name, '.');
}
void
-ClearVolumeStats(register VolumeDiskData * vol)
+ClearVolumeStats(VolumeDiskData * vol)
{
VOL_LOCK;
ClearVolumeStats_r(vol);
}
void
-ClearVolumeStats_r(register VolumeDiskData * vol)
+ClearVolumeStats_r(VolumeDiskData * vol)
{
memset(vol->weekUse, 0, sizeof(vol->weekUse));
vol->dayUse = 0;
*
* @param[in] volid volume id
* @param[in] dp disk partition object
- * @param[out] hdr volume disk header
+ * @param[out] hdr volume disk header or NULL
+ *
+ * @note if hdr is NULL, this is essentially an existence test for the vol
+ * header
*
* @return operation status
* @retval 0 success
int fd;
char path[MAXPATHLEN];
- (void)afs_snprintf(path, sizeof(path),
- "%s/" VFORMAT,
- VPartitionPath(dp), afs_printable_uint32_lu(volid));
+ snprintf(path, sizeof(path), "%s" OS_DIRSEP VFORMAT,
+ VPartitionPath(dp), afs_printable_uint32_lu(volid));
fd = open(path, O_RDONLY);
if (fd < 0) {
- Log("VReadVolumeDiskHeader: Couldn't open header for volume %lu.\n",
- afs_printable_uint32_lu(volid));
+ Log("VReadVolumeDiskHeader: Couldn't open header for volume %lu (errno %d).\n",
+ afs_printable_uint32_lu(volid), errno);
code = -1;
- } else if (read(fd, hdr, sizeof(*hdr)) != sizeof(*hdr)) {
+
+ } else if (hdr && read(fd, hdr, sizeof(*hdr)) != sizeof(*hdr)) {
Log("VReadVolumeDiskHeader: Couldn't read header for volume %lu.\n",
afs_printable_uint32_lu(volid));
code = EIO;
flags |= O_RDWR;
- (void)afs_snprintf(path, sizeof(path),
- "%s/" VFORMAT,
- VPartitionPath(dp), afs_printable_uint32_lu(hdr->id));
+ snprintf(path, sizeof(path), "%s" OS_DIRSEP VFORMAT,
+ VPartitionPath(dp), afs_printable_uint32_lu(hdr->id));
fd = open(path, flags, 0644);
if (fd < 0) {
code = errno;
SYNC_response res;
#endif /* AFS_DEMAND_ATTACH_FS */
- (void)afs_snprintf(path, sizeof(path),
- "%s/" VFORMAT,
- VPartitionPath(dp), afs_printable_uint32_lu(volid));
+ snprintf(path, sizeof(path), "%s" OS_DIRSEP VFORMAT,
+ VPartitionPath(dp), afs_printable_uint32_lu(volid));
code = unlink(path);
if (code) {
Log("VDestroyVolumeDiskHeader: Couldn't unlink disk header, error = %d\n", errno);
int locked, void *rock)
{
int error = 0;
- int fd;
+ FD_t fd;
- if ((fd = afs_open(name, O_RDONLY)) == -1
- || read(fd, hdr, sizeof(*hdr))
+ if ((fd = OS_OPEN(name, O_RDONLY, 0)) == INVALID_FD
+ || OS_READ(fd, hdr, sizeof(*hdr))
!= sizeof(*hdr)
|| hdr->stamp.magic != VOLUMEHEADERMAGIC) {
error = 1;
}
- if (fd >= 0) {
- close(fd);
+ if (fd != INVALID_FD) {
+ OS_CLOSE(fd);
}
#ifdef AFSFS_DEMAND_ATTACH_FS
if (p != NULL && strcmp(p, VHDREXT) == 0) {
char name[VMAXPATHLEN];
- sprintf(name, "%s/%s", partpath, dentry->d_name);
+ sprintf(name, "%s" OS_DIRSEP "%s", partpath, dentry->d_name);
code = _VHandleVolumeHeader(dp, volfunc, name, &diskHeader, -1, rock);
if (code < 0) {
return code;
}
-#ifdef AFS_PTHREAD_ENV
-# define AFS_LF_LOCK(lf) assert(pthread_mutex_lock(&((lf)->mutex)) == 0)
-# define AFS_LF_UNLOCK(lf) assert(pthread_mutex_unlock(&((lf)->mutex)) == 0)
-#else
-# define AFS_LF_LOCK(lf)
-# define AFS_LF_UNLOCK(lf)
-#endif /* AFS_PTHREAD_ENV */
-
/**
* initialize a struct VLockFile.
*
memset(lf, 0, sizeof(*lf));
lf->path = strdup(path);
lf->fd = INVALID_FD;
-#ifdef AFS_PTHREAD_ENV
- assert(pthread_mutex_init(&lf->mutex, NULL) == 0);
-#endif /* AFS_PTHREAD_ENV */
+ MUTEX_INIT(&lf->mutex, "vlockfile", MUTEX_DEFAULT, 0);
}
#ifdef AFS_NT40_ENV
}
static_inline void
-_VUnlockFd(struct VLockFile *lf, afs_uint32 offset)
+_VUnlockFd(FD_t handle, afs_uint32 offset)
{
OVERLAPPED lap;
memset(&lap, 0, sizeof(lap));
lap.Offset = offset;
- UnlockFileEx(lf->fd, 0, 1, 0, &lap);
+ UnlockFileEx(handle, 0, 1, 0, &lap);
}
static_inline void
-_VCloseFd(struct VLockFile *lf)
+_VCloseFd(FD_t handle)
{
- CloseHandle(lf->fd);
+ CloseHandle(handle);
}
#else /* !AFS_NT40_ENV */
* @return file descriptor
* @retval INVALID_FD failure opening file
*/
-static_inline int
+static_inline FD_t
_VOpenPath(const char *path)
{
int fd;
* @retval EIO error acquiring file lock
*/
static_inline int
-_VLockFd(int fd, afs_uint32 offset, int locktype, int nonblock)
+_VLockFd(FD_t fd, afs_uint32 offset, int locktype, int nonblock)
{
int l_type = F_WRLCK;
- int cmd = F_SETLKW;
- struct flock sf;
+ int cmd = AFS_SETLKW;
+ struct afs_st_flock sf;
if (locktype == READ_LOCK) {
l_type = F_RDLCK;
}
if (nonblock) {
- cmd = F_SETLK;
+ cmd = AFS_SETLK;
}
sf.l_start = offset;
if (fcntl(fd, cmd, &sf)) {
if (nonblock && (errno == EACCES || errno == EAGAIN)) {
/* We asked for a nonblocking lock, and it was already locked */
+ sf.l_pid = 0;
+ if (fcntl(fd, F_GETLK, &sf) != 0 || sf.l_pid == 0) {
+ Log("_VLockFd: fcntl failed with error %d when trying to "
+ "query the conflicting lock for fd %d (locktype=%d, "
+ "offset=%lu)\n", errno, fd, locktype,
+ afs_printable_uint32_lu(offset));
+ } else {
+ Log("_VLockFd: conflicting lock held on fd %d, offset %lu by "
+ "pid %ld (locktype=%d)\n", fd,
+ afs_printable_uint32_lu(offset), (long int)sf.l_pid,
+ locktype);
+ }
return EBUSY;
}
Log("_VLockFd: fcntl failed with error %d when trying to lock "
- "fd %d (locktype=%d)\n", errno, fd, locktype);
+ "fd %d (locktype=%d, offset=%lu)\n", errno, fd, locktype,
+ afs_printable_uint32_lu(offset));
return EIO;
}
* @param[in] fd file descriptor to close
*/
static_inline void
-_VCloseFd(int fd)
+_VCloseFd(FD_t fd)
{
if (close(fd)) {
Log("_VCloseFd: error %d closing fd %d\n",
* @param[in] offset offset to unlock
*/
static_inline void
-_VUnlockFd(int fd, afs_uint32 offset)
+_VUnlockFd(FD_t fd, afs_uint32 offset)
{
- struct flock sf;
+ struct afs_st_flock sf;
sf.l_start = offset;
sf.l_len = 1;
sf.l_type = F_UNLCK;
sf.l_whence = SEEK_SET;
- if (fcntl(fd, F_SETLK, &sf)) {
+ if (fcntl(fd, AFS_SETLK, &sf)) {
Log("_VUnlockFd: fcntl failed with error %d when trying to unlock "
"fd %d\n", errno, fd);
}
void
VLockFileReinit(struct VLockFile *lf)
{
-#ifdef AFS_PTHREAD_ENV
- assert(pthread_mutex_lock(&lf->mutex) == 0);
-#endif /* AFS_PTHREAD_ENV */
+ MUTEX_ENTER(&lf->mutex);
if (lf->fd != INVALID_FD) {
_VCloseFd(lf->fd);
lf->refcount = 0;
-#ifdef AFS_PTHREAD_ENV
- assert(pthread_mutex_unlock(&lf->mutex) == 0);
-#endif /* AFS_PTHREAD_ENV */
+ MUTEX_EXIT(&lf->mutex);
}
/**
{
int code;
- assert(locktype == READ_LOCK || locktype == WRITE_LOCK);
+ osi_Assert(locktype == READ_LOCK || locktype == WRITE_LOCK);
- AFS_LF_LOCK(lf);
+ MUTEX_ENTER(&lf->mutex);
if (lf->fd == INVALID_FD) {
lf->fd = _VOpenPath(lf->path);
if (lf->fd == INVALID_FD) {
- AFS_LF_UNLOCK(lf);
+ MUTEX_EXIT(&lf->mutex);
return EIO;
}
}
lf->refcount++;
- AFS_LF_UNLOCK(lf);
+ MUTEX_EXIT(&lf->mutex);
code = _VLockFd(lf->fd, offset, locktype, nonblock);
if (code) {
- AFS_LF_LOCK(lf);
+ MUTEX_ENTER(&lf->mutex);
if (--lf->refcount < 1) {
_VCloseFd(lf->fd);
lf->fd = INVALID_FD;
}
- AFS_LF_UNLOCK(lf);
+ MUTEX_EXIT(&lf->mutex);
}
return code;
void
VLockFileUnlock(struct VLockFile *lf, afs_uint32 offset)
{
- AFS_LF_LOCK(lf);
+ MUTEX_ENTER(&lf->mutex);
- assert(lf->fd != INVALID_FD);
+ osi_Assert(lf->fd != INVALID_FD);
if (--lf->refcount < 1) {
_VCloseFd(lf->fd);
_VUnlockFd(lf->fd, offset);
}
- AFS_LF_UNLOCK(lf);
+ MUTEX_EXIT(&lf->mutex);
}
#ifdef AFS_DEMAND_ATTACH_FS
void
VDiskLockInit(struct VDiskLock *dl, struct VLockFile *lf, afs_uint32 offset)
{
- assert(lf);
+ osi_Assert(lf);
memset(dl, 0, sizeof(*dl));
Lock_Init(&dl->rwlock);
- assert(pthread_mutex_init(&dl->mutex, NULL) == 0);
- assert(pthread_cond_init(&dl->cv, NULL) == 0);
+ MUTEX_INIT(&dl->mutex, "disklock", MUTEX_DEFAULT, 0);
+ CV_INIT(&dl->cv, "disklock cv", CV_DEFAULT, 0);
dl->lockfile = lf;
dl->offset = offset;
}
VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock)
{
int code = 0;
- assert(locktype == READ_LOCK || locktype == WRITE_LOCK);
+ osi_Assert(locktype == READ_LOCK || locktype == WRITE_LOCK);
if (nonblock) {
if (locktype == READ_LOCK) {
ObtainWriteLock(&dl->rwlock);
}
- assert(pthread_mutex_lock(&dl->mutex) == 0);
+ MUTEX_ENTER(&dl->mutex);
if ((dl->flags & VDISKLOCK_ACQUIRING)) {
/* Some other thread is waiting to acquire an fs lock. If nonblock=1,
code = EBUSY;
} else {
while ((dl->flags & VDISKLOCK_ACQUIRING)) {
- assert(pthread_cond_wait(&dl->cv, &dl->mutex) == 0);
+ CV_WAIT(&dl->cv, &dl->mutex);
}
}
}
/* mark that we are waiting on the fs lock */
dl->flags |= VDISKLOCK_ACQUIRING;
- assert(pthread_mutex_unlock(&dl->mutex) == 0);
+ MUTEX_EXIT(&dl->mutex);
code = VLockFileLock(dl->lockfile, dl->offset, locktype, nonblock);
- assert(pthread_mutex_lock(&dl->mutex) == 0);
+ MUTEX_ENTER(&dl->mutex);
dl->flags &= ~VDISKLOCK_ACQUIRING;
dl->flags |= VDISKLOCK_ACQUIRED;
}
- assert(pthread_cond_broadcast(&dl->cv) == 0);
+ CV_BROADCAST(&dl->cv);
}
}
++dl->lockers;
}
- assert(pthread_mutex_unlock(&dl->mutex) == 0);
+ MUTEX_EXIT(&dl->mutex);
return code;
}
void
VReleaseDiskLock(struct VDiskLock *dl, int locktype)
{
- assert(locktype == READ_LOCK || locktype == WRITE_LOCK);
+ osi_Assert(locktype == READ_LOCK || locktype == WRITE_LOCK);
- assert(pthread_mutex_lock(&dl->mutex) == 0);
- assert(dl->lockers > 0);
+ MUTEX_ENTER(&dl->mutex);
+ osi_Assert(dl->lockers > 0);
if (--dl->lockers < 1) {
/* no threads are holding this lock anymore, so we can release the
dl->flags &= ~VDISKLOCK_ACQUIRED;
}
- assert(pthread_mutex_unlock(&dl->mutex) == 0);
+ MUTEX_EXIT(&dl->mutex);
if (locktype == READ_LOCK) {
ReleaseReadLock(&dl->rwlock);
git://git.openafs.org / openafs.git / blobdiff