merge ntops and namei
[openafs.git] / src / vol / vutil.c
index 8f7aefe..1822103 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * 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
 #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 */
+#include <afs/afs_assert.h>
 
 #include <rx/xdr.h>
 #include <afs/afsint.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"
+#include "common.h"
 
 #ifdef AFS_AIX_ENV
 #include <sys/lockf.h>
@@ -73,9 +71,6 @@
 #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
 
 #ifdef FSSYNC_BUILD_CLIENT
 static void
-RemoveInodes(Device dev, VolumeId vid)
+RemoveInodes(struct afs_inode_info *stuff, Device dev, 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++) {
+    for (i = 0; i < MAXINODETYPE; i++) {
        Inode inode = *stuff[i].inode;
        if (VALID_INO(inode))
            IH_DEC(handle, inode, vid);
@@ -126,6 +121,14 @@ VCreateVolume_r(Error * ec, char *partname, VolId volumeId, VolId parentId)
     Inode nearInode = 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));
@@ -160,7 +163,23 @@ VCreateVolume_r(Error * ec, char *partname, VolId volumeId, VolId parentId)
        }
     }
     *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;
@@ -183,12 +202,12 @@ VCreateVolume_r(Error * ec, char *partname, VolId volumeId, VolId parentId)
                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
@@ -197,16 +216,12 @@ VCreateVolume_r(Error * ec, char *partname, VolId volumeId, VolId parentId)
                      (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) {
@@ -232,30 +247,30 @@ VCreateVolume_r(Error * ec, char *partname, VolId volumeId, VolId parentId)
          bad:
            if (handle)
                IH_RELEASE(handle);
-           RemoveInodes(device, vol.id);
+           RemoveInodes(stuff, device, 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);
-           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);
+               PrintInode(stmp, *(p->inode)), errno);
            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);
+               PrintInode(stmp, *(p->inode)), errno);
            FDH_REALLYCLOSE(fdP);
            goto bad;
        }
@@ -268,18 +283,12 @@ VCreateVolume_r(Error * ec, char *partname, VolId volumeId, VolId parentId)
     fdP = IH_OPEN(handle);
     if (fdP == NULL) {
        Log("VCreateVolume:  Problem iopen inode %s (err=%d)\n",
-           PrintInode(NULL, 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);
+           PrintInode(stmp, tempHeader.volumeInfo), errno);
        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;
     }
@@ -298,13 +307,18 @@ VCreateVolume_r(Error * ec, char *partname, VolId volumeId, VolId parentId)
        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);
@@ -312,9 +326,9 @@ AssignVolumeName(register VolumeDiskData * vol, char *name, char *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, '.');
@@ -361,7 +375,7 @@ CopyVolumeHeader(VolumeDiskData * from, VolumeDiskData * to)
 }
 
 void
-ClearVolumeStats(register VolumeDiskData * vol)
+ClearVolumeStats(VolumeDiskData * vol)
 {
     VOL_LOCK;
     ClearVolumeStats_r(vol);
@@ -369,7 +383,7 @@ ClearVolumeStats(register VolumeDiskData * vol)
 }
 
 void
