int
afscp_Lock(const struct afscp_venusfid *fid, int locktype)
{
int code, i, j;
struct AFSFid ff = fid->fid;
struct afscp_volume *vol;
struct AFSVolSync vs;
struct afscp_server *server;
struct rx_connection *c;
vol = afscp_VolumeById(fid->cell, fid->fid.Volume);
if (vol == NULL) {
afscp_errno = ENOENT;
return -1;
}
code = ENOENT;
for (i = 0; i < vol->nservers; i++) {
server = afscp_ServerByIndex(vol->servers[i]);
if (server && server->naddrs > 0) {
for (j = 0; j < server->naddrs; j++) {
c = afscp_ServerConnection(server, j);
if (c == NULL)
break;
if (locktype == LockRelease)
code = RXAFS_ReleaseLock(c, &ff, &vs);
/* read, write, extend */
else if (locktype < LockRelease)
code = RXAFS_SetLock(c, &ff, locktype, &vs);
if (code >= 0)
break;
}
}
if (code >= 0)
break;
}
if (code != 0) {
if ((code == EAGAIN) || (code == UAEWOULDBLOCK) || (code == UAEAGAIN))
code = EWOULDBLOCK;
afscp_errno = code;
return -1;
}
return 0;
}
int
main(int argc, char **argv)
{
char scell[MAXCELLCHARS], dcell[MAXCELLCHARS];
afs_uint32 ssrv, dsrv;
char *databuffer, *srcf = NULL, *destd = NULL, *destf = NULL, *destpath = NULL;
struct stat statbuf;
struct AFSStoreStatus sst;
struct AFSFetchStatus fst, dfst;
struct AFSVolSync vs;
struct AFSCallBack scb, dcb;
struct AFSFid sf, dd, df;
int filesz = 0;
int ch, blksize, bytesremaining, bytes;
struct timeval start, finish;
struct timezone tz;
struct rx_securityClass *ssc = 0, *dsc = 0;
int sscindex, dscindex;
struct rx_connection *sconn = NULL, *dconn = NULL;
struct rx_call *scall = NULL, *dcall = NULL;
int code = 0, fetchcode, storecode, printcallerrs = 0;
int slcl = 0, dlcl = 0, unlock = 0;
int sfd = 0, dfd = 0, unauth = 0;
struct AFSCBFids theFids;
struct AFSCBs theCBs;
blksize = 8 * 1024;
while ((ch = getopt(argc, argv, "iouUb:")) != -1) {
switch (ch) {
case 'b':
blksize = atoi(optarg);
break;
case 'i':
slcl = 1;
break;
case 'o':
dlcl = 1;
break;
case 'u':
unauth = 1;
break;
case 'U':
unlock = 1;
break;
default:
printf("Unknown option '%c'\n", ch);
exit(1);
}
}
if (argc - optind + unlock < 2) {
fprintf(stderr,
"Usage: afscp [-i|-o]] [-b xfersz] [-u] [-U] source [dest]\n");
fprintf(stderr, " -b Set block size\n");
fprintf(stderr, " -i Source is local (copy into AFS)\n");
fprintf(stderr, " -o Dest is local (copy out of AFS)\n");
fprintf(stderr, " -u Run unauthenticated\n");
fprintf(stderr, " -U Send an unlock request for source. (dest path not required)\n");
fprintf(stderr, "source and dest can be paths or specified as:\n");
fprintf(stderr, " @afs:cellname:servername:volume:vnode:uniq\n");
exit(1);
}
srcf = argv[optind++];
if (!unlock) {
destpath = argv[optind++];
destd = strdup(destpath);
if (!destd) {
perror("strdup");
exit(1);
}
if ((destf = strrchr(destd, '/'))) {
*destf++ = 0;
} else {
destf = destd;
destd = ".";
}
} else if (slcl) {
fprintf(stderr, "-i and -U cannot be used together\n");
}
if (!slcl && statfile(srcf, scell, &ssrv, &sf)) {
fprintf(stderr, "Cannot get attributes of %s\n", srcf);
exit(1);
}
if (!unlock && !dlcl && statfile(destd, dcell, &dsrv, &dd)) {
fprintf(stderr, "Cannot get attributes of %s\n", destd);
exit(1);
}
if ((databuffer = malloc(blksize)) == NULL) {
perror("malloc");
exit(1);
}
if (do_rx_Init())
exit(1);
if (start_cb_server()) {
printf("Cannot start callback service\n");
goto Fail_rx;
}
if (!slcl) {
sscindex = scindex_RXKAD;
if (unauth || (ssc = get_sc(scell)) == NULL) {
ssc = rxnull_NewClientSecurityObject();
sscindex = scindex_NULL;
/*printf("Cannot get authentication for cell %s; running unauthenticated\n", scell); */
}
sscindex = scindex_NULL;
if ((sconn =
rx_NewConnection(ssrv, htons(AFSCONF_FILEPORT), 1, ssc,
sscindex))
== NULL) {
struct in_addr s;
s.s_addr = ssrv;
printf("Cannot initialize rx connection to source server (%s)\n",
inet_ntoa(s));
goto Fail_sc;
}
}
if (!dlcl && !unlock) {
if (!slcl && ssrv == dsrv) {
dconn = sconn;
dsc = NULL;
} else {
if (slcl || strcmp(scell, dcell)) {
dscindex = scindex_RXKAD;
if (unauth || (dsc = get_sc(dcell)) == NULL) {
dsc = rxnull_NewClientSecurityObject();
dscindex = scindex_NULL;
/*printf("Cannot get authentication for cell %s; running unauthenticated\n", dcell); */
}
dscindex = scindex_NULL;
} else {
dsc = ssc;
dscindex = sscindex;
}
if ((dconn =
rx_NewConnection(dsrv, htons(AFSCONF_FILEPORT), 1, dsc,
dscindex))
== NULL) {
struct in_addr s;
s.s_addr = dsrv;
printf
("Cannot initialize rx connection to dest server (%s)\n",
inet_ntoa(s));
goto Fail_sconn;
}
}
}
memset(&sst, 0, sizeof(struct AFSStoreStatus));
if (dlcl && !unlock) {
dfd = open(destpath, O_RDWR | O_CREAT | O_EXCL, 0666);
if (dfd < 0 && errno == EEXIST) {
printf("%s already exists, overwriting\n", destpath);
dfd = open(destpath, O_RDWR | O_TRUNC, 0666);
if (dfd < 0) {
fprintf(stderr, "Cannot open %s (%s)\n", destpath,
afs_error_message(errno));
goto Fail_dconn;
}
} else if (dfd < 0) {
fprintf(stderr, "Cannot open %s (%s)\n", destpath,
afs_error_message(errno));
goto Fail_dconn;
}
} else if (!unlock) {
if ((code =
RXAFS_CreateFile(dconn, &dd, destf, &sst, &df, &fst, &dfst, &dcb,
&vs))) {
if (code == EEXIST) {
printf("%s already exits, overwriting\n", destpath);
if (statfile(destpath, dcell, &dsrv, &df))
fprintf(stderr, "Cannot get attributes of %s\n",
destpath);
else
code = 0;
} else {
printf("Cannot create %s (%s)\n", destpath,
afs_error_message(code));
if (code)
goto Fail_dconn;
}
}
}
if (slcl) {
sfd = open(srcf, O_RDONLY, 0);
if (sfd < 0) {
fprintf(stderr, "Cannot open %s (%s)\n", srcf,
afs_error_message(errno));
goto Fail_dconn;
}
if (fstat(sfd, &statbuf) < 0) {
fprintf(stderr, "Cannot stat %s (%s)\n", srcf,
afs_error_message(errno));
close(sfd);
goto Fail_dconn;
}
} else {
if ((code = RXAFS_FetchStatus(sconn, &sf, &fst, &scb, &vs))) {
printf("Cannot fetchstatus of %d.%d (%s)\n", sf.Volume, sf.Vnode,
afs_error_message(code));
goto Fail_dconn;
}
}
if (slcl) {
filesz = statbuf.st_size;
} else {
filesz = fst.Length;
}
printcallerrs = 0;
fetchcode = 0;
storecode = 0;
if (!slcl && !unlock)
scall = rx_NewCall(sconn);
if (!dlcl && !unlock)
dcall = rx_NewCall(dconn);
gettimeofday(&start, &tz);
if (unlock) {
if (fst.lockCount) {
printf("Sending 1 unlock for %s (%d locks)\n", srcf, fst.lockCount);
if ((code = RXAFS_ReleaseLock(sconn, &sf, &vs))) {
printf("Unable to unlock %s (%s)\n", srcf,
afs_error_message(code));
}
} else {
printf("No locks for %s\n", srcf);
}
fetchcode = code;
goto Finish;
}
if (!slcl) {
if ((code = StartRXAFS_FetchData(scall, &sf, 0, filesz))) {
printf("Unable to fetch data from %s (%s)\n", srcf,
afs_error_message(code));
goto Fail_call;
}
}
if (!dlcl) {
if (slcl) {
sst.Mask = AFS_SETMODTIME | AFS_SETMODE;
sst.ClientModTime = statbuf.st_mtime;
sst.UnixModeBits =
statbuf.st_mode & ~(S_IFMT | S_ISUID | S_ISGID);
} else {
sst.Mask = AFS_SETMODTIME | AFS_SETMODE;
sst.ClientModTime = fst.ClientModTime;
sst.UnixModeBits =
fst.UnixModeBits & ~(S_IFMT | S_ISUID | S_ISGID);
}
if ((code =
StartRXAFS_StoreData(dcall, &df, &sst, 0, filesz, filesz))) {
printf("Unable to store data to %s (%s)\n", destpath,
afs_error_message(code));
goto Fail_call;
}
}
if (slcl) {
bytesremaining = statbuf.st_size;
} else {
rx_Read(scall, (char *)&bytesremaining, sizeof(afs_int32));
bytesremaining = ntohl(bytesremaining);
}
while (bytesremaining > 0) {
/*printf("%d bytes remaining\n",bytesremaining); */
if (slcl) {
if ((bytes =
read(sfd, databuffer, min(blksize, bytesremaining))) <= 0) {
fetchcode = errno;
break;
}
} else {
if ((bytes =
rx_Read(scall, databuffer,
min(blksize, bytesremaining))) <= 0)
break;
}
if (dlcl) {
if (write(dfd, databuffer, bytes) != bytes) {
storecode = errno;
break;
}
} else {
if (rx_Write(dcall, databuffer, bytes) != bytes)
break;
}
bytesremaining -= bytes;
/*printf("%d bytes copied\n",bytes); */
}
if (bytesremaining > 0) {
printf("Some network error occured while copying data\n");
goto Fail_call;
}
if (!slcl)
fetchcode = EndRXAFS_FetchData(scall, &fst, &scb, &vs);
if (!dlcl)
storecode = EndRXAFS_StoreData(dcall, &fst, &vs);
printcallerrs = 1;
Fail_call:
if (slcl) {
if (close(sfd) && !fetchcode)
fetchcode = errno;
} else {
fetchcode = rx_EndCall(scall, fetchcode);
}
if (fetchcode && printcallerrs)
printf("Error returned from fetch: %s\n", afs_error_message(fetchcode));
if (dlcl) {
if (close(dfd) && !storecode)
storecode = errno;
} else if (!unlock) {
storecode = rx_EndCall(dcall, storecode);
}
if (storecode && printcallerrs)
printf("Error returned from store: %s\n", afs_error_message(storecode));
Finish:
gettimeofday(&finish, &tz);
if (!slcl) {
theFids.AFSCBFids_len = 1;
theFids.AFSCBFids_val = &sf;
theCBs.AFSCBs_len = 1;
theCBs.AFSCBs_val = &scb;
scb.CallBackType = CB_DROPPED;
if ((code = RXAFS_GiveUpCallBacks(sconn, &theFids, &theCBs)))
printf("Could not give up source callback: %s\n",
afs_error_message(code));
}
if (!dlcl) {
theFids.AFSCBFids_len = 1;
theFids.AFSCBFids_val = &df;
theCBs.AFSCBs_len = 1;
theCBs.AFSCBs_val = &dcb;
dcb.CallBackType = CB_DROPPED;
if ((code = RXAFS_GiveUpCallBacks(dconn, &theFids, &theCBs)))
printf("Could not give up target callback: %s\n",
afs_error_message(code));
}
if (code == 0)
code = storecode;
if (code == 0)
code = fetchcode;
Fail_dconn:
if (!dlcl && !unlock && (slcl || dconn != sconn))
rx_DestroyConnection(dconn);
Fail_sconn:
if (!slcl)
rx_DestroyConnection(sconn);
Fail_sc:
if (dsc && dsc != ssc)
RXS_Close(dsc);
if (ssc)
RXS_Close(ssc);
Fail_rx:
rx_Finalize();
free(databuffer);
if (printcallerrs && !unlock) {
double rate, size, time;
if (finish.tv_sec == start.tv_sec) {
printf("Copied %d bytes in %d microseconds\n", filesz,
(int)(finish.tv_usec - start.tv_usec));
} else {
printf("Copied %d bytes in %d seconds\n", filesz,
(int)(finish.tv_sec - start.tv_sec));
}
size = filesz / 1024.0;
time =
finish.tv_sec - start.tv_sec + (finish.tv_usec -
start.tv_usec) / 1e+06;
rate = size / time;
printf("Transfer rate %g Kbytes/sec\n", rate);
}
exit(code != 0);
}
/*!
* All files that have been dirty before disconnection are going to
* be replayed back to the server.
*
* \param areq Request from the user.
* \param acred User credentials.
*
* \return If all files synchronized succesfully, return 0, otherwise
* return error code
*
* \note For now, it's the request from the PDiscon pioctl.
*
*/
int
afs_ResyncDisconFiles(struct vrequest *areq, afs_ucred_t *acred)
{
struct afs_conn *tc;
struct rx_connection *rxconn;
struct vcache *tvc;
struct AFSFetchStatus fstat;
struct AFSCallBack callback;
struct AFSVolSync tsync;
int code = 0;
afs_int32 start = 0;
XSTATS_DECLS;
/*AFS_STATCNT(afs_ResyncDisconFiles);*/
ObtainWriteLock(&afs_disconDirtyLock, 707);
while (!QEmpty(&afs_disconDirty)) {
tvc = QEntry(QPrev(&afs_disconDirty), struct vcache, dirtyq);
/* Can't lock tvc whilst holding the discon dirty lock */
ReleaseWriteLock(&afs_disconDirtyLock);
/* Get local write lock. */
ObtainWriteLock(&tvc->lock, 705);
if (tvc->f.ddirty_flags & VDisconRemove) {
/* Delete the file on the server and just move on
* to the next file. After all, it has been deleted
* we can't replay any other operation it.
*/
code = afs_ProcessOpRemove(tvc, areq);
goto next_file;
} else if (tvc->f.ddirty_flags & VDisconCreate) {
/* For newly created files, we don't need a server lock. */
code = afs_ProcessOpCreate(tvc, areq, acred);
if (code)
goto next_file;
tvc->f.ddirty_flags &= ~VDisconCreate;
tvc->f.ddirty_flags |= VDisconCreated;
}
#if 0
/* Get server write lock. */
do {
tc = afs_Conn(&tvc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_SETLOCK);
RX_AFS_GUNLOCK();
code = RXAFS_SetLock(rxconn,
(struct AFSFid *)&tvc->f.fid.Fid,
LockWrite,
&tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
} while (afs_Analyze(tc,
rxconn,
code,
&tvc->f.fid,
areq,
AFS_STATS_FS_RPCIDX_SETLOCK,
SHARED_LOCK,
NULL));
if (code)
goto next_file;
#endif
if (tvc->f.ddirty_flags & VDisconRename) {
/* If we're renaming the file, do so now */
code = afs_ProcessOpRename(tvc, areq);
if (code)
goto unlock_srv_file;
}
/* Issue a FetchStatus to get info about DV and callbacks. */
do {
tc = afs_Conn(&tvc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
tvc->callback = tc->srvr->server;
start = osi_Time();
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_FETCHSTATUS);
RX_AFS_GUNLOCK();
code = RXAFS_FetchStatus(rxconn,
(struct AFSFid *)&tvc->f.fid.Fid,
&fstat,
&callback,
&tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
} while (afs_Analyze(tc,
rxconn,
code,
&tvc->f.fid,
areq,
AFS_STATS_FS_RPCIDX_FETCHSTATUS,
SHARED_LOCK,
NULL));
if (code) {
goto unlock_srv_file;
}
if ((dv_match(tvc, fstat) && (tvc->f.m.Date == fstat.ServerModTime)) ||
(afs_ConflictPolicy == CLIENT_WINS) ||
(tvc->f.ddirty_flags & VDisconCreated)) {
/*
* Send changes to the server if there's data version match, or
* client wins policy has been selected or file has been created
* but doesn't have it's the contents on to the server yet.
*/
/*
* XXX: Checking server attr changes by timestamp might not the
* most elegant solution, but it's the most viable one that we could find.
*/
afs_UpdateStatus(tvc, &tvc->f.fid, areq, &fstat, &callback, start);
code = afs_SendChanges(tvc, areq);
} else if (afs_ConflictPolicy == SERVER_WINS) {
/* DV mismatch, apply collision resolution policy. */
/* Discard this files chunks and remove from current dir. */
afs_ResetVCache(tvc, acred, 0);
tvc->f.truncPos = AFS_NOTRUNC;
} else {
/* printf("afs_ResyncDisconFiles: no resolution policy selected.\n"); */
} /* if DV match or client wins policy */
unlock_srv_file:
/* Release server write lock. */
#if 0
do {
tc = afs_Conn(&tvc->f.fid, areq, SHARED_LOCK, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_RELEASELOCK);
RX_AFS_GUNLOCK();
ucode = RXAFS_ReleaseLock(rxconn,
(struct AFSFid *) &tvc->f.fid.Fid,
&tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
ucode = -1;
} while (afs_Analyze(tc,
rxconn,
ucode,
&tvc->f.fid,
areq,
AFS_STATS_FS_RPCIDX_RELEASELOCK,
SHARED_LOCK,
NULL));
#endif
next_file:
ObtainWriteLock(&afs_disconDirtyLock, 710);
if (code == 0) {
/* Replayed successfully - pull the vcache from the
* disconnected list */
tvc->f.ddirty_flags = 0;
QRemove(&tvc->dirtyq);
afs_PutVCache(tvc);
} else {
if (code == EAGAIN) {
/* Operation was deferred. Pull it from the current place in
* the list, and stick it at the end again */
QRemove(&tvc->dirtyq);
QAdd(&afs_disconDirty, &tvc->dirtyq);
} else {
/* Failed - keep state as is, and let the user know we died */
ReleaseWriteLock(&tvc->lock);
break;
}
}
/* Release local write lock. */
ReleaseWriteLock(&tvc->lock);
} /* while (tvc) */
if (code) {
ReleaseWriteLock(&afs_disconDirtyLock);
return code;
}
/* Dispose of all of the shadow directories */
afs_DisconDiscardAllShadows(0, acred);
ReleaseWriteLock(&afs_disconDirtyLock);
return code;
}
/* clid - nonzero on sgi sunos osf1 only */
int
HandleFlock(struct vcache *avc, int acom, struct vrequest *areq,
pid_t clid, int onlymine)
{
struct afs_conn *tc;
struct SimpleLocks *slp, *tlp, **slpp;
afs_int32 code;
struct AFSVolSync tsync;
afs_int32 lockType;
struct AFS_FLOCK flock;
XSTATS_DECLS;
AFS_STATCNT(HandleFlock);
code = 0; /* default when we don't make any network calls */
lockIdSet(&flock, NULL, clid);
#if defined(AFS_SGI_ENV)
osi_Assert(valusema(&avc->vc_rwlock) <= 0);
osi_Assert(OSI_GET_LOCKID() == avc->vc_rwlockid);
#endif
ObtainWriteLock(&avc->lock, 118);
if (acom & LOCK_UN) {
int stored_segments = 0;
retry_unlock:
/* defect 3083 */
#ifdef AFS_AIX_ENV
/* If the lock is held exclusive, then only the owning process
* or a child can unlock it. Use pid and ppid because they are
* unique identifiers.
*/
if ((avc->flockCount < 0) && (getpid() != avc->ownslock)) {
#ifdef AFS_AIX41_ENV
if (onlymine || (getppid() != avc->ownslock)) {
#else
if (onlymine || (u.u_procp->p_ppid != avc->ownslock)) {
#endif
ReleaseWriteLock(&avc->lock);
return 0;
}
}
#endif
if (lockIdcmp2(&flock, avc, NULL, onlymine, clid)) {
ReleaseWriteLock(&avc->lock);
return 0;
}
#ifdef AFS_AIX_ENV
avc->ownslock = 0;
#endif
if (avc->flockCount == 0) {
ReleaseWriteLock(&avc->lock);
return 0 /*ENOTTY*/;
/* no lock held */
}
/* unlock the lock */
if (avc->flockCount > 0) {
slpp = &avc->slocks;
for (slp = *slpp; slp;) {
if (!lockIdcmp2(&flock, avc, slp, onlymine, clid)) {
avc->flockCount--;
tlp = *slpp = slp->next;
osi_FreeSmallSpace(slp);
slp = tlp;
} else {
slpp = &slp->next;
slp = *slpp;
}
}
} else if (avc->flockCount == -1) {
if (!stored_segments) {
afs_StoreAllSegments(avc, areq, AFS_SYNC | AFS_VMSYNC); /* fsync file early */
/* afs_StoreAllSegments can drop and reacquire the write lock
* on avc and GLOCK, so the flocks may be completely different
* now. Go back and perform all checks again. */
stored_segments = 1;
goto retry_unlock;
}
avc->flockCount = 0;
/* And remove the (only) exclusive lock entry from the list... */
osi_FreeSmallSpace(avc->slocks);
avc->slocks = 0;
}
if (avc->flockCount == 0) {
if (!AFS_IS_DISCONNECTED) {
struct rx_connection *rxconn;
do {
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(rxconn, (struct AFSFid *)
&avc->f.fid.Fid, &tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
} while (afs_Analyze
(tc, rxconn, code, &avc->f.fid, areq,
AFS_STATS_FS_RPCIDX_RELEASELOCK, SHARED_LOCK, NULL));
} else {
/*printf("Network is dooooooowwwwwwwnnnnnnn\n");*/
code = ENETDOWN;
}
}
} else {
while (1) { /* set a new lock */
/*
* Upgrading from shared locks to Exclusive and vice versa
* is a bit tricky and we don't really support it yet. But
* we try to support the common used one which is upgrade
* a shared lock to an exclusive for the same process...
*/
if ((avc->flockCount > 0 && (acom & LOCK_EX))
|| (avc->flockCount == -1 && (acom & LOCK_SH))) {
/*
* Upgrading from shared locks to an exclusive one:
* For now if all the shared locks belong to the
* same process then we unlock them on the server
* and proceed with the upgrade. Unless we change the
* server's locking interface impl we prohibit from
* unlocking other processes's shared locks...
* Upgrading from an exclusive lock to a shared one:
* Again only allowed to be done by the same process.
*/
slpp = &avc->slocks;
for (slp = *slpp; slp;) {
if (!lockIdcmp2
(&flock, avc, slp, 1 /*!onlymine */ , clid)) {
if (acom & LOCK_EX)
avc->flockCount--;
else
avc->flockCount = 0;
tlp = *slpp = slp->next;
osi_FreeSmallSpace(slp);
slp = tlp;
} else {
code = EWOULDBLOCK;
slpp = &slp->next;
slp = *slpp;
}
}
if (!code && avc->flockCount == 0) {
if (!AFS_IS_DISCONNECTED) {
struct rx_connection *rxconn;
do {
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(rxconn,
(struct AFSFid *)&avc->
f.fid.Fid, &tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
} while (afs_Analyze
(tc, rxconn, code, &avc->f.fid, areq,
AFS_STATS_FS_RPCIDX_RELEASELOCK, SHARED_LOCK,
NULL));
}
}
} else if (avc->flockCount == -1 && (acom & LOCK_EX)) {
if (lockIdcmp2(&flock, avc, NULL, 1, clid)) {
code = EWOULDBLOCK;
} else {
code = 0;
/* We've just re-grabbed an exclusive lock, so we don't
* need to contact the fileserver, and we don't need to
* add the lock to avc->slocks (since we already have a
* lock there). So, we are done. */
break;
}
}
if (code == 0) {
/* compatible here, decide if needs to go to file server. If
* we've already got the file locked (and thus read-locked, since
* 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, &rxconn);
if (tc) {
XSTATS_START_TIME(AFS_STATS_FS_RPCIDX_SETLOCK);
RX_AFS_GUNLOCK();
code = RXAFS_SetLock(rxconn, (struct AFSFid *)
&avc->f.fid.Fid, lockType,
&tsync);
RX_AFS_GLOCK();
XSTATS_END_TIME;
} else
code = -1;
} while (afs_Analyze
(tc, rxconn, code, &avc->f.fid, areq,
AFS_STATS_FS_RPCIDX_SETLOCK, SHARED_LOCK,
NULL));
if ((lockType == LockWrite) && (code == VREADONLY))
code = EBADF; /* per POSIX; VREADONLY == EROFS */
} else
/* XXX - Should probably try and log this when we're
* XXX - running with logging enabled. But it's horrid
*/
code = 0; /* pretend we worked - ick!!! */
} else
code = 0; /* otherwise, pretend things worked */
}
if (code == 0) {
slp = (struct SimpleLocks *)
osi_AllocSmallSpace(sizeof(struct SimpleLocks));
if (acom & LOCK_EX) {
/* defect 3083 */
#ifdef AFS_AIX_ENV
/* Record unique id of process owning exclusive lock. */
avc->ownslock = getpid();
#endif
slp->type = LockWrite;
slp->next = NULL;
avc->slocks = slp;
avc->flockCount = -1;
} else {
slp->type = LockRead;
slp->next = avc->slocks;
avc->slocks = slp;
avc->flockCount++;
}
lockIdSet(&flock, slp, clid);
break;
}
/* now, if we got EWOULDBLOCK, and we're supposed to wait, we do */
if (((code == EWOULDBLOCK) || (code == EAGAIN) ||
(code == UAEWOULDBLOCK) || (code == UAEAGAIN))
&& !(acom & LOCK_NB)) {
/* sleep for a second, allowing interrupts */
ReleaseWriteLock(&avc->lock);
#if defined(AFS_SGI_ENV)
AFS_RWUNLOCK((vnode_t *) avc, VRWLOCK_WRITE);
#endif
code = afs_osi_Wait(1000, NULL, 1);
#if defined(AFS_SGI_ENV)
AFS_RWLOCK((vnode_t *) avc, VRWLOCK_WRITE);
#endif
ObtainWriteLock(&avc->lock, 120);
if (code) {
code = EINTR; /* return this if ^C typed */
break;
}
} else
break;
} /* while loop */
}
ReleaseWriteLock(&avc->lock);
code = afs_CheckCode(code, areq, 1); /* defeat a buggy AIX optimization */
return code;
}
/* 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)
{
afs_int32 now;
pid_t pid = MyPidxx2Pid(MyPidxx);
char *procname;
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 (!procname)
return;
/* Copies process name to allocated procname, see osi_machdeps for details of macro */
osi_procname(procname, 256);
procname[255] = '\0';
/* 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));
#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, (long)afs_cr_uid(acred));
#endif
afs_osi_Free(procname, 256);
}
return;
}
