Changeset c69ef3b in rtems


Ignore:
Timestamp:
Oct 2, 2012, 9:30:33 AM (7 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
4.11, master
Children:
5633c54c
Parents:
3becac2
git-author:
Sebastian Huber <sebastian.huber@…> (10/02/12 09:30:33)
git-committer:
Sebastian Huber <sebastian.huber@…> (10/02/12 13:27:35)
Message:

nfsclient: Add and use nfsEvaluateStatus()

The NFS status codes do not map directly to the corresponding errno
values.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • cpukit/libfs/src/nfsclient/src/nfs.c

    r3becac2 rc69ef3b  
    704704 *****************************************/
    705705
     706static int nfsEvaluateStatus(nfsstat nfsStatus)
     707{
     708        static const uint8_t nfsStatusToErrno [71] = {
     709                [NFS_OK] = 0,
     710                [NFSERR_PERM] = EPERM,
     711                [NFSERR_NOENT] = ENOENT,
     712                [3] = EIO,
     713                [4] = EIO,
     714                [NFSERR_IO] = EIO,
     715                [NFSERR_NXIO] = ENXIO,
     716                [7] = EIO,
     717                [8] = EIO,
     718                [9] = EIO,
     719                [10] = EIO,
     720                [11] = EIO,
     721                [12] = EIO,
     722                [NFSERR_ACCES] = EACCES,
     723                [14] = EIO,
     724                [15] = EIO,
     725                [16] = EIO,
     726                [NFSERR_EXIST] = EEXIST,
     727                [18] = EIO,
     728                [NFSERR_NODEV] = ENODEV,
     729                [NFSERR_NOTDIR] = ENOTDIR,
     730                [NFSERR_ISDIR] = EISDIR,
     731                [22] = EIO,
     732                [24] = EIO,
     733                [25] = EIO,
     734                [26] = EIO,
     735                [27] = EIO,
     736                [NFSERR_FBIG] = EFBIG,
     737                [NFSERR_NOSPC] = ENOSPC,
     738                [29] = EIO,
     739                [NFSERR_ROFS] = EROFS,
     740                [31] = EIO,
     741                [32] = EIO,
     742                [34] = EIO,
     743                [35] = EIO,
     744                [36] = EIO,
     745                [37] = EIO,
     746                [38] = EIO,
     747                [39] = EIO,
     748                [40] = EIO,
     749                [41] = EIO,
     750                [42] = EIO,
     751                [44] = EIO,
     752                [45] = EIO,
     753                [46] = EIO,
     754                [47] = EIO,
     755                [48] = EIO,
     756                [49] = EIO,
     757                [50] = EIO,
     758                [51] = EIO,
     759                [52] = EIO,
     760                [54] = EIO,
     761                [55] = EIO,
     762                [56] = EIO,
     763                [57] = EIO,
     764                [58] = EIO,
     765                [59] = EIO,
     766                [60] = EIO,
     767                [61] = EIO,
     768                [62] = EIO,
     769                [NFSERR_NAMETOOLONG] = ENAMETOOLONG,
     770                [64] = EIO,
     771                [65] = EIO,
     772                [NFSERR_NOTEMPTY] = ENOTEMPTY,
     773                [67] = EIO,
     774                [68] = EIO,
     775                [NFSERR_DQUOT] = EDQUOT,
     776                [NFSERR_STALE] = ESTALE
     777        };
     778
     779        size_t idx = (size_t) nfsStatus;
     780        int eno = EIO;
     781        int rv = 0;
     782
     783        if (idx < sizeof(nfsStatusToErrno) / sizeof(nfsStatusToErrno [0])) {
     784                eno = nfsStatusToErrno [idx];
     785        }
     786
     787        if (eno != 0) {
     788                errno = eno;
     789                rv = -1;
     790        }
     791
     792        return rv;
     793}
     794
    706795/* Create a Nfs object. This is
    707796 * per-mounted NFS information.
     
    11271216updateAttr(NfsNode node, int force)
    11281217{
     1218        int rv = 0;
    11291219
    11301220        if (force
     
    11321222                || (nowSeconds() - node->age > CONFIG_ATTR_LIFETIME)
    11331223#endif
    1134                 ) {
    1135                 if ( nfscall(node->nfs->server,
    1136                                           NFSPROC_GETATTR,
    1137                                           (xdrproc_t)xdr_nfs_fh,        &SERP_FILE(node),
    1138                                           (xdrproc_t)xdr_attrstat, &node->serporid) )
    1139                 return -1;
    1140 
    1141                 if ( NFS_OK != node->serporid.status ) {
    1142                         errno = node->serporid.status;
    1143                         return -1;
     1224        ) {
     1225                rv = nfscall(
     1226                        node->nfs->server,
     1227                        NFSPROC_GETATTR,
     1228                        (xdrproc_t) xdr_nfs_fh, &SERP_FILE(node),
     1229                        (xdrproc_t) xdr_attrstat, &node->serporid
     1230                );
     1231
     1232                if (rv == 0) {
     1233                        rv = nfsEvaluateStatus(node->serporid.status);
     1234
     1235                        if (rv == 0) {
     1236                                node->age = nowSeconds();
     1237                        }
    11441238                }
    1145 
    1146                 node->age = nowSeconds();
    1147         }
    1148 
    1149         return 0;
     1239        }
     1240
     1241        return rv;
    11501242}
    11511243
     
    15291621        SERP_ARGS(tNode).linkarg.to.name = dupname;
    15301622
    1531         if ( nfscall(tNode->nfs->server,
    1532                                           NFSPROC_LINK,
    1533                                           (xdrproc_t)xdr_linkargs,      &SERP_FILE(tNode),
    1534                                           (xdrproc_t)xdr_nfsstat,       &status)
    1535              || (NFS_OK != (errno = status))
    1536            ) {
     1623        rv = nfscall(
     1624                tNode->nfs->server,
     1625                NFSPROC_LINK,
     1626                (xdrproc_t)xdr_linkargs, &SERP_FILE(tNode),
     1627                (xdrproc_t)xdr_nfsstat, &status
     1628        );
     1629
     1630        if (rv == 0) {
     1631                rv = nfsEvaluateStatus(status);
    15371632#if DEBUG & DEBUG_SYSCALLS
    1538                 perror("nfs_link");
    1539 #endif
    1540                 rv = -1;
     1633                if (rv != 0) {
     1634                        perror("nfs_link");
     1635                }
     1636#endif
    15411637        }
    15421638
     
    15531649)
    15541650{
     1651int rv = 0;
    15551652nfsstat                 status;
    15561653NfsNode                 node  = loc->node_access;
     
    15721669#endif
    15731670
    1574         if ( nfscall(nfs->server,
    1575                                  proc,
    1576                                  (xdrproc_t)xdr_diropargs,      &node->args,
    1577                                  (xdrproc_t)xdr_nfsstat,        &status)
    1578              || (NFS_OK != (errno = status))
    1579             ) {
     1671        rv = nfscall(
     1672                nfs->server,
     1673                proc,
     1674                (xdrproc_t)xdr_diropargs, &node->args,
     1675                (xdrproc_t)xdr_nfsstat, &status
     1676        );
     1677
     1678        if (rv == 0) {
     1679                rv = nfsEvaluateStatus(status);
    15801680#if DEBUG & DEBUG_SYSCALLS
    1581                 perror(name);
    1582 #endif
    1583                 return -1;
    1584         }
    1585 
    1586         return 0;
     1681                if (rv != 0) {
     1682                        perror(name);
     1683                }
     1684#endif
     1685        }
     1686
     1687        return rv;
    15871688}
    15881689
     
    19272028        SERP_ARGS(node).createarg.attributes.mtime.useconds     = now.tv_usec;
    19282029
    1929         if ( nfscall( nfs->server,
    1930                                                 (type == S_IFDIR) ? NFSPROC_MKDIR : NFSPROC_CREATE,
    1931                                                 (xdrproc_t)xdr_createargs,      &SERP_FILE(node),
    1932                                                 (xdrproc_t)xdr_diropres,        &res)
    1933                 || (NFS_OK != (errno = res.status)) ) {
     2030        rv = nfscall(
     2031                nfs->server,
     2032                (type == S_IFDIR) ? NFSPROC_MKDIR : NFSPROC_CREATE,
     2033                (xdrproc_t)xdr_createargs, &SERP_FILE(node),
     2034                (xdrproc_t)xdr_diropres, &res
     2035        );
     2036
     2037        if (rv == 0) {
     2038                rv = nfsEvaluateStatus(res.status);
    19342039#if DEBUG & DEBUG_SYSCALLS
    1935                 perror("nfs_mknod");
    1936 #endif
    1937                 rv = -1;
     2040                if (rv != 0) {
     2041                        perror("nfs_mknod");
     2042                }
     2043#endif
    19382044        }
    19392045
     
    20182124        SERP_ARGS(node).symlinkarg.attributes.mtime.useconds = now.tv_usec;
    20192125
    2020         if ( nfscall( nfs->server,
    2021                                                 NFSPROC_SYMLINK,
    2022                                                 (xdrproc_t)xdr_symlinkargs,     &SERP_FILE(node),
    2023                                                 (xdrproc_t)xdr_nfsstat,         &status)
    2024                 || (NFS_OK != (errno = status)) ) {
     2126        rv = nfscall(
     2127                nfs->server,
     2128                NFSPROC_SYMLINK,
     2129                (xdrproc_t)xdr_symlinkargs, &SERP_FILE(node),
     2130                (xdrproc_t)xdr_nfsstat, &status
     2131        );
     2132
     2133        if (rv == 0) {
     2134                rv = nfsEvaluateStatus(status);
    20252135#if DEBUG & DEBUG_SYSCALLS
    20262136                perror("nfs_symlink");
    20272137#endif
    2028                 rv = -1;
    20292138        }
    20302139
     
    20402149)
    20412150{
     2151        ssize_t rv;
    20422152        Nfs nfs = node->nfs;
    20432153        readlinkres_strbuf rr;
     
    20462156        rr.strbuf.max = len - 1;
    20472157
    2048         if ( nfscall(nfs->server,
    2049                                                         NFSPROC_READLINK,
    2050                                                         (xdrproc_t)xdr_nfs_fh,                  &SERP_FILE(node),
    2051                                                         (xdrproc_t)xdr_readlinkres_strbuf, &rr)
    2052                 || (NFS_OK != (errno = rr.status)) ) {
     2158        rv = nfscall(
     2159                nfs->server,
     2160                NFSPROC_READLINK,
     2161                (xdrproc_t)xdr_nfs_fh, &SERP_FILE(node),
     2162                (xdrproc_t)xdr_readlinkres_strbuf, &rr
     2163        );
     2164
     2165        if (rv == 0) {
     2166                rv = nfsEvaluateStatus(rr.status);
     2167
     2168                if (rv == 0) {
     2169                        rv = (ssize_t) strlen(rr.strbuf.buf);
     2170                } else {
    20532171#if DEBUG & DEBUG_SYSCALLS
    2054                 perror("nfs_readlink_with_node");
    2055 #endif
    2056                 return -1;
    2057         }
    2058 
    2059         return (ssize_t) strlen(rr.strbuf.buf);
     2172                        perror("nfs_readlink_with_node");
     2173#endif
     2174                }
     2175        }
     2176
     2177        return rv;
    20602178}
    20612179
     
    21032221                        &status
    21042222                );
    2105                 if (rv == 0 && (errno = status) != NFS_OK) {
    2106                         rv = -1;
     2223
     2224                if (rv == 0) {
     2225                        rv = nfsEvaluateStatus(status);
    21072226                }
    21082227
     
    22782397)
    22792398{
     2399ssize_t rv;
    22802400readres rr;
    22812401Nfs             nfs  = node->nfs;
     
    22872407        rr.readres_u.reply.data.data_val        = buffer;
    22882408
    2289         if ( nfscall(   nfs->server,
    2290                                                 NFSPROC_READ,
    2291                                                 (xdrproc_t)xdr_readargs,        &SERP_FILE(node),
    2292                                                 (xdrproc_t)xdr_readres, &rr) ) {
    2293                 return -1;
    2294         }
    2295 
    2296 
    2297         if (NFS_OK != rr.status) {
    2298                 rtems_set_errno_and_return_minus_one(rr.status);
    2299         }
     2409        rv = nfscall(
     2410                nfs->server,
     2411                NFSPROC_READ,
     2412                (xdrproc_t)xdr_readargs, &SERP_FILE(node),
     2413                (xdrproc_t)xdr_readres, &rr
     2414        );
     2415
     2416        if (rv == 0) {
     2417                rv = nfsEvaluateStatus(rr.status);
     2418
     2419                if (rv == 0) {
     2420                        rv = rr.readres_u.reply.data.data_len;
    23002421
    23012422#if DEBUG & DEBUG_SYSCALLS
    2302         fprintf(stderr,
    2303                         "Read %i (asked for %i) bytes from offset %i to 0x%08x\n",
    2304                         rr.readres_u.reply.data.data_len,
    2305                         count,
    2306                         iop->offset,
    2307                         rr.readres_u.reply.data.data_val);
    2308 #endif
    2309 
    2310 
    2311         return rr.readres_u.reply.data.data_len;
     2423                        fprintf(stderr,
     2424                                "Read %i (asked for %i) bytes from offset %i to 0x%08x\n",
     2425                                rr.readres_u.reply.data.data_len,
     2426                                count,
     2427                                iop->offset,
     2428                                rr.readres_u.reply.data.data_val);
     2429#endif
     2430                }
     2431        }
     2432
     2433        return rv;
    23122434}
    23132435
     
    23542476)
    23552477{
     2478ssize_t rv;
    23562479DirInfo                 di     = iop->pathinfo.node_access_2;
    23572480RpcUdpServer    server = ((Nfs)iop->pathinfo.mt_entry->fs_info)->server;
     
    23892512#endif
    23902513
    2391         if ( nfscall(
    2392                                         server,
    2393                                         NFSPROC_READDIR,
    2394                                         (xdrproc_t)xdr_readdirargs, &di->readdirargs,
    2395                                         (xdrproc_t)xdr_dir_info,    di) ) {
    2396                 return -1;
    2397         }
    2398 
    2399 
    2400         if (NFS_OK != di->status) {
    2401                 rtems_set_errno_and_return_minus_one(di->status);
    2402         }
    2403 
    2404         return (char*)di->ptr - (char*)buffer;
     2514        rv = nfscall(
     2515                server,
     2516                NFSPROC_READDIR,
     2517                (xdrproc_t)xdr_readdirargs, &di->readdirargs,
     2518                (xdrproc_t)xdr_dir_info, di
     2519        );
     2520
     2521        if (rv == 0) {
     2522                rv = nfsEvaluateStatus(di->status);
     2523
     2524                if (rv == 0) {
     2525                        rv = (char*)di->ptr - (char*)buffer;
     2526                }
     2527        }
     2528
     2529        return rv;
    24052530}
    24062531
     
    24112536)
    24122537{
     2538ssize_t rv;
    24132539NfsNode         node = iop->pathinfo.node_access;
    24142540Nfs                     nfs  = node->nfs;
    2415 int                     e;
    24162541
    24172542        if (count > NFS_MAXDATA)
     
    24362561         */
    24372562
    2438         if ( nfscall(   nfs->server,
    2439                                                 NFSPROC_WRITE,
    2440                                                 (xdrproc_t)xdr_writeargs,       &SERP_FILE(node),
    2441                                                 (xdrproc_t)xdr_attrstat,        &node->serporid) ) {
    2442                 return -1;
    2443         }
    2444 
    2445 
    2446         if (NFS_OK != (e=node->serporid.status) ) {
    2447                 /* try at least to recover the current attributes */
    2448                 updateAttr(node, 1 /* force */);
    2449                 rtems_set_errno_and_return_minus_one(e);
    2450         }
    2451 
    2452         node->age = nowSeconds();
    2453 
    2454         iop->offset += count;
    2455 
    2456         return count;
     2563        rv = nfscall(
     2564                nfs->server,
     2565                NFSPROC_WRITE,
     2566                (xdrproc_t)xdr_writeargs, &SERP_FILE(node),
     2567                (xdrproc_t)xdr_attrstat, &node->serporid
     2568        );
     2569
     2570        if (rv == 0) {
     2571                rv = nfsEvaluateStatus(node->serporid.status);
     2572
     2573                if (rv == 0) {
     2574                        node->age = nowSeconds();
     2575
     2576                        iop->offset += count;
     2577                        rv = count;
     2578                } else {
     2579                        /* try at least to recover the current attributes */
     2580                        updateAttr(node, 1 /* force */);
     2581                }
     2582        }
     2583
     2584        return rv;
    24572585}
    24582586
     
    25912719nfs_sattr(NfsNode node, sattr *arg, u_long mask)
    25922720{
    2593 
     2721int rv;
    25942722struct timeval                          now;
    25952723nfstime                                 nfsnow, t;
    2596 int                                             e;
    25972724u_int                                   mode;
    25982725
     
    26432770        node->serporid.status = NFS_OK;
    26442771
    2645         if ( nfscall( node->nfs->server,
    2646                                                 NFSPROC_SETATTR,
    2647                                                 (xdrproc_t)xdr_sattrargs,       &SERP_FILE(node),
    2648                                                 (xdrproc_t)xdr_attrstat,        &node->serporid) ) {
     2772        rv = nfscall(
     2773                node->nfs->server,
     2774                NFSPROC_SETATTR,
     2775                (xdrproc_t)xdr_sattrargs, &SERP_FILE(node),
     2776                (xdrproc_t)xdr_attrstat, &node->serporid
     2777        );
     2778
     2779        if (rv == 0) {
     2780                rv = nfsEvaluateStatus(node->serporid.status);
     2781
     2782                if (rv == 0) {
     2783                        node->age = nowSeconds();
     2784                } else {
     2785#if DEBUG & DEBUG_SYSCALLS
     2786                        fprintf(stderr,"nfs_sattr: %s\n",strerror(errno));
     2787#endif
     2788                        /* try at least to recover the current attributes */
     2789                        updateAttr(node, 1 /* force */);
     2790                }
     2791        } else {
    26492792#if DEBUG & DEBUG_SYSCALLS
    26502793                fprintf(stderr,
     
    26532796                                strerror(errno));
    26542797#endif
    2655                 return -1;
    2656         }
    2657 
    2658         if (NFS_OK != (e=node->serporid.status) ) {
    2659 #if DEBUG & DEBUG_SYSCALLS
    2660                 fprintf(stderr,"nfs_sattr: %s\n",strerror(e));
    2661 #endif
    2662                 /* try at least to recover the current attributes */
    2663                 updateAttr(node, 1 /* force */);
    2664                 rtems_set_errno_and_return_minus_one(e);
    2665         }
    2666 
    2667         node->age = nowSeconds();
    2668 
    2669         return 0;
     2798        }
     2799
     2800        return rv;
    26702801}
    26712802
Note: See TracChangeset for help on using the changeset viewer.