#include <afsconfig.h>
#include <afs/param.h>
+#include <roken.h>
#include <stdio.h>
#include <sys/types.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 */
+#include <afs/afs_assert.h>
#include <rx/xdr.h>
#include <afs/afsint.h>
#include <strings.h>
#endif
-#ifdef O_LARGEFILE
-#define afs_open open64
-#else /* !O_LARGEFILE */
-#define afs_open open
-#endif /* !O_LARGEFILE */
-
-
/* 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 */
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",
+ (void)afs_snprintf(volumePath, sizeof volumePath, "%s" OS_DIRSEP "%s",
VPartitionPath(partition), headerName);
rc = stat(volumePath, &st);
if (rc == 0 || errno != ENOENT) {
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) {
}
if (FDH_PWRITE(fdP, (char *)&p->stamp, sizeof(p->stamp), 0) !=
sizeof(p->stamp)) {
- Log("VCreateVolume: Problem writing to inode %s (err=%d)\n",
+ Log("VCreateVolume: Problem writing to inode %s (err=%d)\n",
PrintInode(stmp, *(p->inode)), errno);
FDH_REALLYCLOSE(fdP);
goto bad;
char path[MAXPATHLEN];
(void)afs_snprintf(path, sizeof(path),
- "%s/" VFORMAT,
+ "%s" OS_DIRSEP VFORMAT,
VPartitionPath(dp), afs_printable_uint32_lu(volid));
fd = open(path, O_RDONLY);
if (fd < 0) {
flags |= O_RDWR;
(void)afs_snprintf(path, sizeof(path),
- "%s/" VFORMAT,
+ "%s" OS_DIRSEP VFORMAT,
VPartitionPath(dp), afs_printable_uint32_lu(hdr->id));
fd = open(path, flags, 0644);
if (fd < 0) {
#endif /* AFS_DEMAND_ATTACH_FS */
(void)afs_snprintf(path, sizeof(path),
- "%s/" VFORMAT,
+ "%s" OS_DIRSEP VFORMAT,
VPartitionPath(dp), afs_printable_uint32_lu(volid));
code = unlink(path);
if (code) {
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;
* @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;
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