#endif
extern struct vcache *afs_globalVp;
-
-
static ssize_t
afs_linux_read(struct file *fp, char *buf, size_t count, loff_t * offp)
{
else {
osi_FlushPages(vcp, credp); /* ensure stale pages are gone */
AFS_GUNLOCK();
+#ifdef DO_SYNC_READ
+ code = do_sync_read(fp, buf, count, offp);
+#else
code = generic_file_read(fp, buf, count, offp);
+#endif
AFS_GLOCK();
}
afs_linux_write(struct file *fp, const char *buf, size_t count, loff_t * offp)
{
ssize_t code = 0;
- int code2 = 0;
struct vcache *vcp = VTOAFS(fp->f_dentry->d_inode);
struct vrequest treq;
cred_t *credp = crref();
code = -code;
else {
AFS_GUNLOCK();
+#ifdef DO_SYNC_READ
+ code = do_sync_write(fp, buf, count, offp);
+#else
code = generic_file_write(fp, buf, count, offp);
+#endif
AFS_GLOCK();
}
ObtainWriteLock(&vcp->lock, 530);
- vcp->m.Date = osi_Time(); /* set modification time */
afs_FakeClose(vcp, credp);
- if (code >= 0)
- code2 = afs_DoPartialWrite(vcp, &treq);
- if (code2 && code >= 0)
- code = (ssize_t) - code2;
ReleaseWriteLock(&vcp->lock);
afs_Trace4(afs_iclSetp, CM_TRACE_WRITEOP, ICL_TYPE_POINTER, vcp,
code = -ENOENT;
goto out;
}
- ObtainReadLock(&avc->lock);
+ ObtainSharedLock(&avc->lock, 810);
+ UpgradeSToWLock(&avc->lock, 811);
ObtainReadLock(&tdc->lock);
/*
* Make sure that the data in the cache is current. There are two
&& (tdc->dflags & DFFetching)
&& hsame(avc->m.DataVersion, tdc->f.versionNo)) {
ReleaseReadLock(&tdc->lock);
- ReleaseReadLock(&avc->lock);
+ ReleaseSharedLock(&avc->lock);
afs_osi_Sleep(&tdc->validPos);
- ObtainReadLock(&avc->lock);
+ ObtainSharedLock(&avc->lock, 812);
ObtainReadLock(&tdc->lock);
}
if (!(avc->states & CStatd)
|| !hsame(avc->m.DataVersion, tdc->f.versionNo)) {
ReleaseReadLock(&tdc->lock);
- ReleaseReadLock(&avc->lock);
+ ReleaseSharedLock(&avc->lock);
afs_PutDCache(tdc);
goto tagain;
}
+ /* Set the readdir-in-progress flag, and downgrade the lock
+ * to shared so others will be able to acquire a read lock.
+ */
+ avc->states |= CReadDir;
+ avc->dcreaddir = tdc;
+ avc->readdir_pid = MyPidxx;
+ ConvertWToSLock(&avc->lock);
+
/* Fill in until we get an error or we're done. This implementation
* takes an offset in units of blobs, rather than bytes.
*/
if (!de)
break;
- ino = (avc->fid.Fid.Volume << 16) + ntohl(de->fid.vnode);
- ino &= 0x7fffffff; /* Assumes 32 bit ino_t ..... */
+ ino = afs_calc_inum (avc->fid.Fid.Volume, ntohl(de->fid.vnode));
+
if (de->name)
len = strlen(de->name);
else {
printf("afs_linux_readdir: afs_dir_GetBlob failed, null name (inode %lx, dirpos %d)\n",
(unsigned long)&tdc->f.inode, dirpos);
DRelease((struct buffer *) de, 0);
+ ReleaseSharedLock(&avc->lock);
afs_PutDCache(tdc);
- ReleaseReadLock(&avc->lock);
code = -ENOENT;
goto out;
}
/* clean up from afs_FindVCache */
afs_PutVCache(tvc);
}
+ /*
+ * If this is NFS readdirplus, then the filler is going to
+ * call getattr on this inode, which will deadlock if we're
+ * holding the GLOCK.
+ */
+ AFS_GUNLOCK();
code = (*filldir) (dirbuf, de->name, len, offset, ino, type);
+ AFS_GLOCK();
}
#else
code = (*filldir) (dirbuf, de->name, len, offset, ino);
ReleaseReadLock(&tdc->lock);
afs_PutDCache(tdc);
- ReleaseReadLock(&avc->lock);
+ UpgradeSToWLock(&avc->lock, 813);
+ avc->states &= ~CReadDir;
+ avc->dcreaddir = 0;
+ avc->readdir_pid = 0;
+ ReleaseSharedLock(&avc->lock);
code = 0;
out:
}
#endif
-/* We need to detect unmap's after close. To do that, we need our own
- * vm_operations_struct's. And we need to set them up for both the
- * private and shared mappings. The fun part is that these are all static
- * so we'll have to initialize on the fly!
- */
-static struct vm_operations_struct afs_private_mmap_ops;
-static int afs_private_mmap_ops_inited = 0;
-static struct vm_operations_struct afs_shared_mmap_ops;
-static int afs_shared_mmap_ops_inited = 0;
-
-static void
-afs_linux_vma_close(struct vm_area_struct *vmap)
-{
- struct vcache *vcp;
- cred_t *credp;
- int need_unlock = 0;
-
- if (!vmap->vm_file)
- return;
-
- vcp = VTOAFS(FILE_INODE(vmap->vm_file));
- if (!vcp)
- return;
-
- AFS_GLOCK();
- afs_Trace4(afs_iclSetp, CM_TRACE_VM_CLOSE, ICL_TYPE_POINTER, vcp,
- ICL_TYPE_INT32, vcp->mapcnt, ICL_TYPE_INT32, vcp->opens,
- ICL_TYPE_INT32, vcp->execsOrWriters);
- if ((&vcp->lock)->excl_locked == 0 || (&vcp->lock)->pid_writer == MyPidxx) {
- ObtainWriteLock(&vcp->lock, 532);
- need_unlock = 1;
- } else
- printk("AFS_VMA_CLOSE(%d): Skipping Already locked vcp=%p vmap=%p\n",
- MyPidxx, &vcp, &vmap);
- if (vcp->mapcnt) {
- vcp->mapcnt--;
- if (need_unlock)
- ReleaseWriteLock(&vcp->lock);
- if (!vcp->mapcnt) {
- if (need_unlock && vcp->execsOrWriters < 2) {
- credp = crref();
- (void)afs_close(vcp, vmap->vm_file->f_flags, credp);
- /* only decrement the execsOrWriters flag if this is not a
- * writable file. */
- if (!(vcp->states & CRO) )
- if (! (vmap->vm_file->f_flags & (FWRITE | FTRUNC)))
- vcp->execsOrWriters--;
- vcp->states &= ~CMAPPED;
- crfree(credp);
- } else if ((vmap->vm_file->f_flags & (FWRITE | FTRUNC)))
- vcp->execsOrWriters--;
- /* If we did not have the lock */
- if (!need_unlock) {
- vcp->mapcnt++;
- if (!vcp->execsOrWriters)
- vcp->execsOrWriters = 1;
- }
- }
- } else {
- if (need_unlock)
- ReleaseWriteLock(&vcp->lock);
- }
-
- AFS_GUNLOCK();
-}
static int
afs_linux_mmap(struct file *fp, struct vm_area_struct *vmap)
/* get a validated vcache entry */
code = afs_InitReq(&treq, credp);
- if (!code)
- code = afs_VerifyVCache(vcp, &treq);
-
- if (!code && (vcp->states & CRO) &&
- (vmap->vm_file->f_flags & (FWRITE | FTRUNC)))
- code = EACCES;
-
if (code)
- code = -code;
- else {
- osi_FlushPages(vcp, credp); /* ensure stale pages are gone */
-
- AFS_GUNLOCK();
- code = generic_file_mmap(fp, vmap);
- AFS_GLOCK();
- }
+ goto out_err;
- if (code == 0) {
- ObtainWriteLock(&vcp->lock, 531);
- /* Set out vma ops so we catch the close. The following test should be
- * the same as used in generic_file_mmap.
- */
- if ((vmap->vm_flags & VM_SHARED) && (vmap->vm_flags & VM_MAYWRITE)) {
- if (!afs_shared_mmap_ops_inited) {
- afs_shared_mmap_ops_inited = 1;
- afs_shared_mmap_ops = *vmap->vm_ops;
- afs_shared_mmap_ops.close = afs_linux_vma_close;
- }
- vmap->vm_ops = &afs_shared_mmap_ops;
- } else {
- if (!afs_private_mmap_ops_inited) {
- afs_private_mmap_ops_inited = 1;
- afs_private_mmap_ops = *vmap->vm_ops;
- afs_private_mmap_ops.close = afs_linux_vma_close;
- }
- vmap->vm_ops = &afs_private_mmap_ops;
- }
+ code = afs_VerifyVCache(vcp, &treq);
+ if (code)
+ goto out_err;
+ osi_FlushPages(vcp, credp); /* ensure stale pages are gone */
- /* Add an open reference on the first mapping. */
- if (vcp->mapcnt == 0) {
- if (!(vcp->states & CRO))
- vcp->execsOrWriters++;
- vcp->opens++;
- vcp->states |= CMAPPED;
- }
- ReleaseWriteLock(&vcp->lock);
- vcp->mapcnt++;
- }
+ AFS_GUNLOCK();
+ code = generic_file_mmap(fp, vmap);
+ AFS_GLOCK();
+ if (!code)
+ vcp->states |= CMAPPED;
+out:
AFS_GUNLOCK();
crfree(credp);
return code;
+
+out_err:
+ code = -code;
+ goto out;
}
static int
code = afs_lockctl(vcp, &flock, cmd, credp);
AFS_GUNLOCK();
+#ifdef AFS_LINUX24_ENV
+ if ((code == 0 || flp->fl_type == F_UNLCK) &&
+ (cmd == F_SETLK || cmd == F_SETLKW)) {
+#ifdef AFS_LINUX26_ENV
+ flp->fl_flags &=~ FL_SLEEP;
+ code = posix_lock_file(fp, flp);
+#else
+ code = posix_lock_file(fp, flp, 0);
+#endif
+ if (code && flp->fl_type != F_UNLCK) {
+ struct AFS_FLOCK flock2;
+ flock2 = flock;
+ flock2.l_type = F_UNLCK;
+ AFS_GLOCK();
+ afs_lockctl(vcp, &flock2, F_SETLK, credp);
+ AFS_GUNLOCK();
+ }
+ }
+#endif
/* Convert flock back to Linux's file_lock */
flp->fl_type = flock.l_type;
flp->fl_pid = flock.l_pid;
}
+#ifdef STRUCT_FILE_OPERATIONS_HAS_FLOCK
+static int
+afs_linux_flock(struct file *fp, int cmd, struct file_lock *flp) {
+ int code = 0;
+ struct vcache *vcp = VTOAFS(FILE_INODE(fp));
+ cred_t *credp = crref();
+ struct AFS_FLOCK flock;
+ /* Convert to a lock format afs_lockctl understands. */
+ memset((char *)&flock, 0, sizeof(flock));
+ flock.l_type = flp->fl_type;
+ flock.l_pid = flp->fl_pid;
+ flock.l_whence = 0;
+ flock.l_start = 0;
+ flock.l_len = OFFSET_MAX;
+
+ /* Safe because there are no large files, yet */
+#if defined(F_GETLK64) && (F_GETLK != F_GETLK64)
+ if (cmd == F_GETLK64)
+ cmd = F_GETLK;
+ else if (cmd == F_SETLK64)
+ cmd = F_SETLK;
+ else if (cmd == F_SETLKW64)
+ cmd = F_SETLKW;
+#endif /* F_GETLK64 && F_GETLK != F_GETLK64 */
+
+ AFS_GLOCK();
+ code = afs_lockctl(vcp, &flock, cmd, credp);
+ AFS_GUNLOCK();
+
+ if ((code == 0 || flp->fl_type == F_UNLCK) &&
+ (cmd == F_SETLK || cmd == F_SETLKW)) {
+ flp->fl_flags &=~ FL_SLEEP;
+ code = flock_lock_file_wait(fp, flp);
+ if (code && flp->fl_type != F_UNLCK) {
+ struct AFS_FLOCK flock2;
+ flock2 = flock;
+ flock2.l_type = F_UNLCK;
+ AFS_GLOCK();
+ afs_lockctl(vcp, &flock2, F_SETLK, credp);
+ AFS_GUNLOCK();
+ }
+ }
+ /* Convert flock back to Linux's file_lock */
+ flp->fl_type = flock.l_type;
+ flp->fl_pid = flock.l_pid;
+
+ crfree(credp);
+ return -code;
+}
+#endif
+
/* afs_linux_flush
* essentially the same as afs_fsync() but we need to get the return
* code for the sys_close() here, not afs_linux_release(), so call
struct file_operations afs_file_fops = {
.read = afs_linux_read,
.write = afs_linux_write,
+#ifdef GENERIC_FILE_AIO_READ
+ .aio_read = generic_file_aio_read,
+ .aio_write = generic_file_aio_write,
+#endif
#ifdef HAVE_UNLOCKED_IOCTL
.unlocked_ioctl = afs_unlocked_xioctl,
#else
.release = afs_linux_release,
.fsync = afs_linux_fsync,
.lock = afs_linux_lock,
+#ifdef STRUCT_FILE_OPERATIONS_HAS_FLOCK
+ .flock = afs_linux_flock,
+#endif
};
#endif
AFS_GLOCK();
+#ifdef notyet
/* Make this a fast path (no crref), since it's called so often. */
if (vcp->states & CStatd) {
#endif
return 0;
}
+#endif
credp = crref();
code = afs_getattr(vcp, &vattr, credp);
struct vcache *vcp = VTOAFS(ip);
AFS_GLOCK();
- if (vcp->states & CUnlinked)
- (void) afs_remunlink(vcp, 1); /* perhaps afs_InactiveVCache() instead */
+ (void) afs_InactiveVCache(vcp, NULL);
AFS_GUNLOCK();
iput(ip);
afs_linux_lookup(struct inode *dip, struct dentry *dp)
#endif
{
- struct vattr vattr;
cred_t *credp = crref();
struct vcache *vcp = NULL;
const char *comp = dp->d_name.name;
- struct dentry *res = NULL;
struct inode *ip = NULL;
+#if defined(AFS_LINUX26_ENV)
+ struct dentry *newdp = NULL;
+#endif
int code;
#if defined(AFS_LINUX26_ENV)
code = afs_lookup(VTOAFS(dip), comp, &vcp, credp);
if (vcp) {
- ip = AFSTOV(vcp);
+ struct vattr vattr;
+ ip = AFSTOV(vcp);
afs_getattr(vcp, &vattr, credp);
afs_fill_inode(ip, &vattr);
}
dp->d_op = &afs_dentry_operations;
dp->d_time = hgetlo(VTOAFS(dip)->m.DataVersion);
AFS_GUNLOCK();
+
#if defined(AFS_LINUX24_ENV)
if (ip && S_ISDIR(ip->i_mode)) {
- d_prune_aliases(ip);
- res = d_find_alias(ip);
+ struct dentry *alias;
+
+ /* Try to invalidate an existing alias in favor of our new one */
+ alias = d_find_alias(ip);
+#if defined(AFS_LINUX26_ENV)
+ /* But not if it's disconnected; then we want d_splice_alias below */
+ if (alias && !(alias->d_flags & DCACHE_DISCONNECTED)) {
+#else
+ if (alias) {
+#endif
+ if (d_invalidate(alias) == 0) {
+ dput(alias);
+ } else {
+ iput(ip);
+#if defined(AFS_LINUX26_ENV)
+ unlock_kernel();
+#endif
+ return alias;
+ }
+ }
}
- if (res) {
- if (d_unhashed(res))
- d_rehash(res);
- } else
#endif
+#if defined(AFS_LINUX26_ENV)
+ newdp = d_splice_alias(ip, dp);
+#else
d_add(dp, ip);
+#endif
#if defined(AFS_LINUX26_ENV)
unlock_kernel();
/* It's ok for the file to not be found. That's noted by the caller by
* seeing that the dp->d_inode field is NULL.
*/
-#if defined(AFS_LINUX24_ENV)
- if (code == 0)
- return res;
-#endif
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,10)
+#if defined(AFS_LINUX26_ENV)
+ if (!code || code == ENOENT)
+ return newdp;
+#else
if (code == ENOENT)
return ERR_PTR(0);
+#endif
else
return ERR_PTR(-code);
#else
#if defined(AFS_LINUX26_ENV)
lock_kernel();
#endif
- if (((VREFCOUNT(tvc) > 0) && tvc->opens > 0)
+ if (VREFCOUNT(tvc) > 1 && tvc->opens > 0
&& !(tvc->states & CUnlinked)) {
struct dentry *__dp;
char *__name;
cred_t *credp = crref();
const char *name = dp->d_name.name;
-#if defined(AFS_LINUX26_ENV)
- lock_kernel();
-#endif
+ /* locking kernel conflicts with glock? */
+
AFS_GLOCK();
code = afs_rmdir(VTOAFS(dip), name, credp);
AFS_GUNLOCK();
d_drop(dp);
}
-#if defined(AFS_LINUX26_ENV)
- unlock_kernel();
-#endif
crfree(credp);
return -code;
}
cred_t *credp = crref();
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
char *address;
- afs_offs_t offset = pp->index << PAGE_CACHE_SHIFT;
+ afs_offs_t offset = ((loff_t) pp->index) << PAGE_CACHE_SHIFT;
#else
ulong address = afs_linux_page_address(pp);
afs_offs_t offset = pageoff(pp);
clear_bit(PG_error, &pp->flags);
#endif
- setup_uio(&tuio, &iovec, (char *)address, offset, PAGESIZE, UIO_READ,
+ setup_uio(&tuio, &iovec, (char *)address, offset, PAGE_SIZE, UIO_READ,
AFS_UIOSYS);
#ifdef AFS_LINUX24_ENV
lock_kernel();
if (!code) {
if (tuio.uio_resid) /* zero remainder of page */
- memset((void *)(address + (PAGESIZE - tuio.uio_resid)), 0,
+ memset((void *)(address + (PAGE_SIZE - tuio.uio_resid)), 0,
tuio.uio_resid);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
flush_dcache_page(pp);
int f_flags = 0;
buffer = kmap(pp) + offset;
- base = (pp->index << PAGE_CACHE_SHIFT) + offset;
+ base = (((loff_t) pp->index) << PAGE_CACHE_SHIFT) + offset;
credp = crref();
lock_kernel();
ip->i_size = vcp->m.Length;
ip->i_blocks = ((vcp->m.Length + 1023) >> 10) << 1;
- if (!code
- && afs_stats_cmperf.cacheCurrDirtyChunks >
- afs_stats_cmperf.cacheMaxDirtyChunks) {
+ if (!code) {
struct vrequest treq;
ObtainWriteLock(&vcp->lock, 533);
#if defined(AFS_LINUX26_ENV)
if (PageReclaim(pp)) {
+# if defined(WRITEPAGE_ACTIVATE)
return WRITEPAGE_ACTIVATE;
+# else
+ return AOP_WRITEPAGE_ACTIVATE;
+# endif
}
#else
if (PageLaunder(pp)) {
ip->i_size = vcp->m.Length;
ip->i_blocks = ((vcp->m.Length + 1023) >> 10) << 1;
+ if (!code) {
+ struct vrequest treq;
+
+ ObtainWriteLock(&vcp->lock, 533);
+ vcp->m.Date = osi_Time(); /* set modification time */
+ if (!afs_InitReq(&treq, credp))
+ code = afs_DoPartialWrite(vcp, &treq);
+ ReleaseWriteLock(&vcp->lock);
+ }
+
code = code ? -code : count - tuio.uio_resid;
afs_Trace4(afs_iclSetp, CM_TRACE_UPDATEPAGE, ICL_TYPE_POINTER, vcp,
ICL_TYPE_POINTER, pp, ICL_TYPE_INT32, page_count(pp),