Further rationalise our usage of assert()

[openafs.git] / src / vol / fssync-server.c

diff --git a/src/vol/fssync-server.c b/src/vol/fssync-server.c
index c90d86e..5d20c77 100644 (file)
--- a/src/vol/fssync-server.c
+++ b/src/vol/fssync-server.c
@@ -45,7 +45,7 @@
 
 #include <roken.h>
 
-#include <rx/xdr.h>
+#include <afs/opr.h>
 #include <afs/afsint.h>
 #include "nfs.h"
 #include <afs/errors.h>
@@ -198,19 +198,20 @@ FSYNC_fsInit(void)
     Lock_Init(&FSYNC_handler_lock);
 
 #ifdef AFS_PTHREAD_ENV
-    osi_Assert(pthread_attr_init(&tattr) == 0);
-    osi_Assert(pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED) == 0);
-    osi_Assert(pthread_create(&tid, &tattr, FSYNC_sync, NULL) == 0);
+    opr_Verify(pthread_attr_init(&tattr) == 0);
+    opr_Verify(pthread_attr_setdetachstate(&tattr,
+                                          PTHREAD_CREATE_DETACHED) == 0);
+    opr_Verify(pthread_create(&tid, &tattr, FSYNC_sync, NULL) == 0);
 #else /* AFS_PTHREAD_ENV */
-    osi_Assert(LWP_CreateProcess
-          (FSYNC_sync, USUAL_STACK_SIZE, USUAL_PRIORITY, (void *)0,
-           "FSYNC_sync", &pid) == LWP_SUCCESS);
+    opr_Verify(LWP_CreateProcess(FSYNC_sync, USUAL_STACK_SIZE,
+                                USUAL_PRIORITY, NULL,
+                                "FSYNC_sync", &pid) == LWP_SUCCESS);
 #endif /* AFS_PTHREAD_ENV */
 
 #ifdef AFS_DEMAND_ATTACH_FS
     queue_Init(&fsync_salv.head);
     CV_INIT(&fsync_salv.cv, "fsync salv", CV_DEFAULT, 0);
-    osi_Assert(pthread_create(&tid, &tattr, FSYNC_salvageThread, NULL) == 0);
+    opr_Verify(pthread_create(&tid, &tattr, FSYNC_salvageThread, NULL) == 0);
 #endif /* AFS_DEMAND_ATTACH_FS */
 }
 
@@ -244,7 +245,7 @@ FSYNC_sync(void * args)
 
     /* we must not be called before vol package initialization, since we use
      * vol package mutexes and conds etc */
-    osi_Assert(VInit);
+    opr_Assert(VInit);
 
     SYNC_getAddr(&state->endpoint, &state->addr);
     SYNC_cleanupSock(state);
@@ -278,7 +279,7 @@ FSYNC_sync(void * args)
 
     state->fd = SYNC_getSock(&state->endpoint);
     code = SYNC_bindSock(state);
-    osi_Assert(!code);
+    opr_Assert(!code);
 
 #ifdef AFS_DEMAND_ATTACH_FS
     /*
@@ -293,10 +294,10 @@ FSYNC_sync(void * args)
     }
     memcpy(thread_opts, &VThread_defaults, sizeof(VThread_defaults));
     thread_opts->disallow_salvsync = 1;
-    osi_Assert(pthread_setspecific(VThread_key, thread_opts) == 0);
+    opr_Verify(pthread_setspecific(VThread_key, thread_opts) == 0);
 
     code = VVGCache_PkgInit();
-    osi_Assert(code == 0);
+    opr_Assert(code == 0);
 #endif
 
     InitHandler();
@@ -429,10 +430,10 @@ FSYNC_newconnection(osi_socket afd)
     fd = accept(afd, (struct sockaddr *)&other, &junk);
     if (fd == OSI_NULLSOCKET) {
        Log("FSYNC_newconnection:  accept failed, errno==%d\n", errno);
-       osi_Assert(1 == 2);
+       opr_abort();
     } else if (!AddHandler(fd, FSYNC_com)) {
        AcceptOff();
-       osi_Assert(AddHandler(fd, FSYNC_com));
+       opr_Verify(AddHandler(fd, FSYNC_com));
     }
 }
 
@@ -1087,7 +1088,7 @@ FSYNC_com_VolOff(FSSYNC_VolOp_command * vcom, SYNC_response * res)
            VCreateReservation_r(vp);
             VOfflineForVolOp_r(&error, vp, "A volume utility is running.");
             if (error==0) {
-                osi_Assert(vp->nUsers==0);
+                opr_Assert(vp->nUsers==0);
                 vp->pending_vol_op->vol_op_state = FSSYNC_VolOpRunningOffline;
             }
             else {
@@ -1569,7 +1570,7 @@ FSYNC_com_VolOpQuery(FSSYNC_VolOp_command * vcom, SYNC_response * res)
            res->hdr.reason = FSYNC_WRONG_PART;
            code = SYNC_FAILED;
        } else {
-           osi_Assert(sizeof(FSSYNC_VolOp_info) <= res->payload.len);
+           opr_Assert(sizeof(FSSYNC_VolOp_info) <= res->payload.len);
            memcpy(res->payload.buf, vp->pending_vol_op, sizeof(FSSYNC_VolOp_info));
            res->hdr.response_len += sizeof(FSSYNC_VolOp_info);
        }
@@ -1608,7 +1609,7 @@ FSYNC_com_VGQuery(FSSYNC_VolOp_command * vcom, SYNC_response * res)
        goto done;
     }
 
-    osi_Assert(sizeof(FSSYNC_VGQry_response_t) <= res->payload.len);
+    opr_Assert(sizeof(FSSYNC_VGQry_response_t) <= res->payload.len);
 
     rc = VVGCache_query_r(dp, vcom->vop->volume, res->payload.buf);
     switch (rc) {
@@ -2027,7 +2028,7 @@ static void
 AcceptOn(void)
 {
     if (AcceptHandler == -1) {
-       osi_Assert(AddHandler(fssync_server_state.fd, FSYNC_newconnection));
+       opr_Verify(AddHandler(fssync_server_state.fd, FSYNC_newconnection));
        AcceptHandler = FindHandler(fssync_server_state.fd);
     }
 }
@@ -2036,7 +2037,7 @@ static void
 AcceptOff(void)
 {
     if (AcceptHandler != -1) {
-       osi_Assert(RemoveHandler(fssync_server_state.fd));
+       opr_Verify(RemoveHandler(fssync_server_state.fd));
        AcceptHandler = -1;
     }
 }
@@ -2121,7 +2122,7 @@ FindHandler(osi_socket afd)
            return i;
        }
     ReleaseReadLock(&FSYNC_handler_lock);      /* just in case */
-    osi_Assert(1 == 2);
+    opr_abort();
     return -1;                 /* satisfy compiler */
 }
 
@@ -2133,7 +2134,7 @@ FindHandler_r(osi_socket afd)
        if (HandlerFD[i] == afd) {
            return i;
        }
-    osi_Assert(1 == 2);
+    opr_abort();
     return -1;                 /* satisfy compiler */
 }
 
@@ -2155,7 +2156,7 @@ GetHandler(struct pollfd *fds, int maxfds, int events, int *nfds)
     ObtainReadLock(&FSYNC_handler_lock);
     for (i = 0; i < MAXHANDLERS; i++)
        if (HandlerFD[i] != OSI_NULLSOCKET) {
-           osi_Assert(fdi<maxfds);
+           opr_Assert(fdi<maxfds);
            fds[fdi].fd = HandlerFD[i];
            fds[fdi].events = events;
            fds[fdi].revents = 0;