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;
}
* 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
break;
}
+#ifdef AFSIFS
+ /* Why was this added for IFS? - jaltman 06/18/2006 */
+ 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);
bufferOffset = thyper;
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.
*/
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);
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;
+ if (code == CM_ERROR_NOSUCHFILE)
+ code = CM_ERROR_NOSUCHPATH;
/* this stuff is allocated no matter what happened on the namei call,
* so free it */
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);
void **lockpp)
{
long code;
- int Which = ((LockType & 0x1) ? LockRead : LockWrite);
+ int Which = ((LockType & LOCKING_ANDX_SHARED_LOCK) ? LockRead : LockWrite);
AFSFid tfid;
AFSVolSync volSync;
cm_conn_t *connp;
int found = 0;
struct rx_connection * callp;
+ osi_Log1(afsd_logp, "cm_Lock scp 0x%x ...", (long) scp);
+ osi_Log4(afsd_logp, "cm_Lock type 0x%x offset %d length %d timeout %d",
+ LockType, (unsigned long)LOffset.QuadPart, (unsigned long)LLength.QuadPart, Timeout);
+
/* 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)
+ 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 & LOCKING_ANDX_SHARED_LOCK) == 0 ||
+ (fileLock->LockType & LOCKING_ANDX_SHARED_LOCK) == 0)
return CM_ERROR_WOULDBLOCK;
found = 1;
}
q = osi_QNext(q);
}
+ osi_Log1(afsd_logp, "cm_Lock found = %d", found);
+
if (found)
code = 0;
else {
tfid.Unique = scp->fid.unique;
lock_ReleaseMutex(&scp->mx);
do {
+ osi_Log1(afsd_logp, "CALL SetLock scp 0x%x", (long) scp);
code = cm_Conn(&scp->fid, userp, reqp, &connp);
if (code)
break;
} while (cm_Analyze(connp, userp, reqp, &scp->fid, &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);
code = cm_MapRPCError(code, reqp);
}
lock_ReleaseWrite(&cm_scacheLock);
if (code != 0)
*lockpp = fileLock;
+ osi_Log1(afsd_logp, "cm_Lock Lock added 0x%x", (long) fileLock);
}
return code;
}
cm_user_t *userp, cm_req_t *reqp)
{
long code = 0;
- int Which = ((LockType & 0x1) ? LockRead : LockWrite);
+ int Which = ((LockType & LOCKING_ANDX_SHARED_LOCK) ? LockRead : LockWrite);
AFSFid tfid;
AFSVolSync volSync;
cm_conn_t *connp;
int found = 0;
struct rx_connection * callp;
+ osi_Log4(afsd_logp, "cm_Unlock scp 0x%x type 0x%x offset %d length %d",
+ (long) scp, LockType, (unsigned long)LOffset.QuadPart, (unsigned long)LLength.QuadPart);
+
if (LargeIntegerLessThan(LLength, scp->length))
smallLock = 1;
ourLock = fileLock;
qq = q;
}
- else if (fileLock->LockType & 0x1)
+ else if (fileLock->LockType & LOCKING_ANDX_SHARED_LOCK)
anotherReader = 1;
q = osi_QNext(q);
}
/* ignore byte ranges */
- if (smallLock && !found)
+ if (smallLock && !found) {
+ osi_Log0(afsd_logp, "cm_Unlock lock not found and ignored");
return 0;
+ }
/* don't try to unlock other people's locks */
- if (!found)
+ if (!found) {
+ osi_Log0(afsd_logp, "cm_Unlock lock not found; failure");
return CM_ERROR_WOULDBLOCK;
+ }
/* discard lock record */
osi_QRemove(&scp->fileLocks, qq);
tfid.Vnode = scp->fid.vnode;
tfid.Unique = scp->fid.unique;
lock_ReleaseMutex(&scp->mx);
+ osi_Log1(afsd_logp, "CALL ReleaseLock scp 0x%x", (long) scp);
do {
code = cm_Conn(&scp->fid, userp, reqp, &connp);
if (code)
} while (cm_Analyze(connp, userp, reqp, &scp->fid, &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);
}
+ osi_Log1(afsd_logp, "cm_Unlock code 0x%x", code);
return code;
}
tfid.Vnode = fileLock->fid.vnode;
tfid.Unique = fileLock->fid.unique;
lock_ReleaseWrite(&cm_scacheLock);
+ osi_Log1(afsd_logp, "CALL ExtendLock lock 0x%x", (long) fileLock);
do {
code = cm_Conn(&fileLock->fid, fileLock->userp,
&req, &connp);
&fileLock->fid, &volSync, NULL, NULL,
code));
code = cm_MapRPCError(code, &req);
+ if (code)
+ osi_Log1(afsd_logp, "CALL ExtendLock FAILURE, code 0x%x", code);
+ else
+ osi_Log0(afsd_logp, "CALL ExtendLock SUCCESS");
+
lock_ObtainWrite(&cm_scacheLock);
}
q = nq;
long cm_RetryLock(cm_file_lock_t *oldFileLock, int vcp_is_dead)
{
long code;
- int Which = ((oldFileLock->LockType & 0x1) ? LockRead : LockWrite);
+ int Which = ((oldFileLock->LockType & LOCKING_ANDX_SHARED_LOCK) ? LockRead : LockWrite);
cm_scache_t *scp;
AFSFid tfid;
AFSVolSync volSync;
if ((fileLock->flags &
(CM_FILELOCK_FLAG_INVALID | CM_FILELOCK_FLAG_WAITING))
== 0) {
- if ((oldFileLock->LockType & 0x1) == 0
- || (fileLock->LockType & 0x1) == 0) {
+ if ((oldFileLock->LockType & LOCKING_ANDX_SHARED_LOCK) == 0
+ || (fileLock->LockType & LOCKING_ANDX_SHARED_LOCK) == 0) {
cm_ReleaseSCache(scp);
return CM_ERROR_WOULDBLOCK;
}
tfid.Volume = oldFileLock->fid.volume;
tfid.Vnode = oldFileLock->fid.vnode;
tfid.Unique = oldFileLock->fid.unique;
+ osi_Log1(afsd_logp, "CALL SetLock lock 0x%x", (long) oldFileLock);
do {
code = cm_Conn(&oldFileLock->fid, oldFileLock->userp,
&req, &connp);
&oldFileLock->fid, &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");
}
handleCode:
git://git.openafs.org / openafs.git / blobdiff