DEVEL15-windows-afsd-notification-20071104
authorJeffrey Altman <jaltman@secure-endpoints.com>
Mon, 5 Nov 2007 00:24:45 +0000 (00:24 +0000)
committerJeffrey Altman <jaltman@secure-endpoints.com>
Mon, 5 Nov 2007 00:24:45 +0000 (00:24 +0000)
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.

(cherry picked from commit 89ac3ec2f68db045cf719d619eea1fb97a6364a3)

17 files changed:
src/WINNT/afsd/afsd_service.c
src/WINNT/afsd/cm_btree.c
src/WINNT/afsd/cm_buf.c
src/WINNT/afsd/cm_callback.c
src/WINNT/afsd/cm_conn.c
src/WINNT/afsd/cm_daemon.c
src/WINNT/afsd/cm_dcache.c
src/WINNT/afsd/cm_freelance.c
src/WINNT/afsd/cm_ioctl.c
src/WINNT/afsd/cm_scache.c
src/WINNT/afsd/cm_server.c
src/WINNT/afsd/cm_user.c
src/WINNT/afsd/cm_vnodeops.c
src/WINNT/afsd/cm_volume.c
src/WINNT/afsd/smb.c
src/WINNT/afsd/smb3.c
src/WINNT/afsd/smb_ioctl.c

index 30e81d8..328e16e 100644 (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, 
index 761e8ae..80b1b7b 100644 (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);
 
index 042788a..6f4e746 100644 (file)
@@ -91,7 +91,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++;
 }
 
@@ -107,12 +107,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)) {
@@ -327,8 +327,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));
@@ -482,8 +484,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 */
@@ -595,7 +597,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;
@@ -675,7 +677,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
@@ -687,8 +689,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) {
@@ -1036,7 +1039,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;
@@ -1146,7 +1149,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);
@@ -1158,7 +1161,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) {
@@ -1174,8 +1177,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) {
@@ -1425,7 +1428,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);
             }
index cd908cc..00cd505 100644 (file)
@@ -1420,7 +1420,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;
@@ -1551,10 +1551,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;
index 5546294..3b514a5 100644 (file)
@@ -36,7 +36,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);
 }
 
@@ -842,7 +842,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;
     }
@@ -862,7 +862,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,
index 647a5ea..01f52a6 100644 (file)
@@ -101,7 +101,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);
@@ -471,21 +471,21 @@ 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);
 #endif /* DJGPP */
 
         /* 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);
         }
     }
index d551bd5..7ff150e 100644 (file)
@@ -75,8 +75,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
@@ -207,7 +207,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;
@@ -1573,7 +1573,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);
@@ -1624,7 +1624,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 */
index 40174bb..3b2651c 100644 (file)
@@ -169,12 +169,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);
 #endif
 }
index 26592b8..36eff0d 100644 (file)
@@ -812,7 +812,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);
index dd0100b..038c955 100644 (file)
@@ -149,8 +149,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
 
@@ -244,7 +244,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) {
@@ -313,7 +314,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");
@@ -639,7 +641,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 &&
@@ -785,7 +787,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)
@@ -806,7 +808,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
@@ -931,7 +933,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);
 
@@ -1025,7 +1027,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
@@ -1217,7 +1219,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;
@@ -1317,7 +1319,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");
             }
         }
 
@@ -1336,7 +1338,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");
             }
         }
 
@@ -1439,7 +1441,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;
         }
@@ -1676,7 +1678,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);
@@ -1690,7 +1692,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
@@ -1706,10 +1708,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);
@@ -1722,11 +1724,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);
@@ -1744,7 +1746,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) {
index 870631c..24aab7f 100644 (file)
@@ -277,13 +277,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)
@@ -368,7 +368,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) {
@@ -413,7 +413,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) {
index 94be17b..1a0d251 100644 (file)
@@ -106,7 +106,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) {
@@ -137,7 +137,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);
 }       
 
index a0ef4b4..16e5838 100644 (file)
@@ -337,7 +337,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 */
@@ -2286,7 +2286,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;
@@ -3905,7 +3905,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));
@@ -4048,7 +4048,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;
     }
 
@@ -4292,7 +4292,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);
             }
@@ -4508,7 +4508,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
 
@@ -4683,7 +4683,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) &&
@@ -4850,7 +4850,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 */
@@ -4911,10 +4911,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);
 
@@ -4931,7 +4931,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
@@ -5137,7 +5137,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);
@@ -5243,7 +5243,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) ||
@@ -5315,7 +5315,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");
 
@@ -5394,9 +5394,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 
index 8ec752d..79f61d4 100644 (file)
@@ -456,7 +456,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). */
             /*
@@ -605,7 +605,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);
@@ -690,7 +690,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)) {
@@ -856,7 +856,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);
@@ -917,7 +917,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);
 }
 
@@ -956,7 +956,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);
 
@@ -1112,7 +1112,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);
 }
@@ -1205,7 +1205,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);
 }      
index 2302018..781fa3c 100644 (file)
@@ -882,7 +882,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;
 }
@@ -951,7 +951,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);
@@ -1197,14 +1197,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 */
@@ -1306,7 +1306,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;
@@ -1314,7 +1314,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);
@@ -1342,14 +1342,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;
@@ -1566,7 +1566,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;
@@ -2063,7 +2063,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);
@@ -2265,7 +2265,7 @@ static smb_packet_t *GetPacket(void)
         tbp->dos_pkt_sel = tb_sel;
 #endif /* DJGPP */
     }
-    osi_assert(tbp->magic == SMB_PACKETMAGIC);
+    osi_assertx(tbp->magic == SMB_PACKETMAGIC, "invalid smb_packet_t magic");
 
     return tbp;
 }
@@ -2319,7 +2319,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;
@@ -2332,7 +2332,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;
@@ -2360,7 +2360,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;
@@ -3677,7 +3677,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. */
@@ -3984,11 +3984,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;
@@ -4648,7 +4648,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) 
@@ -5144,7 +5144,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;
@@ -6202,8 +6202,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) {
@@ -7495,7 +7495,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);
 
@@ -7907,7 +7907,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]);
@@ -7965,7 +7965,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 */
@@ -8009,7 +8009,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 */
@@ -8118,7 +8118,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];
@@ -8374,7 +8374,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);
@@ -8671,8 +8671,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;
@@ -8902,7 +8902,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;
@@ -8942,7 +8942,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);
     }
 }
@@ -9397,30 +9397,30 @@ void smb_Init(osi_log_t *logp, int useV3,
 #ifndef DJGPP
     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);
 #endif /* !DJGPP */
 
     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);
 
 #ifdef DJGPP
index 52db7ec..4398386 100644 (file)
@@ -2303,13 +2303,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);
@@ -2382,7 +2382,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);
@@ -4149,7 +4149,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 */
 
@@ -4612,7 +4612,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];
@@ -5477,7 +5477,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 */
@@ -5532,7 +5532,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);
@@ -5755,7 +5755,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);
@@ -5786,7 +5786,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;
@@ -5800,7 +5800,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;
@@ -6792,7 +6792,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
@@ -6832,7 +6832,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 */
@@ -6890,7 +6890,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 */
@@ -7026,7 +7026,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);
@@ -7564,7 +7564,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 */
@@ -7615,7 +7615,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));
@@ -7693,7 +7693,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);
index 2a628d4..a650396 100644 (file)
@@ -339,7 +339,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",