code = afs_dir_GetVerifiedBlob(tdc, dirpos, &entry);
if (code) {
- afs_warn("Corrupt directory (inode %lx, dirpos %d)",
- (unsigned long)&tdc->f.inode, dirpos);
- ReleaseSharedLock(&avc->lock);
- afs_PutDCache(tdc);
+ if (!(avc->f.states & CCorrupt)) {
+ struct cell *tc = afs_GetCellStale(avc->f.fid.Cell, READ_LOCK);
+ afs_warn("Corrupt directory (%d.%d.%d.%d [%s] @%lx, pos %d)",
+ avc->f.fid.Cell, avc->f.fid.Fid.Volume,
+ avc->f.fid.Fid.Vnode, avc->f.fid.Fid.Unique,
+ tc ? tc->cellName : "",
+ (unsigned long)&tdc->f.inode, dirpos);
+ if (tc)
+ afs_PutCell(tc, READ_LOCK);
+ UpgradeSToWLock(&avc->lock, 814);
+ avc->f.states |= CCorrupt;
+ }
code = -ENOENT;
- goto out;
+ goto unlock_out;
}
de = (struct DirEntry *)entry.data;
/* If filldir didn't fill in the last one this is still pointing to that
* last attempt.
*/
+ code = 0;
+
+unlock_out:
#if defined(STRUCT_FILE_OPERATIONS_HAS_ITERATE)
ctx->pos = (loff_t) offset;
#else
fp->f_pos = (loff_t) offset;
#endif
-
ReleaseReadLock(&tdc->lock);
afs_PutDCache(tdc);
UpgradeSToWLock(&avc->lock, 813);
avc->dcreaddir = 0;
avc->readdir_pid = 0;
ReleaseSharedLock(&avc->lock);
- code = 0;
out:
afs_PutFakeStat(&fakestat);
#ifdef HAVE_LINUX_GENERIC_FILE_AIO_READ
.aio_read = afs_linux_aio_read,
.aio_write = afs_linux_aio_write,
+ .read = do_sync_read,
+ .write = do_sync_write,
#else
.read = afs_linux_read,
.write = afs_linux_write,
if (iattrp->ia_valid & ATTR_MODE)
vattrp->va_mode = iattrp->ia_mode;
if (iattrp->ia_valid & ATTR_UID)
- vattrp->va_uid = iattrp->ia_uid;
+ vattrp->va_uid = afs_from_kuid(iattrp->ia_uid);
if (iattrp->ia_valid & ATTR_GID)
- vattrp->va_gid = iattrp->ia_gid;
+ vattrp->va_gid = afs_from_kgid(iattrp->ia_gid);
if (iattrp->ia_valid & ATTR_SIZE)
vattrp->va_size = iattrp->ia_size;
if (iattrp->ia_valid & ATTR_ATIME) {
#endif
ip->i_rdev = vp->va_rdev;
ip->i_mode = vp->va_mode;
- ip->i_uid = vp->va_uid;
- ip->i_gid = vp->va_gid;
+ ip->i_uid = afs_make_kuid(vp->va_uid);
+ ip->i_gid = afs_make_kgid(vp->va_gid);
i_size_write(ip, vp->va_size);
ip->i_atime.tv_sec = vp->va_atime.tv_sec;
ip->i_atime.tv_nsec = 0;
int valid;
struct afs_fakestat_state fakestate;
int locked = 0;
+ int force_drop = 0;
#ifdef LOOKUP_RCU
/* We don't support RCU path walking */
}
if (locked && (hgetlo(pvcp->f.m.DataVersion) > dp->d_time || !(vcp->f.states & CStatd))) {
- afs_lookup(pvcp, (char *)dp->d_name.name, &tvc, credp);
+ int code;
+
+ code = afs_lookup(pvcp, (char *)dp->d_name.name, &tvc, credp);
if (!tvc || tvc != vcp) {
dput(parent);
+ /* Force unhash if name is known not to exist. */
+ if (code == ENOENT)
+ force_drop = 1;
goto bad_dentry;
}
crfree(credp);
if (!valid) {
- shrink_dcache_parent(dp);
- d_drop(dp);
+ /*
+ * If we had a negative lookup for the name we want to forcibly
+ * unhash the dentry.
+ * Otherwise use d_invalidate which will not unhash it if still in use.
+ */
+ if (force_drop) {
+ shrink_dcache_parent(dp);
+ d_drop(dp);
+ } else
+ d_invalidate(dp);
}
+
return valid;
bad_dentry:
VATTR_NULL(&vattr);
AFS_GLOCK();
- code = afs_symlink(VTOAFS(dip), (char *)name, &vattr, (char *)target, credp);
+ code = afs_symlink(VTOAFS(dip), (char *)name, &vattr, (char *)target, NULL,
+ credp);
AFS_GUNLOCK();
crfree(credp);
return afs_convert_code(code);
rehash = newdp;
}
-#if defined(D_COUNT_INT)
- spin_lock(&olddp->d_lock);
- if (olddp->d_count > 1) {
- spin_unlock(&olddp->d_lock);
- shrink_dcache_parent(olddp);
- } else
- spin_unlock(&olddp->d_lock);
-#else
- if (atomic_read(&olddp->d_count) > 1)
- shrink_dcache_parent(olddp);
-#endif
+ afs_maybe_shrink_dcache(olddp);
AFS_GLOCK();
code = afs_rename(VTOAFS(oldip), (char *)oldname, VTOAFS(newip), (char *)newname, credp);
ObtainReadLock(&tdc->lock);
if (!hsame(avc->f.m.DataVersion, tdc->f.versionNo) ||
(tdc->dflags & DFFetching)) {
- goto out;
ReleaseReadLock(&tdc->lock);
afs_PutDCache(tdc);
tdc = NULL;