windows-afsd-notification-20071104

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.

diff --git a/src/WINNT/afsd/afsd_service.c b/src/WINNT/afsd/afsd_service.c
index 30e81d8b21ac7e5c9cef89575c04aea46b685eb5..328e16ece62c1fe4a8ff3990c16916f7a5d7a461 100644 (file)
--- a/src/WINNT/afsd/afsd_service.c
+++ b/src/WINNT/afsd/afsd_service.c
@@ -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, 

diff --git a/src/WINNT/afsd/cm_btree.c b/src/WINNT/afsd/cm_btree.c
index 761e8aeae947389a4277a309826977849d734ada..80b1b7b45dd3982bbc6db713b82d1366ac43d165 100644 (file)
--- a/src/WINNT/afsd/cm_btree.c
+++ b/src/WINNT/afsd/cm_btree.c
@@ -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);
 

diff --git a/src/WINNT/afsd/cm_buf.c b/src/WINNT/afsd/cm_buf.c
index 2f580b1827fcfef0eb44953ecb995170f7b079bd..6b4446b721b94b66e7ce6fdfa32b74baf69a197a 100644 (file)
--- a/src/WINNT/afsd/cm_buf.c
+++ b/src/WINNT/afsd/cm_buf.c
@@ -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);
             }

diff --git a/src/WINNT/afsd/cm_callback.c b/src/WINNT/afsd/cm_callback.c
index abf3b1626f549a3e644dbaa1ca28c68668148ec5..d6d9e8311218b148e96df4fed147992559be5bbc 100644 (file)
--- a/src/WINNT/afsd/cm_callback.c
+++ b/src/WINNT/afsd/cm_callback.c
@@ -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;

diff --git a/src/WINNT/afsd/cm_conn.c b/src/WINNT/afsd/cm_conn.c
index e50e143b793c6b373dcea33c5a60f3e9fecf995e..c65bc9cc00e5828bf479b775d5b12de42afe0b6b 100644 (file)
--- a/src/WINNT/afsd/cm_conn.c
+++ b/src/WINNT/afsd/cm_conn.c
@@ -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,

diff --git a/src/WINNT/afsd/cm_daemon.c b/src/WINNT/afsd/cm_daemon.c
index a64750e891ce4289cb111d14b58c356ad10deb9d..15aaad135810e9ca27ddd003ee769c5d27d6af0a 100644 (file)
--- a/src/WINNT/afsd/cm_daemon.c
+++ b/src/WINNT/afsd/cm_daemon.c
@@ -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);
         }
     }

diff --git a/src/WINNT/afsd/cm_dcache.c b/src/WINNT/afsd/cm_dcache.c
index 0c417d24181bfc75a708b045a93528f3acb92ef4..ee7fd07df809f468aa65aec452dfb4ad1a09a1d7 100644 (file)
--- a/src/WINNT/afsd/cm_dcache.c
+++ b/src/WINNT/afsd/cm_dcache.c
@@ -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 */

diff --git a/src/WINNT/afsd/cm_freelance.c b/src/WINNT/afsd/cm_freelance.c
index e3d98cf71fadc2e2785391cc2c12ba0ebf024012..a7646f99907b6695a8ddeaccc1d099419f924501 100644 (file)
--- a/src/WINNT/afsd/cm_freelance.c
+++ b/src/WINNT/afsd/cm_freelance.c
@@ -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);
 }
 

diff --git a/src/WINNT/afsd/cm_ioctl.c b/src/WINNT/afsd/cm_ioctl.c
index 71a268207f81a4bd6a5f872b3c247f883af2ecb0..72f3090cb2ac287dc7d2f1959b4bf5b8e83efe8d 100644 (file)
--- a/src/WINNT/afsd/cm_ioctl.c
+++ b/src/WINNT/afsd/cm_ioctl.c
@@ -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);

diff --git a/src/WINNT/afsd/cm_scache.c b/src/WINNT/afsd/cm_scache.c
index b8b285df494cf8dbf0593f0da2ed6daa96aad2de..6ff096f066c3ab94795a495f2afadd7ac3271290 100644 (file)
--- a/src/WINNT/afsd/cm_scache.c
+++ b/src/WINNT/afsd/cm_scache.c
@@ -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) {

diff --git a/src/WINNT/afsd/cm_server.c b/src/WINNT/afsd/cm_server.c
index 445ea68edc1b7e0d9bebba4731f0773fd2e9f2d9..d73a72e5fc0d5a60284b4a17d6388a93f9c9212b 100644 (file)
--- a/src/WINNT/afsd/cm_server.c
+++ b/src/WINNT/afsd/cm_server.c
@@ -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) {

diff --git a/src/WINNT/afsd/cm_user.c b/src/WINNT/afsd/cm_user.c
index 4e4f4eabd9beee952eea5e57409231401324e533..9000a95145de9e5e99ceaa1239e306c256624bcd 100644 (file)
--- a/src/WINNT/afsd/cm_user.c
+++ b/src/WINNT/afsd/cm_user.c
@@ -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);
 }       
 

diff --git a/src/WINNT/afsd/cm_vnodeops.c b/src/WINNT/afsd/cm_vnodeops.c
index 84fb0f438d8a4a9fad26ac32807f0be2a983ee69..edd79398eb0a1d81e24bbf2429cc70b88fafa498 100644 (file)
--- a/src/WINNT/afsd/cm_vnodeops.c
+++ b/src/WINNT/afsd/cm_vnodeops.c
@@ -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 

diff --git a/src/WINNT/afsd/cm_volume.c b/src/WINNT/afsd/cm_volume.c
index 212fb0cbccb63289103c79c9449f84c3b3beb0a3..b3d46f8e25ceb07c40de6553d3701478848f94b8 100644 (file)
--- a/src/WINNT/afsd/cm_volume.c
+++ b/src/WINNT/afsd/cm_volume.c
@@ -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);
 }      

diff --git a/src/WINNT/afsd/smb.c b/src/WINNT/afsd/smb.c
index 3be3393d47662a9417a8ed1011093f79b3d7ce8a..738d0653584935b4f1cea1d06aeb28470b3af8e5 100644 (file)
--- a/src/WINNT/afsd/smb.c
+++ b/src/WINNT/afsd/smb.c
@@ -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;

diff --git a/src/WINNT/afsd/smb3.c b/src/WINNT/afsd/smb3.c
index d742716c2d5ed3a08ef82b43465e7fbaf8f9c3be..ca6f2c083ec1d0866fa97d17a682770dee72ea12 100644 (file)
--- a/src/WINNT/afsd/smb3.c
+++ b/src/WINNT/afsd/smb3.c
@@ -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);

diff --git a/src/WINNT/afsd/smb_ioctl.c b/src/WINNT/afsd/smb_ioctl.c
index abe3660cc57a999c8619c20fc12cde5c24ab443f..036571187e7d64eede489017837480dac1144c52 100644 (file)
--- a/src/WINNT/afsd/smb_ioctl.c
+++ b/src/WINNT/afsd/smb_ioctl.c
@@ -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",