simple_unlock((void *)&afs_global_lock); \
} while(0)
#define ISAFS_GLOCK() lock_mine((void *)&afs_global_lock)
-
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
-#define ISAFS_RXGLOCK() 1
#endif
#endif /* _OSI_MACHDEP_H_ */
lockmgr(&afs_global_lock, LK_RELEASE, 0, current_proc()); \
} while(0)
#define ISAFS_GLOCK() (afs_global_owner == current_thread())
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
-#define ISAFS_RXGLOCK() 1
#define SPLVAR
#define NETPRI
usimple_unlock(&afs_global_lock); \
} while(0)
#define ISAFS_GLOCK() (afs_global_owner == current_thread())
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
-#define ISAFS_RXGLOCK() 1
#undef SPLVAR
#define SPLVAR
#define ISAFS_GLOCK() (afs_global_owner == curproc && curproc)
#endif /* FBSD50 */
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
-#define ISAFS_RXGLOCK() 1
-
#undef SPLVAR
#define SPLVAR int splvar
#undef NETPRI
#endif
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
-#define ISAFS_RXGLOCK() 1
-
/* Uses splnet only in the SP case */
#define SPLVAR register ulong_t splvar
#define NETPRI NET_SPLNET(splvar)
(AFS_ASSERT_GLOCK(), afs_global_owner = 0, mutex_exit(&afs_global_lock))
#define ISAFS_GLOCK() (osi_ThreadUnique() == afs_global_owner)
#endif /* AFS_SGI64_ENV */
-
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
-#define ISAFS_RXGLOCK() 1
-
#else /* MP */
#define AFS_GLOCK()
#define AFS_GUNLOCK()
#define AFS_GUNLOCK()
#define ISAFS_GLOCK() 1
#define AFS_ASSERT_GLOCK()
-#define AFS_ASSERT_RXGLOCK()
#endif
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
-#define ISAFS_RXGLOCK() 1
#endif /* OSI_MACHDEP_H_ */
simple_unlock(&afs_global_lock); \
} while(0)
#endif /* 0 */
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
-#define ISAFS_RXGLOCK() 1
#undef SPLVAR
#define SPLVAR
#define AFS_ASSERT_GLOCK()
#define ISAFS_GLOCK() 1
#endif
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
-#define ISAFS_RXGLOCK() 1
#undef SPLVAR
#define SPLVAR int splvar
#define AFS_GLOCK() mutex_enter(&afs_global_lock);
#define AFS_GUNLOCK() mutex_exit(&afs_global_lock);
#define ISAFS_GLOCK() mutex_owned(&afs_global_lock)
-
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
-#define ISAFS_RXGLOCK() 1
#endif
{
int index;
osi_wait_t *waitp;
- int rxGlockOwner = ISAFS_RXGLOCK();
int glockOwner = ISAFS_GLOCK();
usr_mutex_lock(&osi_waitq_lock);
if (glockOwner) {
AFS_GUNLOCK();
}
- if (rxGlockOwner) {
- AFS_RXGUNLOCK();
- }
index = WAITHASH(x);
if (osi_waithash_avail == NULL) {
waitp = (osi_wait_t *) afs_osi_Alloc(sizeof(osi_wait_t));
if (glockOwner) {
AFS_GLOCK();
}
- if (rxGlockOwner) {
- AFS_RXGLOCK();
- }
}
int
osi_wait_t *waitp;
struct timespec tv;
int ret;
- int rxGlockOwner = ISAFS_RXGLOCK();
int glockOwner = ISAFS_GLOCK();
tv.tv_sec = msec / 1000;
if (glockOwner) {
AFS_GUNLOCK();
}
- if (rxGlockOwner) {
- AFS_RXGUNLOCK();
- }
usr_thread_sleep(&tv);
ret = 0;
if (glockOwner) {
AFS_GLOCK();
}
- if (rxGlockOwner) {
- AFS_RXGLOCK();
- }
} else {
usr_mutex_lock(&osi_waitq_lock);
if (glockOwner) {
AFS_GUNLOCK();
}
- if (rxGlockOwner) {
- AFS_RXGUNLOCK();
- }
index = WAITHASH((caddr_t) handle);
if (osi_waithash_avail == NULL) {
waitp = (osi_wait_t *) afs_osi_Alloc(sizeof(osi_wait_t));
if (glockOwner) {
AFS_GLOCK();
}
- if (rxGlockOwner) {
- AFS_RXGLOCK();
- }
}
return ret;
}
#ifdef AFS_GLOBAL_SUNLOCK
#define AFS_ASSERT_GLOCK() \
(ISAFS_GLOCK() || (osi_Panic("afs global lock not held at %s:%d\n", __FILE__, __LINE__), 0))
-#define AFS_ASSERT_RXGLOCK() \
- (ISAFS_RXGLOCK() || (osi_Panic("rx global lock not held at %s:%d\n", __FILE__, __LINE__), 0))
#endif /* AFS_GLOBAL_SUNLOCK */
#ifdef RX_ENABLE_LOCKS
#define AFS_GUNLOCK()
#define ISAFS_GLOCK() 1
#define AFS_ASSERT_GLOCK()
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
-#define ISAFS_RXGLOCK() 1
-#define AFS_ASSERT_RXGLOCK()
#endif
/* On an MP that uses multithreading, splnet is not sufficient to provide
#undef MObtainWriteLock /* Defined also in ../rx/rx_machdep.h" */
#undef MReleaseWriteLock
-#ifndef RXObtainWriteLock
-#define RXObtainWriteLock(lock) ObtainWriteLock(lock)
-#define RXReleaseWriteLock(lock) ReleaseWriteLock(lock)
-#endif
#define MObtainReadLock(lock) ObtainReadLock(lock)
#define MObtainWriteLock(lock,src) ObtainWriteLock(lock,src)
#define MObtainSharedLock(lock,src) ObtainSharedLock(lock,src)
__LINE__), \
simple_unlock((void *)(a))
-
-#define RXObtainWriteLock(a) simple_lock((void *)(a)), \
- rxdb_grablock((void *)(a), thread_self(),rxdb_fileID,\
- __LINE__)
-
-#define RXReleaseWriteLock(a) rxdb_droplock((void *)(a), thread_self(), rxdb_fileID,\
- __LINE__), \
- simple_unlock((void *)(a))
-
#define CV_WAIT(_cv, _lck) \
do { \
int haveGlock = ISAFS_GLOCK(); \
#define MUTEX_ENTER(a) simple_lock((void *)(a))
#define MUTEX_TRYENTER(a) simple_lock_try((void *)(a))
#define MUTEX_EXIT(a) simple_unlock((void *)(a))
-#define RXObtainWriteLock(a) simple_lock((void *)(a))
-#define RXReleaseWriteLock(a) simple_unlock((void *)(a))
#define CV_WAIT(_cv, _lck) \
do { \
*/
data_len = ntohs(tu->uh_ulen);
data_len -= 8;
- AFS_RXGLOCK();
if (!(*rxk_GetPacketProc) (&phandle, data_len)) {
if (rx_mb_to_packet(am, m_freem, 28, data_len, phandle)) {
/* XXX should just increment counter here.. */
rxk_portRocks[i], data_len);
} else
m_freem(am);
- AFS_RXGUNLOCK();
USERPRI;
return;
}
*/
data_len = ntohs(tu->uh_ulen);
data_len -= 8;
- AFS_RXGLOCK();
if (!(*rxk_GetPacketProc) (&phandle, data_len)) {
if (rx_mb_to_packet(am, m_freem, 28, data_len, phandle)) {
/* XXX should just increment counter here.. */
rxk_portRocks[i], data_len);
} else
m_freem(am);
- AFS_RXGUNLOCK();
USERPRI;
return;
}
#ifdef AFS_HPUX102_ENV
-#define RXObtainWriteLock(a) AFS_ASSERT_RXGLOCK()
-#define RXReleaseWriteLock(a)
-
-
#if defined(AFS_HPUX110_ENV)
#undef osirx_AssertMine
extern void osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg);
/* You can't have AFS_GLOBAL_SUNLOCK and not RX_ENABLE_LOCKS */
#define RX_ENABLE_LOCKS 1
#define AFS_GLOBAL_RXLOCK_KERNEL
-#ifndef AFS_GLOBAL_SUNLOCK
-#define AFS_ASSERT_RXGLOCK()
-#endif
/* This is incomplete and probably wouldn't work with NCPUS > 1 */
extern void osirx_AssertMine(afs_kmutex_t * lockaddr, char *msg);
#endif
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
-#define ISAFS_RXGLOCK() 1
-#define AFS_ASSERT_RXGLOCK()
-
#define SPLVAR
#define NETPRI
#define USERPRI
rx_CheckPackets();
NETPRI;
- AFS_RXGLOCK();
clock_Init();
* implementation environment--kernel or user space) */
rxi_StartListener();
- AFS_RXGUNLOCK();
USERPRI;
tmp_status = rxinit_status = 0;
UNLOCK_RX_INIT;
clock_NewTime();
NETPRI;
- AFS_RXGLOCK();
/* Start server processes, if necessary (exact function is dependent
* on the implementation environment--kernel or user space). DonateMe
* will be 1 if there is 1 pre-existing proc, i.e. this one. In this
/* Turn on reaping of idle server connections */
rxi_ReapConnections();
- AFS_RXGUNLOCK();
USERPRI;
if (donateMe) {
CV_INIT(&conn->conn_call_cv, "conn call cv", CV_DEFAULT, 0);
#endif
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&rx_connHashTable_lock);
cid = (rx_nextCid += RX_MAXCALLS);
conn->type = RX_CLIENT_CONNECTION;
MUTEX_EXIT(&rx_stats_mutex);
MUTEX_EXIT(&rx_connHashTable_lock);
- AFS_RXGUNLOCK();
USERPRI;
return conn;
}
SPLVAR;
NETPRI;
- AFS_RXGLOCK();
rxi_DestroyConnection(conn);
- AFS_RXGUNLOCK();
USERPRI;
}
SPLVAR;
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&conn->conn_data_lock);
conn->refCount++;
MUTEX_EXIT(&conn->conn_data_lock);
- AFS_RXGUNLOCK();
USERPRI;
}
NETPRI;
clock_GetTime(&queueTime);
- AFS_RXGLOCK();
MUTEX_ENTER(&conn->conn_call_lock);
/*
MUTEX_EXIT(&call->lock);
MUTEX_EXIT(&conn->conn_call_lock);
- AFS_RXGUNLOCK();
USERPRI;
#ifdef AFS_GLOBAL_RXLOCK_KERNEL
/* Now, if TQ wasn't cleared earlier, do it now. */
- AFS_RXGLOCK();
MUTEX_ENTER(&call->lock);
while (call->flags & RX_CALL_TQ_BUSY) {
call->flags |= RX_CALL_TQ_WAIT;
queue_Init(&call->tq);
}
MUTEX_EXIT(&call->lock);
- AFS_RXGUNLOCK();
#endif /* AFS_GLOBAL_RXLOCK_KERNEL */
return call;
tservice = rxi_AllocService();
NETPRI;
- AFS_RXGLOCK();
for (i = 0; i < RX_MAX_SERVICES; i++) {
register struct rx_service *service = rx_services[i];
if (service) {
(osi_Msg
"rx_NewService: tried to install service %s with service id %d, which is already in use for service %s\n",
serviceName, serviceId, service->serviceName);
- AFS_RXGUNLOCK();
USERPRI;
rxi_FreeService(tservice);
return service;
* service on same port) get a new one */
socket = rxi_GetHostUDPSocket(htonl(INADDR_ANY), port);
if (socket == OSI_NULLSOCKET) {
- AFS_RXGUNLOCK();
USERPRI;
rxi_FreeService(tservice);
return 0;
service->executeRequestProc = serviceProc;
service->checkReach = 0;
rx_services[i] = service; /* not visible until now */
- AFS_RXGUNLOCK();
USERPRI;
return service;
}
}
- AFS_RXGUNLOCK();
USERPRI;
rxi_FreeService(tservice);
(osi_Msg "rx_NewService: cannot support > %d services\n",
SPLVAR;
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&call->lock);
rxi_CallError(call, RX_RESTARTING);
rxi_SendCallAbort(call, (struct rx_packet *)0, 0, 0);
MUTEX_EXIT(&call->lock);
- AFS_RXGUNLOCK();
USERPRI;
}
#ifdef KERNEL
SPLVAR;
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&rx_serverPool_lock);
#ifdef RX_ENABLE_LOCKS
#endif /* RX_ENABLE_LOCKS */
}
MUTEX_EXIT(&rx_serverPool_lock);
- AFS_RXGUNLOCK();
USERPRI;
}
SPLVAR;
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&freeSQEList_lock);
if ((sq = rx_FreeSQEList)) {
osi_rxSleep(sq);
#ifdef KERNEL
if (afs_termState == AFSOP_STOP_RXCALLBACK) {
- AFS_RXGUNLOCK();
USERPRI;
rxi_Free(sq, sizeof(struct rx_serverQueueEntry));
return (struct rx_call *)0;
dpf(("rx_GetCall(socketp=0x%x, *socketp=0x%x)\n", socketp, *socketp));
}
- AFS_RXGUNLOCK();
USERPRI;
return call;
dpf(("rx_EndCall(call %x)\n", call));
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&call->lock);
if (rc == 0 && call->error == 0) {
MUTEX_EXIT(&conn->conn_call_lock);
conn->flags &= ~RX_CONN_BUSY;
}
- AFS_RXGUNLOCK();
USERPRI;
/*
* Map errors to the local host's errno.h format.
int isEarliest = 0;
MUTEX_ENTER(&rxevent_lock);
- AFS_ASSERT_RXGLOCK();
#ifdef RXDEBUG
if (rx_Log_event) {
struct clock now;
/* Append it to the free list (rather than prepending) to keep the free
* list hot so nothing pages out
*/
- AFS_ASSERT_RXGLOCK();
MUTEX_ENTER(&rxevent_lock);
if (!ev) {
MUTEX_EXIT(&rxevent_lock);
MUTEX_ENTER(&rxevent_lock);
- AFS_ASSERT_RXGLOCK();
-
/* Events are sorted by time, so only scan until an event is found that has
* not yet timed out */
AFS_GUNLOCK();
#endif /* RX_ENABLE_LOCKS */
NETPRI;
- AFS_RXGLOCK();
rxevent_RaiseEvents(&temp);
- AFS_RXGUNLOCK();
USERPRI;
#ifdef RX_ENABLE_LOCKS
AFS_GLOCK();
osi_Panic("rxk_Listener: No more Rx buffers!\n");
}
if (!(code = rxk_ReadPacket(rx_socket, rxp, &host, &port))) {
- AFS_RXGLOCK();
rxp = rxi_ReceivePacket(rxp, rx_socket, host, port, 0, 0);
- AFS_RXGUNLOCK();
}
}
#define CALL_HOLD(call, type)
#define CALL_RELE(call, type)
-#define RXObtainWriteLock(a) AFS_ASSERT_RXGLOCK()
-#define RXReleaseWriteLock(a)
#define MUTEX_DESTROY(a)
#define MUTEX_ENTER(a)
PIN(p, getme); /* XXXXX */
memset((char *)p, 0, getme);
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&rx_freePktQ_lock);
for (e = p + apackets; p < e; p++) {
rxi_NeedMorePackets = FALSE;
rxi_PacketsUnWait();
- AFS_RXGUNLOCK();
MUTEX_EXIT(&rx_freePktQ_lock);
USERPRI;
}
} else
nbytes -= apacket->wirevec[i].iov_len;
}
- AFS_RXGUNLOCK();
#ifdef KERNEL
#ifdef RX_KERNEL_TRACE
if (ICL_SETACTIVE(afs_iclSetp)) {
AFS_GLOCK();
#endif
#endif
- AFS_RXGLOCK();
if (saven) { /* means we truncated the packet above. */
apacket->wirevec[i - 1].iov_len = savelen;
apacket->niovecs = saven;
* blocking socket, but unfortunately the interface doesn't
* allow us to have the socket block in send mode, and not
* block in receive mode */
- AFS_RXGUNLOCK();
#ifdef KERNEL
waslocked = ISAFS_GLOCK();
#ifdef RX_KERNEL_TRACE
AFS_GLOCK();
#endif
#endif
- AFS_RXGLOCK();
#ifdef RXDEBUG
}
dpf(("%c %d %s: %x.%u.%u.%u.%u.%u.%u flags %d, packet %lx resend %d.%0.3d len %d", deliveryType, p->header.serial, rx_packetTypes[p->header.type - 1], peer->host, peer->port, p->header.serial, p->header.epoch, p->header.cid, p->header.callNumber, p->header.seq, p->header.flags, (unsigned long)p, p->retryTime.sec, p->retryTime.usec / 1000, p->length));
* blocking socket, but unfortunately the interface doesn't
* allow us to have the socket block in send mode, and not
* block in receive mode */
- AFS_RXGUNLOCK();
#if defined(AFS_SUN5_ENV) && defined(KERNEL)
waslocked = ISAFS_GLOCK();
if (!istack && waslocked)
if (!istack && waslocked)
AFS_GLOCK();
#endif
- AFS_RXGLOCK();
#ifdef RXDEBUG
}
#endif
#define MUTEX_EXIT(l) osi_Assert(pthread_mutex_unlock(l) == 0)
-#ifdef RXObtainWriteLock
-#undef RXObtainWriteLock
-#endif
-#define RXObtainWriteLock(l) MUTEX_ENTER(l)
-
-#ifdef RXReleaseWriteLock
-#undef RXReleaseWriteLock
-#endif
-#define RXReleaseWriteLock(l) MUTEX_EXIT(l)
-
#ifdef CV_INIT
#undef CV_INIT
#endif
}
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&call->lock);
bytes = rxi_ReadProc(call, buf, nbytes);
MUTEX_EXIT(&call->lock);
- AFS_RXGUNLOCK();
USERPRI;
return bytes;
}
}
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&call->lock);
bytes = rxi_ReadProc(call, (char *)value, sizeof(afs_int32));
MUTEX_EXIT(&call->lock);
- AFS_RXGUNLOCK();
USERPRI;
return bytes;
}
SPLVAR;
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&call->lock);
bytes = rxi_ReadvProc(call, iov, nio, maxio, nbytes);
MUTEX_EXIT(&call->lock);
- AFS_RXGUNLOCK();
USERPRI;
return bytes;
}
}
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&call->lock);
bytes = rxi_WriteProc(call, buf, nbytes);
MUTEX_EXIT(&call->lock);
- AFS_RXGUNLOCK();
USERPRI;
return bytes;
}
}
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&call->lock);
bytes = rxi_WriteProc(call, (char *)value, sizeof(afs_int32));
MUTEX_EXIT(&call->lock);
- AFS_RXGUNLOCK();
USERPRI;
return bytes;
}
SPLVAR;
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&call->lock);
bytes = rxi_WritevAlloc(call, iov, nio, maxio, nbytes);
MUTEX_EXIT(&call->lock);
- AFS_RXGUNLOCK();
USERPRI;
return bytes;
}
SPLVAR;
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&call->lock);
bytes = rxi_WritevProc(call, iov, nio, nbytes);
MUTEX_EXIT(&call->lock);
- AFS_RXGUNLOCK();
USERPRI;
return bytes;
}
{
SPLVAR;
NETPRI;
- AFS_RXGLOCK();
MUTEX_ENTER(&call->lock);
rxi_FlushWrite(call);
MUTEX_EXIT(&call->lock);
- AFS_RXGUNLOCK();
USERPRI;
}
#define AFS_GLOCK()
#define AFS_GUNLOCK()
#define AFS_ASSERT_GLOCK()
-#define AFS_RXGLOCK()
-#define AFS_RXGUNLOCK()
#ifndef UKERNEL
/* Defined in rx/UKERNEL/rx_kmutex.h */
#define ISAFS_GLOCK()
-#define ISAFS_RXGLOCK()
#endif
-#define AFS_ASSERT_RXGLOCK()
/* Some "operating-system independent" stuff, for the user mode implementation */
#ifdef UAFS_CLIENT
typedef void *osi_socket;