cm_lock_data_t **ldpp)
{
long rights;
- long code;
+ long code = 0;
osi_assertx(ldpp != NULL, "null cm_lock_data_t");
*ldpp = NULL;
/* Always allow delete; the RPC will tell us if it's OK */
- if (desiredAccess == DELETE)
- return 0;
-
rights = 0;
+ if (desiredAccess == DELETE)
+ goto done_2;
+
if (desiredAccess & (AFS_ACCESS_READ|AFS_ACCESS_EXECUTE))
rights |= (scp->fileType == CM_SCACHETYPE_DIRECTORY ? PRSFS_LOOKUP : PRSFS_READ);
if (desiredAccess & AFS_ACCESS_WRITE)
rights |= PRSFS_WRITE;
+ if (desiredAccess & DELETE)
+ rights |= PRSFS_DELETE;
+
lock_ObtainWrite(&scp->rw);
code = cm_SyncOp(scp, NULL, userp, reqp, rights,
_done:
lock_ReleaseWrite(&scp->rw);
+ done_2:
osi_Log3(afsd_logp,"cm_CheckNTOpen scp 0x%p ldp 0x%p code 0x%x", scp, *ldpp, code);
return code;
}
return 0;
}
sp->caseFold = casefold;
+ }
- /* see if we can find it using the directory hash tables.
- we can only do exact matches, since the hash is case
- sensitive. */
- {
- cm_dirOp_t dirop;
+ /*
+ * see if we can find it using the directory hash tables.
+ * we can only do exact matches, since the hash is case
+ * sensitive.
+ */
+ if (funcp != (cm_DirFuncp_t)cm_BPlusDirFoo)
+ {
+ cm_dirOp_t dirop;
#ifdef USE_BPLUS
- int usedBplus = 0;
+ int usedBplus = 0;
#endif
- code = ENOENT;
+ code = ENOENT;
- code = cm_BeginDirOp(scp, userp, reqp, CM_DIRLOCK_READ, &dirop);
- if (code == 0) {
+ code = cm_BeginDirOp(scp, userp, reqp, CM_DIRLOCK_READ,
+ CM_DIROP_FLAG_NONE, &dirop);
+ if (code == 0) {
#ifdef USE_BPLUS
- code = cm_BPlusDirLookup(&dirop, sp->nsearchNamep, &sp->fid);
- if (code != EINVAL)
- usedBplus = 1;
- else
+ code = cm_BPlusDirLookup(&dirop, sp->nsearchNamep, &sp->fid);
+ if (code != EINVAL)
+ usedBplus = 1;
+ else
#endif
- code = cm_DirLookup(&dirop, sp->searchNamep, &sp->fid);
+ code = cm_DirLookup(&dirop, sp->searchNamep, &sp->fid);
- cm_EndDirOp(&dirop);
- }
+ cm_EndDirOp(&dirop);
+ }
- if (code == 0) {
+ if (code == 0) {
+ /* found it */
+ sp->found = TRUE;
+ sp->ExactFound = TRUE;
+ *retscp = NULL; /* force caller to call cm_GetSCache() */
+ return 0;
+ }
+#ifdef USE_BPLUS
+ if (usedBplus) {
+ if (sp->caseFold && code == CM_ERROR_INEXACT_MATCH) {
/* found it */
sp->found = TRUE;
- sp->ExactFound = TRUE;
+ sp->ExactFound = FALSE;
*retscp = NULL; /* force caller to call cm_GetSCache() */
return 0;
}
-#ifdef USE_BPLUS
- if (usedBplus) {
- if (sp->caseFold && code == CM_ERROR_INEXACT_MATCH) {
- /* found it */
- sp->found = TRUE;
- sp->ExactFound = FALSE;
- *retscp = NULL; /* force caller to call cm_GetSCache() */
- return 0;
- }
-
- return CM_ERROR_BPLUS_NOMATCH;
- }
-#endif
+
+ return CM_ERROR_BPLUS_NOMATCH;
}
+#endif
}
}
tp = bufferp->datap + entryInBuffer;
dep = (cm_dirEntry_t *) tp; /* now points to AFS3 dir entry */
+ /*
+ * here are some consistency checks
+ */
+ if (dep->flag != CM_DIR_FFIRST ||
+ strlen(dep->name) > 256) {
+ code = CM_ERROR_INVAL;
+ break;
+ }
+
/* while we're here, compute the next entry's location, too,
* since we'll need it when writing out the cookie into the
* dir listing stream.
{
fschar_t *cellNamep = NULL;
fschar_t *volNamep = NULL;
- int tlen;
afs_uint32 code;
fschar_t *cp;
fschar_t *mpNamep;
mpNamep = scp->mountPointStringp;
if (!mpNamep[0])
return CM_ERROR_NOSUCHPATH;
- tlen = cm_FsStrLen(scp->mountPointStringp);
mtType = *scp->mountPointStringp;
cp = cm_FsStrChr(mpNamep, _FS(':'));
int getroot;
normchar_t *nnamep = NULL;
fschar_t *fnamep = NULL;
+ size_t fnlen;
*outScpp = NULL;
goto done;
}
+retry_lookup:
if (flags & CM_FLAG_NOMOUNTCHASE) {
/* In this case, we should go and call cm_Dir* functions
directly since the following cm_ApplyDir() function will
int usedBplus = 0;
#endif
- code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ, &dirop);
+ code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ,
+ CM_DIROP_FLAG_NONE, &dirop);
if (code == 0) {
#ifdef USE_BPLUS
code = cm_BPlusDirLookup(&dirop, nnamep, &rock.fid);
goto haveFid;
}
- return CM_ERROR_BPLUS_NOMATCH;
+ code = CM_ERROR_BPLUS_NOMATCH;
+ goto notfound;
}
#endif
}
* 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 && code != CM_ERROR_BPLUS_NOMATCH) {
/* 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
goto done;
}
+notfound:
getroot = (dscp==cm_data.rootSCachep) ;
if (!rock.found) {
if (!cm_freelanceEnabled || !getroot) {
/* nonexistent dir on freelance root, so add it */
fschar_t fullname[CELL_MAXNAMELEN + 1] = "."; /* +1 so that when we skip the . the size is still CELL_MAXNAMELEN */
int found = 0;
+ int retry = 0;
osi_Log1(afsd_logp,"cm_Lookup adding mount for non-existent directory: %S",
osi_LogSaveClientString(afsd_logp,cnamep));
*/
code = -1;
+ fnlen = strlen(fnamep);
+ if ( fnamep[fnlen-1] == '.') {
+ fnamep[fnlen-1] = '\0';
+ fnlen--;
+ retry = 1;
+ }
+
if (cnamep[0] == '.') {
if (cm_GetCell_Gen(&fnamep[1], &fullname[1], CM_FLAG_CREATE)) {
found = 1;
- if (!cm_FreelanceMountPointExists(fullname, 0))
- code = cm_FreelanceAddMount(fullname, &fullname[1], "root.cell.",
- 1, &rock.fid);
- if ( cm_FsStrCmpI(&fnamep[1], &fullname[1]) &&
- !cm_FreelanceMountPointExists(fnamep, flags & CM_FLAG_DFS_REFERRAL ? 1 : 0) &&
- !cm_FreelanceSymlinkExists(fnamep, flags & CM_FLAG_DFS_REFERRAL ? 1 : 0))
- code = cm_FreelanceAddSymlink(fnamep, fullname, &rock.fid);
+ code = cm_FreelanceAddMount(fullname, &fullname[1], "root.cell.", 1, &rock.fid);
+ if ( cm_FsStrCmpI(&fnamep[1], &fullname[1])) {
+ /*
+ * Do not permit symlinks that are one of:
+ * . the cellname followed by a dot
+ * . the cellname minus a single character
+ * . a substring of the cellname that does not consist of full components
+ */
+ if ( cm_strnicmp_utf8(&fnamep[1], fullname, (int)fnlen-1) == 0 &&
+ (fnlen-1 == strlen(fullname)-1 || fullname[fnlen-1] != '.'))
+ {
+ /* do not add; substitute fullname for the search */
+ free(fnamep);
+ fnamep = malloc(strlen(fullname)+2);
+ fnamep[0] = '.';
+ strncpy(&fnamep[1], fullname, strlen(fullname)+1);
+ retry = 1;
+ } else {
+ code = cm_FreelanceAddSymlink(fnamep, fullname, &rock.fid);
+ }
+ }
}
} else {
if (cm_GetCell_Gen(fnamep, fullname, CM_FLAG_CREATE)) {
found = 1;
- if (!cm_FreelanceMountPointExists(fullname, 0))
- code = cm_FreelanceAddMount(fullname, fullname, "root.cell.", 0, &rock.fid);
- if ( cm_FsStrCmpI(fnamep, fullname) &&
- !cm_FreelanceMountPointExists(fnamep, flags & CM_FLAG_DFS_REFERRAL ? 1 : 0) &&
- !cm_FreelanceSymlinkExists(fnamep, flags & CM_FLAG_DFS_REFERRAL ? 1 : 0))
- code = cm_FreelanceAddSymlink(fnamep, fullname, &rock.fid);
+ code = cm_FreelanceAddMount(fullname, fullname, "root.cell.", 0, &rock.fid);
+ if ( cm_FsStrCmpI(fnamep, fullname)) {
+ /*
+ * Do not permit symlinks that are one of:
+ * . the cellname followed by a dot
+ * . the cellname minus a single character
+ * . a substring of the cellname that does not consist of full components
+ */
+ if ( cm_strnicmp_utf8(fnamep, fullname, (int)fnlen-1) == 0 &&
+ (fnlen == strlen(fullname)-1 || fullname[fnlen] != '.'))
+ {
+ /* do not add; substitute fullname for the search */
+ free(fnamep);
+ fnamep = strdup(fullname);
+ code = 0;
+ retry = 1;
+ } else {
+ code = cm_FreelanceAddSymlink(fnamep, fullname, &rock.fid);
+ }
+ }
}
}
+
+ if (retry) {
+ if (nnamep)
+ free(nnamep);
+ nnamep = cm_FsStringToNormStringAlloc(fnamep, -1, NULL);
+ goto retry_lookup;
+ }
+
if (!found || code) { /* add mount point failed, so give up */
if (flags & CM_FLAG_CHECKPATH)
code = CM_ERROR_NOSUCHPATH;
}
}
- haveFid:
+ haveFid:
if ( !tscp ) /* we did not find it in the dnlc */
{
dnlcHit = 0;
if (fnamep == NULL) {
code = -1;
#ifdef USE_BPLUS
- code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ, &dirop);
+ code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ,
+ CM_DIROP_FLAG_NONE, &dirop);
if (code == 0) {
code = cm_BPlusDirLookupOriginalName(&dirop, cnamep, &fnamep);
if (code == 0)
#endif
code = cm_Lookup(dscp, cnamep, CM_FLAG_NOMOUNTCHASE, userp, reqp, &scp);
+ if (code)
+ goto done;
+
+ /* Check for RO volume */
+ if (dscp->flags & CM_SCACHEFLAG_RO) {
+ code = CM_ERROR_READONLY;
+ goto done;
+ }
/* make sure we don't screw up the dir status during the merge */
- code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
+ code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE,
+ CM_DIROP_FLAG_NONE, &dirop);
lock_ObtainWrite(&dscp->rw);
sflags = CM_SCACHESYNC_STOREDATA;
StringCbCopyA((char *) tsp->data, sizeof(tsp->data), linkp+cm_mountRootLen+1);
else
tsp->data[0] = 0;
- *newRootScpp = cm_data.rootSCachep;
- cm_HoldSCache(cm_data.rootSCachep);
+ *newRootScpp = cm_RootSCachep(userp, reqp);
+ cm_HoldSCache(*newRootScpp);
} else if (linkp[0] == '\\' && linkp[1] == '\\') {
if (!strnicmp(&linkp[2], cm_NetbiosName, (len = (long)strlen(cm_NetbiosName))))
{
if (*p == '\\')
*p = '/';
}
- *newRootScpp = cm_data.rootSCachep;
- cm_HoldSCache(cm_data.rootSCachep);
+ *newRootScpp = cm_RootSCachep(userp, reqp);
+ cm_HoldSCache(*newRootScpp);
} else {
linkScp->fileType = CM_SCACHETYPE_DFSLINK;
StringCchCopyA(tsp->data,lengthof(tsp->data), linkp);
* but this seems to create problems. instead, we will just
* reject the link */
StringCchCopyA(tsp->data,lengthof(tsp->data), linkp+1);
- *newRootScpp = cm_data.rootSCachep;
- cm_HoldSCache(cm_data.rootSCachep);
+ *newRootScpp = cm_RootSCachep(userp, reqp);
+ cm_HoldSCache(*newRootScpp);
#else
/* we still copy the link data into the response so that
* the user can see what the link points to
cm_scache_t *scp;
cm_fid_t tfid;
struct rx_connection * rxconnp;
- int inlinebulk = 0; /* Did we use InlineBulkStatus RPC or not? */
-
+ int inlinebulk; /* Did we use InlineBulkStatus RPC or not? */
+
memset(&volSync, 0, sizeof(volSync));
/* otherwise, we may have one or more bulk stat's worth of stuff in bb;
callbackStruct.AFSCBs_val = &bbp->callbacks[filex];
cm_StartCallbackGrantingCall(NULL, &cbReq);
osi_Log1(afsd_logp, "CALL BulkStatus, %d entries", filesThisCall);
+
+ /*
+ * Whenever cm_Analyze is called for a RXAFS_ RPC there must
+ * be a FID provided. However, the error code from RXAFS_BulkStatus
+ * or RXAFS_InlinkBulkStatus does not apply to any FID. Therefore,
+ * we generate an invalid FID to match with the RPC error.
+ */
+ cm_SetFid(&tfid, dscp->fid.cell, dscp->fid.volume, 0, 0);
+
do {
- code = cm_ConnFromFID(&dscp->fid, userp, reqp, &connp);
+ inlinebulk = 0;
+
+ code = cm_ConnFromFID(&tfid, userp, reqp, &connp);
if (code)
continue;
rxconnp = cm_GetRxConn(connp);
if (!(connp->serverp->flags & CM_SERVERFLAG_NOINLINEBULK)) {
code = RXAFS_InlineBulkStatus(rxconnp, &fidStruct,
- &statStruct, &callbackStruct, &volSync);
+ &statStruct, &callbackStruct, &volSync);
if (code == RXGEN_OPCODE) {
cm_SetServerNoInlineBulk(connp->serverp, 0);
} else {
}
rx_PutConnection(rxconnp);
- } while (cm_Analyze(connp, userp, reqp, &dscp->fid,
- &volSync, NULL, &cbReq, code));
+ /*
+ * If InlineBulk RPC was called and it succeeded,
+ * then pull out the return code from the status info
+ * and use it for cm_Analyze so that we can failover to other
+ * .readonly volume instances. But only do it for errors that
+ * are volume global.
+ */
+ if (inlinebulk && code == 0 && (&bbp->stats[0])->errorCode) {
+ osi_Log1(afsd_logp, "cm_TryBulkStat inline-bulk stat error: %d",
+ (&bbp->stats[0])->errorCode);
+ switch ((&bbp->stats[0])->errorCode) {
+ case VBUSY:
+ case VRESTARTING:
+ case VNOVOL:
+ case VMOVED:
+ case VOFFLINE:
+ case VSALVAGE:
+ case VNOSERVICE:
+ case VIO:
+ code = (&bbp->stats[0])->errorCode;
+ break;
+ default:
+ /* Rx and Rxkad errors are volume global */
+ if ( (&bbp->stats[0])->errorCode >= -64 && (&bbp->stats[0])->errorCode < 0 ||
+ (&bbp->stats[0])->errorCode >= ERROR_TABLE_BASE_RXK && (&bbp->stats[0])->errorCode < ERROR_TABLE_BASE_RXK + 256)
+ code = (&bbp->stats[0])->errorCode;
+ }
+ }
+ } while (cm_Analyze(connp, userp, reqp, &tfid, &volSync, NULL, &cbReq, code));
code = cm_MapRPCError(code, reqp);
- /* may as well quit on an error, since we're not going to do
+ /*
+ * might as well quit on an error, since we're not going to do
* much better on the next immediate call, either.
*/
if (code) {
inlinebulk ? "Inline" : "", code);
cm_EndCallbackGrantingCall(NULL, &cbReq, NULL, NULL, 0);
break;
- } else {
- osi_Log1(afsd_logp, "CALL %sBulkStatus SUCCESS", inlinebulk ? "Inline" : "");
}
- /* otherwise, we should do the merges */
+ /*
+ * The bulk RPC has succeeded or at least not failed with a
+ * volume global error result. For items that have inlineBulk
+ * errors we must call cm_Analyze in order to perform required
+ * logging of errors.
+ *
+ * If the RPC was not inline bulk or the entry either has no error
+ * the status must be merged.
+ */
+ osi_Log1(afsd_logp, "CALL %sBulkStatus SUCCESS", inlinebulk ? "Inline" : "");
+
for (i = 0; i<filesThisCall; i++) {
j = filex + i;
cm_SetFid(&tfid, dscp->fid.cell, bbp->fids[j].Volume, bbp->fids[j].Vnode, bbp->fids[j].Unique);
- code = cm_GetSCache(&tfid, &scp, userp, reqp);
- if (code != 0)
- continue;
- /* otherwise, if this entry has no callback info,
- * merge in this.
- */
- lock_ObtainWrite(&scp->rw);
- /* now, we have to be extra paranoid on merging in this
- * information, since we didn't use cm_SyncOp before
- * starting the fetch to make sure that no bad races
- * were occurring. Specifically, we need to make sure
- * we don't obliterate any newer information in the
- * vnode than have here.
- *
- * Right now, be pretty conservative: if there's a
- * callback or a pending call, skip it.
- * However, if the prior attempt to obtain status
- * was refused access or the volume is .readonly,
- * take the data in any case since we have nothing
- * better for the in flight directory enumeration that
- * resulted in this function being called.
- */
- if ((scp->cbServerp == NULL &&
- !(scp->flags & (CM_SCACHEFLAG_FETCHING | CM_SCACHEFLAG_STORING | CM_SCACHEFLAG_SIZESTORING))) ||
- (scp->flags & CM_SCACHEFLAG_PURERO) ||
- (scp->flags & CM_SCACHEFLAG_EACCESS)) {
- cm_EndCallbackGrantingCall(scp, &cbReq,
- &bbp->callbacks[j],
- &volSync,
- CM_CALLBACK_MAINTAINCOUNT);
- cm_MergeStatus(dscp, scp, &bbp->stats[j], &volSync, userp, reqp, 0);
- }
- lock_ReleaseWrite(&scp->rw);
- cm_ReleaseSCache(scp);
+ if (inlinebulk && (&bbp->stats[j])->errorCode) {
+ cm_req_t treq = *reqp;
+ cm_Analyze(NULL, userp, &treq, &tfid, &volSync, NULL, &cbReq, (&bbp->stats[j])->errorCode);
+ } else {
+ code = cm_GetSCache(&tfid, &scp, userp, reqp);
+ if (code != 0)
+ continue;
+
+ /*
+ * otherwise, if this entry has no callback info,
+ * merge in this. If there is existing callback info
+ * we skip the merge because the existing data must be
+ * current (we have a callback) and the response from
+ * a non-inline bulk rpc might actually be wrong.
+ *
+ * now, we have to be extra paranoid on merging in this
+ * information, since we didn't use cm_SyncOp before
+ * starting the fetch to make sure that no bad races
+ * were occurring. Specifically, we need to make sure
+ * we don't obliterate any newer information in the
+ * vnode than have here.
+ *
+ * Right now, be pretty conservative: if there's a
+ * callback or a pending call, skip it.
+ * However, if the prior attempt to obtain status
+ * was refused access or the volume is .readonly,
+ * take the data in any case since we have nothing
+ * better for the in flight directory enumeration that
+ * resulted in this function being called.
+ */
+ lock_ObtainRead(&scp->rw);
+ if ((scp->cbServerp == NULL &&
+ !(scp->flags & (CM_SCACHEFLAG_FETCHING | CM_SCACHEFLAG_STORING | CM_SCACHEFLAG_SIZESTORING))) ||
+ (scp->flags & CM_SCACHEFLAG_PURERO) ||
+ (scp->flags & CM_SCACHEFLAG_EACCESS))
+ {
+ lock_ConvertRToW(&scp->rw);
+ cm_EndCallbackGrantingCall(scp, &cbReq,
+ &bbp->callbacks[j],
+ &volSync,
+ CM_CALLBACK_MAINTAINCOUNT);
+ cm_MergeStatus(dscp, scp, &bbp->stats[j], &volSync, userp, reqp, 0);
+ lock_ReleaseWrite(&scp->rw);
+ } else {
+ lock_ReleaseRead(&scp->rw);
+ }
+ cm_ReleaseSCache(scp);
+ }
} /* all files in the response */
/* now tell it to drop the count,
* after doing the vnode processing above */
cm_EndCallbackGrantingCall(NULL, &cbReq, NULL, NULL, 0);
} /* while there are still more files to process */
- /* If we did the InlineBulk RPC pull out the return code and log it */
- if (inlinebulk) {
- if ((&bbp->stats[0])->errorCode) {
- osi_Log1(afsd_logp, "cm_TryBulkStat bulk stat error: %d",
- (&bbp->stats[0])->errorCode);
- code = (&bbp->stats[0])->errorCode;
- }
- }
-
return code;
}
return cm_SetLength(scp, &attrp->length, userp, reqp);
lock_ObtainWrite(&scp->rw);
+ /* Check for RO volume */
+ if (scp->flags & CM_SCACHEFLAG_RO) {
+ code = CM_ERROR_READONLY;
+ lock_ReleaseWrite(&scp->rw);
+ return code;
+ }
+
/* otherwise, we have to make an RPC to get the status */
code = cm_SyncOp(scp, NULL, userp, reqp, 0, CM_SCACHESYNC_STORESTATUS);
if (code) {
}
#endif /* AFS_FREELANCE_CLIENT */
+ /* Check for RO volume */
+ if (dscp->flags & CM_SCACHEFLAG_RO)
+ return CM_ERROR_READONLY;
+
/* before starting the RPC, mark that we're changing the file data, so
* that someone who does a chmod will know to wait until our call
* completes.
*/
- cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
+ cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, CM_DIROP_FLAG_NONE,
+ &dirop);
lock_ObtainWrite(&dscp->rw);
code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
lock_ReleaseWrite(&dscp->rw);
return code;
}
-long cm_FSync(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp)
+/*
+ * locked if TRUE means write-locked
+ * else the cm_scache_t rw must not be held
+ */
+long cm_FSync(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp, afs_uint32 locked)
{
long code;
+ if (locked)
+ lock_ReleaseWrite(&scp->rw);
code = buf_CleanVnode(scp, userp, reqp);
if (code == 0) {
lock_ObtainWrite(&scp->rw);
scp->flags &= ~(CM_SCACHEFLAG_OVERQUOTA | CM_SCACHEFLAG_OUTOFSPACE);
}
- lock_ReleaseWrite(&scp->rw);
+ if (!locked)
+ lock_ReleaseWrite(&scp->rw);
+ } else if (locked) {
+ lock_ObtainWrite(&scp->rw);
}
return code;
}
}
#endif /* AFS_FREELANCE_CLIENT */
+ /* Check for RO volume */
+ if (dscp->flags & CM_SCACHEFLAG_RO)
+ return CM_ERROR_READONLY;
+
/* before starting the RPC, mark that we're changing the directory
* data, so that someone who does a chmod on the dir will wait until
* our call completes.
*/
- cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
+ cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, CM_DIROP_FLAG_NONE,
+ &dirop);
lock_ObtainWrite(&dscp->rw);
code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
lock_ReleaseWrite(&dscp->rw);
return CM_ERROR_CROSSDEVLINK;
}
- cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
+ /* Check for RO volume */
+ if (dscp->flags & CM_SCACHEFLAG_RO)
+ return CM_ERROR_READONLY;
+
+ cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, CM_DIROP_FLAG_NONE,
+ &dirop);
lock_ObtainWrite(&dscp->rw);
code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
lock_ReleaseWrite(&dscp->rw);
cm_dirOp_t dirop;
fschar_t *fnamep = NULL;
+ /* Check for RO volume */
+ if (dscp->flags & CM_SCACHEFLAG_RO)
+ return CM_ERROR_READONLY;
+
memset(&volSync, 0, sizeof(volSync));
/* before starting the RPC, mark that we're changing the directory data,
* so that someone who does a chmod on the dir will wait until our
* call completes.
*/
- cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
+ cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, CM_DIROP_FLAG_NONE,
+ &dirop);
lock_ObtainWrite(&dscp->rw);
code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
lock_ReleaseWrite(&dscp->rw);
if (fnamep == NULL) {
code = -1;
#ifdef USE_BPLUS
- code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ, &dirop);
+ code = cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_READ,
+ CM_DIROP_FLAG_NONE, &dirop);
if (code == 0) {
code = cm_BPlusDirLookupOriginalName(&dirop, cnamep, &fnamep);
if (code == 0)
if (code)
goto done;
+ /* Check for RO volume */
+ if (dscp->flags & CM_SCACHEFLAG_RO) {
+ code = CM_ERROR_READONLY;
+ goto done;
+ }
+
/* before starting the RPC, mark that we're changing the directory data,
* so that someone who does a chmod on the dir will wait until our
* call completes.
*/
- cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, &dirop);
+ cm_BeginDirOp(dscp, userp, reqp, CM_DIRLOCK_NONE, CM_DIROP_FLAG_NONE,
+ &dirop);
lock_ObtainWrite(&dscp->rw);
code = cm_SyncOp(dscp, NULL, userp, reqp, 0, CM_SCACHESYNC_STOREDATA);
lock_ReleaseWrite(&dscp->rw);
} else {
code = 0;
}
+
+ /* Check for RO volume */
+ if (code == 0 &&
+ (oldDscp->flags & CM_SCACHEFLAG_RO) || (newDscp->flags & CM_SCACHEFLAG_RO)) {
+ code = CM_ERROR_READONLY;
+ }
+
if (code)
goto done;
if (oldNamep == NULL) {
code = -1;
#ifdef USE_BPLUS
- code = cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_READ, &oldDirOp);
+ code = cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_READ,
+ CM_DIROP_FLAG_NONE, &oldDirOp);
if (code == 0) {
code = cm_BPlusDirLookupOriginalName(&oldDirOp, cOldNamep, &oldNamep);
if (code == 0)
}
oneDir = 1;
- cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE, &oldDirOp);
+ cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE,
+ CM_DIROP_FLAG_NONE, &oldDirOp);
lock_ObtainWrite(&oldDscp->rw);
cm_dnlcRemove(oldDscp, cOldNamep);
cm_dnlcRemove(oldDscp, cNewNamep);
}
if (oldDscp->fid.vnode < newDscp->fid.vnode) {
- cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE, &oldDirOp);
+ cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE,
+ CM_DIROP_FLAG_NONE, &oldDirOp);
lock_ObtainWrite(&oldDscp->rw);
cm_dnlcRemove(oldDscp, cOldNamep);
code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
if (code != 0)
cm_EndDirOp(&oldDirOp);
if (code == 0) {
- cm_BeginDirOp(newDscp, userp, reqp, CM_DIRLOCK_NONE, &newDirOp);
+ cm_BeginDirOp(newDscp, userp, reqp, CM_DIRLOCK_NONE,
+ CM_DIROP_FLAG_NONE, &newDirOp);
lock_ObtainWrite(&newDscp->rw);
cm_dnlcRemove(newDscp, cNewNamep);
code = cm_SyncOp(newDscp, NULL, userp, reqp, 0,
}
else {
/* lock the new vnode entry first */
- cm_BeginDirOp(newDscp, userp, reqp, CM_DIRLOCK_NONE, &newDirOp);
+ cm_BeginDirOp(newDscp, userp, reqp, CM_DIRLOCK_NONE,
+ CM_DIROP_FLAG_NONE, &newDirOp);
lock_ObtainWrite(&newDscp->rw);
cm_dnlcRemove(newDscp, cNewNamep);
code = cm_SyncOp(newDscp, NULL, userp, reqp, 0,
if (code != 0)
cm_EndDirOp(&newDirOp);
if (code == 0) {
- cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE, &oldDirOp);
+ cm_BeginDirOp(oldDscp, userp, reqp, CM_DIRLOCK_NONE,
+ CM_DIROP_FLAG_NONE, &oldDirOp);
lock_ObtainWrite(&oldDscp->rw);
cm_dnlcRemove(oldDscp, cOldNamep);
code = cm_SyncOp(oldDscp, NULL, userp, reqp, 0,
if (scp->serverLock == LockWrite &&
scp->exclusiveLocks == 0 &&
scp->sharedLocks > 0) {
-
/* The serverLock should be downgraded to LockRead */
osi_Log0(afsd_logp, " DOWNGRADE lock from LockWrite to LockRead");
+ /* Make sure there are no dirty buffers left. */
+ code = cm_FSync(scp, userp, reqp, TRUE);
+
/* since scp->serverLock looked sane, we are going to assume
that we have a valid server lock. */
scp->lockDataVersion = scp->dataVersion;
scp->sharedLocks == 0) {
/* The serverLock should be released entirely */
+ if (scp->serverLock == LockWrite) {
+ /* Make sure there are no dirty buffers left. */
+ code = cm_FSync(scp, userp, reqp, TRUE);
+ }
+
code = cm_IntReleaseLock(scp, userp, reqp);
if (code == 0)
/* The serverLock should be downgraded to LockRead */
osi_Log0(afsd_logp, " DOWNGRADE lock from LockWrite to LockRead");
+ /* Make sure there are no dirty buffers left. */
+ code = cm_FSync(scp, userp, reqp, TRUE);
+
/* Since we already had a lock, we assume that there is a
valid server lock. */
scp->lockDataVersion = scp->dataVersion;
scp->sharedLocks == 0) {
/* The serverLock should be released entirely */
+ if (scp->serverLock == LockWrite) {
+ /* Make sure there are no dirty buffers left. */
+ code = cm_FSync(scp, userp, reqp, TRUE);
+ }
+
code = cm_IntReleaseLock(scp, userp, reqp);
if (code == 0) {
git://git.openafs.org / openafs.git / blobdiff