static int lockIdcmp2(struct AFS_FLOCK *flock1, struct vcache *vp,
struct SimpleLocks *alp, int onlymine,
int clid);
-static void DoLockWarning(afs_ucred_t * acred);
/* int clid; * non-zero on SGI, OSF, SunOS, Darwin, xBSD ** XXX ptr type */
proc_t *procp = ttoproc(curthread);
if (slp) {
-# ifdef AFS_SUN53_ENV
slp->sysid = 0;
slp->pid = procp->p_pid;
-# else
- slp->sysid = procp->p_sysid;
- slp->pid = procp->p_epid;
-# endif
} else {
-# ifdef AFS_SUN53_ENV
flock->l_sysid = 0;
flock->l_pid = procp->p_pid;
-# else
- flock->l_sysid = procp->p_sysid;
- flock->l_pid = procp->p_epid;
-# endif
}
}
#elif defined(AFS_SGI_ENV)
}
if (avc->flockCount == 0) {
if (!AFS_IS_DISCONNECTED) {
+ struct rx_connection *rxconn;
do {
- tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
+ tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_RELEASELOCK);
RX_AFS_GUNLOCK();
- code = RXAFS_ReleaseLock(tc->id, (struct AFSFid *)
+ code = RXAFS_ReleaseLock(rxconn, (struct AFSFid *)
&avc->f.fid.Fid, &tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
} while (afs_Analyze
- (tc, code, &avc->f.fid, areq,
+ (tc, rxconn, code, &avc->f.fid, areq,
AFS_STATS_FS_RPCIDX_RELEASELOCK, SHARED_LOCK, NULL));
} else {
/*printf("Network is dooooooowwwwwwwnnnnnnn\n");*/
}
if (!code && avc->flockCount == 0) {
if (!AFS_IS_DISCONNECTED) {
+ struct rx_connection *rxconn;
do {
- tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
+ tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME
(AFS_STATS_FS_RPCIDX_RELEASELOCK);
RX_AFS_GUNLOCK();
code =
- RXAFS_ReleaseLock(tc->id,
+ RXAFS_ReleaseLock(rxconn,
(struct AFSFid *)&avc->
f.fid.Fid, &tsync);
RX_AFS_GLOCK();
} else
code = -1;
} while (afs_Analyze
- (tc, code, &avc->f.fid, areq,
+ (tc, rxconn, code, &avc->f.fid, areq,
AFS_STATS_FS_RPCIDX_RELEASELOCK, SHARED_LOCK,
NULL));
}
* we've already checked for compatibility), we shouldn't send
* the call through to the server again */
if (avc->flockCount == 0) {
+ struct rx_connection *rxconn;
/* we're the first on our block, send the call through */
lockType = ((acom & LOCK_EX) ? LockWrite : LockRead);
if (!AFS_IS_DISCONNECTED) {
do {
- tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
+ tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_SETLOCK);
RX_AFS_GUNLOCK();
- code = RXAFS_SetLock(tc->id, (struct AFSFid *)
+ code = RXAFS_SetLock(rxconn, (struct AFSFid *)
&avc->f.fid.Fid, lockType,
&tsync);
RX_AFS_GLOCK();
} else
code = -1;
} while (afs_Analyze
- (tc, code, &avc->f.fid, areq,
+ (tc, rxconn, code, &avc->f.fid, areq,
AFS_STATS_FS_RPCIDX_SETLOCK, SHARED_LOCK,
NULL));
if ((lockType == LockWrite) && (code == VREADONLY))
/* warn a user that a lock has been ignored */
-afs_int32 lastWarnTime = 0; /* this is used elsewhere */
-static afs_int32 lastWarnPid = 0;
static void
-DoLockWarning(afs_ucred_t * acred)
+DoLockWarning(struct vcache *avc, afs_ucred_t * acred)
{
- afs_int32 now;
+ static afs_uint32 lastWarnTime;
+ static pid_t lastWarnPid;
+
+ afs_uint32 now;
pid_t pid = MyPidxx2Pid(MyPidxx);
char *procname;
+ const char *message;
now = osi_Time();
AFS_STATCNT(DoLockWarning);
+
/* check if we've already warned this user recently */
- if (!((now < lastWarnTime + 120) && (lastWarnPid == pid))) {
- procname = afs_osi_Alloc(256);
+ if ((now < lastWarnTime + 120) && (lastWarnPid == pid)) {
+ return;
+ }
- if (!procname)
- return;
+ procname = afs_osi_Alloc(256);
- /* Copies process name to allocated procname, see osi_machdeps for details of macro */
- osi_procname(procname, 256);
- procname[255] = '\0';
+ if (!procname)
+ return;
+
+ /* Copies process name to allocated procname, see osi_machdeps for details of macro */
+ osi_procname(procname, 256);
+ procname[255] = '\0';
+
+ lastWarnTime = now;
+ lastWarnPid = pid;
- /* otherwise, it is time to nag the user */
- lastWarnTime = now;
- lastWarnPid = pid;
#ifdef AFS_LINUX26_ENV
- afs_warnuser
- ("afs: byte-range locks only enforced for processes on this machine (pid %d (%s), user %ld).\n", pid, procname, (long)afs_cr_uid(acred));
+ message = "byte-range locks only enforced for processes on this machine";
#else
- afs_warnuser
- ("afs: byte-range lock/unlock ignored; make sure no one else is running this program (pid %d (%s), user %ld).\n", pid, procname, afs_cr_uid(acred));
+ message = "byte-range lock/unlock ignored; make sure no one else is running this program";
#endif
- afs_osi_Free(procname, 256);
- }
- return;
+
+ afs_warnuser("afs: %s (pid %d (%s), user %ld, fid %lu.%lu.%lu).\n",
+ message, pid, procname, (long)afs_cr_uid(acred),
+ (unsigned long)avc->f.fid.Fid.Volume,
+ (unsigned long)avc->f.fid.Fid.Vnode,
+ (unsigned long)avc->f.fid.Fid.Unique);
+
+ afs_osi_Free(procname, 256);
}
if (code) {
goto done;
}
-#if (defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV)) && !defined(AFS_SUN58_ENV)
+#if defined(AFS_SGI_ENV)
if ((acmd == F_GETLK) || (acmd == F_RGETLK)) {
#else
if (acmd == F_GETLK) {
code = afs_CheckCode(code, &treq, 2); /* defeat buggy AIX optimz */
goto done;
} else if ((acmd == F_SETLK) || (acmd == F_SETLKW)
-#if (defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV)) && !defined(AFS_SUN58_ENV)
+#if defined(AFS_SGI_ENV)
|| (acmd == F_RSETLK) || (acmd == F_RSETLKW)) {
#else
) {
#endif
+
+ if ((avc->f.states & CRO)) {
+ /* for RO volumes, don't do anything for locks; the fileserver doesn't
+ * even track them. A write lock should not be possible, though. */
+ if (af->l_type == F_WRLCK) {
+ code = EBADF;
+ } else {
+ code = 0;
+ }
+ goto done;
+ }
+
/* Java VMs ask for l_len=(long)-1 regardless of OS/CPU */
if ((sizeof(af->l_len) == 8) && (af->l_len == 0x7fffffffffffffffLL))
af->l_len = 0;
/* next line makes byte range locks always succeed,
* even when they should block */
if (af->l_whence != 0 || af->l_start != 0 || af->l_len != 0) {
- DoLockWarning(acred);
+ DoLockWarning(avc, acred);
code = 0;
goto done;
}
else if (af->l_type == F_UNLCK)
code = LOCK_UN;
else {
- afs_PutFakeStat(&fakestate);
- return EINVAL; /* unknown lock type */
+ code = EINVAL; /* unknown lock type */
+ goto done;
}
if (((acmd == F_SETLK)
-#if (defined(AFS_SGI_ENV) || defined(AFS_SUN5_ENV)) && !defined(AFS_SUN58_ENV)
+#if defined(AFS_SGI_ENV)
|| (acmd == F_RSETLK)
#endif
) && code != LOCK_UN)
struct AFSFetchStatus OutStatus;
struct AFSCallBack CallBack;
struct AFSVolSync tsync;
+ struct rx_connection *rxconn;
int temp;
XSTATS_DECLS;
temp = areq->flags & O_NONBLOCK;
return 0;
do {
- tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK);
+ tc = afs_Conn(&avc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_FETCHSTATUS);
RX_AFS_GUNLOCK();
code =
- RXAFS_FetchStatus(tc->id, (struct AFSFid *)&avc->f.fid.Fid,
+ RXAFS_FetchStatus(rxconn, (struct AFSFid *)&avc->f.fid.Fid,
&OutStatus, &CallBack, &tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
} while (afs_Analyze
- (tc, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_FETCHSTATUS,
+ (tc, rxconn, code, &avc->f.fid, areq, AFS_STATS_FS_RPCIDX_FETCHSTATUS,
SHARED_LOCK, NULL));
if (temp)