extern void afsi_log(char *pattern, ...);
#endif
-unsigned int cm_mountRootGen = 0;
-
/*
* Case-folding array. This was constructed by inspecting of SMBtrace output.
* I do not know anything more about it.
int cm_Is8Dot3(char *namep)
{
int sawDot = 0;
- int sawUpper = 0, sawLower = 0;
unsigned char tc;
int charCount = 0;
}
if (cm_LegalChars[tc] == 0)
return 0;
- if (tc >= 'A' && tc <= 'Z')
- sawUpper = 1;
- else if (tc >= 'a' && tc <= 'z')
- sawLower = 1;
charCount++;
if (!sawDot && charCount > 8)
/* more than 8 chars in name */
/* more than 3 chars in extension */
return 0;
}
- /*
- * Used to check that all characters were the same case.
- * This doesn't help 16-bit apps, and meanwhile it causes the
- * MS-DOS Command Prompt to misbehave; see Sybase defect 10709.
- *
- if (sawUpper && sawLower)
- return 0;
- */
return 1;
}
/*
* Number unparsing map for generating 8.3 names;
- * Taken from DFS.
+ * The version taken from DFS was on drugs.
+ * You can't include '&' and '@' in a file name.
*/
-char cm_8Dot3Mapping[41] =
+char cm_8Dot3Mapping[42] =
{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
- 'B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S',
- 'T', 'V', 'W', 'X', 'Y', 'Z', '_', '-', '$', '#', '@', '%', '!', '&', 'E', 'O'
+ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K',
+ 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U',
+ 'V', 'W', 'X', 'Y', 'Z', '_', '-', '$', '#', '!', '+', '='
};
int cm_8Dot3MapSize = sizeof(cm_8Dot3Mapping);
code = cm_SyncOp(scp, NULL, userp, reqp, rights,
CM_SCACHESYNC_GETSTATUS
| CM_SCACHESYNC_NEEDCALLBACK);
+
+ if (code == 0 &&
+ ((rights & PRSFS_WRITE) || (rights & PRSFS_READ)) &&
+ scp->fileType == CM_SCACHETYPE_FILE) {
+
+ cm_key_t key;
+ unsigned int sLockType;
+ LARGE_INTEGER LOffset, LLength;
+
+ /* Check if there's some sort of lock on the file at the
+ moment. */
+
+ key = cm_GenerateKey(CM_SESSION_CMINT,0,0);
+
+ if (rights & PRSFS_WRITE)
+ sLockType = 0;
+ else
+ sLockType = LOCKING_ANDX_SHARED_LOCK;
+
+ LOffset.HighPart = 1;
+ LOffset.LowPart = 0;
+ LLength.HighPart = 0;
+ LLength.LowPart = 1;
+
+ code = cm_Lock(scp, sLockType, LOffset, LLength, key, 0, userp, reqp, NULL);
+
+ if (code == 0) {
+ cm_Unlock(scp, sLockType, LOffset, LLength, key, userp, reqp);
+ } else {
+ /* In this case, we allow the file open to go through even
+ though we can't enforce mandatory locking on the
+ file. */
+ if (code == CM_ERROR_NOACCESS &&
+ !(rights & PRSFS_WRITE))
+ code = 0;
+ else
+ code = CM_ERROR_SHARING_VIOLATION;
+ }
+ }
+
lock_ReleaseMutex(&scp->mx);
return code;
code = cm_SyncOp(scp, NULL, userp, reqp, rights,
CM_SCACHESYNC_GETSTATUS
| CM_SCACHESYNC_NEEDCALLBACK);
- lock_ReleaseMutex(&scp->mx);
/*
* If the open will fail because the volume is readonly, then we will
*/
if (code == CM_ERROR_READONLY)
code = CM_ERROR_NOACCESS;
+ else if (code == 0 &&
+ ((rights & PRSFS_WRITE) || (rights & PRSFS_READ)) &&
+ scp->fileType == CM_SCACHETYPE_FILE) {
+ cm_key_t key;
+ unsigned int sLockType;
+ LARGE_INTEGER LOffset, LLength;
+
+ /* Check if there's some sort of lock on the file at the
+ moment. */
+
+ key = cm_GenerateKey(CM_SESSION_CMINT,0,0);
+ if (rights & PRSFS_WRITE)
+ sLockType = 0;
+ else
+ sLockType = LOCKING_ANDX_SHARED_LOCK;
+ LOffset.HighPart = 1;
+ LOffset.LowPart = 0;
+ LLength.HighPart = 0;
+ LLength.LowPart = 1;
+
+ code = cm_Lock(scp, sLockType, LOffset, LLength, key, 0, userp, reqp, NULL);
+
+ if (code == 0) {
+ cm_Unlock(scp, sLockType, LOffset, LLength, key, userp, reqp);
+ } else {
+ /* In this case, we allow the file open to go through even
+ though we can't enforce mandatory locking on the
+ file. */
+ if (code == CM_ERROR_NOACCESS &&
+ !(rights & PRSFS_WRITE))
+ code = 0;
+ else
+ code = CM_ERROR_SHARING_VIOLATION;
+ }
+ }
+
+ lock_ReleaseMutex(&scp->mx);
return code;
}
* When CAP_NT_SMBS has been negotiated, deletion (of files or directories) is
* done in three steps:
* (1) open for deletion (NT_CREATE_AND_X)
- * (2) set for deletion on close (NTWTRANSACTION2, SET_FILE_INFO)
+ * (2) set for deletion on close (NT_TRANSACTION2, SET_FILE_INFO)
* (3) close (CLOSE)
* We must not do the RPC until step 3. But if we are going to return an error
* code (e.g. directory not empty), we must return it by step 2, otherwise most
* do not have an associated cm_server_t
*/
if ( !(cm_freelanceEnabled &&
- sp->fid.cell==AFS_FAKE_ROOT_CELL_ID &&
- sp->fid.volume==AFS_FAKE_ROOT_VOL_ID ) )
+ sp->fid.cell==AFS_FAKE_ROOT_CELL_ID &&
+ sp->fid.volume==AFS_FAKE_ROOT_VOL_ID ) )
#endif /* AFS_FREELANCE_CLIENT */
- {
- int casefold = sp->caseFold;
- sp->caseFold = 0; /* we have a strong preference for exact matches */
- if ( *retscp = cm_dnlcLookup(scp, sp)) /* dnlc hit */
- {
- sp->caseFold = casefold;
- lock_ReleaseMutex(&scp->mx);
- return 0;
- }
- sp->caseFold = casefold;
- }
+ {
+ int casefold = sp->caseFold;
+ sp->caseFold = 0; /* we have a strong preference for exact matches */
+ if ( *retscp = cm_dnlcLookup(scp, sp)) /* dnlc hit */
+ {
+ sp->caseFold = casefold;
+ lock_ReleaseMutex(&scp->mx);
+ return 0;
+ }
+ sp->caseFold = casefold;
+ }
}
/*
* the offset of the buffer we have. If not, get the buffer.
*/
thyper.HighPart = curOffset.HighPart;
- thyper.LowPart = curOffset.LowPart & ~(buf_bufferSize-1);
+ thyper.LowPart = curOffset.LowPart & ~(cm_data.buf_blockSize-1);
if (!bufferp || !LargeIntegerEqualTo(thyper, bufferOffset)) {
/* wrong buffer */
if (bufferp) {
lock_ObtainRead(&scp->bufCreateLock);
code = buf_Get(scp, &thyper, &bufferp);
lock_ReleaseRead(&scp->bufCreateLock);
+ if (code) {
+ /* if buf_Get() fails we do not have a buffer object to lock */
+ bufferp = NULL;
+ break;
+ }
+
+#ifdef AFSIFS
+ /* for the IFS version, we bulkstat the dirents because this
+ routine is used in place of smb_ReceiveCoreSearchDir. our
+ other option is to modify smb_ReceiveCoreSearchDir itself,
+ but this seems to be the proper use for cm_ApplyDir. */
+ lock_ObtainMutex(&scp->mx);
+ if ((scp->flags & CM_SCACHEFLAG_BULKSTATTING) == 0
+ && (scp->bulkStatProgress.QuadPart <= thyper.QuadPart))
+ {
+ scp->flags |= CM_SCACHEFLAG_BULKSTATTING;
+ cm_TryBulkStat(scp, &thyper, userp, reqp);
+ scp->flags &= ~CM_SCACHEFLAG_BULKSTATTING;
+ scp->bulkStatProgress = thyper;
+ }
+ lock_ReleaseMutex(&scp->mx);
+#endif
lock_ObtainMutex(&bufferp->mx);
- if (code)
- break;
bufferOffset = thyper;
/* now get the data in the cache */
break;
}
} /* if (wrong buffer) ... */
-
+
/* now we have the buffer containing the entry we're interested
* in; copy it out if it represents a non-deleted entry.
*/
entryInDir = curOffset.LowPart & (2048-1);
- entryInBuffer = curOffset.LowPart & (buf_bufferSize - 1);
+ entryInBuffer = curOffset.LowPart & (cm_data.buf_blockSize - 1);
/* page header will help tell us which entries are free. Page
* header can change more often than once per buffer, since
* buffer package buffer.
*/
/* only look intra-buffer */
- temp = curOffset.LowPart & (buf_bufferSize - 1);
+ temp = curOffset.LowPart & (cm_data.buf_blockSize - 1);
temp &= ~(2048 - 1); /* turn off intra-page bits */
pageHeaderp = (cm_pageHeader_t *) (bufferp->datap + temp);
match = cm_stricmp(matchName, sp->searchNamep);
else
match = strcmp(matchName, sp->searchNamep);
- }
+ }
if (match != 0)
return 0;
osi_hyper_t thyper;
int tlen;
- if (scp->mountPointStringp)
+ if (scp->mountPointStringp[0])
return 0;
/* otherwise, we have to read it in */
}
/* someone else did the work while we were out */
- if (scp->mountPointStringp) {
+ if (scp->mountPointStringp[0]) {
code = 0;
goto done;
}
/* otherwise, copy out the link */
- scp->mountPointStringp = malloc(tlen);
memcpy(scp->mountPointStringp, bufp->datap, tlen);
/* now make it null-terminated. Note that the original contents of a
* scp remains locked, just for simplicity of describing the interface.
*/
long cm_FollowMountPoint(cm_scache_t *scp, cm_scache_t *dscp, cm_user_t *userp,
- cm_req_t *reqp, cm_scache_t **outScpp)
+ cm_req_t *reqp, cm_scache_t **outScpp)
{
char *cellNamep;
char *volNamep;
size_t vnLength;
int type;
- if (scp->mountRootFidp && scp->mountRootGen >= cm_mountRootGen) {
- tfid = *scp->mountRootFidp;
+ if (scp->mountRootFid.cell != 0 && scp->mountRootGen >= cm_data.mountRootGen) {
+ tfid = scp->mountRootFid;
lock_ReleaseMutex(&scp->mx);
code = cm_GetSCache(&tfid, outScpp, userp, reqp);
lock_ObtainMutex(&scp->mx);
/* parse the volume name */
mpNamep = scp->mountPointStringp;
- osi_assert(mpNamep);
+ osi_assert(mpNamep[0]);
tlen = strlen(scp->mountPointStringp);
mtType = *scp->mountPointStringp;
cellNamep = malloc(tlen);
* (defect 11489)
*/
lock_ObtainMutex(&volp->mx);
- if(volp->dotdotFidp == (cm_fid_t *) NULL)
- volp->dotdotFidp = (cm_fid_t *) malloc(sizeof(cm_fid_t));
- *(volp->dotdotFidp) = dscp->fid;
+ volp->dotdotFid = dscp->fid;
lock_ReleaseMutex(&volp->mx);
- if (scp->mountRootFidp == 0) {
- scp->mountRootFidp = malloc(sizeof(cm_fid_t));
- }
- scp->mountRootFidp->cell = cellp->cellID;
+ scp->mountRootFid.cell = cellp->cellID;
/* if the mt pt is in a read-only volume (not just a
* backup), and if there is a read-only volume for the
* target, and if this is a type '#' mount point, use
&& volp->roID != 0 && type == RWVOL)
type = ROVOL;
if (type == ROVOL)
- scp->mountRootFidp->volume = volp->roID;
+ scp->mountRootFid.volume = volp->roID;
else if (type == BACKVOL)
- scp->mountRootFidp->volume = volp->bkID;
+ scp->mountRootFid.volume = volp->bkID;
else
- scp->mountRootFidp->volume = volp->rwID;
+ scp->mountRootFid.volume = volp->rwID;
/* the rest of the fid is a magic number */
- scp->mountRootFidp->vnode = 1;
- scp->mountRootFidp->unique = 1;
- scp->mountRootGen = cm_mountRootGen;
+ scp->mountRootFid.vnode = 1;
+ scp->mountRootFid.unique = 1;
+ scp->mountRootGen = cm_data.mountRootGen;
- tfid = *scp->mountRootFidp;
+ tfid = scp->mountRootFid;
lock_ReleaseMutex(&scp->mx);
code = cm_GetSCache(&tfid, outScpp, userp, reqp);
lock_ObtainMutex(&scp->mx);
if (dscp->fid.vnode == 1 && dscp->fid.unique == 1
&& strcmp(namep, "..") == 0) {
- if (dscp->dotdotFidp == (cm_fid_t *)NULL
- || dscp->dotdotFidp->volume == 0)
+ if (dscp->dotdotFid.volume == 0)
return CM_ERROR_NOSUCHVOLUME;
- rock.fid = *dscp->dotdotFidp;
+ rock.fid = dscp->dotdotFid;
goto haveFid;
}
* that we stopped early, probably because we found the entry we're
* looking for. Any other non-zero code is an error.
*/
- if (code && code != CM_ERROR_STOPNOW)
+ if (code && code != CM_ERROR_STOPNOW) {
+ /* if the cm_scache_t we are searching in is not a directory
+ * we must return path not found because the error
+ * is to describe the final component not an intermediary
+ */
+ if (code == CM_ERROR_NOTDIR) {
+ if (flags & CM_FLAG_CHECKPATH)
+ return CM_ERROR_NOSUCHPATH;
+ else
+ return CM_ERROR_NOSUCHFILE;
+ }
return code;
+ }
- getroot = (dscp==cm_rootSCachep) ;
+ getroot = (dscp==cm_data.rootSCachep) ;
if (!rock.found) {
if (!cm_freelanceEnabled || !getroot) {
if (flags & CM_FLAG_CHECKPATH)
return CM_ERROR_NOSUCHFILE;
}
else { /* nonexistent dir on freelance root, so add it */
+ char fullname[200] = ".";
+ int found = 0;
+
osi_Log1(afsd_logp,"cm_Lookup adding mount for non-existent directory: %s",
osi_LogSaveString(afsd_logp,namep));
- code = cm_FreelanceAddMount(namep, namep, "root.cell.", namep[0] == '.', &rock.fid);
- if (code < 0) { /* add mount point failed, so give up */
+ if (namep[0] == '.') {
+ if (cm_GetCell_Gen(&namep[1], &fullname[1], CM_FLAG_CREATE)) {
+ found = 1;
+ if ( stricmp(&namep[1], &fullname[1]) )
+ code = cm_FreelanceAddSymlink(namep, fullname, &rock.fid);
+ else
+ code = cm_FreelanceAddMount(namep, &fullname[1], "root.cell.", 1, &rock.fid);
+ }
+ } else {
+ if (cm_GetCell_Gen(namep, fullname, CM_FLAG_CREATE)) {
+ found = 1;
+ if ( stricmp(namep, fullname) )
+ code = cm_FreelanceAddSymlink(namep, fullname, &rock.fid);
+ else
+ code = cm_FreelanceAddMount(namep, fullname, "root.cell.", 0, &rock.fid);
+ }
+ }
+ if (!found || code < 0) { /* add mount point failed, so give up */
if (flags & CM_FLAG_CHECKPATH)
return CM_ERROR_NOSUCHPATH;
else
struct rx_connection * callp;
#ifdef AFS_FREELANCE_CLIENT
- if (cm_freelanceEnabled && dscp == cm_rootSCachep) {
+ if (cm_freelanceEnabled && dscp == cm_data.rootSCachep) {
/* deleting a mount point from the root dir. */
code = cm_FreelanceRemoveMount(namep);
return code;
afsFid.Volume = dscp->fid.volume;
afsFid.Vnode = dscp->fid.vnode;
afsFid.Unique = dscp->fid.unique;
+
+ osi_Log1(afsd_logp, "CALL RemoveFile scp 0x%x", (long) dscp);
do {
code = cm_Conn(&dscp->fid, userp, reqp, &connp);
if (code)
} while (cm_Analyze(connp, userp, reqp, &dscp->fid, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
+ if (code)
+ osi_Log1(afsd_logp, "CALL RemoveFile FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL RemoveFile SUCCESS");
+
lock_ObtainMutex(&dscp->mx);
cm_dnlcRemove(dscp, namep);
cm_SyncOpDone(dscp, NULL, sflags);
osi_hyper_t thyper;
lock_AssertMutex(&linkScp->mx);
- if (!linkScp->mountPointStringp) {
+ if (!linkScp->mountPointStringp[0]) {
/* read the link data */
lock_ReleaseMutex(&linkScp->mx);
thyper.LowPart = thyper.HighPart = 0;
/* now if we still have no link read in,
* copy the data from the buffer */
- if ((temp = linkScp->length.LowPart) >= 1024) {
+ if ((temp = linkScp->length.LowPart) >= MOUNTPOINTLEN) {
buf_Release(bufp);
return CM_ERROR_TOOBIG;
}
* lost race with someone else referencing this link above),
* and if so, copy in the data.
*/
- if (linkScp->mountPointStringp == NULL) {
- linkScp->mountPointStringp = malloc(temp+1);
+ if (!linkScp->mountPointStringp[0]) {
strncpy(linkScp->mountPointStringp, bufp->datap, temp);
linkScp->mountPointStringp[temp] = 0; /* null terminate */
}
cm_scache_t **newRootScpp, cm_space_t **newSpaceBufferp,
cm_user_t *userp, cm_req_t *reqp)
{
- long code;
+ long code = 0;
+ long len;
char *linkp;
cm_space_t *tsp;
strcpy(tsp->data, linkp+cm_mountRootLen+1);
else
tsp->data[0] = 0;
- *newRootScpp = cm_rootSCachep;
- cm_HoldSCache(cm_rootSCachep);
+ *newRootScpp = cm_data.rootSCachep;
+ cm_HoldSCache(cm_data.rootSCachep);
+ } else if (linkp[0] == '\\' && linkp[1] == '\\') {
+ if (!strnicmp(&linkp[2], cm_NetbiosName, (len = strlen(cm_NetbiosName))))
+ {
+ char * p = &linkp[len + 3];
+ if (strnicmp(p, "all", 3) == 0)
+ p += 4;
+
+ strcpy(tsp->data, p);
+ for (p = tsp->data; *p; p++) {
+ if (*p == '\\')
+ *p = '/';
+ }
+ *newRootScpp = cm_data.rootSCachep;
+ cm_HoldSCache(cm_data.rootSCachep);
+ } else {
+ linkScp->fileType = CM_SCACHETYPE_DFSLINK;
+ strcpy(tsp->data, linkp);
+ *newRootScpp = NULL;
+ code = CM_ERROR_PATH_NOT_COVERED;
+ }
+ } else if ( !strnicmp(linkp, "msdfs:", (len = strlen("msdfs:"))) ) {
+ linkScp->fileType = CM_SCACHETYPE_DFSLINK;
+ strcpy(tsp->data, linkp);
+ *newRootScpp = NULL;
+ code = CM_ERROR_PATH_NOT_COVERED;
} else if (*linkp == '\\' || *linkp == '/') {
+#if 0
/* formerly, this was considered to be from the AFS root,
* but this seems to create problems. instead, we will just
* reject the link */
-#if 0
strcpy(tsp->data, linkp+1);
- *newRootScpp = cm_rootSCachep;
- cm_HoldSCache(cm_rootSCachep);
+ *newRootScpp = cm_data.rootSCachep;
+ cm_HoldSCache(cm_data.rootSCachep);
#else
+ /* we still copy the link data into the response so that
+ * the user can see what the link points to
+ */
+ linkScp->fileType = CM_SCACHETYPE_INVALID;
+ strcpy(tsp->data, linkp);
+ *newRootScpp = NULL;
code = CM_ERROR_NOSUCHPATH;
- goto done;
#endif
- }
- else {
+ } else {
/* a relative link */
strcpy(tsp->data, linkp);
*newRootScpp = NULL;
strcat(tsp->data, pathSuffixp);
}
*newSpaceBufferp = tsp;
- code = 0;
done:
lock_ReleaseMutex(&linkScp->mx);
char *tp; /* ptr moving through input buffer */
char tc; /* temp char */
int haveComponent; /* has new component started? */
- char component[256]; /* this is the new component */
+ char component[256]; /* this is the new component */
char *cp; /* component name being assembled */
cm_scache_t *tscp; /* current location in the hierarchy */
cm_scache_t *nscp; /* next dude down */
- cm_scache_t *dirScp; /* last dir we searched */
- cm_scache_t *linkScp; /* new root for the symlink we just
+ cm_scache_t *dirScp; /* last dir we searched */
+ cm_scache_t *linkScp; /* new root for the symlink we just
* looked up */
cm_space_t *psp; /* space for current path, if we've hit
* any symlinks */
cm_space_t *tempsp; /* temp vbl */
- char *restp; /* rest of the pathname to interpret */
+ char *restp; /* rest of the pathname to interpret */
int symlinkCount; /* count of # of symlinks traversed */
- int extraFlag; /* avoid chasing mt pts for dir cmd */
- int phase = 1; /* 1 = tidPathp, 2 = pathp */
+ int extraFlag; /* avoid chasing mt pts for dir cmd */
+ int phase = 1; /* 1 = tidPathp, 2 = pathp */
tp = tidPathp;
if (tp == NULL) {
tscp = rootSCachep;
cm_HoldSCache(tscp);
symlinkCount = 0;
+ dirScp = 0;
+
while (1) {
tc = *tp++;
tc = '\\';
if (!haveComponent) {
- if (tc == '\\')
+ if (tc == '\\') {
continue;
- else if (tc == 0) {
+ } else if (tc == 0) {
if (phase == 1) {
phase = 2;
tp = pathp;
}
code = 0;
break;
- }
- else {
+ } else {
haveComponent = 1;
cp = component;
*cp++ = tc;
}
- }
- else {
+ } else {
/* we have a component here */
if (tc == 0 || tc == '\\') {
/* end of the component; we're at the last
code = cm_Lookup(tscp, component,
flags | extraFlag,
userp, reqp, &nscp);
-
if (code) {
cm_ReleaseSCache(tscp);
+ if (dirScp)
+ cm_ReleaseSCache(dirScp);
if (psp)
cm_FreeSpace(psp);
- return code;
+ if (code == CM_ERROR_NOSUCHFILE && tscp->fileType == CM_SCACHETYPE_SYMLINK)
+ return CM_ERROR_NOSUCHPATH;
+ else
+ return code;
}
haveComponent = 0; /* component done */
+ if (dirScp)
+ cm_ReleaseSCache(dirScp);
dirScp = tscp; /* for some symlinks */
- tscp = nscp; /* already held */
+ tscp = nscp; /* already held */
+ nscp = 0;
if (tc == 0 && !(flags & CM_FLAG_FOLLOW) && phase == 2) {
code = 0;
- cm_ReleaseSCache(dirScp);
+ if (dirScp) {
+ cm_ReleaseSCache(dirScp);
+ dirScp = 0;
+ }
break;
}
if (code) {
lock_ReleaseMutex(&tscp->mx);
cm_ReleaseSCache(tscp);
- cm_ReleaseSCache(dirScp);
+ tscp = 0;
+ if (dirScp) {
+ cm_ReleaseSCache(dirScp);
+ dirScp = 0;
+ }
break;
}
if (tscp->fileType == CM_SCACHETYPE_SYMLINK) {
lock_ReleaseMutex(&tscp->mx);
if (symlinkCount++ >= MAX_SYMLINK_COUNT) {
cm_ReleaseSCache(tscp);
- cm_ReleaseSCache(dirScp);
+ tscp = 0;
+ if (dirScp) {
+ cm_ReleaseSCache(dirScp);
+ dirScp = 0;
+ }
if (psp)
cm_FreeSpace(psp);
return CM_ERROR_TOO_MANY_SYMLINKS;
if (code) {
/* something went wrong */
cm_ReleaseSCache(tscp);
- cm_ReleaseSCache(dirScp);
+ tscp = 0;
+ if (dirScp) {
+ cm_ReleaseSCache(dirScp);
+ dirScp = 0;
+ }
break;
}
psp = tempsp;
tp = psp->data;
cm_ReleaseSCache(tscp);
- tscp = linkScp;
+ tscp = linkScp;
+ linkScp = 0;
/* already held
* by AssembleLink
* now, if linkScp is null, that's
* dir hierarchy.
*/
if (tscp == NULL) {
- cm_HoldSCache(dirScp);
tscp = dirScp;
+ dirScp = 0;
}
- } /* if we have a sym link */
- else {
+ } else {
/* not a symlink, we may be done */
lock_ReleaseMutex(&tscp->mx);
if (tc == 0) {
tp = pathp;
continue;
}
- cm_ReleaseSCache(dirScp);
+ if (dirScp) {
+ cm_ReleaseSCache(dirScp);
+ dirScp = 0;
+ }
code = 0;
break;
}
}
- cm_ReleaseSCache(dirScp);
+ if (dirScp) {
+ cm_ReleaseSCache(dirScp);
+ dirScp = 0;
+ }
} /* end of a component */
- else *cp++ = tc;
+ else
+ *cp++ = tc;
} /* we have a component */
} /* big while loop over all components */
/* already held */
+ if (dirScp)
+ cm_ReleaseSCache(dirScp);
if (psp)
cm_FreeSpace(psp);
if (code == 0)
*outScpp = tscp;
+ else if (tscp)
+ cm_ReleaseSCache(tscp);
return code;
}
cm_space_t *spacep;
cm_scache_t *newRootScp;
- osi_Log1(afsd_logp, "Evaluating symlink vp %x", linkScp);
+ osi_Log1(afsd_logp, "Evaluating symlink scp 0x%x", linkScp);
code = cm_AssembleLink(linkScp, "", &newRootScp, &spacep, userp, reqp);
if (code)
CM_FLAG_CASEFOLD | CM_FLAG_FOLLOW | CM_FLAG_DIRSEARCH,
userp, NULL, reqp, outScpp);
+ if (code == CM_ERROR_NOSUCHFILE)
+ code = CM_ERROR_NOSUCHPATH;
+
/* this stuff is allocated no matter what happened on the namei call,
* so free it */
cm_FreeSpace(spacep);
if (bsp->counter >= CM_BULKMAX)
return CM_ERROR_STOPNOW;
- thyper.LowPart = buf_bufferSize;
+ thyper.LowPart = cm_data.buf_blockSize;
thyper.HighPart = 0;
thyper = LargeIntegerAdd(thyper, bsp->bufOffset);
osi_Log1(afsd_logp, "cm_TryBulkStat dir 0x%x", (long) dscp);
/* should be on a buffer boundary */
- osi_assert((offsetp->LowPart & (buf_bufferSize - 1)) == 0);
+ osi_assert((offsetp->LowPart & (cm_data.buf_blockSize - 1)) == 0);
bb.counter = 0;
bb.bufOffset = *offsetp;
lock_ReleaseMutex(&dscp->mx);
/* first, assemble the file IDs we need to stat */
code = cm_ApplyDir(dscp, cm_TryBulkProc, (void *) &bb, offsetp, userp, reqp, NULL);
- lock_ObtainMutex(&dscp->mx);
/* if we failed, bail out early */
- if (code && code != CM_ERROR_STOPNOW) return;
+ if (code && code != CM_ERROR_STOPNOW) {
+ lock_ObtainMutex(&dscp->mx);
+ return;
+ }
/* otherwise, we may have one or more bulk stat's worth of stuff in bb;
* make the calls to create the entries. Handle AFSCBMAX files at a
filex = 0;
while (filex < bb.counter) {
filesThisCall = bb.counter - filex;
- if (filesThisCall > AFSCBMAX) filesThisCall = AFSCBMAX;
+ if (filesThisCall > AFSCBMAX)
+ filesThisCall = AFSCBMAX;
fidStruct.AFSCBFids_len = filesThisCall;
fidStruct.AFSCBFids_val = &bb.fids[filex];
&volSync, NULL, &cbReq, code));
code = cm_MapRPCError(code, reqp);
- osi_Log0(afsd_logp, "CALL BulkStatus DONE");
+ if (code)
+ osi_Log1(afsd_logp, "CALL BulkStatus FAILURE code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL BulkStatus SUCCESS");
/* may as well quit on an error, since we're not going to do
* much better on the next immediate call, either.
*/
- if (code)
+ if (code) {
+ cm_EndCallbackGrantingCall(NULL, &cbReq, NULL, 0);
break;
+ }
/* otherwise, we should do the merges */
- for(i = 0; i<filesThisCall; i++) {
+ for (i = 0; i<filesThisCall; i++) {
j = filex + i;
tfid.cell = dscp->fid.cell;
tfid.volume = bb.fids[j].Volume;
filex += filesThisCall;
} /* while there are still more files to process */
+ lock_ObtainMutex(&dscp->mx);
osi_Log0(afsd_logp, "END cm_TryBulkStat");
}
/* make the attr structure */
cm_StatusFromAttr(&afsInStatus, scp, attrp);
+ tfid.Volume = scp->fid.volume;
+ tfid.Vnode = scp->fid.vnode;
+ tfid.Unique = scp->fid.unique;
+
lock_ReleaseMutex(&scp->mx);
if (code)
return code;
/* now make the RPC */
- osi_Log1(afsd_logp, "CALL StoreStatus vp %x", (long) scp);
- tfid.Volume = scp->fid.volume;
- tfid.Vnode = scp->fid.vnode;
- tfid.Unique = scp->fid.unique;
+ osi_Log1(afsd_logp, "CALL StoreStatus scp 0x%x", (long) scp);
do {
code = cm_Conn(&scp->fid, userp, reqp, &connp);
if (code)
&scp->fid, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
- osi_Log1(afsd_logp, "CALL StoreStatus DONE, code %d", code);
+ if (code)
+ osi_Log1(afsd_logp, "CALL StoreStatus FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL StoreStatus SUCCESS");
lock_ObtainMutex(&scp->mx);
cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_STORESTATUS);
cm_StatusFromAttr(&inStatus, NULL, attrp);
/* try the RPC now */
+ osi_Log1(afsd_logp, "CALL CreateFile scp 0x%x", (long) dscp);
do {
code = cm_Conn(&dscp->fid, userp, reqp, &connp);
if (code)
&dscp->fid, &volSync, NULL, &cbReq, code));
code = cm_MapRPCError(code, reqp);
+ if (code)
+ osi_Log1(afsd_logp, "CALL CreateFile FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL CreateFile SUCCESS");
+
lock_ObtainMutex(&dscp->mx);
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
if (code == 0) {
cm_StatusFromAttr(&inStatus, NULL, attrp);
/* try the RPC now */
+ osi_Log1(afsd_logp, "CALL MakeDir scp 0x%x", (long) dscp);
do {
code = cm_Conn(&dscp->fid, userp, reqp, &connp);
if (code)
&dscp->fid, &volSync, NULL, &cbReq, code));
code = cm_MapRPCError(code, reqp);
+ if (code)
+ osi_Log1(afsd_logp, "CALL MakeDir FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL MakeDir SUCCESS");
+
lock_ObtainMutex(&dscp->mx);
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
if (code == 0) {
if (code)
return code;
+ /* try the RPC now */
+ osi_Log1(afsd_logp, "CALL Link scp 0x%x", (long) dscp);
do {
code = cm_Conn(&dscp->fid, userp, reqp, &connp);
if (code) continue;
code = RXAFS_Link(callp, &dirAFSFid, namep, &existingAFSFid,
&newLinkStatus, &updatedDirStatus, &volSync);
rx_PutConnection(callp);
- osi_Log1(smb_logp," RXAFS_Link returns %d", code);
+ osi_Log1(smb_logp," RXAFS_Link returns 0x%x", code);
} while (cm_Analyze(connp, userp, reqp,
&dscp->fid, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
+ if (code)
+ osi_Log1(afsd_logp, "CALL Link FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL Link SUCCESS");
+
lock_ObtainMutex(&dscp->mx);
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
if (code == 0) {
cm_StatusFromAttr(&inStatus, NULL, attrp);
/* try the RPC now */
+ osi_Log1(afsd_logp, "CALL Symlink scp 0x%x", (long) dscp);
do {
code = cm_Conn(&dscp->fid, userp, reqp, &connp);
if (code)
&dscp->fid, &volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
+ if (code)
+ osi_Log1(afsd_logp, "CALL Symlink FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL Symlink SUCCESS");
+
lock_ObtainMutex(&dscp->mx);
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
if (code == 0) {
didEnd = 0;
/* try the RPC now */
+ osi_Log1(afsd_logp, "CALL RemoveDir scp 0x%x", (long) dscp);
do {
code = cm_Conn(&dscp->fid, userp, reqp, &connp);
if (code)
} while (cm_Analyze(connp, userp, reqp,
&dscp->fid, &volSync, NULL, NULL, code));
code = cm_MapRPCErrorRmdir(code, reqp);
-
+
+ if (code)
+ osi_Log1(afsd_logp, "CALL RemoveDir FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL RemoveDir SUCCESS");
+
lock_ObtainMutex(&dscp->mx);
- cm_dnlcRemove(dscp, namep);
cm_SyncOpDone(dscp, NULL, CM_SCACHESYNC_STOREDATA);
if (code == 0) {
+ cm_dnlcRemove(dscp, namep);
cm_MergeStatus(dscp, &updatedDirStatus, &volSync, userp, 0);
}
lock_ReleaseMutex(&dscp->mx);
lock_ReleaseMutex(&newDscp->mx);
if (code) {
/* cleanup first one */
+ lock_ObtainMutex(&newDscp->mx);
cm_SyncOpDone(oldDscp, NULL,
CM_SCACHESYNC_STOREDATA);
+ lock_ReleaseMutex(&oldDscp->mx);
}
}
}
lock_ReleaseMutex(&oldDscp->mx);
if (code) {
/* cleanup first one */
+ lock_ObtainMutex(&newDscp->mx);
cm_SyncOpDone(newDscp, NULL,
CM_SCACHESYNC_STOREDATA);
+ lock_ReleaseMutex(&newDscp->mx);
}
}
}
didEnd = 0;
/* try the RPC now */
+ osi_Log2(afsd_logp, "CALL Rename old scp 0x%x new scp 0x%x",
+ (long) oldDscp, (long) newDscp);
do {
code = cm_Conn(&oldDscp->fid, userp, reqp, &connp);
if (code)
&volSync, NULL, NULL, code));
code = cm_MapRPCError(code, reqp);
+ if (code)
+ osi_Log1(afsd_logp, "CALL Rename FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL Rename SUCCESS");
+
/* update the individual stat cache entries for the directories */
lock_ObtainMutex(&oldDscp->mx);
cm_SyncOpDone(oldDscp, NULL, CM_SCACHESYNC_STOREDATA);
return code;
}
-long cm_Lock(cm_scache_t *scp, unsigned char LockType,
- LARGE_INTEGER LOffset, LARGE_INTEGER LLength,
- u_long Timeout, cm_user_t *userp, cm_req_t *reqp,
- void **lockpp)
-{
- long code;
- int Which = ((LockType & 0x1) ? LockRead : LockWrite);
- AFSFid tfid;
- AFSVolSync volSync;
- cm_conn_t *connp;
- cm_file_lock_t *fileLock;
- osi_queue_t *q;
- int found = 0;
- struct rx_connection * callp;
+/* Byte range locks:
- /* Look for a conflict. Also, if we are asking for a shared lock,
- * look for another shared lock, so we don't have to do an RPC.
- */
- q = scp->fileLocks;
- while (q) {
- fileLock = (cm_file_lock_t *)
- ((char *) q - offsetof(cm_file_lock_t, fileq));
- if ((fileLock->flags &
- (CM_FILELOCK_FLAG_INVALID | CM_FILELOCK_FLAG_WAITING))
- == 0) {
- if ((LockType & 0x1) == 0
- || (fileLock->LockType & 0x1) == 0)
- return CM_ERROR_WOULDBLOCK;
- found = 1;
- }
- q = osi_QNext(q);
- }
+ The OpenAFS Windows client has to fake byte range locks given no
+ server side support for such locks. This is implemented as keyed
+ byte range locks on the cache manager.
- if (found)
- code = 0;
- else {
- tfid.Volume = scp->fid.volume;
- tfid.Vnode = scp->fid.vnode;
- tfid.Unique = scp->fid.unique;
- lock_ReleaseMutex(&scp->mx);
- do {
- code = cm_Conn(&scp->fid, userp, reqp, &connp);
- if (code)
- break;
+ Keyed byte range locks:
+
+ Each cm_scache_t structure keeps track of a list of keyed locks.
+ The key for a lock is essentially a token which identifies an owner
+ of a set of locks (referred to as a client). The set of keys used
+ within a specific cm_scache_t structure form a namespace that has a
+ scope of just that cm_scache_t structure. The same key value can
+ be used with another cm_scache_t structure and correspond to a
+ completely different client. However it is advantageous for the
+ SMB or IFS layer to make sure that there is a 1-1 mapping between
+ client and keys irrespective of the cm_scache_t.
- callp = cm_GetRxConn(connp);
- code = RXAFS_SetLock(callp, &tfid, Which,
- &volSync);
- rx_PutConnection(callp);
+ Assume a client C has key Key(C) (although, since the scope of the
+ key is a cm_scache_t, the key can be Key(C,S), where S is the
+ cm_scache_t. But assume a 1-1 relation between keys and clients).
+ A byte range (O,+L) denotes byte addresses (O) through (O+L-1)
+ inclusive (a.k.a. [O,O+L-1]). The function Key(x) is implemented
+ through cm_generateKey() function for both SMB and IFS.
- } while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync,
- NULL, NULL, code));
- lock_ObtainMutex(&scp->mx);
- code = cm_MapRPCError(code, reqp);
- }
+ The cache manager will set a lock on the AFS file server in order
+ to assert the locks in S->fileLocks. If only shared locks are in
+ place for S, then the cache manager will obtain a LockRead lock,
+ while if there are any exclusive locks, it will obtain a LockWrite
+ lock. If the exclusive locks are all released while the shared
+ locks remain, then the cache manager will downgrade the lock from
+ LockWrite to LockRead.
- if (code == 0 || Timeout != 0) {
- fileLock = malloc(sizeof(cm_file_lock_t));
- fileLock->LockType = LockType;
- cm_HoldUser(userp);
- fileLock->userp = userp;
- fileLock->fid = scp->fid;
- fileLock->LOffset = LOffset;
- fileLock->LLength = LLength;
- fileLock->flags = (code == 0 ? 0 : CM_FILELOCK_FLAG_WAITING);
- osi_QAdd(&scp->fileLocks, &fileLock->fileq);
- lock_ObtainWrite(&cm_scacheLock);
- osi_QAdd(&cm_allFileLocks, &fileLock->q);
- lock_ReleaseWrite(&cm_scacheLock);
- if (code != 0)
- *lockpp = fileLock;
- }
- return code;
-}
+ Lock states:
-long cm_Unlock(cm_scache_t *scp, unsigned char LockType,
- LARGE_INTEGER LOffset, LARGE_INTEGER LLength,
- cm_user_t *userp, cm_req_t *reqp)
-{
- long code = 0;
- int Which = ((LockType & 0x1) ? LockRead : LockWrite);
- AFSFid tfid;
- AFSVolSync volSync;
- cm_conn_t *connp;
- cm_file_lock_t *fileLock, *ourLock;
- osi_queue_t *q, *qq;
- int anotherReader = 0;
- int smallLock = 0;
- int found = 0;
- struct rx_connection * callp;
+ A lock exists iff it is in S->fileLocks for some cm_scache_t
+ S. Existing locks are in one of the following states: ACTIVE,
+ WAITLOCK, WAITUNLOCK, LOST, DELETED.
- if (LargeIntegerLessThan(LLength, scp->length))
- smallLock = 1;
+ The following sections describe each lock and the associated
+ transitions.
- /* Look for our own lock on the list, so as to remove it.
- * Also, determine if we're the last reader; if not, avoid an RPC.
- */
- q = scp->fileLocks;
- while (q) {
- fileLock = (cm_file_lock_t *)
- ((char *) q - offsetof(cm_file_lock_t, fileq));
- if (!found
- && fileLock->userp == userp
- && LargeIntegerEqualTo(fileLock->LOffset, LOffset)
- && LargeIntegerEqualTo(fileLock->LLength, LLength)) {
- found = 1;
- ourLock = fileLock;
- qq = q;
- }
- else if (fileLock->LockType & 0x1)
- anotherReader = 1;
- q = osi_QNext(q);
- }
+ 1. ACTIVE: A lock L is ACTIVE iff the cache manager has asserted
+ the lock with the AFS file server. This type of lock can be
+ exercised by a client to read or write to the locked region (as
+ the lock allows).
- /* ignore byte ranges */
- if (smallLock && !found)
- return 0;
+ 1.1 ACTIVE->LOST: When the AFS file server fails to extend a
+ server lock that was required to assert the lock.
- /* don't try to unlock other people's locks */
- if (!found)
- return CM_ERROR_WOULDBLOCK;
+ 1.2 ACTIVE->DELETED: Lock is released.
- /* discard lock record */
- osi_QRemove(&scp->fileLocks, qq);
- /*
- * Don't delete it here; let the daemon delete it, to simplify
- * the daemon's traversal of the list.
- */
- lock_ObtainWrite(&cm_scacheLock);
- ourLock->flags |= CM_FILELOCK_FLAG_INVALID;
- cm_ReleaseUser(ourLock->userp);
- lock_ReleaseWrite(&cm_scacheLock);
+ 2. WAITLOCK: A lock is in a WAITLOCK state if the cache manager
+ grants the lock but the lock is yet to be asserted with the AFS
+ file server. Once the file server grants the lock, the state
+ will transition to an ACTIVE lock.
- if (!anotherReader) {
- tfid.Volume = scp->fid.volume;
- tfid.Vnode = scp->fid.vnode;
- tfid.Unique = scp->fid.unique;
- lock_ReleaseMutex(&scp->mx);
- do {
- code = cm_Conn(&scp->fid, userp, reqp, &connp);
- if (code)
- break;
+ 2.1 WAITLOCK->ACTIVE: The server granted the lock.
- callp = cm_GetRxConn(connp);
- code = RXAFS_ReleaseLock(callp, &tfid, &volSync);
- rx_PutConnection(callp);
+ 2.2 WAITLOCK->DELETED: Lock is abandoned, or timed out during
+ waiting.
- } while (cm_Analyze(connp, userp, reqp, &scp->fid, &volSync,
- NULL, NULL, code));
- code = cm_MapRPCError(code, reqp);
- lock_ObtainMutex(&scp->mx);
- }
+ 2.3 WAITLOCK->LOST: One or more locks from this client were
+ marked as LOST. No further locks will be granted to this
+ client until al lost locks are removed.
- return code;
-}
+ 3. WAITUNLOCK: A lock is in a WAITUNLOCK state if the cache manager
+ receives a request for a lock that conflicts with an existing
+ ACTIVE or WAITLOCK lock. The lock will be placed in the queue
+ and will be granted at such time the conflicting locks are
+ removed, at which point the state will transition to either
+ WAITLOCK or ACTIVE.
-void cm_CheckLocks()
-{
- osi_queue_t *q, *nq;
- cm_file_lock_t *fileLock;
- cm_req_t req;
- AFSFid tfid;
- AFSVolSync volSync;
- cm_conn_t *connp;
- long code;
- struct rx_connection * callp;
+ 3.1 WAITUNLOCK->ACTIVE: The conflicting lock was removed. The
+ current serverLock is sufficient to assert this lock, or a
+ sufficient serverLock is obtained.
- cm_InitReq(&req);
+ 3.2 WAITUNLOCK->WAITLOCK: The conflicting lock was removed,
+ however the required serverLock is yet to be asserted with the
+ server.
- lock_ObtainWrite(&cm_scacheLock);
- q = cm_allFileLocks;
- while (q) {
- fileLock = (cm_file_lock_t *) q;
- nq = osi_QNext(q);
- if (fileLock->flags & CM_FILELOCK_FLAG_INVALID) {
- osi_QRemove(&cm_allFileLocks, q);
- free(fileLock);
- }
- else if (!(fileLock->flags & CM_FILELOCK_FLAG_WAITING)) {
- tfid.Volume = fileLock->fid.volume;
- tfid.Vnode = fileLock->fid.vnode;
- tfid.Unique = fileLock->fid.unique;
- lock_ReleaseWrite(&cm_scacheLock);
- do {
- code = cm_Conn(&fileLock->fid, fileLock->userp,
- &req, &connp);
- if (code)
- break;
+ 3.3 WAITUNLOCK->DELETED: The lock is abandoned or timed out.
- callp = cm_GetRxConn(connp);
- code = RXAFS_ExtendLock(callp, &tfid,
- &volSync);
- rx_PutConnection(callp);
+ 3.5 WAITUNLOCK->LOST: One or more locks from this client were
+ marked as LOST. No further locks will be granted to this
+ client until all lost locks are removed.
- } while (cm_Analyze(connp, fileLock->userp, &req,
- &fileLock->fid, &volSync, NULL, NULL,
- code));
- code = cm_MapRPCError(code, &req);
- lock_ObtainWrite(&cm_scacheLock);
- }
- q = nq;
- }
- lock_ReleaseWrite(&cm_scacheLock);
-}
+ 4. LOST: A lock L is LOST if the server lock that was required to
+ assert the lock could not be obtained or if it could not be
+ extended, or if other locks by the same client were LOST.
+ Effectively, once a lock is LOST, the contract between the cache
+ manager and that specific client is no longer valid.
-long cm_RetryLock(cm_file_lock_t *oldFileLock, int vcp_is_dead)
-{
- long code;
- int Which = ((oldFileLock->LockType & 0x1) ? LockRead : LockWrite);
- cm_scache_t *scp;
- AFSFid tfid;
- AFSVolSync volSync;
- cm_conn_t *connp;
- cm_file_lock_t *fileLock;
- osi_queue_t *q;
+ The cache manager rechecks the server lock once every minute and
+ extends it as appropriate. If this is not done for 5 minutes,
+ the AFS file server will release the lock. Once released, the
+ lock cannot be re-obtained without verifying that the contents
+ of the file hasn't been modified since the time the lock was
+ released. Doing so may cause data corruption.
+
+ 4.1 LOST->DELETED: The lock is released.
+
+ 4.2 LOST->ACTIVE: The lock is reassertd. This requires
+ verifying that the file was not modified in between.
+
+ 4.3 LOST->WAITLOCK: All LOST ACTIVE locks from this client were
+ reasserted. The cache manager can reinstate this waiting
+ lock.
+
+ 4.4 LOST->WAITUNLOCK: All LOST ACTIVE locks from this client
+ were reasserted. The cache manager can reinstate this waiting
+ lock.
+
+ 5. DELETED: The lock is no longer relevant. Eventually, it will
+ get removed from the cm_scache_t. In the meantime, it will be
+ treated as if it does not exist.
+
+ 5.1 DELETED->not exist: The lock is removed from the
+ cm_scache_t.
+
+ 6* A lock L is ACCEPTED if it is ACTIVE or WAITLOCK.
+ These locks have been accepted by the cache manager, but may or
+ may not have been granted back to the client.
+
+ 7* A lock L is QUEUED if it is ACTIVE, WAITLOCK or WAITUNLOCK.
+
+ 8* A lock L is EFFECTIVE if it is ACTIVE or LOST.
+
+ 9* A lock L is WAITING if it is WAITLOCK or WAITUNLOCK.
+
+ Lock operation:
+
+ A client C can READ range (Offset,+Length) of cm_scache_t S iff:
+
+ 1. for all _a_ in (Offset,+Length), one of the following is true:
+
+ 1.1 There does NOT exist an ACTIVE lock L in S->fileLocks such
+ that _a_ in (L->LOffset,+L->LLength) (IOW: byte _a_ of S is
+ unowned)
+
+ AND
+
+ For each LOST lock M in S->fileLocks such that
+ _a_ in (M->LOffset,+M->LLength), M->LockType is shared AND
+ M->key != Key(C).
+
+ (Note: If this is a different client from one whose shared
+ lock was LOST, then the contract between this client and the
+ cache manager is indistinguishable from that where no lock
+ was lost. If an exclusive lock was lost, then the range is
+ considered unsafe for consumption.)
+
+ 1.3 There is an ACTIVE lock L in S->fileLocks such that: L->key
+ == Key(C) && _a_ in (L->LOffset,+L->LLength) (IOW: byte _a_
+ of S is owned by C under lock L)
+
+ 1.4 There is an ACTIVE lock L in S->fileLocks such that _a_ in
+ (L->LOffset,L->+LLength) && L->LockType is shared (IOW: byte
+ _a_ of S is shared) AND there is no LOST lock M such that _a_
+ in (M->LOffset,+M->LLength) and M->key == Key(C)
+
+ A client C can WRITE range (Offset,+Length) of cm_scache_t S iff:
+
+ 2. for all _a_ in (Offset,+Length), one of the following is true:
+
+ 2.1 Byte _a_ of S is unowned (as above) AND for each LOST lock
+ L in S->fileLocks _a_ NOT in (L->LOffset,+L->LLength).
+
+ 2.2 Byte _a_ of S is owned by C under lock L (as above) AND
+ L->LockType is exclusive.
+
+ A client C can OBTAIN a lock L on cm_scache_t S iff:
+
+ 3. for all _a_ in (L->LOffset,+L->LLength), ALL of the following is
+ true:
+
+ 3.1 L->LockType is exclusive IMPLIES there does NOT exist a QUEUED lock
+ M in S->fileLocks such that _a_ in (M->LOffset,+M->LLength).
+
+ (Note: If we count all QUEUED locks then we hit cases such as
+ cascading waiting locks where the locks later on in the queue
+ can be granted without compromising file integrity. On the
+ other hand if only ACCEPTED locks are considered, then locks
+ that were received earlier may end up waiting for locks that
+ were received later to be unlocked. The choice of QUEUED
+ locks were made so that large locks don't consistently get
+ trumped by smaller locks which were requested later.)
+
+ 3.2 L->LockType is shared IMPLIES for each QUEUED lock M in
+ S->fileLocks, if _a_ in (M->LOffset,+M->LLength) then
+ M->LockType is shared.
+
+ 4. For each LOST lock M in S->fileLocks, M->key != Key(C)
+
+ (Note: If a client loses a lock, it loses all locks.
+ Subsequently, it will not be allowed to obtain any more locks
+ until all existing LOST locks that belong to the client are
+ released. Once all locks are released by a single client,
+ there exists no further contract between the client and AFS
+ about the contents of the file, hence the client can then
+ proceed to obtain new locks and establish a new contract.)
+
+ A client C can only unlock locks L in S->fileLocks which have
+ L->key == Key(C).
+
+ The representation and invariants are as follows:
+
+ - Each cm_scache_t structure keeps:
+
+ - A queue of byte-range locks (cm_scache_t::fileLocks) which
+ are of type cm_file_lock_t.
+
+ - A record of the highest server-side lock that has been
+ obtained for this object (cm_scache_t::serverLock), which is
+ one of (-1), LockRead, LockWrite.
+
+ - A count of ACCEPTED exclusive and shared locks that are in the
+ queue (cm_scache_t::sharedLocks and
+ cm_scache_t::exclusiveLocks)
+
+ - Each cm_file_lock_t structure keeps:
+
+ - The type of lock (cm_file_lock_t::LockType)
+
+ - The key associated with the lock (cm_file_lock_t::key)
+
+ - The offset and length of the lock (cm_file_lock_t::LOffset
+ and cm_file_lock_t::LLength)
+
+ - The state of the lock.
+
+ - Time of issuance or last successful extension
+
+ Semantic invariants:
+
+ I1. The number of ACCEPTED locks in S->fileLocks are
+ (S->sharedLocks + S->exclusiveLocks)
+
+ External invariants:
+
+ I3. S->serverLock is the lock that we have asserted with the
+ AFS file server for this cm_scache_t.
+
+ I4. S->serverLock == LockRead iff there is at least one ACTIVE
+ shared lock, but no ACTIVE exclusive locks.
+
+ I5. S->serverLock == LockWrite iff there is at least one ACTIVE
+ exclusive lock.
+
+ I6. If a WAITUNLOCK lock L exists in S->fileLocks, then all
+ locks that L is waiting on are ahead of L in S->fileLocks.
+
+ I7. If L is a LOST lock, then for each lock M in S->fileLocks,
+ M->key == L->key IMPLIES M is LOST or DELETED.
+
+ --asanka
+ */
+
+#define IS_LOCK_ACTIVE(lockp) (((lockp)->flags & (CM_FILELOCK_FLAG_DELETED|CM_FILELOCK_FLAG_WAITLOCK|CM_FILELOCK_FLAG_WAITUNLOCK|CM_FILELOCK_FLAG_LOST))==0)
+
+#define IS_LOCK_WAITLOCK(lockp) (((lockp)->flags & (CM_FILELOCK_FLAG_DELETED|CM_FILELOCK_FLAG_WAITLOCK|CM_FILELOCK_FLAG_WAITUNLOCK|CM_FILELOCK_FLAG_LOST)) == CM_FILELOCK_FLAG_WAITLOCK)
+
+#define IS_LOCK_WAITUNLOCK(lockp) (((lockp)->flags & (CM_FILELOCK_FLAG_DELETED|CM_FILELOCK_FLAG_WAITLOCK|CM_FILELOCK_FLAG_WAITUNLOCK|CM_FILELOCK_FLAG_LOST)) == CM_FILELOCK_FLAG_WAITUNLOCK)
+
+#define IS_LOCK_LOST(lockp) (((lockp)->flags & (CM_FILELOCK_FLAG_DELETED|CM_FILELOCK_FLAG_LOST)) == CM_FILELOCK_FLAG_LOST)
+
+#define IS_LOCK_DELETED(lockp) (((lockp)->flags & CM_FILELOCK_FLAG_DELETED) == CM_FILELOCK_FLAG_DELETED)
+
+/* the following macros are unsafe */
+#define IS_LOCK_ACCEPTED(lockp) (IS_LOCK_ACTIVE(lockp) || IS_LOCK_WAITLOCK(lockp))
+
+#define IS_LOCK_QUEUED(lockp) (IS_LOCK_ACTIVE(lockp) || IS_LOCK_WAITLOCK(lockp) || IS_LOCK_WAITUNLOCK(lockp))
+
+#define IS_LOCK_EFFECTIVE(lockp) (IS_LOCK_ACTIVE(lockp) || IS_LOCK_LOST(lockp))
+
+#define IS_LOCK_CLIENTONLY(lockp) (((lockp)->flags & CM_FILELOCK_FLAG_CLIENTONLY) == CM_FILELOCK_FLAG_CLIENTONLY)
+
+#define INTERSECT_RANGE(r1,r2) (((r2).offset+(r2).length) > (r1).offset && ((r1).offset +(r1).length) > (r2).offset)
+
+#define CONTAINS_RANGE(r1,r2) (((r2).offset+(r2).length) <= ((r1).offset+(r1).length) && (r1).offset <= (r2).offset)
+
+static void cm_LockRangeSubtract(cm_range_t * pos, const cm_range_t * neg)
+{
+ afs_int64 int_begin;
+ afs_int64 int_end;
+
+ int_begin = MAX(pos->offset, neg->offset);
+ int_end = MIN(pos->offset+pos->length, neg->offset+neg->length);
+
+ if(int_begin < int_end) {
+ if(int_begin == pos->offset) {
+ pos->length = pos->offset + pos->length - int_end;
+ pos->offset = int_end;
+ } else if(int_end == pos->offset + pos->length) {
+ pos->offset = int_begin;
+ pos->length = int_end - int_begin;
+ }
+ }
+}
+
+/* Called with scp->mx held. Returns 0 if all is clear to read the
+ specified range by the client identified by key.
+ */
+long cm_LockCheckRead(cm_scache_t *scp,
+ LARGE_INTEGER LOffset,
+ LARGE_INTEGER LLength,
+ cm_key_t key)
+{
+#ifndef ADVISORY_LOCKS
+
+ cm_file_lock_t *fileLock;
+ osi_queue_t *q;
+ long code = 0;
+ cm_range_t range;
+ int substract_ranges = FALSE;
+
+ range.offset = LOffset.QuadPart;
+ range.length = LLength.QuadPart;
+
+ /*
+ 1. for all _a_ in (Offset,+Length), one of the following is true:
+
+ 1.1 There does NOT exist an ACTIVE lock L in S->fileLocks such
+ that _a_ in (L->LOffset,+L->LLength) (IOW: byte _a_ of S is
+ unowned)
+
+ AND
+
+ For each LOST lock M in S->fileLocks such that
+ _a_ in (M->LOffset,+M->LLength), M->LockType is shared AND
+ M->key != Key(C).
+
+ 1.3 There is an ACTIVE lock L in S->fileLocks such that: L->key
+ == Key(C) && _a_ in (L->LOffset,+L->LLength) (IOW: byte _a_
+ of S is owned by C under lock L)
+
+ 1.4 There is an ACTIVE lock L in S->fileLocks such that _a_ in
+ (L->LOffset,L->+LLength) && L->LockType is shared (IOW: byte
+ _a_ of S is shared) AND there is no LOST lock M such that _a_
+ in (M->LOffset,+M->LLength) and M->key == Key(C)
+ */
+
+ lock_ObtainRead(&cm_scacheLock);
+
+ for(q = scp->fileLocksH; q && range.length > 0; q = osi_QNext(q)) {
+ fileLock =
+ (cm_file_lock_t *)((char *) q - offsetof(cm_file_lock_t, fileq));
+
+#if 0
+ if(IS_LOCK_DELETED(fileLock) ||
+ (IS_LOCK_LOST(fileLock) &&
+ fileLock->lockType == LockRead &&
+ fileLock->key != key))
+ continue;
+#endif
+
+ if(INTERSECT_RANGE(range, fileLock->range)) {
+ if(IS_LOCK_ACTIVE(fileLock)) {
+ if(fileLock->key == key) {
+
+ /* if there is an active lock for this client, it
+ is safe to substract ranges */
+ cm_LockRangeSubtract(&range, &fileLock->range);
+ substract_ranges = TRUE;
+ } else {
+ if(fileLock->lockType != LockRead) {
+ code = CM_ERROR_LOCK_CONFLICT;
+ break;
+ }
+
+ /* even if the entire range is locked for reading,
+ we still can't grant the lock at this point
+ because the client may have lost locks. That
+ is, unless we have already seen an active lock
+ belonging to the client, in which case there
+ can't be any lost locks. */
+ if(substract_ranges)
+ cm_LockRangeSubtract(&range, &fileLock->range);
+ }
+ } else if(IS_LOCK_LOST(fileLock)
+#if 0
+ /* Uncomment for less aggressive handling of
+ lost locks. */
+ &&
+ (fileLock->key == key || fileLock->lockType == LockWrite)
+#endif
+ ) {
+ code = CM_ERROR_BADFD;
+ break;
+ }
+ } else if (IS_LOCK_LOST(fileLock)) {
+ code = CM_ERROR_BADFD;
+ break;
+ }
+ }
+
+ lock_ReleaseRead(&cm_scacheLock);
+
+ return code;
+
+#else
+
+ return 0;
+
+#endif
+}
+
+/* Called with scp->mx held. Returns 0 if all is clear to write the
+ specified range by the client identified by key.
+ */
+long cm_LockCheckWrite(cm_scache_t *scp,
+ LARGE_INTEGER LOffset,
+ LARGE_INTEGER LLength,
+ cm_key_t key)
+{
+#ifndef ADVISORY_LOCKS
+
+ cm_file_lock_t *fileLock;
+ osi_queue_t *q;
+ long code = 0;
+ cm_range_t range;
+
+ range.offset = LOffset.QuadPart;
+ range.length = LLength.QuadPart;
+
+ /*
+ A client C can WRITE range (Offset,+Length) of cm_scache_t S iff:
+
+ 2. for all _a_ in (Offset,+Length), one of the following is true:
+
+ 2.1 Byte _a_ of S is unowned (as above) AND for each LOST lock
+ L in S->fileLocks _a_ NOT in (L->LOffset,+L->LLength).
+
+ 2.2 Byte _a_ of S is owned by C under lock L (as above) AND
+ L->LockType is exclusive.
+
+ */
+
+ lock_ObtainRead(&cm_scacheLock);
+
+ for(q = scp->fileLocksH; q && range.length > 0; q = osi_QNext(q)) {
+ fileLock =
+ (cm_file_lock_t *)((char *) q - offsetof(cm_file_lock_t, fileq));
+
+#if 0
+ if(IS_LOCK_DELETED(fileLock) ||
+ (IS_LOCK_LOST(fileLock) &&
+ fileLock->lockType == LockRead &&
+ fileLock->key != key))
+ continue;
+#endif
+
+ if(INTERSECT_RANGE(range, fileLock->range)) {
+ if(IS_LOCK_ACTIVE(fileLock)) {
+ if(fileLock->key == key) {
+ if(fileLock->lockType == LockWrite) {
+
+ /* if there is an active lock for this client, it
+ is safe to substract ranges */
+ cm_LockRangeSubtract(&range, &fileLock->range);
+ } else {
+ code = CM_ERROR_LOCK_CONFLICT;
+ break;
+ }
+ } else {
+ code = CM_ERROR_LOCK_CONFLICT;
+ break;
+ }
+ } else if(IS_LOCK_LOST(fileLock)) {
+ code = CM_ERROR_BADFD;
+ break;
+ }
+ } else if (IS_LOCK_LOST(fileLock)) {
+ code = CM_ERROR_BADFD;
+ break;
+ }
+ }
+
+ lock_ReleaseRead(&cm_scacheLock);
+
+ return code;
+
+#else
+
+ return 0;
+
+#endif
+}
+
+/* Forward dcl. */
+static void cm_LockMarkSCacheLost(cm_scache_t * scp);
+
+/* Called with cm_scacheLock write locked */
+static cm_file_lock_t * cm_GetFileLock(void) {
+ cm_file_lock_t * l;
+
+ l = (cm_file_lock_t *) cm_freeFileLocks;
+ if(l) {
+ osi_QRemove(&cm_freeFileLocks, &l->q);
+ } else {
+ l = malloc(sizeof(cm_file_lock_t));
+ osi_assert(l);
+ }
+
+ memset(l, 0, sizeof(cm_file_lock_t));
+
+ return l;
+}
+
+/* Called with cm_scacheLock write locked */
+static void cm_PutFileLock(cm_file_lock_t *l) {
+ osi_QAdd(&cm_freeFileLocks, &l->q);
+}
+
+/* called with scp->mx held */
+long cm_Lock(cm_scache_t *scp, unsigned char sLockType,
+ LARGE_INTEGER LOffset, LARGE_INTEGER LLength,
+ cm_key_t key,
+ int allowWait, cm_user_t *userp, cm_req_t *reqp,
+ cm_file_lock_t **lockpp)
+{
+ long code = 0;
+ int Which = ((sLockType & LOCKING_ANDX_SHARED_LOCK) ? LockRead : LockWrite);
+ AFSFid tfid;
+ AFSVolSync volSync;
+ cm_conn_t *connp;
+ cm_file_lock_t *fileLock;
+ osi_queue_t *q;
+ struct rx_connection * callp;
+ cm_range_t range;
+ int wait_unlock = FALSE;
+
+ osi_Log4(afsd_logp, "cm_Lock scp 0x%x type 0x%x offset %d length %d",
+ scp, sLockType, (unsigned long)LOffset.QuadPart, (unsigned long)LLength.QuadPart);
+ osi_Log3(afsd_logp, "... allowWait %d key 0x%x:%x", allowWait,
+ (unsigned long)(key >> 32), (unsigned long)(key & 0xffffffff));
+
+ /*
+ A client C can OBTAIN a lock L on cm_scache_t S iff:
+
+ 3. for all _a_ in (L->LOffset,+L->LLength), ALL of the following is
+ true:
+
+ 3.1 L->LockType is exclusive IMPLIES there does NOT exist a QUEUED lock
+ M in S->fileLocks such that _a_ in (M->LOffset,+M->LLength).
+
+ 3.2 L->LockType is shared IMPLIES for each QUEUED lock M in
+ S->fileLocks, if _a_ in (M->LOffset,+M->LLength) then
+ M->LockType is shared.
+
+ 4. For each LOST lock M in S->fileLocks, M->key != Key(C)
+ */
+
+ range.offset = LOffset.QuadPart;
+ range.length = LLength.QuadPart;
+
+ lock_ObtainRead(&cm_scacheLock);
+
+ for(q = scp->fileLocksH; q; q = osi_QNext(q)) {
+ fileLock =
+ (cm_file_lock_t *)((char *) q - offsetof(cm_file_lock_t, fileq));
+
+ if(IS_LOCK_LOST(fileLock) && fileLock->key == key) {
+ code = CM_ERROR_BADFD;
+ break;
+ }
+
+ /* we don't need to check for deleted locks here since deleted
+ locks are dequeued from fileLocks */
+ if(INTERSECT_RANGE(range, fileLock->range)) {
+
+ if((sLockType & LOCKING_ANDX_SHARED_LOCK) == 0 ||
+ fileLock->lockType != LockRead) {
+ wait_unlock = TRUE;
+ code = CM_ERROR_WOULDBLOCK;
+ break;
+ }
+ }
+ }
+
+ lock_ReleaseRead(&cm_scacheLock);
+
+ if(code == 0 && !(scp->flags & CM_SCACHEFLAG_RO)) {
+ if(Which == scp->serverLock ||
+ (Which == LockRead && scp->serverLock == LockWrite)) {
+
+ /* we already have the lock we need */
+ osi_Log3(afsd_logp, " we already have the correct lock. exclusives[%d], shared[%d], serverLock[%d]",
+ scp->exclusiveLocks, scp->sharedLocks, (int)(signed char) scp->serverLock);
+ code = 0; /* redundant */
+
+ } else if((scp->exclusiveLocks > 0) ||
+ (scp->sharedLocks > 0 && scp->serverLock != LockRead)) {
+
+ /* We are already waiting for some other lock. We should
+ wait for the daemon to catch up instead of generating a
+ flood of SetLock calls. */
+ osi_Log3(afsd_logp, " already waiting for other lock. exclusives[%d], shared[%d], serverLock[%d]",
+ scp->exclusiveLocks, scp->sharedLocks, (int)(signed char) scp->serverLock);
+ code = CM_ERROR_WOULDBLOCK;
+
+ } else {
+ cm_fid_t cfid;
+ int newLock;
+
+ if (scp->serverLock == LockRead && Which == LockWrite) {
+
+ /* We want to escalate the lock to a LockWrite.
+ Unfortunately that's not really possible without
+ letting go of the current lock. But for now we do
+ it anyway. */
+
+ osi_Log0(afsd_logp, " attempting to UPGRADE from LockRead to LockWrite.");
+
+ tfid.Volume = scp->fid.volume;
+ tfid.Vnode = scp->fid.vnode;
+ tfid.Unique = scp->fid.unique;
+ cfid = scp->fid;
+
+ lock_ReleaseMutex(&scp->mx);
+
+ osi_Log1(afsd_logp, "CALL ReleaseLock scp 0x%x", (long) scp);
+
+ do {
+ code = cm_Conn(&cfid, userp, reqp, &connp);
+ if (code)
+ break;
+
+ callp = cm_GetRxConn(connp);
+ code = RXAFS_ReleaseLock(callp, &tfid, &volSync);
+ rx_PutConnection(callp);
+
+ } while (cm_Analyze(connp, userp, reqp, &cfid, &volSync,
+ NULL, NULL, code));
+ code = cm_MapRPCError(code, reqp);
+
+ if (code)
+ osi_Log1(afsd_logp, "CALL ReleaseLock FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL ReleaseLock SUCCESS");
+
+ lock_ObtainMutex(&scp->mx);
+
+ if (code) {
+ /* We couldn't release the lock */
+ goto check_code;
+ } else {
+ scp->serverLock = -1;
+ }
+ }
+
+ /* We need to obtain a server lock of type Which in order
+ to assert this file lock */
+ tfid.Volume = scp->fid.volume;
+ tfid.Vnode = scp->fid.vnode;
+ tfid.Unique = scp->fid.unique;
+ cfid = scp->fid;
+
+#ifndef AGGRESSIVE_LOCKS
+ newLock = Which;
+#else
+ newLock = LockWrite;
+#endif
+ osi_Log3(afsd_logp, "CALL SetLock scp 0x%x from %d to %d", (long) scp, (int) scp->serverLock, newLock);
+
+ lock_ReleaseMutex(&scp->mx);
+
+ do {
+ code = cm_Conn(&cfid, userp, reqp, &connp);
+ if (code)
+ break;
+
+ callp = cm_GetRxConn(connp);
+ code = RXAFS_SetLock(callp, &tfid, newLock,
+ &volSync);
+ rx_PutConnection(callp);
+
+ } while (cm_Analyze(connp, userp, reqp, &cfid, &volSync,
+ NULL, NULL, code));
+
+ code = cm_MapRPCError(code, reqp);
+
+ if (code) {
+ osi_Log1(afsd_logp, "CALL SetLock FAILURE, code 0x%x", code);
+ } else {
+ osi_Log0(afsd_logp, "CALL SetLock SUCCESS");
+ }
+
+ if (code == CM_ERROR_WOULDBLOCK && newLock != Which) {
+ /* we wanted LockRead. We tried LockWrite. Now try LockRead again */
+ newLock = Which;
+
+ /* am I sane? */
+ osi_assert(newLock == LockRead);
+
+ osi_Log3(afsd_logp, "CALL SetLock AGAIN scp 0x%x from %d to %d",
+ (long) scp, (int) scp->serverLock, newLock);
+
+ do {
+ code = cm_Conn(&cfid, userp, reqp, &connp);
+ if (code)
+ break;
+
+ callp = cm_GetRxConn(connp);
+ code = RXAFS_SetLock(callp, &tfid, newLock,
+ &volSync);
+ rx_PutConnection(callp);
+
+ } while (cm_Analyze(connp, userp, reqp, &cfid, &volSync,
+ NULL, NULL, code));
+
+ code = cm_MapRPCError(code, reqp);
+
+ if (code) {
+ osi_Log1(afsd_logp, "CALL SetLock FAILURE AGAIN, code 0x%x", code);
+ } else {
+ osi_Log0(afsd_logp, "CALL SetLock SUCCESS");
+ }
+ }
+
+ lock_ObtainMutex(&scp->mx);
+
+ if(code == 0)
+ scp->serverLock = newLock;
+ else {
+ if ((scp->sharedLocks > 0 || scp->exclusiveLocks > 0) &&
+ scp->serverLock == -1) {
+ /* Oops. We lost the lock. */
+ cm_LockMarkSCacheLost(scp);
+ }
+ }
+ }
+ } else if (scp->flags & CM_SCACHEFLAG_RO) {
+ osi_Log0(afsd_logp, " Skipping server lock for RO scp");
+ }
+
+ check_code:
+
+ if (code != 0) {
+ /* Special case error translations
+
+ Applications don't expect certain errors from a
+ LockFile/UnlockFile call. We need to translate some error
+ code to codes that apps expect and handle. */
+
+ /* We shouldn't actually need to handle this case since we
+ simulate locks for RO scps anyway. */
+ if (code == CM_ERROR_READONLY) {
+ osi_Log0(afsd_logp, " Reinterpreting CM_ERROR_READONLY as CM_ERROR_NOACCESS");
+ code = CM_ERROR_NOACCESS;
+ }
+ }
+
+ if (code == 0 || (code == CM_ERROR_WOULDBLOCK && allowWait)) {
+
+ lock_ObtainWrite(&cm_scacheLock);
+ fileLock = cm_GetFileLock();
+ lock_ReleaseWrite(&cm_scacheLock);
+#ifdef DEBUG
+ fileLock->fid = scp->fid;
+#endif
+ fileLock->key = key;
+ fileLock->lockType = Which;
+ cm_HoldUser(userp);
+ fileLock->userp = userp;
+ fileLock->range = range;
+ fileLock->flags = (code == 0 ? 0 :
+ ((wait_unlock)?
+ CM_FILELOCK_FLAG_WAITUNLOCK :
+ CM_FILELOCK_FLAG_WAITLOCK));
+ if (scp->flags & CM_SCACHEFLAG_RO)
+ fileLock->flags |= CM_FILELOCK_FLAG_CLIENTONLY;
+
+ fileLock->lastUpdate = (code == 0) ? time(NULL) : 0;
+
+ osi_QAddT(&scp->fileLocksH, &scp->fileLocksT, &fileLock->fileq);
+
+ lock_ObtainWrite(&cm_scacheLock);
+ cm_HoldSCacheNoLock(scp);
+ fileLock->scp = scp;
+ osi_QAdd(&cm_allFileLocks, &fileLock->q);
+ lock_ReleaseWrite(&cm_scacheLock);
+
+ if (code != 0) {
+ *lockpp = fileLock;
+ }
+
+ if (IS_LOCK_ACCEPTED(fileLock)) {
+ if(Which == LockRead)
+ scp->sharedLocks++;
+ else
+ scp->exclusiveLocks++;
+ }
+
+ osi_Log1(afsd_logp, "cm_Lock Lock added 0x%x", (long) fileLock);
+ osi_Log4(afsd_logp, " scp[0x%x] exclusives[%d] shared[%d] serverLock[%d]",
+ scp, scp->exclusiveLocks, scp->sharedLocks, (int)(signed char) scp->serverLock);
+ }
+
+ return code;
+}
+
+static int cm_KeyEquals(cm_key_t k1, cm_key_t k2, int flags);
+
+/* Called with scp->mx held */
+long cm_UnlockByKey(cm_scache_t * scp,
+ cm_key_t key,
+ int flags,
+ cm_user_t * userp,
+ cm_req_t * reqp)
+{
+ long code = 0;
+ AFSFid tfid;
+ AFSVolSync volSync;
+ cm_conn_t *connp;
+ cm_file_lock_t *fileLock;
+ osi_queue_t *q, *qn;
+ struct rx_connection * callp;
+ int n_unlocks = 0;
+
+ osi_Log3(afsd_logp, "cm_UnlockByKey scp 0x%x key 0x%x:%x",
+ (long) scp, (unsigned long)(key >> 32), (unsigned long)(key & 0xffffffff));
+
+ lock_ObtainWrite(&cm_scacheLock);
+
+ for(q = scp->fileLocksH; q; q = qn) {
+ qn = osi_QNext(q);
+
+ fileLock = (cm_file_lock_t *)
+ ((char *) q - offsetof(cm_file_lock_t, fileq));
+
+#ifdef DEBUG
+ osi_Log4(afsd_logp, " Checking lock[0x%x] range[%d,+%d] type[%d]",
+ fileLock, (unsigned long) fileLock->range.offset, (unsigned long) fileLock->range.length,
+ fileLock->lockType);
+ osi_Log3(afsd_logp, " key[0x%x:%x] flags[0x%x]",
+ (unsigned long)(fileLock->key >> 32),
+ (unsigned long)(fileLock->key & 0xffffffff),
+ fileLock->flags);
+
+ if(cm_FidCmp(&fileLock->fid, &fileLock->scp->fid)) {
+ osi_Log0(afsd_logp, "!!fileLock->fid != scp->fid");
+ osi_Log4(afsd_logp, " fileLock->fid(cell=[%d], volume=[%d], vnode=[%d], unique=[%d]",
+ fileLock->fid.cell,
+ fileLock->fid.volume,
+ fileLock->fid.vnode,
+ fileLock->fid.unique);
+ osi_Log4(afsd_logp, " scp->fid(cell=[%d], volume=[%d], vnode=[%d], unique=[%d]",
+ fileLock->scp->fid.cell,
+ fileLock->scp->fid.volume,
+ fileLock->scp->fid.vnode,
+ fileLock->scp->fid.unique);
+ osi_assert(FALSE);
+ }
+#endif
+
+ if (!IS_LOCK_DELETED(fileLock) &&
+ cm_KeyEquals(fileLock->key, key, flags)) {
+ osi_Log3(afsd_logp, "...Unlock range [%d,+%d] type %d",
+ fileLock->range.offset,
+ fileLock->range.length,
+ fileLock->lockType);
+
+ if (scp->fileLocksT == q)
+ scp->fileLocksT = osi_QPrev(q);
+ osi_QRemove(&scp->fileLocksH,q);
+
+ if(IS_LOCK_ACCEPTED(fileLock)) {
+ if(fileLock->lockType == LockRead)
+ scp->sharedLocks--;
+ else
+ scp->exclusiveLocks--;
+ }
+
+ fileLock->flags |= CM_FILELOCK_FLAG_DELETED;
+
+ cm_ReleaseUser(fileLock->userp);
+ cm_ReleaseSCacheNoLock(scp);
+
+ fileLock->userp = NULL;
+ fileLock->scp = NULL;
+
+ n_unlocks++;
+ }
+ }
+
+ lock_ReleaseWrite(&cm_scacheLock);
+
+ if(n_unlocks == 0) {
+ osi_Log0(afsd_logp, "cm_UnlockByKey no locks found");
+ osi_Log3(afsd_logp, " Leaving scp with exclusives[%d], shared[%d], serverLock[%d]",
+ scp->exclusiveLocks, scp->sharedLocks, (int)(signed char) scp->serverLock);
+
+ return 0;
+ }
+
+ osi_Log1(afsd_logp, "cm_UnlockByKey done with %d locks", n_unlocks);
+
+ osi_assertx(scp->sharedLocks >= 0, "scp->sharedLocks < 0");
+ osi_assertx(scp->exclusiveLocks >= 0, "scp->exclusiveLocks < 0");
+
+ if (scp->flags & CM_SCACHEFLAG_RO) {
+ osi_Log0(afsd_logp, " Skipping server lock for RO scp");
+ goto done;
+ }
+
+ /* Ideally we would go through the rest of the locks to determine
+ * if one or more locks that were formerly in WAITUNLOCK can now
+ * be put to ACTIVE or WAITLOCK and update scp->exclusiveLocks and
+ * scp->sharedLocks accordingly. However, the retrying of locks
+ * in that manner is done cm_RetryLock() manually.
+ */
+
+ if (scp->serverLock == LockWrite && scp->exclusiveLocks == 0 && scp->sharedLocks > 0) {
+
+ cm_fid_t cfid;
+
+ /* The serverLock should be downgraded to LockRead */
+ osi_Log0(afsd_logp, " DOWNGRADE lock from LockWrite to LockRead");
+
+ tfid.Volume = scp->fid.volume;
+ tfid.Vnode = scp->fid.vnode;
+ tfid.Unique = scp->fid.unique;
+ cfid = scp->fid;
+
+ lock_ReleaseMutex(&scp->mx);
+
+ osi_Log1(afsd_logp, "CALL ReleaseLock scp 0x%x", (long) scp);
+
+ do {
+ code = cm_Conn(&cfid, userp, reqp, &connp);
+ if (code)
+ break;
+
+ callp = cm_GetRxConn(connp);
+ code = RXAFS_ReleaseLock(callp, &tfid, &volSync);
+ rx_PutConnection(callp);
+
+ } while (cm_Analyze(connp, userp, reqp, &cfid, &volSync,
+ NULL, NULL, code));
+ code = cm_MapRPCError(code, reqp);
+
+ if (code)
+ osi_Log1(afsd_logp, "CALL ReleaseLock FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL ReleaseLock SUCCESS");
+
+ lock_ObtainMutex(&scp->mx);
+
+ if (code) {
+ /* so we couldn't release it. Just let the lock be for now */
+ code = 0;
+ goto done;
+ } else {
+ scp->serverLock = -1;
+ }
+
+ tfid.Volume = scp->fid.volume;
+ tfid.Vnode = scp->fid.vnode;
+ tfid.Unique = scp->fid.unique;
+ cfid = scp->fid;
+
+ osi_Log3(afsd_logp, "CALL SetLock scp 0x%x from %d to %d", (long) scp, (int) scp->serverLock, LockRead);
+
+ lock_ReleaseMutex(&scp->mx);
+
+ do {
+
+ code = cm_Conn(&cfid, userp, reqp, &connp);
+ if (code)
+ break;
+
+ callp = cm_GetRxConn(connp);
+ code = RXAFS_SetLock(callp, &tfid, LockRead,
+ &volSync);
+
+ rx_PutConnection(callp);
+
+ } while (cm_Analyze(connp, userp, reqp, &cfid, &volSync,
+ NULL, NULL, code));
+
+ if (code)
+ osi_Log1(afsd_logp, "CALL SetLock FAILURE, code 0x%x", code);
+ else {
+ osi_Log0(afsd_logp, "CALL SetLock SUCCESS");
+ }
+
+ lock_ObtainMutex(&scp->mx);
+
+ if(code == 0)
+ scp->serverLock = LockRead;
+ else {
+ if ((scp->sharedLocks > 0 || scp->exclusiveLocks > 0) &&
+ (scp->serverLock == -1)) {
+ /* Oopsie */
+ cm_LockMarkSCacheLost(scp);
+ }
+ }
+
+ /* failure here has no bearing on the return value of
+ cm_Unlock() */
+ code = 0;
+
+ } else if(scp->serverLock != (-1) && scp->exclusiveLocks == 0 && scp->sharedLocks == 0) {
+ cm_fid_t cfid;
+
+ /* The serverLock should be released entirely */
+
+ tfid.Volume = scp->fid.volume;
+ tfid.Vnode = scp->fid.vnode;
+ tfid.Unique = scp->fid.unique;
+ cfid = scp->fid;
+
+ lock_ReleaseMutex(&scp->mx);
+
+ osi_Log1(afsd_logp, "CALL ReleaseLock scp 0x%x", (long) scp);
+
+ do {
+ code = cm_Conn(&cfid, userp, reqp, &connp);
+ if (code)
+ break;
+
+ callp = cm_GetRxConn(connp);
+ code = RXAFS_ReleaseLock(callp, &tfid, &volSync);
+ rx_PutConnection(callp);
+
+ } while (cm_Analyze(connp, userp, reqp, &cfid, &volSync,
+ NULL, NULL, code));
+ code = cm_MapRPCError(code, reqp);
+
+ if (code)
+ osi_Log1(afsd_logp, "CALL ReleaseLock FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL ReleaseLock SUCCESS");
+
+ lock_ObtainMutex(&scp->mx);
+
+ if (code == 0)
+ scp->serverLock = (-1);
+ }
+
+ done:
+
+ osi_Log1(afsd_logp, "cm_UnlockByKey code 0x%x", code);
+ osi_Log3(afsd_logp, " Leaving scp with exclusives[%d], shared[%d], serverLock[%d]",
+ scp->exclusiveLocks, scp->sharedLocks, (int)(signed char) scp->serverLock);
+
+ return code;
+}
+
+long cm_Unlock(cm_scache_t *scp,
+ unsigned char sLockType,
+ LARGE_INTEGER LOffset, LARGE_INTEGER LLength,
+ cm_key_t key,
+ cm_user_t *userp,
+ cm_req_t *reqp)
+{
+ long code = 0;
+ int Which = ((sLockType & LOCKING_ANDX_SHARED_LOCK) ? LockRead : LockWrite);
+ AFSFid tfid;
+ AFSVolSync volSync;
+ cm_conn_t *connp;
+ cm_file_lock_t *fileLock;
+ osi_queue_t *q;
+ int release_userp = FALSE;
+ struct rx_connection * callp;
+
+ osi_Log4(afsd_logp, "cm_Unlock scp 0x%x type 0x%x offset %d length %d",
+ (long) scp, sLockType, (unsigned long)LOffset.QuadPart, (unsigned long)LLength.QuadPart);
+ osi_Log2(afsd_logp, "... key 0x%x:%x",
+ (unsigned long) (key >> 32), (unsigned long) (key & 0xffffffff));
+
+ lock_ObtainRead(&cm_scacheLock);
+
+ for(q = scp->fileLocksH; q; q = osi_QNext(q)) {
+ fileLock = (cm_file_lock_t *)
+ ((char *) q - offsetof(cm_file_lock_t, fileq));
+
+#ifdef DEBUG
+ if(cm_FidCmp(&fileLock->fid, &fileLock->scp->fid)) {
+ osi_Log0(afsd_logp, "!!fileLock->fid != scp->fid");
+ osi_Log4(afsd_logp, " fileLock->fid(cell=[%d], volume=[%d], vnode=[%d], unique=[%d]",
+ fileLock->fid.cell,
+ fileLock->fid.volume,
+ fileLock->fid.vnode,
+ fileLock->fid.unique);
+ osi_Log4(afsd_logp, " scp->fid(cell=[%d], volume=[%d], vnode=[%d], unique=[%d]",
+ fileLock->scp->fid.cell,
+ fileLock->scp->fid.volume,
+ fileLock->scp->fid.vnode,
+ fileLock->scp->fid.unique);
+ osi_assert(FALSE);
+ }
+#endif
+ if (!IS_LOCK_DELETED(fileLock) &&
+ fileLock->key == key &&
+ fileLock->range.offset == LOffset.QuadPart &&
+ fileLock->range.length == LLength.QuadPart) {
+ break;
+ }
+ }
+
+ if(!q) {
+ osi_Log0(afsd_logp, "cm_Unlock lock not found; failure");
+
+ lock_ReleaseRead(&cm_scacheLock);
+
+ return CM_ERROR_WOULDBLOCK; /* how is this an appropriate error code? */
+ }
+
+ /* discard lock record */
+ if (scp->fileLocksT == q)
+ scp->fileLocksT = osi_QPrev(q);
+ osi_QRemove(&scp->fileLocksH, q);
+
+ if(IS_LOCK_ACCEPTED(fileLock)) {
+ if(fileLock->lockType == LockRead)
+ scp->sharedLocks--;
+ else
+ scp->exclusiveLocks--;
+ }
+
+ lock_ReleaseRead(&cm_scacheLock);
+
+ /*
+ * Don't delete it here; let the daemon delete it, to simplify
+ * the daemon's traversal of the list.
+ */
+
+ lock_ObtainWrite(&cm_scacheLock);
+ fileLock->flags |= CM_FILELOCK_FLAG_DELETED;
+ if (userp != NULL) {
+ cm_ReleaseUser(fileLock->userp);
+ } else {
+ userp = fileLock->userp;
+ release_userp = TRUE;
+ }
+ fileLock->userp = NULL;
+ cm_ReleaseSCacheNoLock(scp);
+ fileLock->scp = NULL;
+ lock_ReleaseWrite(&cm_scacheLock);
+
+ if (scp->flags & CM_SCACHEFLAG_RO) {
+ osi_Log0(afsd_logp, " Skipping server locks for RO scp");
+ goto done;
+ }
+
+ /* Ideally we would go through the rest of the locks to determine
+ * if one or more locks that were formerly in WAITUNLOCK can now
+ * be put to ACTIVE or WAITLOCK and update scp->exclusiveLocks and
+ * scp->sharedLocks accordingly. However, the retrying of locks
+ * in that manner is done cm_RetryLock() manually.
+ */
+
+ if (scp->serverLock == LockWrite && scp->exclusiveLocks == 0 && scp->sharedLocks > 0) {
+
+ cm_fid_t cfid;
+
+ /* The serverLock should be downgraded to LockRead */
+ osi_Log0(afsd_logp, " DOWNGRADE lock from LockWrite to LockRead");
+
+ tfid.Volume = scp->fid.volume;
+ tfid.Vnode = scp->fid.vnode;
+ tfid.Unique = scp->fid.unique;
+ cfid = scp->fid;
+
+ lock_ReleaseMutex(&scp->mx);
+
+ osi_Log1(afsd_logp, "CALL ReleaseLock scp 0x%x", (long) scp);
+
+ do {
+ code = cm_Conn(&cfid, userp, reqp, &connp);
+ if (code)
+ break;
+
+ callp = cm_GetRxConn(connp);
+ code = RXAFS_ReleaseLock(callp, &tfid, &volSync);
+ rx_PutConnection(callp);
+
+ } while (cm_Analyze(connp, userp, reqp, &cfid, &volSync,
+ NULL, NULL, code));
+
+ code = cm_MapRPCError(code, reqp);
+
+ if (code)
+ osi_Log1(afsd_logp, "CALL ReleaseLock FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL ReleaseLock SUCCESS");
+
+ lock_ObtainMutex(&scp->mx);
+
+ if (code) {
+ /* so we couldn't release it. Just let the lock be for now */
+ code = 0;
+ goto done;
+ } else {
+ scp->serverLock = -1;
+ }
+
+ tfid.Volume = scp->fid.volume;
+ tfid.Vnode = scp->fid.vnode;
+ tfid.Unique = scp->fid.unique;
+ cfid = scp->fid;
+
+ osi_Log3(afsd_logp, "CALL SetLock scp 0x%x from %d to %d", (long) scp, (int) scp->serverLock, LockRead);
+
+ lock_ReleaseMutex(&scp->mx);
+
+ do {
+
+ code = cm_Conn(&cfid, userp, reqp, &connp);
+ if (code)
+ break;
+
+ callp = cm_GetRxConn(connp);
+ code = RXAFS_SetLock(callp, &tfid, LockRead,
+ &volSync);
+
+ rx_PutConnection(callp);
+
+ } while (cm_Analyze(connp, userp, reqp, &cfid, &volSync,
+ NULL, NULL, code));
+
+ if (code)
+ osi_Log1(afsd_logp, "CALL SetLock FAILURE, code 0x%x", code);
+ else {
+ osi_Log0(afsd_logp, "CALL SetLock SUCCESS");
+ }
+
+ lock_ObtainMutex(&scp->mx);
+
+ if(code == 0)
+ scp->serverLock = LockRead;
+ else {
+ if ((scp->sharedLocks > 0 || scp->exclusiveLocks > 0) &&
+ (scp->serverLock == -1)) {
+ /* Oopsie */
+ cm_LockMarkSCacheLost(scp);
+ }
+ }
+
+ /* failure here has no bearing on the return value of
+ cm_Unlock() */
+ code = 0;
+
+ } else if(scp->serverLock != (-1) && scp->exclusiveLocks == 0 && scp->sharedLocks == 0) {
+ cm_fid_t cfid;
+
+ /* The serverLock should be released entirely */
+
+ tfid.Volume = scp->fid.volume;
+ tfid.Vnode = scp->fid.vnode;
+ tfid.Unique = scp->fid.unique;
+ cfid = scp->fid;
+
+ lock_ReleaseMutex(&scp->mx);
+
+ osi_Log1(afsd_logp, "CALL ReleaseLock scp 0x%x", (long) scp);
+
+ do {
+ code = cm_Conn(&cfid, userp, reqp, &connp);
+ if (code)
+ break;
+
+ callp = cm_GetRxConn(connp);
+ code = RXAFS_ReleaseLock(callp, &tfid, &volSync);
+ rx_PutConnection(callp);
+
+ } while (cm_Analyze(connp, userp, reqp, &cfid, &volSync,
+ NULL, NULL, code));
+ code = cm_MapRPCError(code, reqp);
+
+ if (code)
+ osi_Log1(afsd_logp, "CALL ReleaseLock FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL ReleaseLock SUCCESS");
+
+ lock_ObtainMutex(&scp->mx);
+
+ if (code == 0) {
+ scp->serverLock = (-1);
+ }
+ }
+
+ if (release_userp)
+ cm_ReleaseUser(userp);
+
+ done:
+
+ osi_Log1(afsd_logp, "cm_Unlock code 0x%x", code);
+ osi_Log3(afsd_logp, " Leaving scp with exclusives[%d], shared[%d], serverLock[%d]",
+ scp->exclusiveLocks, scp->sharedLocks, (int)(signed char) scp->serverLock);
+
+ return code;
+}
+
+/* called with scp->mx held */
+static void cm_LockMarkSCacheLost(cm_scache_t * scp)
+{
+ cm_file_lock_t *fileLock;
+ osi_queue_t *q;
+
+ /* cm_scacheLock needed because we are modifying
+ fileLock->flags */
+ lock_ObtainWrite(&cm_scacheLock);
+
+ for(q = scp->fileLocksH; q; q = osi_QNext(q)) {
+ fileLock =
+ (cm_file_lock_t *)((char *) q - offsetof(cm_file_lock_t, fileq));
+
+ if(IS_LOCK_ACTIVE(fileLock)) {
+ fileLock->flags |= CM_FILELOCK_FLAG_LOST;
+ }
+ }
+
+ scp->serverLock = -1;
+ lock_ReleaseWrite(&cm_scacheLock);
+}
+
+/* Called with no relevant locks held */
+void cm_CheckLocks()
+{
+ osi_queue_t *q, *nq;
+ cm_file_lock_t *fileLock;
+ cm_req_t req;
+ AFSFid tfid;
+ AFSVolSync volSync;
+ cm_conn_t *connp;
+ long code;
+ struct rx_connection * callp;
+ cm_scache_t * scp;
+
+ lock_ObtainWrite(&cm_scacheLock);
+
+ cm_lockRefreshCycle++;
+
+ osi_Log1(afsd_logp, "cm_CheckLocks starting lock check cycle %d", cm_lockRefreshCycle);
+
+ for(q = cm_allFileLocks; q; q = nq) {
+ fileLock = (cm_file_lock_t *) q;
+
+ nq = osi_QNext(q);
+
+ if (IS_LOCK_DELETED(fileLock)) {
+
+ osi_QRemove(&cm_allFileLocks, q);
+ cm_PutFileLock(fileLock);
+
+ } else if (IS_LOCK_ACTIVE(fileLock) && !IS_LOCK_CLIENTONLY(fileLock)) {
+
+ scp = fileLock->scp;
+ osi_assert(scp != NULL);
+ cm_HoldSCacheNoLock(scp);
+
+#ifdef DEBUG
+ if(cm_FidCmp(&fileLock->fid, &fileLock->scp->fid)) {
+ osi_Log0(afsd_logp, "!!fileLock->fid != scp->fid");
+ osi_Log4(afsd_logp, " fileLock->fid(cell=[%d], volume=[%d], vnode=[%d], unique=[%d]",
+ fileLock->fid.cell,
+ fileLock->fid.volume,
+ fileLock->fid.vnode,
+ fileLock->fid.unique);
+ osi_Log4(afsd_logp, " scp->fid(cell=[%d], volume=[%d], vnode=[%d], unique=[%d]",
+ fileLock->scp->fid.cell,
+ fileLock->scp->fid.volume,
+ fileLock->scp->fid.vnode,
+ fileLock->scp->fid.unique);
+ osi_assert(FALSE);
+ }
+#endif
+ /* Server locks are extended once per scp per refresh
+ cycle. */
+ if (scp->lastRefreshCycle != cm_lockRefreshCycle) {
+
+ int scp_done = FALSE;
+
+ osi_Log1(afsd_logp, "cm_CheckLocks Updating scp 0x%x", scp);
+
+ lock_ReleaseWrite(&cm_scacheLock);
+ lock_ObtainMutex(&scp->mx);
+
+ /* did the lock change while we weren't holding the lock? */
+ if (!IS_LOCK_ACTIVE(fileLock))
+ goto post_syncopdone;
+
+ code = cm_SyncOp(scp, NULL, fileLock->userp, &req, 0,
+ CM_SCACHESYNC_NEEDCALLBACK
+ | CM_SCACHESYNC_GETSTATUS
+ | CM_SCACHESYNC_LOCK);
+
+ if (code) {
+ osi_Log1(smb_logp, "cm_CheckLocks SyncOp failure code 0x%x", code);
+ goto post_syncopdone;
+ }
+
+ /* cm_SyncOp releases scp->mx during which the lock
+ may get released. */
+ if (!IS_LOCK_ACTIVE(fileLock))
+ goto pre_syncopdone;
+
+ if(scp->serverLock != -1) {
+ cm_fid_t cfid;
+ cm_user_t * userp;
+
+ cm_InitReq(&req);
+
+ tfid.Volume = scp->fid.volume;
+ tfid.Vnode = scp->fid.vnode;
+ tfid.Unique = scp->fid.unique;
+ cfid = scp->fid;
+ userp = fileLock->userp;
+
+ osi_Log3(afsd_logp, "CALL ExtendLock lock 0x%x for scp=0x%x with lock %d",
+ (long) fileLock,
+ (long) scp,
+ (int) scp->serverLock);
+
+ lock_ReleaseMutex(&scp->mx);
+
+ do {
+ code = cm_Conn(&cfid, userp,
+ &req, &connp);
+ if (code)
+ break;
+
+ callp = cm_GetRxConn(connp);
+ code = RXAFS_ExtendLock(callp, &tfid,
+ &volSync);
+ rx_PutConnection(callp);
+
+ osi_Log1(afsd_logp, " ExtendLock returns %d", code);
+
+ } while (cm_Analyze(connp, userp, &req,
+ &cfid, &volSync, NULL, NULL,
+ code));
+
+ code = cm_MapRPCError(code, &req);
+
+ lock_ObtainMutex(&scp->mx);
+
+ if (code) {
+ osi_Log1(afsd_logp, "CALL ExtendLock FAILURE, code 0x%x", code);
+ cm_LockMarkSCacheLost(scp);
+ } else {
+ osi_Log0(afsd_logp, "CALL ExtendLock SUCCESS");
+ }
+ } else {
+ /* interestingly, we have found an active lock
+ belonging to an scache that has no
+ serverLock */
+ cm_LockMarkSCacheLost(scp);
+ }
+
+ scp_done = TRUE;
+
+ pre_syncopdone:
+
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK);
+
+ post_syncopdone:
+ lock_ReleaseMutex(&scp->mx);
+
+ lock_ObtainWrite(&cm_scacheLock);
+
+ if (code == 0) {
+ fileLock->lastUpdate = time(NULL);
+ }
+
+ if (scp_done)
+ scp->lastRefreshCycle = cm_lockRefreshCycle;
+
+ } else {
+ /* we have already refreshed the locks on this scp */
+ fileLock->lastUpdate = time(NULL);
+ }
+
+ cm_ReleaseSCacheNoLock(scp);
+
+ } else if (IS_LOCK_ACTIVE(fileLock) && IS_LOCK_CLIENTONLY(fileLock)) {
+ /* TODO: Check callbacks */
+ }
+ }
+
+ lock_ReleaseWrite(&cm_scacheLock);
+}
+
+/* NOT called with scp->mx held. */
+long cm_RetryLock(cm_file_lock_t *oldFileLock, int client_is_dead)
+{
+ long code = 0;
+ cm_scache_t *scp;
+ AFSFid tfid;
+ AFSVolSync volSync;
+ cm_conn_t *connp;
+ cm_file_lock_t *fileLock;
+ osi_queue_t *q;
cm_req_t req;
- int found = 0;
struct rx_connection * callp;
+ int newLock = -1;
- if (vcp_is_dead) {
+ if (client_is_dead) {
code = CM_ERROR_TIMEDOUT;
goto handleCode;
}
- cm_InitReq(&req);
+ lock_ObtainRead(&cm_scacheLock);
- /* Look for a conflict. Also, if we are asking for a shared lock,
- * look for another shared lock, so we don't have to do an RPC.
- */
- code = cm_GetSCache(&oldFileLock->fid, &scp, oldFileLock->userp, &req);
- if (code)
- return code;
+ /* if the lock has already been granted, then we have nothing to do */
+ if(IS_LOCK_ACTIVE(oldFileLock)) {
+ lock_ReleaseRead(&cm_scacheLock);
+ return 0;
+ }
- q = scp->fileLocks;
- while (q) {
- fileLock = (cm_file_lock_t *)
- ((char *) q - offsetof(cm_file_lock_t, fileq));
- if ((fileLock->flags &
- (CM_FILELOCK_FLAG_INVALID | CM_FILELOCK_FLAG_WAITING))
- == 0) {
- if ((oldFileLock->LockType & 0x1) == 0
- || (fileLock->LockType & 0x1) == 0) {
- cm_ReleaseSCache(scp);
- return CM_ERROR_WOULDBLOCK;
+ /* we can't do anything with lost or deleted locks at the moment. */
+ if(IS_LOCK_LOST(oldFileLock) || IS_LOCK_DELETED(oldFileLock)) {
+ code = CM_ERROR_BADFD;
+ lock_ReleaseRead(&cm_scacheLock);
+ goto handleCode;
+ }
+
+ scp = oldFileLock->scp;
+
+ osi_assert(scp != NULL);
+
+ lock_ReleaseRead(&cm_scacheLock);
+ lock_ObtainMutex(&scp->mx);
+ lock_ObtainWrite(&cm_scacheLock);
+
+ /* Check if we already have a sufficient server lock to allow this
+ lock to go through */
+ if(IS_LOCK_WAITLOCK(oldFileLock) &&
+ (scp->serverLock == oldFileLock->lockType ||
+ scp->serverLock == LockWrite)) {
+
+ oldFileLock->flags &= ~CM_FILELOCK_FLAG_WAITLOCK;
+
+ lock_ReleaseWrite(&cm_scacheLock);
+ lock_ReleaseMutex(&scp->mx);
+
+ return 0;
+ }
+
+ if(IS_LOCK_WAITUNLOCK(oldFileLock)) {
+
+ /* check if the conflicting locks have dissappeared already */
+
+ for(q = scp->fileLocksH; q; q = osi_QNext(q)) {
+
+ fileLock = (cm_file_lock_t *)
+ ((char *) q - offsetof(cm_file_lock_t, fileq));
+
+ /* a oldFileLock can only depend on locks that are ahead
+ of it in the queue. If we came this far, then all
+ should be ok */
+ if(fileLock == oldFileLock) {
+ break;
+ }
+
+ if(IS_LOCK_LOST(fileLock)
+#if 0
+ && fileLock->key == oldFileLock->key
+#endif
+ ) {
+ code = CM_ERROR_BADFD;
+ oldFileLock->flags |= CM_FILELOCK_FLAG_LOST;
+ break;
+ }
+
+ /* we don't need to check for deleted locks here since deleted
+ locks are dequeued from fileLocks */
+ if(INTERSECT_RANGE(oldFileLock->range, fileLock->range)) {
+
+ if(oldFileLock->lockType != LockRead ||
+ fileLock->lockType != LockRead) {
+ code = CM_ERROR_WOULDBLOCK;
+ break;
+ }
}
- found = 1;
}
- q = osi_QNext(q);
}
- if (found)
- code = 0;
- else {
- tfid.Volume = oldFileLock->fid.volume;
- tfid.Vnode = oldFileLock->fid.vnode;
- tfid.Unique = oldFileLock->fid.unique;
+ if (code != 0) {
+ lock_ReleaseWrite(&cm_scacheLock);
+ lock_ReleaseMutex(&scp->mx);
+
+ goto handleCode;
+ }
+
+ /* when we get here, the lock is either a WAITUNLOCK or WAITLOCK.
+ If it is WAITUNLOCK, then we didn't find any conflicting lock
+ but we haven't verfied whether the serverLock is sufficient to
+ assert it. If it is WAITLOCK, then the serverLock is
+ insufficient to assert it. Eitherway, we are ready to accept
+ the lock as either ACTIVE or WAITLOCK depending on the
+ serverLock. */
+
+ oldFileLock->flags &= ~CM_FILELOCK_FLAG_WAITUNLOCK;
+
+ if (scp->serverLock == oldFileLock->lockType ||
+ (oldFileLock->lockType == LockRead &&
+ scp->serverLock == LockWrite)) {
+
+ oldFileLock->flags &= ~CM_FILELOCK_FLAG_WAITLOCK;
+
+ lock_ReleaseWrite(&cm_scacheLock);
+ lock_ReleaseMutex(&scp->mx);
+
+ return 0;
+
+ } else {
+ cm_fid_t cfid;
+ cm_user_t * userp;
+
+ oldFileLock->flags |= CM_FILELOCK_FLAG_WAITLOCK;
+
+ cm_InitReq(&req);
+
+ code = cm_SyncOp(scp, NULL, oldFileLock->userp, &req, 0,
+ CM_SCACHESYNC_NEEDCALLBACK
+ | CM_SCACHESYNC_GETSTATUS
+ | CM_SCACHESYNC_LOCK);
+ if (code) {
+ osi_Log1(smb_logp, "cm_RetryLock SyncOp failure code 0x%x", code);
+ lock_ReleaseWrite(&cm_scacheLock);
+ goto post_syncopdone;
+ }
+
+ if(!IS_LOCK_WAITLOCK(oldFileLock))
+ goto pre_syncopdone;
+
+ tfid.Volume = scp->fid.volume;
+ tfid.Vnode = scp->fid.vnode;
+ tfid.Unique = scp->fid.unique;
+ cfid = scp->fid;
+ userp = oldFileLock->userp;
+
+#ifndef AGGRESSIVE_LOCKS
+ newLock = oldFileLock->lockType;
+#else
+ newLock = LockWrite;
+#endif
+
+ osi_Log1(afsd_logp, "CALL SetLock lock 0x%x", (long) oldFileLock);
+
+ lock_ReleaseWrite(&cm_scacheLock);
+ lock_ReleaseMutex(&scp->mx);
+
do {
- code = cm_Conn(&oldFileLock->fid, oldFileLock->userp,
- &req, &connp);
+ code = cm_Conn(&cfid, userp, &req, &connp);
if (code)
break;
callp = cm_GetRxConn(connp);
- code = RXAFS_SetLock(callp, &tfid, Which,
+ code = RXAFS_SetLock(callp, &tfid, newLock,
&volSync);
rx_PutConnection(callp);
- } while (cm_Analyze(connp, oldFileLock->userp, &req,
- &oldFileLock->fid, &volSync,
+ } while (cm_Analyze(connp, userp, &req,
+ &cfid, &volSync,
NULL, NULL, code));
code = cm_MapRPCError(code, &req);
+
+ if (code) {
+ osi_Log1(afsd_logp, "CALL SetLock FAILURE, code 0x%x", code);
+ } else {
+ osi_Log0(afsd_logp, "CALL SetLock SUCCESS");
+ }
+
+ lock_ObtainMutex(&scp->mx);
+ pre_syncopdone:
+ cm_SyncOpDone(scp, NULL, CM_SCACHESYNC_LOCK);
+ post_syncopdone:
+ ;
}
handleCode:
if (code != 0 && code != CM_ERROR_WOULDBLOCK) {
- lock_ObtainMutex(&scp->mx);
- osi_QRemove(&scp->fileLocks, &oldFileLock->fileq);
- lock_ReleaseMutex(&scp->mx);
+ if (scp->fileLocksT == &oldFileLock->fileq)
+ scp->fileLocksT = osi_QPrev(&oldFileLock->fileq);
+ osi_QRemove(&scp->fileLocksH, &oldFileLock->fileq);
+ } else if (code == 0 && IS_LOCK_WAITLOCK(oldFileLock)) {
+ scp->serverLock = newLock;
}
+ lock_ReleaseMutex(&scp->mx);
+
lock_ObtainWrite(&cm_scacheLock);
- if (code == 0)
- oldFileLock->flags = 0;
- else if (code != CM_ERROR_WOULDBLOCK) {
- oldFileLock->flags |= CM_FILELOCK_FLAG_INVALID;
+ if (code == 0) {
+ oldFileLock->flags &= ~CM_FILELOCK_FLAG_WAITLOCK;
+ } else if (code != CM_ERROR_WOULDBLOCK) {
+ oldFileLock->flags |= CM_FILELOCK_FLAG_DELETED;
cm_ReleaseUser(oldFileLock->userp);
oldFileLock->userp = NULL;
+ cm_ReleaseSCacheNoLock(scp);
+ oldFileLock->scp = NULL;
}
lock_ReleaseWrite(&cm_scacheLock);
return code;
}
+
+cm_key_t cm_GenerateKey(unsigned int session_id, unsigned long process_id, unsigned int file_id)
+{
+ return (((cm_key_t) process_id) << 32) |
+ (((cm_key_t) session_id) << 16) |
+ (((cm_key_t) file_id));
+}
+
+static int cm_KeyEquals(cm_key_t k1, cm_key_t k2, int flags)
+{
+ if (flags & CM_UNLOCK_BY_FID) {
+ return ((k1 & 0xffffffff) == (k2 & 0xffffffff));
+ } else {
+ return (k1 == k2);
+ }
+}
git://git.openafs.org / openafs.git / blobdiff