Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset e97b8c6 in mainline


Ignore:
Timestamp:
2011-08-10T18:08:40Z (10 years ago)
Author:
Oleg Romanenko <romanenko.oleg@…>
Branches:
lfn, master
Children:
e090244c
Parents:
ccfbf71
Message:

Update exfat_ops.c to support new VFS_OUT interface

File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/fs/exfat/exfat_ops.c

    rccfbf71 re97b8c6  
    6868
    6969/** List of cached free FAT nodes. */
    70 static LIST_INITIALIZE(ffn_head);
     70static LIST_INITIALIZE(ffn_list);
    7171
    7272/*
     
    9090static aoff64_t exfat_size_get(fs_node_t *);
    9191static unsigned exfat_lnkcnt_get(fs_node_t *);
    92 static char exfat_plb_get_char(unsigned);
    9392static bool exfat_is_directory(fs_node_t *);
    9493static bool exfat_is_file(fs_node_t *node);
     
    124123static int exfat_node_fini_by_devmap_handle(devmap_handle_t devmap_handle)
    125124{
    126         link_t *lnk;
    127125        exfat_node_t *nodep;
    128126        int rc;
     
    136134restart:
    137135        fibril_mutex_lock(&ffn_mutex);
    138         for (lnk = ffn_head.next; lnk != &ffn_head; lnk = lnk->next) {
     136        list_foreach(ffn_list, lnk) {
    139137                nodep = list_get_instance(lnk, exfat_node_t, ffn_link);
    140138                if (!fibril_mutex_trylock(&nodep->lock)) {
     
    173171                free(nodep);
    174172
    175                 /* Need to restart because we changed the ffn_head list. */
     173                /* Need to restart because we changed the ffn_list. */
    176174                goto restart;
    177175        }
     
    188186
    189187        fibril_mutex_lock(&ffn_mutex);
    190         if (!list_empty(&ffn_head)) {
     188        if (!list_empty(&ffn_list)) {
    191189                /* Try to use a cached free node structure. */
    192190                exfat_idx_t *idxp_tmp;
    193                 nodep = list_get_instance(ffn_head.next, exfat_node_t, ffn_link);
     191                nodep = list_get_instance(list_first(&ffn_list), exfat_node_t,
     192                    ffn_link);
    194193                if (!fibril_mutex_trylock(&nodep->lock))
    195194                        goto skip_cache;
     
    483482                if (nodep->idx) {
    484483                        fibril_mutex_lock(&ffn_mutex);
    485                         list_append(&nodep->ffn_link, &ffn_head);
     484                        list_append(&nodep->ffn_link, &ffn_list);
    486485                        fibril_mutex_unlock(&ffn_mutex);
    487486                } else {
     
    588587{
    589588        return EXFAT_NODE(fn)->lnkcnt;
    590 }
    591 
    592 char exfat_plb_get_char(unsigned pos)
    593 {
    594         return exfat_reg.plb_ro[pos % PLB_SIZE];
    595589}
    596590
     
    626620        .size_get = exfat_size_get,
    627621        .lnkcnt_get = exfat_lnkcnt_get,
    628         .plb_get_char = exfat_plb_get_char,
    629622        .is_directory = exfat_is_directory,
    630623        .is_file = exfat_is_file,
     
    634627
    635628/*
    636  * VFS operations.
     629 * VFS_OUT operations.
    637630 */
    638631
     
    664657}
    665658
    666 void exfat_mounted(ipc_callid_t rid, ipc_call_t *request)
    667 {
    668         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     659static int
     660exfat_mounted(devmap_handle_t devmap_handle, const char *opts, fs_index_t *index,
     661    aoff64_t *size, unsigned *linkcnt)
     662{
     663        int rc;
    669664        exfat_node_t *rootp=NULL, *bitmapp=NULL, *uctablep=NULL;
    670665        enum cache_mode cmode;
    671666        exfat_bs_t *bs;
    672 
    673         /* Accept the mount options */
    674         char *opts;
    675         int rc = async_data_write_accept((void **) &opts, true, 0, 0, 0, NULL);
    676 
    677         if (rc != EOK) {
    678                 async_answer_0(rid, rc);
    679                 return;
    680         }
    681667
    682668        /* Check for option enabling write through. */
     
    686672                cmode = CACHE_MODE_WB;
    687673
    688         free(opts);
    689 
    690674        /* initialize libblock */
    691         rc = block_init(devmap_handle, BS_SIZE);
    692         if (rc != EOK) {
    693                 async_answer_0(rid, rc);
    694                 return;
    695         }
     675        rc = block_init(EXCHANGE_SERIALIZE, devmap_handle, BS_SIZE);
     676        if (rc != EOK)
     677                return rc;
    696678
    697679        /* prepare the boot block */
     
    699681        if (rc != EOK) {
    700682                block_fini(devmap_handle);
    701                 async_answer_0(rid, rc);
    702                 return;
     683                return rc;
    703684        }
    704685
     
    710691        if (rc != EOK) {
    711692                block_fini(devmap_handle);
    712                 async_answer_0(rid, rc);
    713                 return;
     693                return rc;
    714694        }
    715695
     
    719699                (void) block_cache_fini(devmap_handle);
    720700                block_fini(devmap_handle);
    721                 async_answer_0(rid, rc);
    722                 return;
     701                return rc;
    723702        }
    724703
     
    727706                (void) block_cache_fini(devmap_handle);
    728707                block_fini(devmap_handle);
    729                 async_answer_0(rid, rc);
    730                 return;
     708                return rc;
    731709        }
    732710
     
    738716                block_fini(devmap_handle);
    739717                exfat_idx_fini_by_devmap_handle(devmap_handle);
    740                 async_answer_0(rid, ENOMEM);
    741                 return;
     718                return ENOMEM;
    742719        }
    743720        assert(rootp->idx->index == EXFAT_ROOT_IDX);
     
    756733                block_fini(devmap_handle);
    757734                exfat_idx_fini_by_devmap_handle(devmap_handle);
    758                 async_answer_0(rid, ENOTSUP);
    759                 return;
     735                return ENOTSUP;
    760736        }
    761737        rootp->size = BPS(bs) * SPC(bs) * clusters;
     
    771747                block_fini(devmap_handle);
    772748                exfat_idx_fini_by_devmap_handle(devmap_handle);
    773                 async_answer_0(rid, ENOTSUP);
    774                 return;
     749                return ENOTSUP;
    775750        }
    776751
     
    782757                block_fini(devmap_handle);
    783758                exfat_idx_fini_by_devmap_handle(devmap_handle);
    784                 async_answer_0(rid, ENOTSUP);
    785                 return;
     759                return ENOTSUP;
    786760        }
    787761
     
    793767                block_fini(devmap_handle);
    794768                exfat_idx_fini_by_devmap_handle(devmap_handle);
    795                 async_answer_0(rid, ENOMEM);
    796                 return;
     769                return ENOMEM;
    797770        }
    798771        assert(bitmapp->idx->index == EXFAT_BITMAP_IDX);
     
    815788                block_fini(devmap_handle);
    816789                exfat_idx_fini_by_devmap_handle(devmap_handle);
    817                 async_answer_0(rid, ENOTSUP);
    818                 return;
     790                return ENOTSUP;
    819791        }
    820792
     
    826798                block_fini(devmap_handle);
    827799                exfat_idx_fini_by_devmap_handle(devmap_handle);
    828                 async_answer_0(rid, ENOTSUP);
    829                 return;
     800                return ENOTSUP;
    830801        }
    831802
     
    838809                block_fini(devmap_handle);
    839810                exfat_idx_fini_by_devmap_handle(devmap_handle);
    840                 async_answer_0(rid, ENOMEM);
    841                 return;
     811                return ENOMEM;
    842812        }
    843813        assert(uctablep->idx->index == EXFAT_UCTABLE_IDX);
     
    860830                block_fini(devmap_handle);
    861831                exfat_idx_fini_by_devmap_handle(devmap_handle);
    862                 async_answer_0(rid, ENOMEM);
    863                 return;
     832                return ENOMEM;
    864833        }
    865834
     
    867836        printf("Root dir size: %lld\n", rootp->size);
    868837
    869         async_answer_3(rid, EOK, rootp->idx->index, rootp->size, rootp->lnkcnt);
    870 }
    871 
    872 void exfat_mount(ipc_callid_t rid, ipc_call_t *request)
    873 {
    874         libfs_mount(&exfat_libfs_ops, exfat_reg.fs_handle, rid, request);
    875 }
    876 
    877 void exfat_unmounted(ipc_callid_t rid, ipc_call_t *request)
    878 {
    879         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
     838        *index = rootp->idx->index;
     839        *size = rootp->size;
     840        *linkcnt = rootp->lnkcnt;
     841       
     842        return EOK;
     843}
     844
     845static int exfat_unmounted(devmap_handle_t devmap_handle)
     846{
    880847        fs_node_t *fn;
    881848        exfat_node_t *nodep;
     
    883850
    884851        rc = exfat_root_get(&fn, devmap_handle);
    885         if (rc != EOK) {
    886                 async_answer_0(rid, rc);
    887                 return;
    888         }
     852        if (rc != EOK)
     853                return rc;
    889854        nodep = EXFAT_NODE(fn);
    890855
     
    895860        if (nodep->refcnt != 2) {
    896861                (void) exfat_node_put(fn);
    897                 async_answer_0(rid, EBUSY);
    898                 return;
     862                return EBUSY;
    899863        }
    900864
     
    915879        block_fini(devmap_handle);
    916880
    917         async_answer_0(rid, EOK);
    918 }
    919 
    920 void exfat_unmount(ipc_callid_t rid, ipc_call_t *request)
    921 {
    922         libfs_unmount(&exfat_libfs_ops, rid, request);
     881        return EOK;
    923882}
    924883
     
    942901*/
    943902
    944 void exfat_lookup(ipc_callid_t rid, ipc_call_t *request)
    945 {
    946         libfs_lookup(&exfat_libfs_ops, exfat_reg.fs_handle, rid, request);
    947 }
    948 
    949 void exfat_read(ipc_callid_t rid, ipc_call_t *request)
    950 {
    951         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    952         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    953         aoff64_t pos =
    954             (aoff64_t) MERGE_LOUP32(IPC_GET_ARG3(*request), IPC_GET_ARG4(*request));
     903static int
     904exfat_read(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     905    size_t *rbytes)
     906{
    955907        fs_node_t *fn;
    956908        exfat_node_t *nodep;
     
    961913
    962914        rc = exfat_node_get(&fn, devmap_handle, index);
    963         if (rc != EOK) {
    964                 async_answer_0(rid, rc);
    965                 return;
    966         }
    967         if (!fn) {
    968                 async_answer_0(rid, ENOENT);
    969                 return;
    970         }
     915        if (rc != EOK)
     916                return rc;
     917        if (!fn)
     918                return ENOENT;
    971919        nodep = EXFAT_NODE(fn);
    972920
     
    976924                exfat_node_put(fn);
    977925                async_answer_0(callid, EINVAL);
    978                 async_answer_0(rid, EINVAL);
    979                 return;
     926                return EINVAL;
    980927        }
    981928
     
    1000947                                exfat_node_put(fn);
    1001948                                async_answer_0(callid, rc);
    1002                                 async_answer_0(rid, rc);
    1003                                 return;
     949                                return rc;
    1004950                        }
    1005951                        (void) async_data_read_finalize(callid,
     
    1008954                        if (rc != EOK) {
    1009955                                exfat_node_put(fn);
    1010                                 async_answer_0(rid, rc);
    1011                                 return;
     956                                return rc;
    1012957                        }
    1013958                }
     
    1015960                if (nodep->type != EXFAT_DIRECTORY) {
    1016961                        async_answer_0(callid, ENOTSUP);
    1017                         async_answer_0(rid, ENOTSUP);
    1018                         return;
     962                        return ENOTSUP;
    1019963                }
    1020964                       
     
    1043987                (void) exfat_node_put(fn);
    1044988                async_answer_0(callid, rc);
    1045                 async_answer_0(rid, rc);
    1046                 return;
     989                return rc;
    1047990
    1048991miss:
     
    1052995                rc = exfat_node_put(fn);
    1053996                async_answer_0(callid, rc != EOK ? rc : ENOENT);
    1054                 async_answer_1(rid, rc != EOK ? rc : ENOENT, 0);
    1055                 return;
     997                *rbytes = 0;
     998                return rc != EOK ? rc : ENOENT;
    1056999
    10571000hit:
     
    10651008
    10661009        rc = exfat_node_put(fn);
    1067         async_answer_1(rid, rc, (sysarg_t)bytes);
    1068 }
    1069 
    1070 void exfat_close(ipc_callid_t rid, ipc_call_t *request)
    1071 {
    1072         async_answer_0(rid, EOK);
    1073 }
    1074 
    1075 void exfat_open_node(ipc_callid_t rid, ipc_call_t *request)
    1076 {
    1077         libfs_open_node(&exfat_libfs_ops, exfat_reg.fs_handle, rid, request);
    1078 }
    1079 
    1080 void exfat_stat(ipc_callid_t rid, ipc_call_t *request)
    1081 {
    1082         libfs_stat(&exfat_libfs_ops, exfat_reg.fs_handle, rid, request);
    1083 }
    1084 
    1085 void exfat_sync(ipc_callid_t rid, ipc_call_t *request)
    1086 {
    1087         devmap_handle_t devmap_handle = (devmap_handle_t) IPC_GET_ARG1(*request);
    1088         fs_index_t index = (fs_index_t) IPC_GET_ARG2(*request);
    1089 
     1010        *rbytes = bytes;
     1011        return rc;
     1012}
     1013
     1014static int exfat_close(devmap_handle_t devmap_handle, fs_index_t index)
     1015{
     1016        return EOK;
     1017}
     1018
     1019static int exfat_sync(devmap_handle_t devmap_handle, fs_index_t index)
     1020{
    10901021        fs_node_t *fn;
    10911022        int rc = exfat_node_get(&fn, devmap_handle, index);
    1092         if (rc != EOK) {
    1093                 async_answer_0(rid, rc);
    1094                 return;
    1095         }
    1096         if (!fn) {
    1097                 async_answer_0(rid, ENOENT);
    1098                 return;
    1099         }
     1023        if (rc != EOK)
     1024                return rc;
     1025        if (!fn)
     1026                return ENOENT;
    11001027
    11011028        exfat_node_t *nodep = EXFAT_NODE(fn);
     
    11051032
    11061033        exfat_node_put(fn);
    1107         async_answer_0(rid, rc);
    1108 }
     1034        return rc;
     1035}
     1036
     1037static int
     1038exfat_write(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t pos,
     1039    size_t *wbytes, aoff64_t *nsize)
     1040{
     1041        /* TODO */
     1042        return EOK;
     1043}
     1044
     1045static int
     1046exfat_truncate(devmap_handle_t devmap_handle, fs_index_t index, aoff64_t size)
     1047{
     1048        /* TODO */
     1049        return EOK;
     1050}
     1051static int exfat_destroy(devmap_handle_t devmap_handle, fs_index_t index)
     1052{
     1053        /* TODO */
     1054        return EOK;
     1055}
     1056
     1057vfs_out_ops_t exfat_ops = {
     1058        .mounted = exfat_mounted,
     1059        .unmounted = exfat_unmounted,
     1060        .read = exfat_read,
     1061        .write = exfat_write,
     1062        .truncate = exfat_truncate,
     1063        .close = exfat_close,
     1064        .destroy = exfat_destroy,
     1065        .sync = exfat_sync,
     1066};
     1067
    11091068
    11101069/**
Note: See TracChangeset for help on using the changeset viewer.