jimzah/openafs
1
0
Fork 0
mirror of https://git.openafs.org/openafs.git synced 2025-02-01 05:57:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

windows-afsd-notification-20071104

Browse Source 
the difference between osi_assert() and osi_assertx() is whether or not
a description is specified as part of the call.  When no message is
specified afsd_notifier() is called with a NULL msgp parameter.  This
results in a null pointer dereference during the EventLog() call.

As a result, none of the information describing the assertion is written
to the log file.

This commit sets a default message for use when no other message is
provided and it replaces all calls to osi_assert with osi_assertx and
adds descriptions.
This commit is contained in:
Jeffrey Altman 2007-11-05 00:23:54 +00:00
parent bc7a0be8eb
commit 89ac3ec2f6
17 changed files with 150 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/WINNT/afsd/afsd_service.c
View File

@ -61,6 +61,8 @@ static void afsd_notifier(char *msgp, char *filep, long line)
#ifdef AFSIFS
int i;
#endif
if (!msgp)
msgp = "unspecified assert";
if (filep)
LogEvent(EVENTLOG_ERROR_TYPE, MSG_SERVICE_ERROR_STOP_WITH_MSG_AND_LOCATION,

2
src/WINNT/afsd/cm_btree.c
View File

@ -1805,7 +1805,7 @@ long cm_BPlusDirBuildTree(cm_scache_t *scp, cm_user_t *userp, cm_req_t* reqp)
osi_hyper_t thyper;
LARGE_INTEGER start, end;
osi_assert(scp->dirBplus == NULL);
osi_assertx(scp->dirBplus == NULL, "cm_BPlusDirBuildTree called on non-empty tree");
lock_AssertWrite(&scp->dirlock);

37
src/WINNT/afsd/cm_buf.c
View File

@ -89,7 +89,7 @@ static int buf_ShutdownFlag = 0;
void buf_HoldLocked(cm_buf_t *bp)
{
osi_assert(bp->magic == CM_BUF_MAGIC);
osi_assertx(bp->magic == CM_BUF_MAGIC,"incorrect cm_buf_t magic");
bp->refCount++;
}
@ -105,12 +105,12 @@ void buf_Hold(cm_buf_t *bp)
void buf_ReleaseLocked(cm_buf_t *bp)
{
/* ensure that we're in the LRU queue if our ref count is 0 */
osi_assert(bp->magic == CM_BUF_MAGIC);
osi_assertx(bp->magic == CM_BUF_MAGIC,"incorrect cm_buf_t magic");
#ifdef DEBUG
if (bp->refCount == 0)
osi_panic("buf refcount 0",__FILE__,__LINE__);;
#else
osi_assert(bp->refCount > 0);
osi_assertx(bp->refCount > 0, "cm_buf_t refCount == 0");
#endif
if (--bp->refCount == 0) {
if (!(bp->flags & CM_BUF_INLRU)) {
@ -321,8 +321,10 @@ long buf_Init(int newFile, cm_buf_ops_t *opsp, afs_uint64 nbuffers)
cm_data.buf_allp = NULL;
for (i=0; i<cm_data.buf_nbuffers; i++) {
osi_assert(bp >= cm_data.bufHeaderBaseAddress && bp < (cm_buf_t *)cm_data.bufDataBaseAddress);
osi_assert(data >= cm_data.bufDataBaseAddress && data < cm_data.bufEndOfData);
osi_assertx(bp >= cm_data.bufHeaderBaseAddress && bp < (cm_buf_t *)cm_data.bufDataBaseAddress,
"invalid cm_buf_t address");
osi_assertx(data >= cm_data.bufDataBaseAddress && data < cm_data.bufEndOfData,
"invalid cm_buf_t data address");
/* allocate and zero some storage */
memset(bp, 0, sizeof(cm_buf_t));
@ -436,8 +438,8 @@ void buf_WaitIO(cm_scache_t * scp, cm_buf_t *bp)
int release = 0;
if (scp)
osi_assert(scp->magic == CM_SCACHE_MAGIC);
osi_assert(bp->magic == CM_BUF_MAGIC);
osi_assertx(scp->magic == CM_SCACHE_MAGIC, "invalid cm_scache_t magic");
osi_assertx(bp->magic == CM_BUF_MAGIC, "invalid cm_buf_t magic");
while (1) {
/* if no IO is happening, we're done */
@ -549,7 +551,7 @@ long buf_CleanAsyncLocked(cm_buf_t *bp, cm_req_t *reqp)
cm_scache_t * scp = NULL;
osi_hyper_t offset;
osi_assert(bp->magic == CM_BUF_MAGIC);
osi_assertx(bp->magic == CM_BUF_MAGIC, "invalid cm_buf_t magic");
while ((bp->flags & CM_BUF_DIRTY) == CM_BUF_DIRTY) {
isdirty = 1;
@ -629,7 +631,7 @@ void buf_Recycle(cm_buf_t *bp)
cm_buf_t *tbp;
cm_buf_t *prevBp, *nextBp;
osi_assert(bp->magic == CM_BUF_MAGIC);
osi_assertx(bp->magic == CM_BUF_MAGIC, "invalid cm_buf_t magic");
/* if we get here, we know that the buffer still has a 0 ref count,
* and that it is clean and has no currently pending I/O. This is
@ -641,8 +643,9 @@ void buf_Recycle(cm_buf_t *bp)
osi_Log3( buf_logp, "buf_Recycle recycles 0x%p, off 0x%x:%08x",
bp, bp->offset.HighPart, bp->offset.LowPart);
osi_assert(bp->refCount == 0);
osi_assert(!(bp->flags & (CM_BUF_READING | CM_BUF_WRITING | CM_BUF_DIRTY)));
osi_assertx(bp->refCount == 0, "cm_buf_t refcount != 0");
osi_assertx(!(bp->flags & (CM_BUF_READING | CM_BUF_WRITING | CM_BUF_DIRTY)),
"incorrect cm_buf_t flags");
lock_AssertWrite(&buf_globalLock);
if (bp->flags & CM_BUF_INHASH) {
@ -990,7 +993,7 @@ long buf_Get(struct cm_scache *scp, osi_hyper_t *offsetp, cm_buf_t **bufpp)
*/
if (created) {
/* load the page; freshly created pages should be idle */
osi_assert(!(bp->flags & (CM_BUF_READING | CM_BUF_WRITING)));
osi_assertx(!(bp->flags & (CM_BUF_READING | CM_BUF_WRITING)), "incorrect cm_buf_t flags");
/* start the I/O; may drop lock */
bp->flags |= CM_BUF_READING;
@ -1096,7 +1099,7 @@ long buf_CountFreeList(void)
long buf_CleanAsync(cm_buf_t *bp, cm_req_t *reqp)
{
long code;
osi_assert(bp->magic == CM_BUF_MAGIC);
osi_assertx(bp->magic == CM_BUF_MAGIC, "invalid cm_buf_t magic");
lock_ObtainMutex(&bp->mx);
code = buf_CleanAsyncLocked(bp, reqp);
@ -1108,7 +1111,7 @@ long buf_CleanAsync(cm_buf_t *bp, cm_req_t *reqp)
/* wait for a buffer's cleaning to finish */
void buf_CleanWait(cm_scache_t * scp, cm_buf_t *bp)
{
osi_assert(bp->magic == CM_BUF_MAGIC);
osi_assertx(bp->magic == CM_BUF_MAGIC, "invalid cm_buf_t magic");
lock_ObtainMutex(&bp->mx);
if (bp->flags & CM_BUF_WRITING) {
@ -1124,8 +1127,8 @@ void buf_CleanWait(cm_scache_t * scp, cm_buf_t *bp)
*/
void buf_SetDirty(cm_buf_t *bp, afs_uint32 offset, afs_uint32 length)
{
osi_assert(bp->magic == CM_BUF_MAGIC);
osi_assert(bp->refCount > 0);
osi_assertx(bp->magic == CM_BUF_MAGIC, "invalid cm_buf_t magic");
osi_assertx(bp->refCount > 0, "cm_buf_t refcount 0");
lock_ObtainWrite(&buf_globalLock);
if (bp->flags & CM_BUF_DIRTY) {
@ -1375,7 +1378,7 @@ long buf_Truncate(cm_scache_t *scp, cm_user_t *userp, cm_req_t *reqp,
* visible again.
*/
bufferPos = sizep->LowPart & (cm_data.buf_blockSize - 1);
osi_assert(bufferPos != 0);
osi_assertx(bufferPos != 0, "non-zero bufferPos");
memset(bufp->datap + bufferPos, 0,
cm_data.buf_blockSize - bufferPos);
}

8
src/WINNT/afsd/cm_callback.c
View File

@ -1416,7 +1416,7 @@ int SRXAFSCB_GetCacheConfig(struct rx_call *callp,
#ifndef SIZE_MAX
#define SIZE_MAX UINT_MAX
#endif
osi_assert(allocsize < SIZE_MAX);
osi_assertx(allocsize < SIZE_MAX, "allocsize >= SIZE_MAX");
#endif
*configCount = (afs_uint32)allocsize;
config->cacheConfig_val = t_config;
@ -1547,10 +1547,12 @@ void cm_EndCallbackGrantingCall(cm_scache_t *scp, cm_callbackRequest_t *cbrp,
lock_ObtainWrite(&cm_callbackLock);
if (flags & CM_CALLBACK_MAINTAINCOUNT) {
osi_assert(cm_activeCallbackGrantingCalls > 0);
osi_assertx(cm_activeCallbackGrantingCalls > 0,
"CM_CALLBACK_MAINTAINCOUNT && cm_activeCallbackGrantingCalls == 0");
}
else {
osi_assert(cm_activeCallbackGrantingCalls-- > 0);
osi_assertx(cm_activeCallbackGrantingCalls-- > 0,
"!CM_CALLBACK_MAINTAINCOUNT && cm_activeCallbackGrantingCalls == 0");
}
if (cm_activeCallbackGrantingCalls == 0)
freeFlag = 1;

6
src/WINNT/afsd/cm_conn.c
View File

@ -34,7 +34,7 @@ afs_int32 cryptall = 0;
void cm_PutConn(cm_conn_t *connp)
{
lock_ObtainWrite(&cm_connLock);
osi_assert(connp->refCount-- > 0);
osi_assertx(connp->refCount-- > 0, "cm_conn_t refcount 0");
lock_ReleaseWrite(&cm_connLock);
}
@ -805,7 +805,7 @@ static void cm_NewRXConnection(cm_conn_t *tcp, cm_ucell_t *ucellp,
serviceID = 52;
}
else {
osi_assert(serverp->type == CM_SERVER_FILE);
osi_assertx(serverp->type == CM_SERVER_FILE, "incorrect server type");
port = htons(7000);
serviceID = 1;
}
@ -825,7 +825,7 @@ static void cm_NewRXConnection(cm_conn_t *tcp, cm_ucell_t *ucellp,
tcp->cryptlevel = rxkad_clear;
secObjp = rxnull_NewClientSecurityObject();
}
osi_assert(secObjp != NULL);
osi_assertx(secObjp != NULL, "null rx_securityClass");
tcp->callp = rx_NewConnection(serverp->addr.sin_addr.s_addr,
port,
serviceID,

8
src/WINNT/afsd/cm_daemon.c
View File

@ -95,7 +95,7 @@ void cm_BkgDaemon(long parm)
}
osi_QRemoveHT((osi_queue_t **) &cm_bkgListp, (osi_queue_t **) &cm_bkgListEndp, &rp->q);
osi_assert(cm_bkgQueueCount-- > 0);
osi_assertx(cm_bkgQueueCount-- > 0, "cm_bkgQueueCount 0");
lock_ReleaseWrite(&cm_daemonLock);
osi_Log1(afsd_logp,"cm_BkgDaemon processing request 0x%p", rp);
@ -464,20 +464,20 @@ void cm_InitDaemon(int nDaemons)
/* creating IP Address Change monitor daemon */
phandle = thrd_Create((SecurityAttrib) 0, 0,
(ThreadFunc) cm_IpAddrDaemon, 0, 0, &pid, "cm_IpAddrDaemon");
osi_assert(phandle != NULL);
osi_assertx(phandle != NULL, "cm_IpAddrDaemon thread creation failure");
thrd_CloseHandle(phandle);
/* creating pinging daemon */
phandle = thrd_Create((SecurityAttrib) 0, 0,
(ThreadFunc) cm_Daemon, 0, 0, &pid, "cm_Daemon");
osi_assert(phandle != NULL);
osi_assertx(phandle != NULL, "cm_Daemon thread creation failure");
thrd_CloseHandle(phandle);
for(i=0; i < nDaemons; i++) {
phandle = thrd_Create((SecurityAttrib) 0, 0,
(ThreadFunc) cm_BkgDaemon, 0, 0, &pid,
"cm_BkgDaemon");
osi_assert(phandle != NULL);
osi_assertx(phandle != NULL, "cm_BkgDaemon thread creation failure");
thrd_CloseHandle(phandle);
}
}

10
src/WINNT/afsd/cm_dcache.c
View File

@ -73,8 +73,8 @@ long cm_BufWrite(void *vscp, osi_hyper_t *offsetp, long length, long flags,
cm_bulkIO_t biod; /* bulk IO descriptor */
int require_64bit_ops = 0;
osi_assert(userp != NULL);
osi_assert(scp != NULL);
osi_assertx(userp != NULL, "null cm_user_t");
osi_assertx(scp != NULL, "null cm_scache_t");
/* now, the buffer may or may not be filled with good data (buf_GetNew
* drops lots of locks, and may indeed return a properly initialized
@ -205,7 +205,7 @@ long cm_BufWrite(void *vscp, osi_hyper_t *offsetp, long length, long flags,
qdp = biod.bufListEndp;
else
qdp = (osi_queueData_t *) osi_QPrev(&qdp->q);
osi_assert(qdp != NULL);
osi_assertx(qdp != NULL, "null osi_queueData_t");
bufp = osi_GetQData(qdp);
bufferp = bufp->datap;
wbytes = nbytes;
@ -1571,7 +1571,7 @@ long cm_GetBuffer(cm_scache_t *scp, cm_buf_t *bufp, int *cpffp, cm_user_t *userp
* our check above for nbytes being less than
* biod.length should ensure this.
*/
osi_assert(bufferp != NULL);
osi_assertx(bufferp != NULL, "null cm_buf_t");
/* read rbytes of data */
rbytes = (nbytes > cm_data.buf_blockSize? cm_data.buf_blockSize : nbytes);
@ -1622,7 +1622,7 @@ long cm_GetBuffer(cm_scache_t *scp, cm_buf_t *bufp, int *cpffp, cm_user_t *userp
* all of the rest of the pages.
*/
/* bytes fetched */
osi_assert((bufferp - tbufp->datap) < LONG_MAX);
osi_assertx((bufferp - tbufp->datap) < LONG_MAX, "data >= LONG_MAX");
rbytes = (long) (bufferp - tbufp->datap);
/* bytes left to zero */

4
src/WINNT/afsd/cm_freelance.c
View File

@ -156,12 +156,12 @@ void cm_InitFreelance() {
/* Start the registry monitor */
phandle = thrd_Create(NULL, 65536, (ThreadFunc) cm_FreelanceChangeNotifier,
NULL, 0, &lpid, "cm_FreelanceChangeNotifier");
osi_assert(phandle != NULL);
osi_assertx(phandle != NULL, "cm_FreelanceChangeNotifier thread create failure");
thrd_CloseHandle(phandle);
phandle = thrd_Create(NULL, 65536, (ThreadFunc) cm_FreelanceSymlinkChangeNotifier,
NULL, 0, &lpid, "cm_FreelanceSymlinkChangeNotifier");
osi_assert(phandle != NULL);
osi_assertx(phandle != NULL, "cm_FreelanceSymlinkChangeNotifier thread create failure");
thrd_CloseHandle(phandle);
}

2
src/WINNT/afsd/cm_ioctl.c
View File

@ -794,7 +794,7 @@ long cm_IoctlSetVolumeStatus(struct smb_ioctl *ioctlp, struct cm_user *userp)
#endif
{
cellp = cm_FindCellByID(scp->fid.cell);
osi_assert(cellp);
osi_assertx(cellp, "null cm_cell_t");
if (scp->flags & CM_SCACHEFLAG_RO) {
cm_ReleaseSCache(scp);

42
src/WINNT/afsd/cm_scache.c
View File

@ -147,8 +147,8 @@ long cm_RecycleSCache(cm_scache_t *scp, afs_int32 flags)
buf_CleanDirtyBuffers(scp);
} else {
/* look for things that shouldn't still be set */
osi_assert(scp->bufWritesp == NULL);
osi_assert(scp->bufReadsp == NULL);
osi_assertx(scp->bufWritesp == NULL, "non-null cm_scache_t bufWritesp");
osi_assertx(scp->bufReadsp == NULL, "non-null cm_scache_t bufReadsp");
}
#endif
@ -242,7 +242,8 @@ cm_scache_t *cm_GetNewSCache(void)
scp;
scp = (cm_scache_t *) osi_QPrev(&scp->q))
{
osi_assert(scp >= cm_data.scacheBaseAddress && scp < (cm_scache_t *)cm_data.scacheHashTablep);
osi_assertx(scp >= cm_data.scacheBaseAddress && scp < (cm_scache_t *)cm_data.scacheHashTablep,
"invalid cm_scache_t address");
if (scp->refCount == 0) {
if (scp->flags & CM_SCACHEFLAG_DELETED) {
@ -311,7 +312,8 @@ cm_scache_t *cm_GetNewSCache(void)
* quota or we have a leak and need to allocate a new one to avoid panicing.
*/
scp = cm_data.scacheBaseAddress + cm_data.currentSCaches;
osi_assert(scp >= cm_data.scacheBaseAddress && scp < (cm_scache_t *)cm_data.scacheHashTablep);
osi_assertx(scp >= cm_data.scacheBaseAddress && scp < (cm_scache_t *)cm_data.scacheHashTablep,
"invalid cm_scache_t address");
memset(scp, 0, sizeof(cm_scache_t));
scp->magic = CM_SCACHE_MAGIC;
lock_InitializeMutex(&scp->mx, "cm_scache_t mutex");
@ -637,7 +639,7 @@ long cm_GetSCache(cm_fid_t *fidp, cm_scache_t **outScpp, cm_user_t *userp,
hash = CM_SCACHE_HASH(fidp);
osi_assert(fidp->cell != 0);
osi_assertx(fidp->cell != NULL, "null cm_cell_t");
if (fidp->cell== cm_data.rootFid.cell &&
fidp->volume==cm_data.rootFid.volume &&
@ -783,7 +785,7 @@ long cm_GetSCache(cm_fid_t *fidp, cm_scache_t **outScpp, cm_user_t *userp,
osi_Log1(afsd_logp,"cm_GetSCache (3) outScpp 0x%p", scp);
#endif
cm_HoldSCacheNoLock(scp);
osi_assert(scp->volp == volp);
osi_assertx(scp->volp == volp, "cm_scache_t volume has unexpected value");
cm_AdjustScacheLRU(scp);
lock_ReleaseWrite(&cm_scacheLock);
if (volp)
@ -804,7 +806,7 @@ long cm_GetSCache(cm_fid_t *fidp, cm_scache_t **outScpp, cm_user_t *userp,
}
osi_Log2(afsd_logp,"cm_GetNewSCache returns scp 0x%x flags 0x%x", scp, scp->flags);
osi_assert(!(scp->flags & CM_SCACHEFLAG_INHASH));
osi_assertx(!(scp->flags & CM_SCACHEFLAG_INHASH), "CM_SCACHEFLAG_INHASH set");
#if not_too_dangerous
/* dropping the cm_scacheLock allows more than one thread
@ -929,7 +931,7 @@ int cm_SyncOpCheckContinue(cm_scache_t * scp, afs_int32 flags, cm_buf_t * bufp)
}
}
osi_assert(w != NULL);
osi_assertx(w != NULL, "null cm_scache_waiter_t");
this_is_me = (w->threadId == thrd_Current());
lock_ReleaseRead(&cm_scacheLock);
@ -1023,7 +1025,7 @@ long cm_SyncOp(cm_scache_t *scp, cm_buf_t *bufp, cm_user_t *userp, cm_req_t *req
bufLocked = flags & CM_SCACHESYNC_BUFLOCKED;
if (bufp)
osi_assert(bufp->refCount > 0);
osi_assertx(bufp->refCount > 0, "cm_buf_t refCount 0");
/* Do the access check. Now we don't really do the access check
@ -1215,7 +1217,7 @@ long cm_SyncOp(cm_scache_t *scp, cm_buf_t *bufp, cm_user_t *userp, cm_req_t *req
if (rights) {
/* can't check access rights without a callback */
osi_assert(flags & CM_SCACHESYNC_NEEDCALLBACK);
osi_assertx(flags & CM_SCACHESYNC_NEEDCALLBACK, "!CM_SCACHESYNC_NEEDCALLBACK");
if ((rights & PRSFS_WRITE) && (scp->flags & CM_SCACHEFLAG_RO))
return CM_ERROR_READONLY;
@ -1315,7 +1317,7 @@ long cm_SyncOp(cm_scache_t *scp, cm_buf_t *bufp, cm_user_t *userp, cm_req_t *req
if (bufp) {
for(qdp = scp->bufReadsp; qdp; qdp = (osi_queueData_t *) osi_QNext(&qdp->q)) {
tbufp = osi_GetQData(qdp);
osi_assert(tbufp != bufp);
osi_assertx(tbufp != bufp, "unexpected cm_buf_t value");
}
}
@ -1334,7 +1336,7 @@ long cm_SyncOp(cm_scache_t *scp, cm_buf_t *bufp, cm_user_t *userp, cm_req_t *req
if (bufp) {
for(qdp = scp->bufWritesp; qdp; qdp = (osi_queueData_t *) osi_QNext(&qdp->q)) {
tbufp = osi_GetQData(qdp);
osi_assert(tbufp != bufp);
osi_assertx(tbufp != bufp, "unexpected cm_buf_t value");
}
}
@ -1437,7 +1439,7 @@ void cm_SyncOpDone(cm_scache_t *scp, cm_buf_t *bufp, afs_uint32 flags)
if (flags & CM_SCACHESYNC_WRITE) {
if (bufp) {
osi_assert(bufp->cmFlags & CM_BUF_CMWRITING);
osi_assertx(bufp->cmFlags & CM_BUF_CMWRITING, "!CM_BUF_CMWRITING");
bufp->cmFlags &= ~CM_BUF_CMWRITING;
}
@ -1674,7 +1676,7 @@ void cm_HoldSCacheNoLockDbg(cm_scache_t *scp, char * file, long line)
void cm_HoldSCacheNoLock(cm_scache_t *scp)
#endif
{
osi_assert(scp != 0);
osi_assertx(scp != NULL, "null cm_scache_t");
scp->refCount++;
#ifdef DEBUG_REFCOUNT
osi_Log2(afsd_logp,"cm_HoldSCacheNoLock scp 0x%p ref %d",scp, scp->refCount);
@ -1688,7 +1690,7 @@ void cm_HoldSCacheDbg(cm_scache_t *scp, char * file, long line)
void cm_HoldSCache(cm_scache_t *scp)
#endif
{
osi_assert(scp != 0);
osi_assertx(scp != NULL, "null cm_scache_t");
lock_ObtainWrite(&cm_scacheLock);
scp->refCount++;
#ifdef DEBUG_REFCOUNT
@ -1704,10 +1706,10 @@ void cm_ReleaseSCacheNoLockDbg(cm_scache_t *scp, char * file, long line)
void cm_ReleaseSCacheNoLock(cm_scache_t *scp)
#endif
{
osi_assert(scp != NULL);
osi_assertx(scp != NULL, "null cm_scache_t");
if (scp->refCount == 0)
osi_Log1(afsd_logp,"cm_ReleaseSCacheNoLock about to panic scp 0x%x",scp);
osi_assert(scp->refCount-- >= 0);
osi_assertx(scp->refCount-- >= 0, "cm_scache_t refCount 0");
#ifdef DEBUG_REFCOUNT
osi_Log2(afsd_logp,"cm_ReleaseSCacheNoLock scp 0x%p ref %d",scp,scp->refCount);
afsi_log("%s:%d cm_ReleaseSCacheNoLock scp 0x%p ref %d", file, line, scp, scp->refCount);
@ -1720,11 +1722,11 @@ void cm_ReleaseSCacheDbg(cm_scache_t *scp, char * file, long line)
void cm_ReleaseSCache(cm_scache_t *scp)
#endif
{
osi_assert(scp != NULL);
osi_assertx(scp != NULL, "null cm_scache_t");
lock_ObtainWrite(&cm_scacheLock);
if (scp->refCount == 0)
osi_Log1(afsd_logp,"cm_ReleaseSCache about to panic scp 0x%x",scp);
osi_assert(scp->refCount != 0);
osi_assertx(scp->refCount != 0, "cm_scache_t refCount 0");
scp->refCount--;
#ifdef DEBUG_REFCOUNT
osi_Log2(afsd_logp,"cm_ReleaseSCache scp 0x%p ref %d",scp,scp->refCount);
@ -1742,7 +1744,7 @@ int cm_FindFileType(cm_fid_t *fidp)
hash = CM_SCACHE_HASH(fidp);
osi_assert(fidp->cell != 0);
osi_assertx(fidp->cell != NULL, "null cm_cell_t");
lock_ObtainWrite(&cm_scacheLock);
for (scp=cm_data.scacheHashTablep[hash]; scp; scp=scp->nextp) {

8
src/WINNT/afsd/cm_server.c
View File

@ -273,13 +273,13 @@ void cm_GetServerNoLock(cm_server_t *serverp)
void cm_PutServer(cm_server_t *serverp)
{
lock_ObtainWrite(&cm_serverLock);
osi_assert(serverp->refCount-- > 0);
osi_assertx(serverp->refCount-- > 0, "cm_server_t refCount 0");
lock_ReleaseWrite(&cm_serverLock);
}
void cm_PutServerNoLock(cm_server_t *serverp)
{
osi_assert(serverp->refCount-- > 0);
osi_assertx(serverp->refCount-- > 0, "cm_server_t refCount 0");
}
void cm_SetServerNo64Bit(cm_server_t * serverp, int no64bit)
@ -364,7 +364,7 @@ void cm_SetServerPrefs(cm_server_t * serverp)
cm_server_t *cm_NewServer(struct sockaddr_in *socketp, int type, cm_cell_t *cellp) {
cm_server_t *tsp;
osi_assert(socketp->sin_family == AF_INET);
osi_assertx(socketp->sin_family == AF_INET, "unexpected socket family");
tsp = malloc(sizeof(*tsp));
if (tsp) {
@ -409,7 +409,7 @@ cm_server_t *cm_FindServer(struct sockaddr_in *addrp, int type)
{
cm_server_t *tsp;
osi_assert(addrp->sin_family == AF_INET);
osi_assertx(addrp->sin_family == AF_INET, "unexpected socket value");
lock_ObtainWrite(&cm_serverLock);
for (tsp = cm_allServersp; tsp; tsp=tsp->allNextp) {

4
src/WINNT/afsd/cm_user.c
View File

@ -104,7 +104,7 @@ void cm_ReleaseUser(cm_user_t *userp)
return;
lock_ObtainWrite(&cm_userLock);
osi_assert(userp->refCount-- > 0);
osi_assertx(userp->refCount-- > 0, "cm_user_t refCount 0");
if (userp->refCount == 0) {
lock_FinalizeMutex(&userp->mx);
for (ucp = userp->cellInfop; ucp; ucp = ncp) {
@ -135,7 +135,7 @@ void cm_HoldUserVCRef(cm_user_t *userp)
void cm_ReleaseUserVCRef(cm_user_t *userp)
{
lock_ObtainMutex(&userp->mx);
osi_assert(userp->vcRefs-- > 0);
osi_assertx(userp->vcRefs-- > 0, "cm_user_t refCount 0");
lock_ReleaseMutex(&userp->mx);
}

34
src/WINNT/afsd/cm_vnodeops.c
View File

@ -335,7 +335,7 @@ long cm_CheckNTOpen(cm_scache_t *scp, unsigned int desiredAccess,
long rights;
long code;
osi_assert(ldpp != NULL);
osi_assertx(ldpp != NULL, "null cm_lock_data_t");
*ldpp = NULL;
/* Always allow delete; the RPC will tell us if it's OK */
@ -2284,7 +2284,7 @@ cm_TryBulkStat(cm_scache_t *dscp, osi_hyper_t *offsetp, cm_user_t *userp,
osi_Log1(afsd_logp, "cm_TryBulkStat dir 0x%p", dscp);
/* should be on a buffer boundary */
osi_assert((offsetp->LowPart & (cm_data.buf_blockSize - 1)) == 0);
osi_assertx((offsetp->LowPart & (cm_data.buf_blockSize - 1)) == 0, "invalid offset");
memset(&bb, 0, sizeof(bb));
bb.bufOffset = *offsetp;
@ -3903,7 +3903,7 @@ static cm_file_lock_t * cm_GetFileLock(void) {
osi_QRemove(&cm_freeFileLocks, &l->q);
} else {
l = malloc(sizeof(cm_file_lock_t));
osi_assert(l);
osi_assertx(l, "null cm_file_lock_t");
}
memset(l, 0, sizeof(cm_file_lock_t));
@ -4046,7 +4046,7 @@ long cm_LockCheckPerms(cm_scache_t * scp,
rights |= PRSFS_WRITE | PRSFS_LOCK;
else {
/* hmmkay */
osi_assert(FALSE);
osi_assertx(FALSE, "invalid lock type");
return 0;
}
@ -4290,7 +4290,7 @@ long cm_Lock(cm_scache_t *scp, unsigned char sLockType,
newLock = Which;
/* am I sane? */
osi_assert(newLock == LockRead);
osi_assertx(newLock == LockRead, "lock type not read");
code = cm_IntSetLock(scp, userp, newLock, reqp);
}
@ -4506,7 +4506,7 @@ long cm_UnlockByKey(cm_scache_t * scp,
fileLock->scp->fid.volume,
fileLock->scp->fid.vnode,
fileLock->scp->fid.unique);
osi_assert(FALSE);
osi_assertx(FALSE, "invalid fid value");
}
#endif
@ -4681,7 +4681,7 @@ long cm_Unlock(cm_scache_t *scp,
fileLock->scp->fid.volume,
fileLock->scp->fid.vnode,
fileLock->scp->fid.unique);
osi_assert(FALSE);
osi_assertx(FALSE, "invalid fid value");
}
#endif
if (!IS_LOCK_DELETED(fileLock) &&
@ -4848,7 +4848,7 @@ static void cm_LockMarkSCacheLost(cm_scache_t * scp)
#ifdef DEBUG
/* With the current code, we can't lose a lock on a RO scp */
osi_assert(!(scp->flags & CM_SCACHEFLAG_RO));
osi_assertx(!(scp->flags & CM_SCACHEFLAG_RO), "CM_SCACHEFLAG_RO unexpected");
#endif
/* cm_scacheLock needed because we are modifying fileLock->flags */
@ -4909,10 +4909,10 @@ void cm_CheckLocks()
/* Server locks must have been enabled for us to have
received an active non-client-only lock. */
osi_assert(cm_enableServerLocks);
osi_assertx(cm_enableServerLocks, "!cm_enableServerLocks");
scp = fileLock->scp;
osi_assert(scp != NULL);
osi_assertx(scp != NULL, "null cm_scache_t");
cm_HoldSCacheNoLock(scp);
@ -4929,7 +4929,7 @@ void cm_CheckLocks()
fileLock->scp->fid.volume,
fileLock->scp->fid.vnode,
fileLock->scp->fid.unique);
osi_assert(FALSE);
osi_assertx(FALSE, "invalid fid");
}
#endif
/* Server locks are extended once per scp per refresh
@ -5135,7 +5135,7 @@ long cm_RetryLock(cm_file_lock_t *oldFileLock, int client_is_dead)
scp = oldFileLock->scp;
osi_assert(scp != NULL);
osi_assertx(scp != NULL, "null cm_scache_t");
lock_ReleaseRead(&cm_scacheLock);
lock_ObtainMutex(&scp->mx);
@ -5241,7 +5241,7 @@ long cm_RetryLock(cm_file_lock_t *oldFileLock, int client_is_dead)
oldFileLock->flags |= CM_FILELOCK_FLAG_WAITLOCK;
}
osi_assert(IS_LOCK_WAITLOCK(oldFileLock));
osi_assertx(IS_LOCK_WAITLOCK(oldFileLock), "!IS_LOCK_WAITLOCK");
if (force_client_lock ||
!SERVERLOCKS_ENABLED(scp) ||
@ -5313,7 +5313,7 @@ long cm_RetryLock(cm_file_lock_t *oldFileLock, int client_is_dead)
if (scp->serverLock == LockRead) {
osi_assert(newLock == LockWrite);
osi_assertx(newLock == LockWrite, "!LockWrite");
osi_Log0(afsd_logp, " Attempting to UPGRADE from LockRead to LockWrite");
@ -5392,9 +5392,9 @@ long cm_RetryLock(cm_file_lock_t *oldFileLock, int client_is_dead)
cm_key_t cm_GenerateKey(unsigned int session_id, unsigned long process_id, unsigned int file_id)
{
#ifdef DEBUG
osi_assert((process_id & 0xffffffff) == process_id);
osi_assert((session_id & 0xffff) == session_id);
osi_assert((file_id & 0xffff) == file_id);
osi_assertx((process_id & 0xffffffff) == process_id, "unexpected process_id");
osi_assertx((session_id & 0xffff) == session_id, "unexpected session_id");
osi_assertx((file_id & 0xffff) == file_id, "unexpected file_id");
#endif
return

16
src/WINNT/afsd/cm_volume.c
View File

@ -452,7 +452,7 @@ long cm_UpdateVolume(struct cm_cell *cellp, cm_user_t *userp, cm_req_t *reqp,
if ( !tsp->cellp )
tsp->cellp = cellp;
osi_assert(tsp != NULL);
osi_assertx(tsp != NULL, "null cm_server_t");
/* and add it to the list(s). */
/*
@ -601,7 +601,7 @@ long cm_GetVolumeByID(cm_cell_t *cellp, afs_uint32 volumeID, cm_user_t *userp,
}
#ifdef SEARCH_ALL_VOLUMES
osi_assert(volp == volp2);
osi_assertx(volp == volp2, "unexpected cm_vol_t");
#endif
lock_ReleaseRead(&cm_volumeLock);
@ -686,7 +686,7 @@ long cm_GetVolumeByName(struct cm_cell *cellp, char *volumeNamep,
}
#ifdef SEARCH_ALL_VOLUMES
osi_assert(volp2 == volp);
osi_assertx(volp2 == volp, "unexpected cm_vol_t");
#endif
if (!volp && (flags & CM_GETVOL_FLAG_CREATE)) {
@ -852,7 +852,7 @@ void cm_ForceUpdateVolume(cm_fid_t *fidp, cm_user_t *userp, cm_req_t *reqp)
}
#ifdef SEARCH_ALL_VOLUMES
osi_assert(volp == volp2);
osi_assertx(volp == volp2, "unexpected cm_vol_t");
#endif
lock_ReleaseRead(&cm_volumeLock);
@ -913,7 +913,7 @@ cm_serverRef_t **cm_GetVolServers(cm_volume_t *volp, afs_uint32 volume)
void cm_PutVolume(cm_volume_t *volp)
{
lock_ObtainWrite(&cm_volumeLock);
osi_assert(volp->refCount-- > 0);
osi_assertx(volp->refCount-- > 0, "cm_volume_t refCount 0");
lock_ReleaseWrite(&cm_volumeLock);
}
@ -952,7 +952,7 @@ void cm_RefreshVolumes(void)
lock_ReleaseMutex(&volp->mx);
lock_ObtainWrite(&cm_volumeLock);
osi_assert(volp->refCount-- > 0);
osi_assertx(volp->refCount-- > 0, "cm_volume_t refCount 0");
}
lock_ReleaseWrite(&cm_volumeLock);
@ -1108,7 +1108,7 @@ void cm_CheckOfflineVolumes(void)
cm_CheckOfflineVolume(volp, 0);
lock_ObtainWrite(&cm_volumeLock);
osi_assert(volp->refCount-- > 0);
osi_assertx(volp->refCount-- > 0, "cm_volume_t refCount 0");
}
lock_ReleaseWrite(&cm_volumeLock);
}
@ -1201,7 +1201,7 @@ void cm_ChangeRankVolume(cm_server_t *tsp)
lock_ReleaseMutex(&volp->mx);
lock_ObtainWrite(&cm_volumeLock);
osi_assert(volp->refCount-- > 0);
osi_assertx(volp->refCount-- > 0, "cm_volume_t refCount 0");
}
lock_ReleaseWrite(&cm_volumeLock);
}

72
src/WINNT/afsd/smb.c
View File

@ -791,7 +791,7 @@ void smb_DosUTimeFromUnixTime(afs_uint32 *dosUTimep, time_t unixTime)
{
time_t diff_t = unixTime - smb_localZero;
#if defined(DEBUG) && !defined(_USE_32BIT_TIME_T)
osi_assert(diff_t < _UI32_MAX);
osi_assertx(diff_t < _UI32_MAX, "time_t > _UI32_MAX");
#endif
*dosUTimep = (afs_uint32)diff_t;
}
@ -855,7 +855,7 @@ smb_vc_t *smb_FindVC(unsigned short lsn, int flags, int lana)
if (nts != STATUS_SUCCESS)
osi_Log4(smb_logp,"MsV1_0Lm20ChallengeRequest failure: nts 0x%x ntsEx 0x%x respSize is %u needs %u",
nts, ntsEx, sizeof(lsaReq), lsaRespSize);
osi_assert(nts == STATUS_SUCCESS); /* this had better work! */
osi_assertx(nts == STATUS_SUCCESS, "LsaCallAuthenticationPackage failed"); /* this had better work! */
memcpy(vcp->encKey, lsaResp->ChallengeToClient, MSV1_0_CHALLENGE_LENGTH);
LsaFreeReturnBuffer(lsaResp);
@ -1101,14 +1101,14 @@ void smb_ReleaseTID(smb_tid_t *tidp)
userp = NULL;
lock_ObtainWrite(&smb_rctLock);
osi_assert(tidp->refCount-- > 0);
osi_assertx(tidp->refCount-- > 0, "smb_tid_t refCount 0");
if (tidp->refCount == 0 && (tidp->delete)) {
ltpp = &tidp->vcp->tidsp;
for(tp = *ltpp; tp; ltpp = &tp->nextp, tp = *ltpp) {
if (tp == tidp)
break;
}
osi_assert(tp != NULL);
osi_assertx(tp != NULL, "null smb_tid_t");
*ltpp = tp->nextp;
lock_FinalizeMutex(&tidp->mx);
userp = tidp->userp; /* remember to drop ref later */
@ -1210,7 +1210,7 @@ void smb_ReleaseUsername(smb_username_t *unp)
time_t now = osi_Time();
lock_ObtainWrite(&smb_rctLock);
osi_assert(unp->refCount-- > 0);
osi_assertx(unp->refCount-- > 0, "smb_username_t refCount 0");
if (unp->refCount == 0 && !(unp->flags & SMB_USERNAMEFLAG_AFSLOGON) &&
(unp->flags & SMB_USERNAMEFLAG_LOGOFF)) {
lupp = &usernamesp;
@ -1218,7 +1218,7 @@ void smb_ReleaseUsername(smb_username_t *unp)
if (up == unp)
break;
}
osi_assert(up != NULL);
osi_assertx(up != NULL, "null smb_username_t");
*lupp = up->nextp;
up->nextp = NULL; /* do not remove this */
lock_FinalizeMutex(&unp->mx);
@ -1246,14 +1246,14 @@ void smb_ReleaseUID(smb_user_t *uidp)
smb_username_t *unp = NULL;
lock_ObtainWrite(&smb_rctLock);
osi_assert(uidp->refCount-- > 0);
osi_assertx(uidp->refCount-- > 0, "smb_user_t refCount 0");
if (uidp->refCount == 0) {
lupp = &uidp->vcp->usersp;
for(up = *lupp; up; lupp = &up->nextp, up = *lupp) {
if (up == uidp)
break;
}
osi_assert(up != NULL);
osi_assertx(up != NULL, "null smb_user_t");
*lupp = up->nextp;
lock_FinalizeMutex(&uidp->mx);
unp = uidp->unp;
@ -1470,7 +1470,7 @@ void smb_ReleaseFID(smb_fid_t *fidp)
lock_ObtainMutex(&fidp->mx);
lock_ObtainWrite(&smb_rctLock);
osi_assert(fidp->refCount-- > 0);
osi_assertx(fidp->refCount-- > 0, "smb_fid_t refCount 0");
if (fidp->refCount == 0 && (fidp->delete)) {
vcp = fidp->vcp;
fidp->vcp = NULL;
@ -1892,7 +1892,7 @@ void smb_ReleaseDirSearchNoLock(smb_dirSearch_t *dsp)
cm_scache_t *scp = NULL;
lock_ObtainMutex(&dsp->mx);
osi_assert(dsp->refCount-- > 0);
osi_assertx(dsp->refCount-- > 0, "cm_scache_t refCount 0");
if (dsp->refCount == 0 && (dsp->flags & SMB_DIRSEARCH_DELETE)) {
if (&dsp->q == (osi_queue_t *) smb_lastDirSearchp)
smb_lastDirSearchp = (smb_dirSearch_t *) osi_QPrev(&smb_lastDirSearchp->q);
@ -2068,7 +2068,7 @@ static smb_packet_t *GetPacket(void)
tbp->spacep = NULL;
}
osi_assert(tbp->magic == SMB_PACKETMAGIC);
osi_assertx(tbp->magic == SMB_PACKETMAGIC, "invalid smb_packet_t magic");
return tbp;
}
@ -2099,7 +2099,7 @@ static NCB *GetNCB(void)
tbp->magic = SMB_NCBMAGIC;
}
osi_assert(tbp->magic == SMB_NCBMAGIC);
osi_assertx(tbp->magic == SMB_NCBMAGIC, "invalid smb_packet_t magic");
memset(&tbp->ncb, 0, sizeof(NCB));
ncbp = &tbp->ncb;
@ -2109,7 +2109,7 @@ static NCB *GetNCB(void)
void smb_FreePacket(smb_packet_t *tbp)
{
smb_vc_t * vcp = NULL;
osi_assert(tbp->magic == SMB_PACKETMAGIC);
osi_assertx(tbp->magic == SMB_PACKETMAGIC, "invalid smb_packet_t magic");
lock_ObtainWrite(&smb_globalLock);
tbp->nextp = smb_packetFreeListp;
@ -2137,7 +2137,7 @@ static void FreeNCB(NCB *bufferp)
smb_ncb_t *tbp;
tbp = (smb_ncb_t *) bufferp;
osi_assert(tbp->magic == SMB_NCBMAGIC);
osi_assertx(tbp->magic == SMB_NCBMAGIC, "invalid smb_packet_t magic");
lock_ObtainWrite(&smb_globalLock);
tbp->nextp = smb_ncbFreeListp;
@ -3397,7 +3397,7 @@ void smb_WaitingLocksDaemon()
if (wl->state == SMB_WAITINGLOCKSTATE_DONE)
continue;
osi_assert(wl->state != SMB_WAITINGLOCKSTATE_ERROR);
osi_assertx(wl->state != SMB_WAITINGLOCKSTATE_ERROR, "!SMB_WAITINGLOCKSTATE_ERROR");
/* wl->state is either _DONE or _WAITING. _ERROR
would no longer be on the queue. */
@ -3704,11 +3704,11 @@ long smb_ReceiveCoreSearchVolume(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t
/* pull pathname and stat block out of request */
tp = smb_GetSMBData(inp, NULL);
pathp = smb_ParseASCIIBlock(tp, (char **) &tp);
osi_assert(pathp != NULL);
osi_assertx(pathp != NULL, "null path");
if (smb_StoreAnsiFilenames)
OemToChar(pathp,pathp);
statBlockp = smb_ParseVblBlock(tp, (char **) &tp, &statLen);
osi_assert(statBlockp != NULL);
osi_assertx(statBlockp != NULL, "null statBlock");
if (statLen == 0) {
statBlockp = initStatBlock;
statBlockp[0] = 8;
@ -4368,7 +4368,7 @@ long smb_ReceiveCoreSearchDir(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *ou
* Deduct for them and fill in the length field.
*/
temp -= 3; /* deduct vbl block info */
osi_assert(temp == (43 * returnedNames));
osi_assertx(temp == (43 * returnedNames), "unexpected data length");
origOp[1] = (char)(temp & 0xff);
origOp[2] = (char)((temp>>8) & 0xff);
if (returnedNames == 0)
@ -4864,7 +4864,7 @@ long smb_ReceiveCoreOpen(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
}
fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
osi_assert(fidp);
osi_assertx(fidp, "null smb_fid_t");
/* save a pointer to the vnode */
fidp->scp = scp;
@ -5922,8 +5922,8 @@ long smb_CloseFID(smb_vc_t *vcp, smb_fid_t *fidp, cm_user_t *userp,
fidp->NTopen_pathp = NULL;
fidp->flags &= ~SMB_FID_NTOPEN;
} else {
osi_assert(fidp->NTopen_dscp == NULL);
osi_assert(fidp->NTopen_pathp == NULL);
osi_assertx(fidp->NTopen_dscp == NULL, "null NTopen_dsc");
osi_assertx(fidp->NTopen_pathp == NULL, "null NTopen_path");
}
if (fidp->NTopen_wholepathp) {
@ -7158,7 +7158,7 @@ long smb_ReceiveCoreCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
/* now all we have to do is open the file itself */
fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
osi_assert(fidp);
osi_assertx(fidp, "null smb_fid_t");
cm_HoldUser(userp);
@ -7561,7 +7561,7 @@ void smb_ClientWaiter(void *parmp)
{
/* this is fatal - log as much as possible */
osi_Log1(smb_logp, "Fatal: NCBevents idx [ %d ] out of range.\n", idx);
osi_assert(0);
osi_assertx(0, "invalid index");
}
thrd_ResetEvent(NCBevents[idx]);
@ -7615,7 +7615,7 @@ void smb_ServerWaiter(void *parmp)
{
/* this is fatal - log as much as possible */
osi_Log1(smb_logp, "Fatal: session idx [ %d ] out of range.\n", idx_session);
osi_assert(0);
osi_assertx(0, "invalid index");
}
/* Get an NCB */
@ -7659,7 +7659,7 @@ void smb_ServerWaiter(void *parmp)
{
/* this is fatal - log as much as possible */
osi_Log1(smb_logp, "Fatal: idx_NCB [ %d ] out of range.\n", idx_NCB);
osi_assert(0);
osi_assertx(0, "invalid index");
}
/* Link them together */
@ -7756,7 +7756,7 @@ void smb_Server(VOID *parmp)
{
/* this is fatal - log as much as possible */
osi_Log1(smb_logp, "Fatal: idx_NCB %d out of range.\n", idx_NCB);
osi_assert(0);
osi_assertx(0, "invalid index");
}
ncbp = NCBs[idx_NCB];
@ -7986,7 +7986,7 @@ void InitNCBslot(int idx)
int i;
char eventName[MAX_PATH];
osi_assert( idx < (sizeof(NCBs) / sizeof(NCBs[0])) );
osi_assertx( idx < (sizeof(NCBs) / sizeof(NCBs[0])), "invalid index" );
NCBs[idx] = GetNCB();
sprintf(eventName,"NCBavails[%d]", idx);
@ -8238,8 +8238,8 @@ void smb_Listener(void *parmp)
* we should probably want to wait for a session to be freed in case
* we run out.
*/
osi_assert(session < SESSION_MAX - 1);
osi_assert(numNCBs < NCB_MAX - 1); /* if we pass this test we can allocate one more */
osi_assertx(session < SESSION_MAX - 1, "invalid session");
osi_assertx(numNCBs < NCB_MAX - 1, "invalid numNCBs"); /* if we pass this test we can allocate one more */
lock_ObtainMutex(&vcp->mx);
vcp->session = session;
@ -8433,7 +8433,7 @@ int smb_NetbiosInit(void)
}
}
osi_assert(lana_list.length >= 0);
osi_assertx(lana_list.length >= 0, "empty lana list");
if (!lana_found) {
afsi_log("No valid LANA numbers found!");
lana_list.length = 0;
@ -8473,7 +8473,7 @@ void smb_StartListeners()
continue;
phandle = thrd_Create(NULL, 65536, (ThreadFunc) smb_Listener,
(void*)lana_list.lana[i], 0, &lpid, "smb_Listener");
osi_assert(phandle != NULL);
osi_assertx(phandle != NULL, "smb_Listener thread creation failure");
thrd_CloseHandle(phandle);
}
}
@ -8885,29 +8885,29 @@ void smb_Init(osi_log_t *logp, int useV3,
phandle = thrd_Create(NULL, 65536, (ThreadFunc) smb_ClientWaiter,
NULL, 0, &lpid, "smb_ClientWaiter");
osi_assert(phandle != NULL);
osi_assertx(phandle != NULL, , "smb_ClientWaiter thread creation failure");
thrd_CloseHandle(phandle);
phandle = thrd_Create(NULL, 65536, (ThreadFunc) smb_ServerWaiter,
NULL, 0, &lpid, "smb_ServerWaiter");
osi_assert(phandle != NULL);
osi_assertx(phandle != NULL, "smb_ServerWaiter thread creation failure");
thrd_CloseHandle(phandle);
for (i=0; i<smb_NumServerThreads; i++) {
phandle = thrd_Create(NULL, 65536, (ThreadFunc) smb_Server,
(void *) i, 0, &lpid, "smb_Server");
osi_assert(phandle != NULL);
osi_assertx(phandle != NULL, "smb_Server thread creation failure");
thrd_CloseHandle(phandle);
}
phandle = thrd_Create(NULL, 65536, (ThreadFunc) smb_Daemon,
NULL, 0, &lpid, "smb_Daemon");
osi_assert(phandle != NULL);
osi_assertx(phandle != NULL, "smb_Daemon thread creation failure");
thrd_CloseHandle(phandle);
phandle = thrd_Create(NULL, 65536, (ThreadFunc) smb_WaitingLocksDaemon,
NULL, 0, &lpid, "smb_WaitingLocksDaemon");
osi_assert(phandle != NULL);
osi_assertx(phandle != NULL, "smb_WaitingLocksDaemon thread creation failure");
thrd_CloseHandle(phandle);
return;

34
src/WINNT/afsd/smb3.c
View File

@ -2297,13 +2297,13 @@ long smb_ReceiveTran2Open(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op)
/* don't create if not found */
if (dscp)
cm_ReleaseSCache(dscp);
osi_assert(scp == NULL);
osi_assertx(scp == NULL, "null cm_scache_t");
cm_ReleaseUser(userp);
smb_FreeTran2Packet(outp);
return CM_ERROR_NOSUCHFILE;
}
else {
osi_assert(dscp != NULL && scp == NULL);
osi_assertx(dscp != NULL && scp == NULL, "null dsc || non-null sc");
openAction = 2; /* created file */
setAttr.mask = CM_ATTRMASK_CLIENTMODTIME;
smb_UnixTimeFromSearchTime(&setAttr.clientModTime, dosTime);
@ -2376,7 +2376,7 @@ long smb_ReceiveTran2Open(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op)
/* now all we have to do is open the file itself */
fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
osi_assert(fidp);
osi_assertx(fidp, "null smb_fid_t");
cm_HoldUser(userp);
lock_ObtainMutex(&fidp->mx);
@ -4143,7 +4143,7 @@ long smb_T2SearchDirSingle(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t *op
cm_InitReq(&req);
eos = 0;
osi_assert(p->opcode == 1);
osi_assertx(p->opcode == 1, "invalid opcode");
/* find first; obtain basic parameters from request */
@ -4606,7 +4606,7 @@ long smb_ReceiveTran2SearchDir(smb_vc_t *vcp, smb_tran2Packet_t *p, smb_packet_t
strcpy(dsp->mask, maskp); /* and save mask */
}
else {
osi_assert(p->opcode == 2);
osi_assertx(p->opcode == 2, "invalid opcode");
/* find next; obtain basic parameters from request or open dir file */
dsp = smb_FindDirSearch(p->parmsp[0]);
maxCount = p->parmsp[1];
@ -5471,7 +5471,7 @@ long smb_ReceiveV3OpenX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
return CM_ERROR_NOSUCHFILE;
}
else {
osi_assert(dscp != NULL);
osi_assertx(dscp != NULL, "null cm_scache_t");
osi_Log1(smb_logp, "smb_ReceiveV3OpenX creating file %s",
osi_LogSaveString(smb_logp, lastNamep));
openAction = 2; /* created file */
@ -5526,7 +5526,7 @@ long smb_ReceiveV3OpenX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
/* now all we have to do is open the file itself */
fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
osi_assert(fidp);
osi_assertx(fidp, "null smb_fid_t");
cm_HoldUser(userp);
lock_ObtainMutex(&fidp->mx);
@ -5749,7 +5749,7 @@ long smb_ReceiveV3LockingX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
wlRequest = malloc(sizeof(smb_waitingLockRequest_t));
osi_assert(wlRequest != NULL);
osi_assertx(wlRequest != NULL, "null wlRequest");
wlRequest->vcp = vcp;
smb_HoldVC(vcp);
@ -5780,7 +5780,7 @@ long smb_ReceiveV3LockingX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
wLock = malloc(sizeof(smb_waitingLock_t));
osi_assert(wLock != NULL);
osi_assertx(wLock != NULL, "null smb_waitingLock_t");
wLock->key = tkey;
wLock->LOffset = tOffset;
@ -5794,7 +5794,7 @@ long smb_ReceiveV3LockingX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
wLock = malloc(sizeof(smb_waitingLock_t));
osi_assert(wLock != NULL);
osi_assertx(wLock != NULL, "null smb_waitingLock_t");
wLock->key = key;
wLock->LOffset = LOffset;
@ -6778,7 +6778,7 @@ long smb_ReceiveNTCreateX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
code = 0;
while (code == 0 && scp->fileType == CM_SCACHETYPE_SYMLINK) {
targetScp = 0;
osi_assert(dscp != NULL);
osi_assertx(dscp != NULL, "null cm_scache_t");
code = cm_EvaluateSymLink(dscp, scp, &targetScp, userp, &req);
if (code == 0) {
/* we have a more accurate file to use (the
@ -6818,7 +6818,7 @@ long smb_ReceiveNTCreateX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
free(realPathp);
return CM_ERROR_NOSUCHFILE;
} else if (realDirFlag == 0 || realDirFlag == -1) {
osi_assert(dscp != NULL);
osi_assertx(dscp != NULL, "null cm_scache_t");
osi_Log1(smb_logp, "smb_ReceiveNTCreateX creating file %s",
osi_LogSaveString(smb_logp, lastNamep));
openAction = 2; /* created file */
@ -6876,7 +6876,7 @@ long smb_ReceiveNTCreateX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
/* create directory */
if ( !treeCreate )
treeStartp = lastNamep;
osi_assert(dscp != NULL);
osi_assertx(dscp != NULL, "null cm_scache_t");
osi_Log1(smb_logp, "smb_ReceiveNTCreateX creating directory [%s]",
osi_LogSaveString(smb_logp, treeStartp));
openAction = 2; /* created directory */
@ -7012,7 +7012,7 @@ long smb_ReceiveNTCreateX(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *outp)
/* open the file itself */
fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
osi_assert(fidp);
osi_assertx(fidp, "null smb_fid_t");
/* save a reference to the user */
cm_HoldUser(userp);
@ -7550,7 +7550,7 @@ long smb_ReceiveNTTranCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *out
return CM_ERROR_NOSUCHFILE;
}
else if (realDirFlag == 0 || realDirFlag == -1) {
osi_assert(dscp != NULL);
osi_assertx(dscp != NULL, "null cm_scache_t");
osi_Log1(smb_logp, "smb_ReceiveNTTranCreate creating file %s",
osi_LogSaveString(smb_logp, lastNamep));
openAction = 2; /* created file */
@ -7601,7 +7601,7 @@ long smb_ReceiveNTTranCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *out
}
} else {
/* create directory */
osi_assert(dscp != NULL);
osi_assertx(dscp != NULL, "null cm_scache_t");
osi_Log1(smb_logp,
"smb_ReceiveNTTranCreate creating directory %s",
osi_LogSaveString(smb_logp, lastNamep));
@ -7679,7 +7679,7 @@ long smb_ReceiveNTTranCreate(smb_vc_t *vcp, smb_packet_t *inp, smb_packet_t *out
/* open the file itself */
fidp = smb_FindFID(vcp, 0, SMB_FLAG_CREATE);
osi_assert(fidp);
osi_assertx(fidp, "null smb_fid_t");
/* save a reference to the user */
cm_HoldUser(userp);

2
src/WINNT/afsd/smb_ioctl.c
View File

@ -334,7 +334,7 @@ long smb_IoctlV3Read(smb_fid_t *fidp, smb_vc_t *vcp, smb_packet_t *inp, smb_pack
uidp = smb_FindUID(vcp, ((smb_t *)inp)->uid, 0);
userp = smb_GetUserFromUID(uidp);
osi_assert(userp != 0);
osi_assertx(userp != NULL, "null cm_user_t");
iop->uidp = uidp;
if (uidp && uidp->unp) {
osi_Log3(afsd_logp, "Ioctl uid %d user %x name %s",