Changeset 14d1db6 in rtems


Ignore:
Timestamp:
Aug 19, 2008, 6:18:54 PM (11 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.9, master
Children:
1a7c300
Parents:
6bdeeb31
Message:

2008-08-19 Joel Sherrill <joel.sherrill@…>

  • libfs/src/nfsclient/src/nfs.c, libfs/src/nfsclient/src/rpcio.c: Remove some warnings. Using ASSERT/assert macros confuses gcc who is unsure actions take place. More importantly if you ever compiled with NDEBUG set wrong, intended actions would not occur. Likely I did not catch all of these.
Location:
cpukit
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • cpukit/ChangeLog

    r6bdeeb31 r14d1db6  
     12008-08-19      Joel Sherrill <joel.sherrill@OARcorp.com>
     2
     3        * libfs/src/nfsclient/src/nfs.c, libfs/src/nfsclient/src/rpcio.c:
     4        Remove some warnings. Using ASSERT/assert macros confuses gcc who is
     5        unsure actions take place. More importantly if you ever compiled with
     6        NDEBUG set wrong, intended actions would not occur. Likely I did not
     7        catch all of these.
     8
    192008-08-19      Joel Sherrill <joel.sherrill@OARcorp.com>
    210
  • cpukit/libfs/src/nfsclient/src/nfs.c

    r6bdeeb31 r14d1db6  
    962962static int initialised = 0;
    963963entry   dummy;
     964rtems_status_code status;
    964965
    965966        if (initialised)
     
    998999        dirres_entry_size = xdr_sizeof((xdrproc_t)xdr_entry, &dummy);
    9991000
    1000         assert( smallPool = rpcUdpXactPoolCreate(
    1001                                                         NFS_PROGRAM,
    1002                                                         NFS_VERSION_2,
    1003                                                         CONFIG_NFS_SMALL_XACT_SIZE,
    1004                                                         smallPoolDepth) );
    1005 
    1006         assert( bigPool   = rpcUdpXactPoolCreate(
    1007                                                         NFS_PROGRAM,
    1008                                                         NFS_VERSION_2,
    1009                                                         CONFIG_NFS_BIG_XACT_SIZE,
    1010                                                         bigPoolDepth) );
    1011 
    1012         assert( RTEMS_SUCCESSFUL == rtems_semaphore_create(
    1013                                                         rtems_build_name('N','F','S','l'),
    1014                                                         1,
    1015                                                         MUTEX_ATTRIBUTES,
    1016                                                         0,
    1017                                                         &nfsGlob.llock) );
    1018 
    1019         assert( RTEMS_SUCCESSFUL == rtems_semaphore_create(
    1020                                                         rtems_build_name('N','F','S','m'),
    1021                                                         1,
    1022                                                         MUTEX_ATTRIBUTES,
    1023                                                         0,
    1024                                                         &nfsGlob.lock) );
     1001        smallPool = rpcUdpXactPoolCreate(
     1002                NFS_PROGRAM,
     1003                NFS_VERSION_2,
     1004                CONFIG_NFS_SMALL_XACT_SIZE,
     1005                smallPoolDepth);
     1006        assert( smallPool );
     1007
     1008        bigPool = rpcUdpXactPoolCreate(
     1009                NFS_PROGRAM,
     1010                NFS_VERSION_2,
     1011                CONFIG_NFS_BIG_XACT_SIZE,
     1012                bigPoolDepth);
     1013        assert( bigPool );
     1014
     1015        status = rtems_semaphore_create(
     1016                rtems_build_name('N','F','S','l'),
     1017                1,
     1018                MUTEX_ATTRIBUTES,
     1019                0,
     1020                &nfsGlob.llock);
     1021        assert( status == RTEMS_SUCCESSFUL );
     1022        status = rtems_semaphore_create(
     1023                rtems_build_name('N','F','S','m'),
     1024                1,
     1025                MUTEX_ATTRIBUTES,
     1026                0,
     1027                &nfsGlob.lock);
     1028        assert( status == RTEMS_SUCCESSFUL );
    10251029
    10261030        if (sizeof(ino_t) < sizeof(u_int)) {
    10271031                fprintf(stderr,
    1028                                 "WARNING: Using 'short st_ino' hits performance and may fail to access/find correct files\n");
     1032                        "WARNING: Using 'short st_ino' hits performance and may fail to access/find correct files\n");
    10291033                fprintf(stderr,
    1030                                 "you should fix newlib's sys/stat.h - for now I'll enable a hack...\n");
     1034                        "you should fix newlib's sys/stat.h - for now I'll enable a hack...\n");
    10311035
    10321036        }
     
    19821986        }
    19831987
    1984         assert( nfs = nfsCreate(nfsServer) );
     1988        nfs = nfsCreate(nfsServer);
     1989        assert( nfs );
    19851990        nfsServer = 0;
    19861991
     
    19911996         * and we also must obtain the root node attributes
    19921997         */
    1993         assert( rootNode = nfsNodeCreate(nfs, &fhstat.fhstatus_u.fhs_fhandle) );
     1998        rootNode = nfsNodeCreate(nfs, &fhstat.fhstatus_u.fhs_fhandle);
     1999        assert( rootNode );
    19942000
    19952001        if ( updateAttr(rootNode, 1 /* force */) ) {
     
    20402046enum clnt_stat          stat;
    20412047struct sockaddr_in      saddr;
    2042 char                            *path = mt_entry->dev;
    2043 int                                     nodesInUse;
    2044 u_long                          uid,gid;
     2048char                    *path = mt_entry->dev;
     2049int                     nodesInUse;
     2050u_long                  uid,gid;
     2051int                     status;
    20452052
    20462053LOCK(nfsGlob.llock);
     
    20552062        }
    20562063
    2057         assert( 0 == buildIpAddr(&uid, &gid, 0, &saddr, &path) );
     2064        status = buildIpAddr(&uid, &gid, 0, &saddr, &path);
     2065        assert( !status );
    20582066       
    20592067        stat = mntcall( &saddr,
  • cpukit/libfs/src/nfsclient/src/rpcio.c

    r6bdeeb31 r14d1db6  
    829829{
    830830int                                     refresh;
    831 XDR                                     reply_xdrs;
     831XDR                     reply_xdrs;
    832832struct rpc_msg          reply_msg;
     833rtems_status_code       status;
    833834rtems_event_set         gotEvents;
    834835
     
    838839
    839840        /* block for the reply */
    840         ASSERT( RTEMS_SUCCESSFUL ==
    841                         rtems_event_receive(
    842                                         RTEMS_RPC_EVENT,
    843                                         RTEMS_WAIT | RTEMS_EVENT_ANY,
    844                                         RTEMS_NO_TIMEOUT,
    845                                         &gotEvents) );
     841        status = rtems_event_receive(
     842                RTEMS_RPC_EVENT,
     843                RTEMS_WAIT | RTEMS_EVENT_ANY,
     844                RTEMS_NO_TIMEOUT,
     845                &gotEvents);
     846        ASSERT( status == RTEMS_SUCCESSFUL );
    846847
    847848        if (xact->status.re_status) {
     
    925926rpcUdpInit(void)
    926927{
    927 int                                     noblock = 1;
     928int                     s;
     929rtems_status_code       status;
     930int                     noblock = 1;
    928931struct sockwakeup       wkup;
    929932
     
    936939                if (ourSock>=0) {
    937940                        bindresvport(ourSock,(struct sockaddr_in*)0);
    938                         assert( 0==ioctl(ourSock, FIONBIO, (char*)&noblock) );
     941                        s = ioctl(ourSock, FIONBIO, (char*)&noblock);
     942                        assert( s == 0 );
    939943                        /* assume nobody tampers with the clock !! */
    940                         assert( RTEMS_SUCCESSFUL == rtems_clock_get(
    941                                                                                         RTEMS_CLOCK_GET_TICKS_PER_SECOND,
    942                                                                                         &ticksPerSec));
     944                        status = rtems_clock_get(RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticksPerSec);
     945                        assert( status == RTEMS_SUCCESSFUL );
    943946                        MU_CREAT( &hlock );
    944947                        MU_CREAT( &llock );
     
    950953                        }
    951954
    952                         assert( RTEMS_SUCCESSFUL == rtems_task_create(
     955                        status = rtems_task_create(
    953956                                                                                        rtems_build_name('R','P','C','d'),
    954957                                                                                        rpciodPriority,
     
    957960                                                                                        /* fprintf saves/restores FP registers on PPC :-( */
    958961                                                                                        RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT,
    959                                                                                         &rpciod) );
     962                                                                                        &rpciod);
     963                        assert( status = RTEMS_SUCCESSFUL );
     964
    960965                        wkup.sw_pfn = rxWakeupCB;
    961966                        wkup.sw_arg = (caddr_t)rpciod;
    962967                        assert( 0==setsockopt(ourSock, SOL_SOCKET, SO_RCVWAKEUP, &wkup, sizeof(wkup)) );
    963                         assert( RTEMS_SUCCESSFUL == rtems_message_queue_create(
     968                        status = rtems_message_queue_create(
    964969                                                                                        rtems_build_name('R','P','C','q'),
    965970                                                                                        RPCIOD_QDEPTH,
    966971                                                                                        sizeof(RpcUdpXact),
    967972                                                                                        RTEMS_DEFAULT_ATTRIBUTES,
    968                                                                                         &msgQ) );
    969                         assert( RTEMS_SUCCESSFUL == rtems_task_start(
    970                                                                                         rpciod,
    971                                                                                         rpcio_daemon,
    972                                                                                         0 ) );
     973                                                                                        &msgQ);
     974                        assert( status = RTEMS_SUCCESSFUL );
     975                        status = rtems_task_start( rpciod, rpcio_daemon, 0 );
     976                        assert( status = RTEMS_SUCCESSFUL );
    973977
    974978                } else {
     
    11411145RpcUdpServer      srv;
    11421146rtems_interval    next_retrans, then, unow;
    1143 long                      now;  /* need to do signed comparison with age! */
     1147long                                            now;    /* need to do signed comparison with age! */
    11441148rtems_event_set   events;
    11451149ListNode          newList;
     
    11481152ListNodeRec       listHead   = {0};
    11491153unsigned long     epoch      = RPCIOD_EPOCH_SECS * ticksPerSec;
    1150 unsigned long     max_period = RPCIOD_RETX_CAP_S * ticksPerSec;
    1151 
    1152         assert( RTEMS_SUCCESSFUL == rtems_clock_get(
    1153                                                                         RTEMS_CLOCK_GET_TICKS_SINCE_BOOT,
    1154                                                                         &then) );
     1154unsigned long                   max_period = RPCIOD_RETX_CAP_S * ticksPerSec;
     1155rtems_status_code       status;
     1156
     1157
     1158        status = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then );
     1159        assert( status == RTEMS_SUCCESSFUL );
    11551160
    11561161        for (next_retrans = epoch;;) {
     
    11951200                }
    11961201
    1197                 ASSERT( RTEMS_SUCCESSFUL == rtems_clock_get(
    1198                                                                                 RTEMS_CLOCK_GET_TICKS_SINCE_BOOT,
    1199                                                                                 &unow ) );
     1202                status = rtems_clock_get( RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &unow );
     1203                assert( status == RTEMS_SUCCESSFUL );
    12001204
    12011205                /* measure everything relative to then to protect against
     
    13451349                                                /* wakeup requestor */
    13461350                                                fprintf(stderr,"RPCIO: SEND failure\n");
    1347                                                 ASSERT( RTEMS_SUCCESSFUL ==
    1348                                                                         rtems_event_send(xact->requestor, RTEMS_RPC_EVENT) );
     1351                                                status = rtems_event_send(xact->requestor, RTEMS_RPC_EVENT);
     1352                                                assert( status == RTEMS_SUCCESSFUL );
    13491353
    13501354                                        } else {
     
    15121516{
    15131517RpcUdpXactPool  rval = MY_MALLOC(sizeof(*rval));
    1514 
    1515         ASSERT( rval &&
    1516                         RTEMS_SUCCESSFUL == rtems_message_queue_create(
    1517                                                                         rtems_build_name('R','P','C','p'),
    1518                                                                         poolsize,
    1519                                                                         sizeof(RpcUdpXact),
    1520                                                                         RTEMS_DEFAULT_ATTRIBUTES,
    1521                                                                         &rval->box) );
     1518rtems_status_code       status;
     1519
     1520        ASSERT( rval );
     1521        status = rtems_message_queue_create(
     1522                                        rtems_build_name('R','P','C','p'),
     1523                                        poolsize,
     1524                                        sizeof(RpcUdpXact),
     1525                                        RTEMS_DEFAULT_ATTRIBUTES,
     1526                                        &rval->box);
     1527        assert( status == RTEMS_SUCCESSFUL );
     1528
    15221529        rval->prog     = prog;
    15231530        rval->version  = version;
     
    15701577{
    15711578RpcUdpXactPool pool;
    1572         ASSERT( pool=xact->pool );
     1579
     1580        pool = xact->pool;
     1581        ASSERT( pool );
     1582
    15731583        if (RTEMS_SUCCESSFUL != rtems_message_queue_send(
    15741584                                                                pool->box,
Note: See TracChangeset for help on using the changeset viewer.