Changeset 8b655705 in mainline for uspace/srv/fs/fat/fat_ops.c


Ignore:
Timestamp:
2011-04-15T19:38:07Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9dd730d1
Parents:
6b9e85b (diff), b2fb47f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/fs/fat/fat_ops.c

    r6b9e85b r8b655705  
    4242#include <libfs.h>
    4343#include <libblock.h>
    44 #include <ipc/ipc.h>
    4544#include <ipc/services.h>
    4645#include <ipc/devmap.h>
    … …  
    326325                    uint16_t_le2host(d->firstc));
    327326                if (rc != EOK) {
     327                        (void) block_put(b);
    328328                        (void) fat_node_put(FS_NODE(nodep));
    329329                        return rc;
    … …  
    722722                    (str_cmp((char *) d->name, FAT_NAME_DOT)) == 0) {
    723723                        memset(d, 0, sizeof(fat_dentry_t));
    724                         str_cpy((char *) d->name, 8, FAT_NAME_DOT);
    725                         str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
     724                        memcpy(d->name, FAT_NAME_DOT, FAT_NAME_LEN);
     725                        memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
    726726                        d->attr = FAT_ATTR_SUBDIR;
    727727                        d->firstc = host2uint16_t_le(childp->firstc);
    … …  
    732732                    (str_cmp((char *) d->name, FAT_NAME_DOT_DOT) == 0)) {
    733733                        memset(d, 0, sizeof(fat_dentry_t));
    734                         str_cpy((char *) d->name, 8, FAT_NAME_DOT_DOT);
    735                         str_cpy((char *) d->ext, 3, FAT_EXT_PAD);
     734                        memcpy(d->name, FAT_NAME_DOT_DOT, FAT_NAME_LEN);
     735                        memcpy(d->ext, FAT_EXT_PAD, FAT_EXT_LEN);
    736736                        d->attr = FAT_ATTR_SUBDIR;
    737737                        d->firstc = (parentp->firstc == FAT_CLST_ROOT) ?
    … …  
    812812        fibril_mutex_unlock(&childp->idx->lock);
    813813        childp->lnkcnt = 0;
     814        childp->refcnt++;       /* keep the node in memory until destroyed */
    814815        childp->dirty = true;
    815816        fibril_mutex_unlock(&childp->lock);
    … …  
    955956       
    956957        if (rc != EOK) {
    957                 ipc_answer_0(rid, rc);
     958                async_answer_0(rid, rc);
    958959                return;
    959960        }
    … …  
    970971        rc = block_init(devmap_handle, BS_SIZE);
    971972        if (rc != EOK) {
    972                 ipc_answer_0(rid, rc);
     973                async_answer_0(rid, rc);
    973974                return;
    974975        }
    … …  
    978979        if (rc != EOK) {
    979980                block_fini(devmap_handle);
    980                 ipc_answer_0(rid, rc);
     981                async_answer_0(rid, rc);
    981982                return;
    982983        }
    … …  
    987988        if (BPS(bs) != BS_SIZE) {
    988989                block_fini(devmap_handle);
    989                 ipc_answer_0(rid, ENOTSUP);
     990                async_answer_0(rid, ENOTSUP);
    990991                return;
    991992        }
    … …  
    995996        if (rc != EOK) {
    996997                block_fini(devmap_handle);
    997                 ipc_answer_0(rid, rc);
     998                async_answer_0(rid, rc);
    998999                return;
    9991000        }
    … …  
    10041005                (void) block_cache_fini(devmap_handle);
    10051006                block_fini(devmap_handle);
    1006                 ipc_answer_0(rid, rc);
     1007                async_answer_0(rid, rc);
    10071008                return;
    10081009        }
    … …  
    10121013                (void) block_cache_fini(devmap_handle);
    10131014                block_fini(devmap_handle);
    1014                 ipc_answer_0(rid, rc);
     1015                async_answer_0(rid, rc);
    10151016                return;
    10161017        }
    … …  
    10221023                block_fini(devmap_handle);
    10231024                fat_idx_fini_by_devmap_handle(devmap_handle);
    1024                 ipc_answer_0(rid, ENOMEM);
     1025                async_answer_0(rid, ENOMEM);
    10251026                return;
    10261027        }
    … …  
    10321033                block_fini(devmap_handle);
    10331034                fat_idx_fini_by_devmap_handle(devmap_handle);
    1034                 ipc_answer_0(rid, ENOMEM);
     1035                async_answer_0(rid, ENOMEM);
    10351036                return;
    10361037        }
    … …  
    10441045                block_fini(devmap_handle);
    10451046                fat_idx_fini_by_devmap_handle(devmap_handle);
    1046                 ipc_answer_0(rid, ENOMEM);
     1047                async_answer_0(rid, ENOMEM);
    10471048                return;
    10481049        }
    … …  
    10621063        fibril_mutex_unlock(&ridxp->lock);
    10631064
    1064         ipc_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
     1065        async_answer_3(rid, EOK, ridxp->index, rootp->size, rootp->lnkcnt);
    10651066}
    10661067
    … …  
    10791080        rc = fat_root_get(&fn, devmap_handle);
    10801081        if (rc != EOK) {
    1081                 ipc_answer_0(rid, rc);
     1082                async_answer_0(rid, rc);
    10821083                return;
    10831084        }
    … …  
    10901091        if (nodep->refcnt != 2) {
    10911092                (void) fat_node_put(fn);
    1092                 ipc_answer_0(rid, EBUSY);
     1093                async_answer_0(rid, EBUSY);
    10931094                return;
    10941095        }
    … …  
    11101111        block_fini(devmap_handle);
    11111112
    1112         ipc_answer_0(rid, EOK);
     1113        async_answer_0(rid, EOK);
    11131114}
    11141115
    … …  
    11381139        rc = fat_node_get(&fn, devmap_handle, index);
    11391140        if (rc != EOK) {
    1140                 ipc_answer_0(rid, rc);
     1141                async_answer_0(rid, rc);
    11411142                return;
    11421143        }
    11431144        if (!fn) {
    1144                 ipc_answer_0(rid, ENOENT);
     1145                async_answer_0(rid, ENOENT);
    11451146                return;
    11461147        }
    … …  
    11511152        if (!async_data_read_receive(&callid, &len)) {
    11521153                fat_node_put(fn);
    1153                 ipc_answer_0(callid, EINVAL);
    1154                 ipc_answer_0(rid, EINVAL);
     1154                async_answer_0(callid, EINVAL);
     1155                async_answer_0(rid, EINVAL);
    11551156                return;
    11561157        }
    … …  
    11751176                        if (rc != EOK) {
    11761177                                fat_node_put(fn);
    1177                                 ipc_answer_0(callid, rc);
    1178                                 ipc_answer_0(rid, rc);
     1178                                async_answer_0(callid, rc);
     1179                                async_answer_0(rid, rc);
    11791180                                return;
    11801181                        }
    … …  
    11841185                        if (rc != EOK) {
    11851186                                fat_node_put(fn);
    1186                                 ipc_answer_0(rid, rc);
     1187                                async_answer_0(rid, rc);
    11871188                                return;
    11881189                        }
    … …  
    12411242miss:
    12421243                rc = fat_node_put(fn);
    1243                 ipc_answer_0(callid, rc != EOK ? rc : ENOENT);
    1244                 ipc_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
     1244                async_answer_0(callid, rc != EOK ? rc : ENOENT);
     1245                async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
    12451246                return;
    12461247
    12471248err:
    12481249                (void) fat_node_put(fn);
    1249                 ipc_answer_0(callid, rc);
    1250                 ipc_answer_0(rid, rc);
     1250                async_answer_0(callid, rc);
     1251                async_answer_0(rid, rc);
    12511252                return;
    12521253
    … …  
    12571258
    12581259        rc = fat_node_put(fn);
    1259         ipc_answer_1(rid, rc, (sysarg_t)bytes);
     1260        async_answer_1(rid, rc, (sysarg_t)bytes);
    12601261}
    12611262
    … …  
    12771278        rc = fat_node_get(&fn, devmap_handle, index);
    12781279        if (rc != EOK) {
    1279                 ipc_answer_0(rid, rc);
     1280                async_answer_0(rid, rc);
    12801281                return;
    12811282        }
    12821283        if (!fn) {
    1283                 ipc_answer_0(rid, ENOENT);
     1284                async_answer_0(rid, ENOENT);
    12841285                return;
    12851286        }
    … …  
    12901291        if (!async_data_write_receive(&callid, &len)) {
    12911292                (void) fat_node_put(fn);
    1292                 ipc_answer_0(callid, EINVAL);
    1293                 ipc_answer_0(rid, EINVAL);
     1293                async_answer_0(callid, EINVAL);
     1294                async_answer_0(rid, EINVAL);
    12941295                return;
    12951296        }
    … …  
    13191320                if (rc != EOK) {
    13201321                        (void) fat_node_put(fn);
    1321                         ipc_answer_0(callid, rc);
    1322                         ipc_answer_0(rid, rc);
     1322                        async_answer_0(callid, rc);
     1323                        async_answer_0(rid, rc);
    13231324                        return;
    13241325                }
    … …  
    13261327                if (rc != EOK) {
    13271328                        (void) fat_node_put(fn);
    1328                         ipc_answer_0(callid, rc);
    1329                         ipc_answer_0(rid, rc);
     1329                        async_answer_0(callid, rc);
     1330                        async_answer_0(rid, rc);
    13301331                        return;
    13311332                }
    … …  
    13361337                if (rc != EOK) {
    13371338                        (void) fat_node_put(fn);
    1338                         ipc_answer_0(rid, rc);
     1339                        async_answer_0(rid, rc);
    13391340                        return;
    13401341                }
    … …  
    13451346                size = nodep->size;
    13461347                rc = fat_node_put(fn);
    1347                 ipc_answer_2(rid, rc, bytes, nodep->size);
     1348                async_answer_2(rid, rc, bytes, nodep->size);
    13481349                return;
    13491350        } else {
    … …  
    13611362                        /* could not allocate a chain of nclsts clusters */
    13621363                        (void) fat_node_put(fn);
    1363                         ipc_answer_0(callid, rc);
    1364                         ipc_answer_0(rid, rc);
     1364                        async_answer_0(callid, rc);
     1365                        async_answer_0(rid, rc);
    13651366                        return;
    13661367                }
    … …  
    13701371                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13711372                        (void) fat_node_put(fn);
    1372                         ipc_answer_0(callid, rc);
    1373                         ipc_answer_0(rid, rc);
     1373                        async_answer_0(callid, rc);
     1374                        async_answer_0(rid, rc);
    13741375                        return;
    13751376                }
    … …  
    13791380                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13801381                        (void) fat_node_put(fn);
    1381                         ipc_answer_0(callid, rc);
    1382                         ipc_answer_0(rid, rc);
     1382                        async_answer_0(callid, rc);
     1383                        async_answer_0(rid, rc);
    13831384                        return;
    13841385                }
    … …  
    13901391                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    13911392                        (void) fat_node_put(fn);
    1392                         ipc_answer_0(rid, rc);
     1393                        async_answer_0(rid, rc);
    13931394                        return;
    13941395                }
    … …  
    14011402                        (void) fat_free_clusters(bs, devmap_handle, mcl);
    14021403                        (void) fat_node_put(fn);
    1403                         ipc_answer_0(rid, rc);
     1404                        async_answer_0(rid, rc);
    14041405                        return;
    14051406                }
    … …  
    14071408                nodep->dirty = true;            /* need to sync node */
    14081409                rc = fat_node_put(fn);
    1409                 ipc_answer_2(rid, rc, bytes, size);
     1410                async_answer_2(rid, rc, bytes, size);
    14101411                return;
    14111412        }
    … …  
    14251426        rc = fat_node_get(&fn, devmap_handle, index);
    14261427        if (rc != EOK) {
    1427                 ipc_answer_0(rid, rc);
     1428                async_answer_0(rid, rc);
    14281429                return;
    14291430        }
    14301431        if (!fn) {
    1431                 ipc_answer_0(rid, ENOENT);
     1432                async_answer_0(rid, ENOENT);
    14321433                return;
    14331434        }
    … …  
    14751476out:
    14761477        fat_node_put(fn);
    1477         ipc_answer_0(rid, rc);
     1478        async_answer_0(rid, rc);
    14781479        return;
    14791480}
    … …  
    14811482void fat_close(ipc_callid_t rid, ipc_call_t *request)
    14821483{
    1483         ipc_answer_0(rid, EOK);
     1484        async_answer_0(rid, EOK);
    14841485}
    14851486
    … …  
    14891490        fs_index_t index = (fs_index_t)IPC_GET_ARG2(*request);
    14901491        fs_node_t *fn;
     1492        fat_node_t *nodep;
    14911493        int rc;
    14921494
    14931495        rc = fat_node_get(&fn, devmap_handle, index);
    14941496        if (rc != EOK) {
    1495                 ipc_answer_0(rid, rc);
     1497                async_answer_0(rid, rc);
    14961498                return;
    14971499        }
    14981500        if (!fn) {
    1499                 ipc_answer_0(rid, ENOENT);
    1500                 return;
    1501         }
     1501                async_answer_0(rid, ENOENT);
     1502                return;
     1503        }
     1504
     1505        nodep = FAT_NODE(fn);
     1506        /*
     1507         * We should have exactly two references. One for the above
     1508         * call to fat_node_get() and one from fat_unlink().
     1509         */
     1510        assert(nodep->refcnt == 2);
    15021511
    15031512        rc = fat_destroy_node(fn);
    1504         ipc_answer_0(rid, rc);
     1513        async_answer_0(rid, rc);
    15051514}
    15061515
    … …  
    15231532        int rc = fat_node_get(&fn, devmap_handle, index);
    15241533        if (rc != EOK) {
    1525                 ipc_answer_0(rid, rc);
     1534                async_answer_0(rid, rc);
    15261535                return;
    15271536        }
    15281537        if (!fn) {
    1529                 ipc_answer_0(rid, ENOENT);
     1538                async_answer_0(rid, ENOENT);
    15301539                return;
    15311540        }
    … …  
    15371546       
    15381547        fat_node_put(fn);
    1539         ipc_answer_0(rid, rc);
     1548        async_answer_0(rid, rc);
    15401549}
    15411550
Note: See TracChangeset for help on using the changeset viewer.