{
long code;
cm_fid_t tfid;
- cm_scache_t *aclScp;
+ cm_scache_t *aclScp = NULL;
int got_cb = 0;
/* pretty easy: just force a pass through the fetch status code */
code = cm_GetSCache(&tfid, &aclScp, userp, reqp);
if (code) {
lock_ObtainMutex(&scp->mx);
- return code;
+ goto _done;
}
osi_Log2(afsd_logp, "GetAccess parent scp %x user %x", aclScp, userp);
lock_ObtainMutex(&aclScp->mx);
-
- code = cm_GetCallback(aclScp, userp, reqp, 1);
+ code = cm_SyncOp(aclScp, NULL, userp, reqp, 0,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ if (!code) {
+ code = cm_GetCallback(aclScp, userp, reqp, 1);
+ cm_SyncOpDone(aclScp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ }
lock_ReleaseMutex(&aclScp->mx);
cm_ReleaseSCache(aclScp);
lock_ObtainMutex(&scp->mx);
code = cm_GetCallback(scp, userp, reqp, 1);
}
+ _done:
+ if (got_cb)
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
return code;
}
{
/* ensure that we're in the LRU queue if our ref count is 0 */
osi_assert(bp->magic == CM_BUF_MAGIC);
+#ifdef DEBUG
+ if (bp->refCount == 0)
+ DebugBreak();
+#else
osi_assert(bp->refCount > 0);
+#endif
if (--bp->refCount == 0) {
if (!(bp->flags & CM_BUF_INLRU)) {
osi_QAdd((osi_queue_t **) &cm_data.buf_freeListp, &bp->q);
{
cm_buf_t *bp; /* buffer we're hacking on; held */
long i; /* counter */
- long nAtOnce; /* how many to do at once */
+ long wasDirty;
cm_req_t req;
lock_ObtainWrite(&buf_globalLock);
bp = cm_data.buf_allp;
buf_HoldLocked(bp);
lock_ReleaseWrite(&buf_globalLock);
- nAtOnce = (long)sqrt((double)cm_data.buf_nbuffers);
+ wasDirty = 0;
+
while (buf_ShutdownFlag == 0) {
- i = SleepEx(5000, 1);
- if (i != 0) continue;
-
+ if (!wasDirty) {
+ i = SleepEx(5000, 1);
+ if (i != 0) continue;
+ }
+
if (buf_ShutdownFlag == 1)
return;
+ wasDirty = 0;
+
/* now go through our percentage of the buffers */
- for (i=0; i<nAtOnce; i++) {
+ for (i=0; i<cm_data.buf_nbuffers; i++) {
/* don't want its identity changing while we're
* messing with it, so must do all of this with
* bp held.
* a log page at any given instant.
*/
cm_InitReq(&req);
+#ifdef NO_BKG_RETRIES
req.flags |= CM_REQ_NORETRY;
- buf_CleanAsync(bp, &req);
+#endif
+ wasDirty |= buf_CleanAsync(bp, &req);
/* now advance to the next buffer; the allp chain never changes,
* and so can be followed even when holding no locks.
if ( bp->flags & CM_BUF_WAITING ) {
bp->waitCount++;
bp->waitRequests++;
- osi_Log1(afsd_logp, "buf_WaitIO CM_BUF_WAITING already set for 0x%p", bp);
+ osi_Log1(buf_logp, "buf_WaitIO CM_BUF_WAITING already set for 0x%p", bp);
} else {
- osi_Log1(afsd_logp, "buf_WaitIO CM_BUF_WAITING set for 0x%p", bp);
+ osi_Log1(buf_logp, "buf_WaitIO CM_BUF_WAITING set for 0x%p", bp);
bp->flags |= CM_BUF_WAITING;
bp->waitCount = bp->waitRequests = 1;
}
smb_UpdateServerPriority();
lock_ObtainMutex(&bp->mx);
- osi_Log1(afsd_logp, "buf_WaitIO conflict wait done for 0x%p", bp);
+ osi_Log1(buf_logp, "buf_WaitIO conflict wait done for 0x%p", bp);
bp->waitCount--;
if (bp->waitCount == 0) {
- osi_Log1(afsd_logp, "buf_WaitIO CM_BUF_WAITING reset for 0x%p", bp);
+ osi_Log1(buf_logp, "buf_WaitIO CM_BUF_WAITING reset for 0x%p", bp);
bp->flags &= ~CM_BUF_WAITING;
bp->waitRequests = 0;
}
if ( scp ) {
lock_ObtainMutex(&scp->mx);
if (scp->flags & CM_SCACHEFLAG_WAITING) {
- osi_Log1(afsd_logp, "buf_WaitIO waking scp 0x%p", scp);
+ osi_Log1(buf_logp, "buf_WaitIO waking scp 0x%p", scp);
osi_Wakeup((LONG_PTR)&scp->flags);
}
lock_ReleaseMutex(&scp->mx);
* the I/O to complete. Do so.
*/
if (bp->flags & CM_BUF_WAITING) {
- osi_Log1(afsd_logp, "buf_WaitIO Waking bp 0x%p", bp);
+ osi_Log1(buf_logp, "buf_WaitIO Waking bp 0x%p", bp);
osi_Wakeup((LONG_PTR) bp);
}
- osi_Log1(afsd_logp, "WaitIO finished wait for bp 0x%p", bp);
+ osi_Log1(buf_logp, "WaitIO finished wait for bp 0x%p", bp);
}
/* find a buffer, if any, for a particular file ID and offset. Assumes
* Makes sure that there's only one person writing this block
* at any given time, and also ensures that the log is forced sufficiently far,
* if this buffer contains logged data.
+ *
+ * Returns one if the buffer was dirty.
*/
-void buf_CleanAsyncLocked(cm_buf_t *bp, cm_req_t *reqp)
+long buf_CleanAsyncLocked(cm_buf_t *bp, cm_req_t *reqp)
{
long code = 0;
+ long isdirty = 0;
osi_assert(bp->magic == CM_BUF_MAGIC);
while ((bp->flags & CM_BUF_DIRTY) == CM_BUF_DIRTY) {
+ isdirty = 1;
lock_ReleaseMutex(&bp->mx);
- osi_Log1(afsd_logp, "buf_CleanAsyncLocked starts I/O on 0x%p", bp);
+ osi_Log1(buf_logp, "buf_CleanAsyncLocked starts I/O on 0x%p", bp);
code = (*cm_buf_opsp->Writep)(&bp->fid, &bp->offset,
cm_data.buf_blockSize, 0, bp->userp,
reqp);
- osi_Log2(afsd_logp, "buf_CleanAsyncLocked I/O on 0x%p, done=%d", bp, code);
+ osi_Log2(buf_logp, "buf_CleanAsyncLocked I/O on 0x%p, done=%d", bp, code);
lock_ObtainMutex(&bp->mx);
- if (code)
- break;
+ /* if the Write routine returns No Such File, clear the dirty flag
+ * because we aren't going to be able to write this data to the file
+ * server.
+ */
+ if (code == CM_ERROR_NOSUCHFILE){
+ bp->flags &= ~CM_BUF_DIRTY;
+ bp->flags |= CM_BUF_ERROR;
+ bp->error = CM_ERROR_NOSUCHFILE;
+ }
#ifdef DISKCACHE95
/* Disk cache support */
osi_Log1(buf_logp, "buf_WaitIO Waking bp 0x%p", bp);
osi_Wakeup((LONG_PTR) bp);
}
+ return isdirty;
}
/* Called with a zero-ref count buffer and with the buf_globalLock write locked.
if (scp) {
bp->flags |= CM_BUF_INHASH;
bp->fid = scp->fid;
+#ifdef DEBUG
+ bp->scp = scp;
+#endif
bp->offset = *offsetp;
i = BUF_HASH(&scp->fid, offsetp);
bp->hashp = cm_data.buf_hashTablepp[i];
if (bp) {
/* lock it and break out */
lock_ObtainMutex(&bp->mx);
- break;
#ifdef DISKCACHE95
/* touch disk chunk to update LRU info */
diskcache_Touch(bp->dcp);
#endif /* DISKCACHE95 */
+ break;
}
/* otherwise, we have to create a page */
code = buf_GetNewLocked(scp, &pageOffset, &bp);
+ /* bp->mx is now held */
/* check if the buffer was created in a race condition branch.
* If so, go around so we can hold a reference to it.
}
/* clean a buffer synchronously */
-void buf_CleanAsync(cm_buf_t *bp, cm_req_t *reqp)
+long buf_CleanAsync(cm_buf_t *bp, cm_req_t *reqp)
{
+ long code;
osi_assert(bp->magic == CM_BUF_MAGIC);
lock_ObtainMutex(&bp->mx);
- buf_CleanAsyncLocked(bp, reqp);
+ code = buf_CleanAsyncLocked(bp, reqp);
lock_ReleaseMutex(&bp->mx);
+
+ return code;
}
/* wait for a buffer's cleaning to finish */
/* now no locks are held; clean buffer and go on */
cm_InitReq(&req);
- buf_CleanAsync(bp, &req);
- buf_CleanWait(NULL, bp);
+ buf_CleanAsync(bp, &req);
+ buf_CleanWait(NULL, bp);
/* relock and release buffer */
lock_ObtainWrite(&buf_globalLock);
}
}
+ cm_SyncOpDone( scp, bufp,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS
+ | CM_SCACHESYNC_SETSIZE | CM_SCACHESYNC_BUFLOCKED);
+
lock_ReleaseMutex(&scp->mx);
lock_ReleaseMutex(&bufp->mx);
bp->userp = userp;
lock_ReleaseMutex(&bp->mx);
}
- buf_CleanAsync(bp, reqp);
- buf_CleanWait(scp, bp);
+ code = buf_CleanAsync(bp, reqp);
+ buf_CleanWait(scp, bp);
lock_ObtainMutex(&bp->mx);
if (bp->flags & CM_BUF_ERROR) {
if (code == 0 || code == -1)
FlushFileBuffers(handle);
CloseHandle(handle);
}
+
+long buf_DirtyBuffersExist(cm_fid_t *fidp)
+{
+ cm_buf_t *bp;
+ afs_uint32 bcount = 0;
+
+ for (bp = cm_data.buf_allp; bp; bp=bp->allp, bcount++) {
+ if (!cm_FidCmp(fidp, &bp->fid) && (bp->flags & CM_BUF_DIRTY))
+ return 1;
+ }
+ return 0;
+}
+
+long buf_CleanDirtyBuffers(cm_scache_t *scp)
+{
+ cm_buf_t *bp;
+ afs_uint32 bcount = 0;
+ cm_fid_t * fidp = &scp->fid;
+
+ for (bp = cm_data.buf_allp; bp; bp=bp->allp, bcount++) {
+ if (!cm_FidCmp(fidp, &bp->fid) && (bp->flags & CM_BUF_DIRTY)) {
+ buf_Hold(bp);
+ lock_ObtainMutex(&bp->mx);
+ bp->cmFlags &= ~CM_BUF_CMSTORING;
+ bp->flags &= ~CM_BUF_DIRTY;
+ bp->flags |= CM_BUF_ERROR;
+ bp->error = VNOVNODE;
+ bp->dataVersion = -1; /* bad */
+ bp->dirtyCounter++;
+ if (bp->flags & CM_BUF_WAITING) {
+ osi_Log2(buf_logp, "BUF CleanDirtyBuffers Waking [scp 0x%x] bp 0x%x", scp, bp);
+ osi_Wakeup((long) &bp);
+ }
+ lock_ReleaseMutex(&bp->mx);
+ buf_Release(bp);
+ }
+ }
+ return 0;
+}
+
#endif /* notdef */
osi_hyper_t offset; /* offset */
cm_fid_t fid; /* file ID */
+#ifdef DEBUG
+ cm_scache_t *scp; /* for debugging, the scache object belonging to */
+ /* the fid at the time of fid assignment. */
+#endif
long flags; /* flags we're using */
long size; /* size in bytes of this buffer */
char *datap; /* data in this buffer */
long counter; /* counter of changes to identity */
} cm_softRef_t;
-#define CM_BUF_READING 1 /* now reading buffer to the disk */
+#define CM_BUF_READING 1 /* now reading buffer from the disk */
#define CM_BUF_WRITING 2 /* now writing buffer to the disk */
#define CM_BUF_INHASH 4 /* in the hash table */
#define CM_BUF_DIRTY 8 /* buffer is dirty */
extern long buf_GetNew(struct cm_scache *, osi_hyper_t *, cm_buf_t **);
-extern void buf_CleanAsyncLocked(cm_buf_t *, cm_req_t *);
+extern long buf_CleanAsyncLocked(cm_buf_t *, cm_req_t *);
-extern void buf_CleanAsync(cm_buf_t *, cm_req_t *);
+extern long buf_CleanAsync(cm_buf_t *, cm_req_t *);
extern void buf_CleanWait(cm_scache_t *, cm_buf_t *);
extern void buf_ForceTrace(BOOL flush);
+extern long buf_DirtyBuffersExist(cm_fid_t * fidp);
+
+extern long buf_CleanDirtyBuffers(cm_scache_t *scp);
+
/* error codes */
#define CM_BUF_EXISTS 1 /* buffer exists, and shouldn't */
#endif /* _BUF_H__ENV_ */
/* turn off mustCall, since it has now forced us past the check above */
mustCall = 0;
+#if 0
+ /* 20060929 jaltman - We are being called from within cm_SyncOp.
+ * if we call cm_SyncOp again and another thread has attempted
+ * to obtain current status CM_SCACHEFLAG_WAITING will be set
+ * and we will deadlock.
+ */
/* otherwise, we have to make an RPC to get the status */
sflags = CM_SCACHESYNC_FETCHSTATUS | CM_SCACHESYNC_GETCALLBACK;
cm_SyncOp(scp, NULL, userp, reqp, 0, sflags);
+#endif /* deadlock */
cm_StartCallbackGrantingCall(scp, &cbr);
sfid = scp->fid;
lock_ReleaseMutex(&scp->mx);
} else {
cm_EndCallbackGrantingCall(NULL, &cbr, NULL, 0);
}
+#if 0
+ /* 20060929 jaltman - don't deadlock */
cm_SyncOpDone(scp, NULL, sflags);
+#endif
/* now check to see if we got an error */
if (code) {
lock_ReleaseWrite(&cm_daemonLock);
}
-void cm_QueueBKGRequest(cm_scache_t *scp, cm_bkgProc_t *procp, long p1, long p2, long p3, long p4,
+void cm_QueueBKGRequest(cm_scache_t *scp, cm_bkgProc_t *procp, afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, afs_uint32 p4,
cm_user_t *userp)
{
cm_bkgRequest_t *rp;
void cm_InitDaemon(int nDaemons);
-typedef void (cm_bkgProc_t)(cm_scache_t *scp, long p1, long p2, long p3,
- long p4, struct cm_user *up);
+typedef void (cm_bkgProc_t)(cm_scache_t *scp, afs_uint32 p1, afs_uint32 p2, afs_uint32 p3,
+ afs_uint32 p4, struct cm_user *up);
typedef struct cm_bkgRequest {
osi_queue_t q;
cm_bkgProc_t *procp;
cm_scache_t *scp;
- long p1;
- long p2;
- long p3;
- long p4;
+ afs_uint32 p1;
+ afs_uint32 p2;
+ afs_uint32 p3;
+ afs_uint32 p4;
struct cm_user *userp;
} cm_bkgRequest_t;
-extern void cm_QueueBKGRequest(cm_scache_t *scp, cm_bkgProc_t *procp, long p1,
- long p2, long p3, long p4, cm_user_t *userp);
+extern void cm_QueueBKGRequest(cm_scache_t *scp, cm_bkgProc_t *procp, afs_uint32 p1,
+ afs_uint32 p2, afs_uint32 p3, afs_uint32 p4, cm_user_t *userp);
#endif /* __CM_DAEMON_H_ENV_ */
* buffer, although more likely it will just return a new, empty, buffer.
*/
scp = cm_FindSCache(fidp);
- if (scp == NULL)
+ if (scp == NULL) {
return CM_ERROR_NOSUCHFILE; /* shouldn't happen */
+ }
cm_AFSFidFromFid(&tfid, fidp);
lock_ObtainMutex(&scp->mx);
+ if (scp->flags & CM_SCACHEFLAG_DELETED) {
+ lock_ReleaseMutex(&scp->mx);
+ cm_ReleaseSCache(scp);
+ return CM_ERROR_NOSUCHFILE;
+ }
code = cm_SetupStoreBIOD(scp, offsetp, length, &biod, userp, reqp);
if (code) {
scp = parmp;
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_SETSIZE);
+
lock_ReleaseMutex(&scp->mx);
/* always succeeds */
&& bp->dataVersion != scp->dataVersion)
stop = 1;
buf_Release(bp);
+ bp = NULL;
}
else
stop = 1;
return code;
}
-void cm_BkgStore(cm_scache_t *scp, long p1, long p2, long p3, long p4,
+void cm_BkgStore(cm_scache_t *scp, afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, afs_uint32 p4,
cm_user_t *userp)
{
osi_hyper_t toffset;
long length;
cm_req_t req;
+ long code;
+
+ if (scp->flags & CM_SCACHEFLAG_DELETED) {
+ osi_Log4(afsd_logp, "Skipping BKG store - Deleted scp 0x%p, offset 0x%x:%08x, length 0x%x", scp, p2, p1, p3);
+ return;
+ }
cm_InitReq(&req);
+#ifdef NO_BKG_RETRIES
req.flags |= CM_REQ_NORETRY;
+#endif
toffset.LowPart = p1;
toffset.HighPart = p2;
osi_Log4(afsd_logp, "Starting BKG store scp 0x%p, offset 0x%x:%08x, length 0x%x", scp, p2, p1, p3);
- cm_BufWrite(&scp->fid, &toffset, length, /* flags */ 0, userp, &req);
+ code = cm_BufWrite(&scp->fid, &toffset, length, /* flags */ 0, userp, &req);
lock_ObtainMutex(&scp->mx);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_ASYNCSTORE);
lock_ObtainMutex(&scp->mx);
bufp = NULL;
- for (temp = 0; temp < inSize; temp += cm_data.buf_blockSize, bufp = NULL) {
+ for (temp = 0; temp < inSize; temp += cm_data.buf_blockSize) {
thyper.HighPart = 0;
thyper.LowPart = temp;
tbase = LargeIntegerAdd(*inOffsetp, thyper);
cm_SyncOpDone(scp, bufp, flags);
lock_ReleaseMutex(&bufp->mx);
buf_Release(bufp);
+ bufp = NULL;
}
}
biop->length = cm_data.buf_blockSize;
firstModOffset = bufp->offset;
biop->offset = firstModOffset;
+ bufp = NULL; /* this buffer and reference added to the queue */
/* compute the window surrounding *inOffsetp of size cm_chunkSize */
scanStart = *inOffsetp;
lock_ObtainMutex(&scp->mx);
if (code == 0) {
buf_Release(bufp);
+ bufp = NULL;
break;
}
if (code) {
lock_ReleaseMutex(&bufp->mx);
buf_Release(bufp);
+ bufp = NULL;
break;
}
cm_SyncOpDone(scp, bufp, flags);
lock_ReleaseMutex(&bufp->mx);
buf_Release(bufp);
+ bufp = NULL;
break;
}
osi_QAddT((osi_queue_t **) &biop->bufListp,
(osi_queue_t **) &biop->bufListEndp,
&qdp->q);
+ bufp = NULL; /* added to the queue */
/* update biod info describing the transfer */
biop->offset = LargeIntegerSubtract(biop->offset, thyper);
lock_ObtainMutex(&scp->mx);
if (code == 0) {
buf_Release(bufp);
+ bufp = NULL;
break;
}
if (code) {
lock_ReleaseMutex(&bufp->mx);
buf_Release(bufp);
+ bufp = NULL;
break;
}
cm_SyncOpDone(scp, bufp, flags);
lock_ReleaseMutex(&bufp->mx);
buf_Release(bufp);
+ bufp = NULL;
break;
}
osi_QAddH((osi_queue_t **) &biop->bufListp,
(osi_queue_t **) &biop->bufListEndp,
&qdp->q);
+ bufp = NULL;
/* update biod info describing the transfer */
biop->length += cm_data.buf_blockSize;
lock_ReleaseMutex(&scp->mx);
lock_ReleaseMutex(&bufp->mx);
buf_Release(bufp);
+ bufp = NULL;
}
/* clean things out */
nbytes_hi = ntohl(nbytes_hi);
} else {
nbytes_hi = 0;
- code = callp->error;
+ code = callp->error;
rx_EndCall(callp, code);
callp = NULL;
}
extern long cm_SetupStoreBIOD(cm_scache_t *scp, osi_hyper_t *inOffsetp,
long inSize, cm_bulkIO_t *biop, cm_user_t *userp, cm_req_t *reqp);
-extern void cm_BkgPrefetch(cm_scache_t *scp, long p1, long p2, long p3, long p4,
+extern void cm_BkgPrefetch(cm_scache_t *scp, afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, afs_uint32 p4,
struct cm_user *userp);
-extern void cm_BkgStore(cm_scache_t *scp, long p1, long p2, long p3, long p4,
+extern void cm_BkgStore(cm_scache_t *scp, afs_uint32 p1, afs_uint32 p2, afs_uint32 p3, afs_uint32 p4,
struct cm_user *userp);
extern void cm_ConsiderPrefetch(cm_scache_t *scp, osi_hyper_t *offsetp,
/* if something went wrong, bail out now */
if (code) {
- goto done;
+ goto done2;
}
lock_ObtainMutex(&scp->mx);
if (code) {
lock_ReleaseMutex(&scp->mx);
cm_ReleaseSCache(scp);
- goto done;
+ goto done2;
}
/* now check that this is a real mount point */
lock_ReleaseMutex(&scp->mx);
cm_ReleaseSCache(scp);
code = CM_ERROR_INVAL;
- goto done;
+ goto done1;
}
/* time to make the RPC, so drop the lock */
FILE_NOTIFY_CHANGE_DIR_NAME,
dscp, cp, NULL, TRUE);
- done:
+ done1:
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
+ done2:
cm_ReleaseSCache(dscp);
return code;
}
/* if something went wrong, bail out now */
if (code) {
- goto done;
+ goto done2;
}
lock_ObtainMutex(&scp->mx);
if (code) {
lock_ReleaseMutex(&scp->mx);
cm_ReleaseSCache(scp);
- goto done;
+ goto done2;
}
/* now check that this is a real symlink */
lock_ReleaseMutex(&scp->mx);
cm_ReleaseSCache(scp);
code = CM_ERROR_INVAL;
- goto done;
+ goto done1;
}
/* time to make the RPC, so drop the lock */
| FILE_NOTIFY_CHANGE_DIR_NAME,
dscp, cp, NULL, TRUE);
- done:
+ done1:
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
+ done2:
cm_ReleaseSCache(dscp);
return code;
}
lock_ObtainMutex(&bufp->mx);
bufp->cmFlags &= ~CM_BUF_CMSTORING;
bufp->flags &= ~CM_BUF_DIRTY;
+ bufp->flags |= CM_BUF_ERROR;
+ bufp->error = VNOVNODE;
bufp->dataVersion = -1; /* bad */
bufp->dirtyCounter++;
if (bufp->flags & CM_BUF_WAITING) {
lock_ObtainMutex(&bufp->mx);
bufp->cmFlags &= ~CM_BUF_CMFETCHING;
bufp->flags &= ~CM_BUF_DIRTY;
+ bufp->flags |= CM_BUF_ERROR;
+ bufp->error = VNOVNODE;
bufp->dataVersion = -1; /* bad */
bufp->dirtyCounter++;
if (bufp->flags & CM_BUF_WAITING) {
buf_Release(bufp);
}
}
+ buf_CleanDirtyBuffers(scp);
} else {
/* look for things that shouldn't still be set */
osi_assert(scp->bufWritesp == NULL);
/* invalidate so next merge works fine;
* also initialize some flags */
scp->flags &= ~(CM_SCACHEFLAG_STATD
+ | CM_SCACHEFLAG_DELETED
| CM_SCACHEFLAG_RO
| CM_SCACHEFLAG_PURERO
| CM_SCACHEFLAG_OVERQUOTA
cm_scache_t *cm_GetNewSCache(void)
{
cm_scache_t *scp;
+ int retry = 0;
- start:
- if (cm_data.currentSCaches >= cm_data.maxSCaches) {
- for (scp = cm_data.scacheLRULastp;
- scp;
- scp = (cm_scache_t *) osi_QPrev(&scp->q)) {
- if (scp->refCount == 0)
- break;
- }
-
- if (scp) {
- osi_assert(scp >= cm_data.scacheBaseAddress && scp < (cm_scache_t *)cm_data.hashTablep);
-
- if (!cm_RecycleSCache(scp, 0)) {
-
+ /* first pass - look for deleted objects */
+ for ( scp = cm_data.scacheLRULastp;
+ scp;
+ scp = (cm_scache_t *) osi_QPrev(&scp->q))
+ {
+ osi_assert(scp >= cm_data.scacheBaseAddress && scp < (cm_scache_t *)cm_data.hashTablep);
+
+ if (scp->refCount == 0) {
+ if (scp->flags & CM_SCACHEFLAG_DELETED) {
+ osi_Log1(afsd_logp, "GetNewSCache attempting to recycle deleted scp 0x%x", scp);
+ if (!cm_RecycleSCache(scp, CM_SCACHE_RECYCLEFLAG_DESTROY_BUFFERS)) {
+
+ /* we found an entry, so return it */
+ /* now remove from the LRU queue and put it back at the
+ * head of the LRU queue.
+ */
+ cm_AdjustLRU(scp);
+
+ /* and we're done */
+ return scp;
+ }
+ osi_Log1(afsd_logp, "GetNewSCache recycled failed scp 0x%x", scp);
+ } else if (!(scp->flags & CM_SCACHEFLAG_INHASH)) {
/* we found an entry, so return it */
/* now remove from the LRU queue and put it back at the
- * head of the LRU queue.
- */
+ * head of the LRU queue.
+ */
cm_AdjustLRU(scp);
/* and we're done */
return scp;
+ }
+ }
+ }
+ osi_Log0(afsd_logp, "GetNewSCache no deleted or recycled entries available for reuse");
+
+ if (cm_data.currentSCaches >= cm_data.maxSCaches) {
+ /* There were no deleted scache objects that we could use. Try to find
+ * one that simply hasn't been used in a while.
+ */
+ while (1) {
+ for ( scp = cm_data.scacheLRULastp;
+ scp;
+ scp = (cm_scache_t *) osi_QPrev(&scp->q))
+ {
+ /* It is possible for the refCount to be zero and for there still
+ * to be outstanding dirty buffers. If there are dirty buffers,
+ * we must not recycle the scp. */
+ if (scp->refCount == 0 && scp->bufReadsp == NULL && scp->bufWritesp == NULL) {
+ if (!buf_DirtyBuffersExist(&scp->fid)) {
+ if (!cm_RecycleSCache(scp, 0)) {
+ /* we found an entry, so return it */
+ /* now remove from the LRU queue and put it back at the
+ * head of the LRU queue.
+ */
+ cm_AdjustLRU(scp);
+
+ /* and we're done */
+ return scp;
+ }
+ } else {
+ osi_Log1(afsd_logp,"GetNewSCache dirty buffers exist scp 0x%x", scp);
+ }
+ }
+ }
+ osi_Log1(afsd_logp, "GetNewSCache all scache entries in use (retry = %d)", retry);
+
+ /* If get here it means that every scache is either in use or has dirty buffers.
+ * We used to panic. Now we will give up our lock and wait.
+ */
+ if (++retry < 10) {
+ lock_ReleaseWrite(&cm_scacheLock);
+ Sleep(1000);
+ lock_ObtainWrite(&cm_scacheLock);
} else {
- /* We don't like this entry, choose another one. */
- goto start;
+ return NULL;
}
- }
+ } /* forever */
}
/* if we get here, we should allocate a new scache entry. We either are below
cm_scache_t *scp;
hash = CM_SCACHE_HASH(fidp);
-
- osi_assert(fidp->cell != 0);
+
+ if (fidp->cell == 0) {
+#ifdef DEBUG
+ DebugBreak();
+#endif
+ return NULL;
+ }
lock_ObtainWrite(&cm_scacheLock);
for (scp=cm_data.hashTablep[hash]; scp; scp=scp->nextp) {
mp = "";
}
scp = cm_GetNewSCache();
-
+ if (scp == NULL) {
+ osi_Log0(afsd_logp,"cm_getSCache unable to obtain *new* scache entry");
+ lock_ReleaseWrite(&cm_scacheLock);
+ return CM_ERROR_WOULDBLOCK;
+ }
+
lock_ObtainMutex(&scp->mx);
scp->fid = *fidp;
scp->volp = cm_data.rootSCachep->volp;
/* now, if we don't have the fid, recycle something */
scp = cm_GetNewSCache();
+ if (scp == NULL) {
+ osi_Log0(afsd_logp,"cm_getSCache unable to obtain *new* scache entry");
+ lock_ReleaseWrite(&cm_scacheLock);
+ return CM_ERROR_WOULDBLOCK;
+ }
+
osi_assert(!(scp->flags & CM_SCACHEFLAG_INHASH));
lock_ObtainMutex(&scp->mx);
scp->fid = *fidp;
// yj: modified this so that callback only checked if we're
// not checking something on /afs
/* fix the conditional to match the one in cm_HaveCallback */
- if ( (flags & CM_SCACHESYNC_NEEDCALLBACK)
+ if ((flags & CM_SCACHESYNC_NEEDCALLBACK)
#ifdef AFS_FREELANCE_CLIENT
&& (!cm_freelanceEnabled ||
!(scp->fid.vnode==0x1 && scp->fid.unique==0x1) ||
scp);
if (bufLocked)
lock_ReleaseMutex(&bufp->mx);
- code = cm_GetCallback(scp, userp, reqp, 0);
+ code = cm_GetCallback(scp, userp, reqp, (flags & CM_SCACHESYNC_FORCECB)?1:0);
if (bufLocked) {
lock_ReleaseMutex(&scp->mx);
lock_ObtainMutex(&bufp->mx);
osi_QDFree(qdp);
}
if (bufp) {
+ int release = 0;
+ if (bufp->cmFlags & CM_BUF_CMFETCHING)
+ release = 1;
bufp->cmFlags &= ~(CM_BUF_CMFETCHING | CM_BUF_CMFULLYFETCHED);
if (bufp->flags & CM_BUF_WAITING) {
osi_Log2(afsd_logp, "CM SyncOpDone Waking [scp 0x%p] bufp 0x%p", scp, bufp);
osi_Wakeup((LONG_PTR) &bufp);
}
- buf_Release(bufp);
+ if (release)
+ buf_Release(bufp);
}
}
osi_QDFree(qdp);
}
if (bufp) {
+ int release = 0;
+ if (bufp->cmFlags & CM_BUF_CMSTORING)
+ release = 1;
bufp->cmFlags &= ~CM_BUF_CMSTORING;
if (bufp->flags & CM_BUF_WAITING) {
osi_Log2(afsd_logp, "CM SyncOpDone Waking [scp 0x%p] bufp 0x%p", scp, bufp);
osi_Wakeup((LONG_PTR) &bufp);
}
- buf_Release(bufp);
+ if (release)
+ buf_Release(bufp);
}
}
#define CM_SCACHESYNC_BUFLOCKED 0x80000 /* the buffer is locked */
#define CM_SCACHESYNC_NOWAIT 0x100000/* don't wait for the state,
* just fail */
+#define CM_SCACHESYNC_FORCECB 0x200000/* when calling cm_GetCallback()
+ * set the force flag */
/* flags for cm_RecycleSCache */
#define CM_SCACHE_RECYCLEFLAG_DESTROY_BUFFERS 0x1
/* First check permissions */
lock_ObtainMutex(&dscp->mx);
code = cm_SyncOp(dscp, NULL, userp, reqp, PRSFS_DELETE,
- CM_SCACHESYNC_GETSTATUS
- | CM_SCACHESYNC_NEEDCALLBACK);
+ CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
+ cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
lock_ReleaseMutex(&dscp->mx);
if (code)
return code;
lock_ReleaseMutex(&scp->mx);
lock_ObtainMutex(&bufferp->mx);
lock_ObtainMutex(&scp->mx);
+ cm_SyncOpDone(scp, bufferp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ | CM_SCACHESYNC_BUFLOCKED);
if (code)
break;
}
lock_ReleaseMutex(&scp->mx);
break;
}
+ cm_SyncOpDone(scp, bufferp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ | CM_SCACHESYNC_BUFLOCKED);
if (cm_HaveBuffer(scp, bufferp, 1)) {
lock_ReleaseMutex(&scp->mx);
if (code) {
goto done;
}
+ cm_SyncOpDone(scp, bufp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
+
if (cm_HaveBuffer(scp, bufp, 0))
break;
cm_ReleaseSCache(tscp);
return code;
}
+ cm_SyncOpDone(tscp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
/* tscp is now locked */
if (!(flags & CM_FLAG_NOMOUNTCHASE)
buf_Release(bufp);
return code;
}
+ cm_SyncOpDone(linkScp, bufp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
+
if (cm_HaveBuffer(linkScp, bufp, 0))
break;
}
break;
}
+ cm_SyncOpDone(tscp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
if (tscp->fileType == CM_SCACHETYPE_SYMLINK) {
/* this is a symlink; assemble a new buffer */
lock_ReleaseMutex(&tscp->mx);
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code)
goto done;
-
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
if (scp->fileType != CM_SCACHETYPE_FILE) {
code = CM_ERROR_ISDIR;
goto done;
/* done successfully */
code = 0;
+ cm_SyncOpDone(scp, NULL,
+ CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS
+ | CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_SETSIZE);
+
done:
lock_ReleaseMutex(&scp->mx);
lock_ReleaseWrite(&scp->bufCreateLock);
cm_req_t *reqp)
{
long code;
- int flags;
AFSFetchStatus afsOutStatus;
AFSVolSync volSync;
cm_conn_t *connp;
if (attrp->mask & CM_ATTRMASK_LENGTH)
return cm_SetLength(scp, &attrp->length, userp, reqp);
- flags = CM_SCACHESYNC_STORESTATUS;
-
lock_ObtainMutex(&scp->mx);
/* otherwise, we have to make an RPC to get the status */
code = cm_SyncOp(scp, NULL, userp, reqp, 0, CM_SCACHESYNC_STORESTATUS);
osi_Log0(afsd_logp, "cm_LockCheckPerms user is creator but has no INSERT bits for scp");
}
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
osi_Log1(afsd_logp, "cm_LockCheckPerms returning code %d", code);
return code;
if (code)
goto done;
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
/* now we have the entry locked, look up the length */
fileLength = scp->length;
if (code)
goto done;
+ cm_SyncOpDone(scp, bufferp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
+
if (cm_HaveBuffer(scp, bufferp, 0)) break;
/* otherwise, load the buffer and try again */
if (code)
goto done;
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_GETSTATUS);
+
#if 0
/* make sure we have a writable FD */
if (!(fidp->flags & SMB_FID_OPENWRITE)) {
| CM_SCACHESYNC_BUFLOCKED);
if (code)
goto done;
-
+
+ cm_SyncOpDone(scp, bufferp,
+ CM_SCACHESYNC_NEEDCALLBACK
+ | CM_SCACHESYNC_WRITE
+ | CM_SCACHESYNC_BUFLOCKED);
+
/* If we're overwriting the entire buffer, or
* if we're writing at or past EOF, mark the
* buffer as current so we don't call
lock_ReleaseMutex(&scp->mx);
cm_QueueBKGRequest(scp, cm_BkgStore, writeBackOffset.LowPart,
writeBackOffset.HighPart, cm_chunkSize, 0, userp);
- }
+ }
+ /* cm_SyncOpDone is called when cm_BkgStore completes */
return code;
}
void smb_SetRequestStartTime()
{
- time_t * tp = malloc(sizeof(time_t));
+ time_t * tp = TlsGetValue(smb_TlsRequestSlot);
+ if (!tp)
+ tp = malloc(sizeof(time_t));
if (tp) {
*tp = osi_Time();
smb_tid_t *tidp;
lock_ObtainWrite(&smb_rctLock);
+ retry:
for (tidp = vcp->tidsp; tidp; tidp = tidp->nextp) {
+ if (tidp->refCount == 0 && tidp->delete) {
+ tidp->refCount++;
+ lock_ReleaseWrite(&smb_rctLock);
+ smb_ReleaseTID(tidp);
+ lock_ObtainWrite(&smb_rctLock);
+ goto retry;
+ }
+
if (tid == tidp->tid) {
tidp->refCount++;
break;
retry:
for(fidp = vcp->fidsp; fidp; fidp = (smb_fid_t *) osi_QNext(&fidp->q)) {
+ if (fidp->refCount == 0 && fidp->delete) {
+ fidp->refCount++;
+ lock_ReleaseWrite(&smb_rctLock);
+ smb_ReleaseFID(fidp);
+ lock_ObtainWrite(&smb_rctLock);
+ goto retry;
+ }
if (fid == fidp->fid) {
if (newFid) {
fid++;
continue;
}
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
attr = smb_Attributes(scp);
/* check hidden attribute (the flag is only ON when dot file hiding is on ) */
if (patchp->flags & SMB_DIRLISTPATCH_DOTFILE)
return code;
}
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
dirLength = scp->length;
bufferp = NULL;
bufferOffset.LowPart = bufferOffset.HighPart = 0;
break;
}
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
+
if (cm_HaveBuffer(scp, bufferp, 0)) {
osi_Log2(smb_logp, "SMB search dir !HaveBuffer scp %x bufferp %x", scp, bufferp);
break;
/* release the mutex */
lock_ReleaseMutex(&scp->mx);
- if (bufferp) buf_Release(bufferp);
+ if (bufferp) {
+ buf_Release(bufferp);
+ bufferp = NULL;
+ }
/* apply and free last set of patches; if not doing a star match, this
* will be empty, but better safe (and freeing everything) than sorry.
lock_ObtainMutex(&newScp->mx);
code = cm_SyncOp(newScp, NULL, userp, &req, PRSFS_LOOKUP,
CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_NEEDCALLBACK);
- if (code && code != CM_ERROR_NOACCESS) {
- lock_ReleaseMutex(&newScp->mx);
- cm_ReleaseSCache(newScp);
- cm_ReleaseUser(userp);
- return code;
+ if (code) {
+ if (code != CM_ERROR_NOACCESS) {
+ lock_ReleaseMutex(&newScp->mx);
+ cm_ReleaseSCache(newScp);
+ cm_ReleaseUser(userp);
+ return code;
+ }
+ } else {
+ cm_SyncOpDone(newScp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
}
attrs = smb_Attributes(newScp);
return code;
}
+ cm_SyncOpDone(newScp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
/* Check for RO volume */
if (newScp->flags & CM_SCACHEFLAG_RO) {
lock_ReleaseMutex(&newScp->mx);
code = CM_ERROR_NOSUCHFILE;
else if (dscp->fileType == CM_SCACHETYPE_DIRECTORY) {
cm_buf_t *bp = buf_Find(dscp, &hzero);
- if (bp)
+ if (bp) {
buf_Release(bp);
- else
+ bp = NULL;
+ } else
code = CM_ERROR_NOSUCHFILE;
}
cm_ReleaseSCache(dscp);
return code;
}
+ cm_SyncOpDone(newScp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
#ifdef undef
/* use smb_Attributes instead. Also the fact that a file is
* in a readonly volume doesn't mean it shojuld be marked as RO
cm_UnlockByKey(scp, key, CM_UNLOCK_BY_FID, userp, &req);
- cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK);
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS | CM_SCACHESYNC_LOCK);
post_syncopdone:
smb_FullName(dscp, scp, pathp, &fullPathp, userp, &req);
if (scp->fileType == CM_SCACHETYPE_DIRECTORY) {
code = cm_RemoveDir(dscp, fullPathp, userp, &req);
- if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
- smb_NotifyChange(FILE_ACTION_REMOVED,
- FILE_NOTIFY_CHANGE_DIR_NAME,
- dscp, fullPathp, NULL, TRUE);
+ if (code == 0) {
+ scp->flags |= CM_SCACHEFLAG_DELETED;
+ if (dscp->flags & CM_SCACHEFLAG_ANYWATCH)
+ smb_NotifyChange(FILE_ACTION_REMOVED,
+ FILE_NOTIFY_CHANGE_DIR_NAME,
+ dscp, fullPathp, NULL, TRUE);
+ }
} else {
code = cm_Unlink(dscp, fullPathp, userp, &req);
- if (code == 0 && (dscp->flags & CM_SCACHEFLAG_ANYWATCH))
- smb_NotifyChange(FILE_ACTION_REMOVED,
- FILE_NOTIFY_CHANGE_FILE_NAME,
- dscp, fullPathp, NULL, TRUE);
+ if (code == 0) {
+ scp->flags |= CM_SCACHEFLAG_DELETED;
+ if (dscp->flags & CM_SCACHEFLAG_ANYWATCH)
+ smb_NotifyChange(FILE_ACTION_REMOVED,
+ FILE_NOTIFY_CHANGE_FILE_NAME,
+ dscp, fullPathp, NULL, TRUE);
+ }
}
free(fullPathp);
lock_ObtainMutex(&fidp->mx);
osi_hyper_t bufferOffset;
long bufIndex, nbytes;
int chunk;
- int sequential = 0;
+ int sequential = (fidp->flags & SMB_FID_SEQUENTIAL);
cm_req_t req;
cm_InitReq(&req);
fidp->prev_chunk = fidp->curr_chunk;
fidp->curr_chunk = chunk;
}
- if (fidp->curr_chunk == fidp->prev_chunk + 1)
+ if (!(fidp->flags & SMB_FID_RANDOM) && (fidp->curr_chunk == fidp->prev_chunk + 1))
sequential = 1;
}
lock_ReleaseMutex(&fidp->mx);
/* start by looking up the file's end */
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
- if (code) goto done;
+ if (code)
+ goto done;
+
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
/* now we have the entry locked, look up the length */
fileLength = scp->length;
code = cm_SyncOp(scp, bufferp, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK |
CM_SCACHESYNC_READ);
- if (code) goto done;
-
+ if (code)
+ goto done;
+
+ cm_SyncOpDone(scp, bufferp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
+
if (cm_HaveBuffer(scp, bufferp, 0)) break;
/* otherwise, load the buffer and try again */
done:
lock_ReleaseMutex(&scp->mx);
- if (bufferp)
+ if (bufferp)
buf_Release(bufferp);
if (code == 0 && sequential)
if (code)
goto done;
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_SETSTATUS | CM_SCACHESYNC_GETSTATUS);
+
/* now we have the entry locked, look up the length */
fileLength = scp->length;
minLength = fileLength;
if (code)
goto done;
+ cm_SyncOpDone(scp, bufferp,
+ CM_SCACHESYNC_NEEDCALLBACK
+ | CM_SCACHESYNC_WRITE
+ | CM_SCACHESYNC_BUFLOCKED);
+
/* If we're overwriting the entire buffer, or
* if we're writing at or past EOF, mark the
* buffer as current so we don't call
lock_ReleaseMutex(&scp->mx);
cm_QueueBKGRequest(scp, cm_BkgStore, writeBackOffset.LowPart,
writeBackOffset.HighPart, cm_chunkSize, 0, userp);
+ /* cm_SyncOpDone is called at the completion of cm_BkgStore */
}
cm_ReleaseSCache(scp);
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code == 0) {
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (whence == 1) {
/* offset from current offset */
new_offset = LargeIntegerAdd(fidp->offset,
#define SMB_FID_MTIMESETDONE 0x80 /* have set modtime via Tr2 */
#define SMB_FID_LOOKSLIKECOPY (SMB_FID_LENGTHSETDONE | SMB_FID_MTIMESETDONE)
#define SMB_FID_NTOPEN 0x100 /* have dscp and pathp */
+#define SMB_FID_SEQUENTIAL 0x200
+#define SMB_FID_RANDOM 0x400
#define SMB_FID_SHARE_READ 0x1000
#define SMB_FID_SHARE_WRITE 0x2000
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
if (code) goto done;
+
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
/* now we have the status in the cache entry, and everything is locked.
* Marshall the output data.
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_GETSTATUS
| CM_SCACHESYNC_NEEDCALLBACK);
- lock_ReleaseMutex(&scp->mx);
if (code) {
+ lock_ReleaseMutex(&scp->mx);
goto done;
}
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ReleaseMutex(&scp->mx);
lock_ObtainMutex(&fidp->mx);
lock_ObtainMutex(&scp->mx);
if (code)
goto done;
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
/* now we have the status in the cache entry, and everything is locked.
* Marshall the output data.
*/
code = cm_SyncOp(scp, NULL, userp, &req, 0,
CM_SCACHESYNC_GETSTATUS
| CM_SCACHESYNC_NEEDCALLBACK);
- lock_ReleaseMutex(&scp->mx);
- if (code)
+ if (code) {
+ lock_ReleaseMutex(&scp->mx);
goto done;
+ }
+
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+ lock_ReleaseMutex(&scp->mx);
lock_ObtainMutex(&fidp->mx);
lock_ObtainMutex(&scp->mx);
}
continue;
}
-
+
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
/* now watch for a symlink */
code = 0;
while (code == 0 && scp->fileType == CM_SCACHETYPE_SYMLINK) {
return code;
}
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
startsearch:
dirLength = scp->length;
bufferp = NULL;
osi_Log2(smb_logp, "T2 search dir cm_SyncOp scp %x failed %d", scp, code);
break;
}
-
+
+ cm_SyncOpDone(scp, bufferp, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_READ);
+
if (cm_HaveBuffer(scp, bufferp, 0)) {
osi_Log2(smb_logp, "T2 search dir !HaveBuffer scp %x bufferp %x", scp, bufferp);
break;
/* release the mutex */
lock_ReleaseMutex(&scp->mx);
- if (bufferp)
+ if (bufferp) {
buf_Release(bufferp);
+ bufferp = NULL;
+ }
/* apply and free last set of patches; if not doing a star match, this
* will be empty, but better safe (and freeing everything) than sorry.
if (code)
goto done;
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_NEEDCALLBACK | CM_SCACHESYNC_GETSTATUS);
+
/* decode times. We need a search time, but the response to this
* call provides the date first, not the time, as returned in the
* searchTime variable. So we take the high-order bits first.
fidflags |= SMB_FID_OPENWRITE;
if (createOptions & FILE_DELETE_ON_CLOSE)
fidflags |= SMB_FID_DELONCLOSE;
+ if (createOptions & FILE_SEQUENTIAL_ONLY && !(createOptions & FILE_RANDOM_ACCESS))
+ fidflags | SMB_FID_SEQUENTIAL;
+ if (createOptions & FILE_RANDOM_ACCESS && !(createOptions & FILE_SEQUENTIAL_ONLY))
+ fidflags & SMB_FID_RANDOM;
/* and the share mode */
if (shareAccess & FILE_SHARE_READ)
fidflags |= SMB_FID_OPENWRITE;
if (createOptions & FILE_DELETE_ON_CLOSE)
fidflags |= SMB_FID_DELONCLOSE;
+ if (createOptions & FILE_SEQUENTIAL_ONLY && !(createOptions & FILE_RANDOM_ACCESS))
+ fidflags | SMB_FID_SEQUENTIAL;
+ if (createOptions & FILE_RANDOM_ACCESS && !(createOptions & FILE_SEQUENTIAL_ONLY))
+ fidflags & SMB_FID_RANDOM;
/* And the share mode */
if (shareAccess & FILE_SHARE_READ)
projects / packages / o / openafs.git / commitdiff