*/
#include <afsconfig.h>
-#include "../afs/param.h"
+#include "afs/param.h"
RCSID("$Header$");
-#include "../afs/sysincludes.h"
-#include "../afs/afsincludes.h"
-#include "../afs/afs_stats.h"
-#include "../afs/afs_osidnlc.h"
-#include "../h/mm.h"
-#include "../h/pagemap.h"
+#include "afs/sysincludes.h"
+#include "afsincludes.h"
+#include "afs/afs_stats.h"
+#include "afs/afs_osidnlc.h"
+#include "h/mm.h"
+#include "h/pagemap.h"
#if defined(AFS_LINUX24_ENV)
-#include "../h/smp_lock.h"
+#include "h/smp_lock.h"
#endif
#ifdef pgoff2loff
code = afs_read(vcp, &tuio, credp, 0, 0, 0);
xfered += count - tuio.uio_resid;
if (code != 0) {
+ afs_Trace4(afs_iclSetp, CM_TRACE_READOP, ICL_TYPE_POINTER, vcp,
+ ICL_TYPE_OFFSET, offp,
+ ICL_TYPE_INT32, -1,
+ ICL_TYPE_INT32, code);
code = xfered;
*offp += count - tuio.uio_resid;
} else {
if (!dirpos)
break;
- de = (struct DirEntry*)afs_dir_GetBlob(&tdc->f.inode, dirpos);
+ de = afs_dir_GetBlob(&tdc->f.inode, dirpos);
if (!de)
break;
if ((avc->states & CForeign) == 0 &&
(ntohl(de->fid.vnode) & 1)) {
type=DT_DIR;
- } else if ((tvc=afs_FindVCache(&afid,0,0,0,0))) {
+ } else if ((tvc=afs_FindVCache(&afid,0,0))) {
if (tvc->mvstat) {
type=DT_DIR;
} else if (((tvc->states) & (CStatd|CTruth))) {
/* what other types does AFS support? */
}
/* clean up from afs_FindVCache */
- afs_PutVCache(tvc, WRITE_LOCK);
+ afs_PutVCache(tvc);
}
code = (*filldir)(dirbuf, de->name, len, offset, ino, type);
}
flock.l_start = flp->fl_start;
flock.l_len = flp->fl_end - flp->fl_start;
+ /* Safe because there are no large files, yet */
+#if 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_GETLK != F_GETLK64 */
+
AFS_GLOCK();
code = afs_lockctl(vcp, &flock, cmd, credp);
AFS_GUNLOCK();
+
+ /* Convert flock back to Linux's file_lock */
+ flp->fl_type = flock.l_type;
+ flp->fl_pid = flock.l_pid;
+ flp->fl_start = flock.l_start;
+ flp->fl_end = flock.l_start + flock.l_len;
+
crfree(credp);
return -code;
if (afs_fakestat_enable && vcp->mvstat == 1 && vcp->mvid &&
(vcp->states & CMValid) && (vcp->states & CStatd)) {
ObtainSharedLock(&afs_xvcache, 680);
- rootvp = afs_FindVCache(vcp->mvid, 0, 0, 0, 0);
+ rootvp = afs_FindVCache(vcp->mvid, 0, 0);
ReleaseSharedLock(&afs_xvcache);
}
struct vcache *parentvcp = ITOAFS(dp->d_parent->d_inode);
AFS_GLOCK();
+ lock_kernel();
sysState.allocked = 0;
goto done;
}
- if (code = afs_InitReq(&treq, credp))
+ if ((code = afs_InitReq(&treq, credp)))
goto done;
Check_AtSys(parentvcp, dp->d_name.name, &sysState, &treq);
name = sysState.name;
/* First try looking up the DNLC */
- if (lookupvcp = osi_dnlc_lookup(parentvcp, name, WRITE_LOCK)) {
+ if ((lookupvcp = osi_dnlc_lookup(parentvcp, name, WRITE_LOCK))) {
/* Verify that the dentry does not point to an old inode */
if (vcp != lookupvcp)
goto done;
done:
/* Clean up */
if (lookupvcp)
- afs_PutVCache(lookupvcp, WRITE_LOCK);
+ afs_PutVCache(lookupvcp);
if (sysState.allocked)
osi_FreeLargeSpace(name);
shrink_dcache_parent(dp);
d_drop(dp);
}
+ unlock_kernel();
return !bad_dentry;
}
/* afs_dentry_iput */
static void afs_dentry_iput(struct dentry *dp, struct inode *ip)
{
+ if (ICL_SETACTIVE(afs_iclSetp)) {
+ AFS_GLOCK();
+ afs_Trace3(afs_iclSetp, CM_TRACE_DENTRYIPUT,
+ ICL_TYPE_POINTER, ip,
+ ICL_TYPE_STRING, dp->d_parent->d_name.name,
+ ICL_TYPE_STRING, dp->d_name.name);
+ AFS_GUNLOCK();
+ }
+
osi_iput(ip);
}
static int afs_dentry_delete(struct dentry *dp)
{
+ if (ICL_SETACTIVE(afs_iclSetp)) {
+ AFS_GLOCK();
+ afs_Trace3(afs_iclSetp, CM_TRACE_DENTRYDELETE, ICL_TYPE_POINTER,
+ dp->d_inode, ICL_TYPE_STRING, dp->d_parent->d_name.name,
+ ICL_TYPE_STRING, dp->d_name.name);
+ AFS_GUNLOCK();
+ }
+
if (dp->d_inode && (ITOAFS(dp->d_inode)->states & CUnlinked))
return 1; /* bad inode? */
- afs_Trace3(afs_iclSetp, CM_TRACE_DENTRYDELETE, ICL_TYPE_POINTER,
- dp->d_inode, ICL_TYPE_STRING, dp->d_parent->d_name.name,
- ICL_TYPE_STRING, dp->d_name.name);
return 0;
}
afs_linux_dentry_revalidate, /* d_validate(struct dentry *) */
NULL, /* d_hash */
NULL, /* d_compare */
- NULL, /* d_delete(struct dentry *) */
+ afs_dentry_delete, /* d_delete(struct dentry *) */
NULL, /* d_release(struct dentry *) */
afs_dentry_iput /* d_iput(struct dentry *, struct inode *) */
};
struct iovec iovec;
struct inode *ip = FILE_INODE(fp);
int cnt = atomic_read(&pp->count);
+ struct vcache *avc = ITOAFS(ip);
AFS_GLOCK();
afs_Trace4(afs_iclSetp, CM_TRACE_READPAGE,
setup_uio(&tuio, &iovec, (char*)address, offset, PAGESIZE,
UIO_READ, AFS_UIOSYS);
- code = afs_rdwr(ITOAFS(ip), &tuio, UIO_READ, 0, credp);
+ code = afs_rdwr(avc, &tuio, UIO_READ, 0, credp);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
unlock_kernel();
#endif
free_page(address);
#endif
+ if (!code && AFS_CHUNKOFFSET(offset) == 0) {
+ struct dcache *tdc;
+ struct vrequest treq;
+
+ code = afs_InitReq(&treq, credp);
+ if (!code && !NBObtainWriteLock(&avc->lock, 534)) {
+ tdc = afs_FindDCache(avc, offset);
+ if (tdc) {
+ if (!(tdc->mflags & DFNextStarted))
+ afs_PrefetchChunk(avc, tdc, credp, &treq);
+ afs_PutDCache(tdc);
+ }
+ ReleaseWriteLock(&avc->lock);
+ }
+ }
+
crfree(credp);
afs_Trace4(afs_iclSetp, CM_TRACE_READPAGE,
ICL_TYPE_POINTER, ip,
ICL_TYPE_POINTER, pp,
ICL_TYPE_INT32, atomic_read(&pp->count),
ICL_TYPE_INT32, 99999);
+
setup_uio(&tuio, &iovec, buffer, base, count, UIO_WRITE, AFS_UIOSYS);
code = afs_write(vcp, &tuio, f_flags, credp, 0);
vcache2inode(vcp);
+ if (!code && afs_stats_cmperf.cacheCurrDirtyChunks >
+ afs_stats_cmperf.cacheMaxDirtyChunks) {
+ struct vrequest treq;
+
+ ObtainWriteLock(&vcp->lock, 533);
+ 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, atomic_read(&pp->count),
git://git.openafs.org / openafs.git / blobdiff