-ClearVolumeStats_r(register VolumeDiskData * vol)
+ClearVolumeStats_r(VolumeDiskData * vol)
 {
     memset(vol->weekUse, 0, sizeof(vol->weekUse));
     vol->dayUse = 0;
@@ -381,7 +395,10 @@ ClearVolumeStats_r(register VolumeDiskData * vol)
  *
  * @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
@@ -404,10 +421,11 @@ VReadVolumeDiskHeader(VolumeId volid,
                       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;
@@ -837,8 +855,6 @@ VWalkVolumeHeaders(struct DiskPartition64 *dp, const char *partpath,
     return code;
 }
 
-#ifdef AFS_DEMAND_ATTACH_FS
-
 /**
  * initialize a struct VLockFile.
  *
@@ -852,10 +868,10 @@ VLockFileInit(struct VLockFile *lf, const char *path)
     memset(lf, 0, sizeof(*lf));
     lf->path = strdup(path);
     lf->fd = INVALID_FD;
-    assert(pthread_mutex_init(&lf->mutex, NULL) == 0);
+    MUTEX_INIT(&lf->mutex, "vlockfile", MUTEX_DEFAULT, 0);
 }
 
-# ifdef AFS_NT40_ENV
+#ifdef AFS_NT40_ENV
 static_inline FD_t
 _VOpenPath(const char *path)
 {
@@ -918,7 +934,7 @@ _VCloseFd(struct VLockFile *lf)
     CloseHandle(lf->fd);
 }
 
-# else /* !AFS_NT40_ENV */
+#else /* !AFS_NT40_ENV */
 
 /**
  * open a file on the local filesystem suitable for locking
@@ -976,10 +992,23 @@ _VLockFd(int fd, afs_uint32 offset, int locktype, int nonblock)
     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;
     }
 
@@ -1021,7 +1050,36 @@ _VUnlockFd(int fd, afs_uint32 offset)
            "fd %d\n", errno, fd);
     }
 }
-# endif /* !AFS_NT40_ENV */
+#endif /* !AFS_NT40_ENV */
+
+/**
+ * reinitialize a struct VLockFile.
+ *
+ * Use this to close the lock file (unlocking any locks in it), and effectively
+ * restore lf to the state it was in when it was initialized. This is the same
+ * as unlocking all of the locks on the file, without having to remember what
+ * all of the locks were. Do not unlock previously held locks after calling
+ * this.
+ *
+ * @param[in] lf  struct VLockFile to reinit
+ *
+ * @pre nobody is waiting for a lock on this lockfile or otherwise using
+ *      this lockfile at all
+ */
+void
+VLockFileReinit(struct VLockFile *lf)
+{
+    MUTEX_ENTER(&lf->mutex);
+
+    if (lf->fd != INVALID_FD) {
+       _VCloseFd(lf->fd);
+       lf->fd = INVALID_FD;
+    }
+
+    lf->refcount = 0;
+
+    MUTEX_EXIT(&lf->mutex);
+}
 
 /**
  * lock a file on disk for the process.
@@ -1050,29 +1108,31 @@ VLockFileLock(struct VLockFile *lf, afs_uint32 offset, int locktype, int nonbloc
 {
     int code;
 
-    assert(pthread_mutex_lock(&lf->mutex) == 0);
+    osi_Assert(locktype == READ_LOCK || locktype == WRITE_LOCK);
+
+    MUTEX_ENTER(&lf->mutex);
 
     if (lf->fd == INVALID_FD) {
        lf->fd = _VOpenPath(lf->path);
        if (lf->fd == INVALID_FD) {
-           assert(pthread_mutex_unlock(&lf->mutex) == 0);
+           MUTEX_EXIT(&lf->mutex);
            return EIO;
        }
     }
 
     lf->refcount++;
 
-    assert(pthread_mutex_unlock(&lf->mutex) == 0);
+    MUTEX_EXIT(&lf->mutex);
 
     code = _VLockFd(lf->fd, offset, locktype, nonblock);
 
     if (code) {
-       assert(pthread_mutex_lock(&lf->mutex) == 0);
+       MUTEX_ENTER(&lf->mutex);
        if (--lf->refcount < 1) {
            _VCloseFd(lf->fd);
            lf->fd = INVALID_FD;
        }
-       assert(pthread_mutex_unlock(&lf->mutex) == 0);
+       MUTEX_EXIT(&lf->mutex);
     }
 
     return code;
@@ -1081,7 +1141,9 @@ VLockFileLock(struct VLockFile *lf, afs_uint32 offset, int locktype, int nonbloc
 void
 VLockFileUnlock(struct VLockFile *lf, afs_uint32 offset)
 {
-    assert(pthread_mutex_lock(&lf->mutex) == 0);
+    MUTEX_ENTER(&lf->mutex);
+
+    osi_Assert(lf->fd != INVALID_FD);
 
     if (--lf->refcount < 1) {
        _VCloseFd(lf->fd);
@@ -1090,9 +1152,11 @@ VLockFileUnlock(struct VLockFile *lf, afs_uint32 offset)
        _VUnlockFd(lf->fd, offset);
     }
 
-    assert(pthread_mutex_unlock(&lf->mutex) == 0);
+    MUTEX_EXIT(&lf->mutex);
 }
 
+#ifdef AFS_DEMAND_ATTACH_FS
+
 /**
  * initialize a struct VDiskLock.
  *
@@ -1102,11 +1166,11 @@ VLockFileUnlock(struct VLockFile *lf, afs_uint32 offset)
 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;
 }
@@ -1137,7 +1201,7 @@ int
 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) {
@@ -1156,7 +1220,7 @@ VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock)
        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,
@@ -1167,7 +1231,7 @@ VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock)
            code = EBUSY;
        } else {
            while ((dl->flags & VDISKLOCK_ACQUIRING)) {
-               assert(pthread_cond_wait(&dl->cv, &dl->mutex) == 0);
+               CV_WAIT(&dl->cv, &dl->mutex);
            }
        }
     }
@@ -1184,9 +1248,9 @@ VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock)
            /* 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;
 
@@ -1194,7 +1258,7 @@ VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock)
                dl->flags |= VDISKLOCK_ACQUIRED;
            }
 
-           assert(pthread_cond_broadcast(&dl->cv) == 0);
+           CV_BROADCAST(&dl->cv);
        }
     }
 
@@ -1210,7 +1274,7 @@ VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock)
        ++dl->lockers;
     }
 
-    assert(pthread_mutex_unlock(&dl->mutex) == 0);
+    MUTEX_EXIT(&dl->mutex);
 
     return code;
 }
@@ -1228,10 +1292,10 @@ VGetDiskLock(struct VDiskLock *dl, int locktype, int nonblock)
 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
@@ -1240,7 +1304,7 @@ VReleaseDiskLock(struct VDiskLock *dl, int locktype)
        dl->flags &= ~VDISKLOCK_ACQUIRED;
     }
 
-    assert(pthread_mutex_unlock(&dl->mutex) == 0);
+    MUTEX_EXIT(&dl->mutex);
 
     if (locktype == READ_LOCK) {
        ReleaseReadLock(&dl->rwlock);