Changeset 7858bc5f in mainline for uspace/srv/fs/fat/fat_ops.c


Ignore:
Timestamp:
2008-10-28T15:40:19Z (17 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
916bf1a
Parents:
5cf723b
Message:

Setup communication parameters with the block device in block_init(). The file
system now doesn't know anything about the communication with the block device.
Rename blockread() to block_read(). The boot block is now read only once. The file
system can get access it using the block_bb_get() function.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r5cf723b r7858bc5f  
    7676static void fat_node_sync(fat_node_t *node)
    7777{
    78         block_t *bb, *b;
     78        block_t *b;
     79        fat_bs_t *bs;
    7980        fat_dentry_t *d;
    8081        uint16_t bps;
    … …  
    8384        assert(node->dirty);
    8485
    85         bb = block_get(node->idx->dev_handle, BS_BLOCK, BS_SIZE);
    86         bps = uint16_t_le2host(FAT_BS(bb)->bps);
     86        bs = block_bb_get(node->idx->dev_handle);
     87        bps = uint16_t_le2host(bs->bps);
    8788        dps = bps / sizeof(fat_dentry_t);
    8889       
    8990        /* Read the block that contains the dentry of interest. */
    90         b = _fat_block_get(bb->data, node->idx->dev_handle, node->idx->pfc,
     91        b = _fat_block_get(bs, node->idx->dev_handle, node->idx->pfc,
    9192            (node->idx->pdi * sizeof(fat_dentry_t)) / bps);
    9293
    … …  
    100101        b->dirty = true;                /* need to sync block */
    101102        block_put(b);
    102         block_put(bb);
    103103}
    104104
    … …  
    109109static void *fat_node_get_core(fat_idx_t *idxp)
    110110{
    111         block_t *bb, *b;
     111        block_t *b;
     112        fat_bs_t *bs;
    112113        fat_dentry_t *d;
    113114        fat_node_t *nodep = NULL;
    … …  
    162163        fat_node_initialize(nodep);
    163164
    164         bb = block_get(idxp->dev_handle, BS_BLOCK, BS_SIZE);
    165         bps = uint16_t_le2host(FAT_BS(bb)->bps);
     165        bs = block_bb_get(idxp->dev_handle);
     166        bps = uint16_t_le2host(bs->bps);
    166167        dps = bps / sizeof(fat_dentry_t);
    167168
    168169        /* Read the block that contains the dentry of interest. */
    169         b = _fat_block_get(bb->data, idxp->dev_handle, idxp->pfc,
     170        b = _fat_block_get(bs, idxp->dev_handle, idxp->pfc,
    170171            (idxp->pdi * sizeof(fat_dentry_t)) / bps);
    171172        assert(b);
    … …  
    184185                 * size of the directory by walking the FAT.
    185186                 */
    186                 nodep->size = bps * _fat_blcks_get(bb->data, idxp->dev_handle,
     187                nodep->size = bps * _fat_blcks_get(bs, idxp->dev_handle,
    187188                    uint16_t_le2host(d->firstc), NULL);
    188189        } else {
    … …  
    195196
    196197        block_put(b);
    197         block_put(bb);
    198198
    199199        /* Link the idx structure with the node structure. */
    … …  
    254254static void *fat_match(void *prnt, const char *component)
    255255{
     256        fat_bs_t *bs;
    256257        fat_node_t *parentp = (fat_node_t *)prnt;
    257258        char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1];
    … …  
    261262        unsigned blocks;
    262263        fat_dentry_t *d;
    263         block_t *bb, *b;
     264        block_t *b;
    264265
    265266        futex_down(&parentp->idx->lock);
    266         bb = block_get(parentp->idx->dev_handle, BS_BLOCK, BS_SIZE);
    267         bps = uint16_t_le2host(FAT_BS(bb)->bps);
     267        bs = block_bb_get(parentp->idx->dev_handle);
     268        bps = uint16_t_le2host(bs->bps);
    268269        dps = bps / sizeof(fat_dentry_t);
    269270        blocks = parentp->size / bps;
    270271        for (i = 0; i < blocks; i++) {
    271                 b = fat_block_get(bb->data, parentp, i);
     272                b = fat_block_get(bs, parentp, i);
    272273                for (j = 0; j < dps; j++) {
    273274                        d = ((fat_dentry_t *)b->data) + j;
    … …  
    277278                        case FAT_DENTRY_LAST:
    278279                                block_put(b);
    279                                 block_put(bb);
    280280                                futex_up(&parentp->idx->lock);
    281281                                return NULL;
    … …  
    304304                                         */
    305305                                        block_put(b);
    306                                         block_put(bb);
    307306                                        return NULL;
    308307                                }
    … …  
    310309                                futex_up(&idx->lock);
    311310                                block_put(b);
    312                                 block_put(bb);
    313311                                return node;
    314312                        }
    … …  
    316314                block_put(b);
    317315        }
    318         block_put(bb);
    319316
    320317        futex_up(&parentp->idx->lock);
    … …  
    342339static bool fat_has_children(void *node)
    343340{
     341        fat_bs_t *bs;
    344342        fat_node_t *nodep = (fat_node_t *)node;
    345343        unsigned bps;
    346344        unsigned dps;
    347345        unsigned blocks;
    348         block_t *bb, *b;
     346        block_t *b;
    349347        unsigned i, j;
    350348
    … …  
    353351       
    354352        futex_down(&nodep->idx->lock);
    355         bb = block_get(nodep->idx->dev_handle, BS_BLOCK, BS_SIZE);
    356         bps = uint16_t_le2host(FAT_BS(bb)->bps);
     353        bs = block_bb_get(nodep->idx->dev_handle);
     354        bps = uint16_t_le2host(bs->bps);
    357355        dps = bps / sizeof(fat_dentry_t);
    358356
    … …  
    362360                fat_dentry_t *d;
    363361       
    364                 b = fat_block_get(bb->data, nodep, i);
     362                b = fat_block_get(bs, nodep, i);
    365363                for (j = 0; j < dps; j++) {
    366364                        d = ((fat_dentry_t *)b->data) + j;
    … …  
    370368                        case FAT_DENTRY_LAST:
    371369                                block_put(b);
    372                                 block_put(bb);
    373370                                futex_up(&nodep->idx->lock);
    374371                                return false;
    … …  
    376373                        case FAT_DENTRY_VALID:
    377374                                block_put(b);
    378                                 block_put(bb);
    379375                                futex_up(&nodep->idx->lock);
    380376                                return true;
    381377                        }
    382378                        block_put(b);
    383                         block_put(bb);
    384379                        futex_up(&nodep->idx->lock);
    385380                        return true;
    … …  
    387382                block_put(b);
    388383        }
    389         block_put(bb);
    390384
    391385        futex_up(&nodep->idx->lock);
    … …  
    435429{
    436430        dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request);
    437         block_t *bb;
     431        fat_bs_t *bs;
    438432        uint16_t bps;
    439433        uint16_t rde;
    440434        int rc;
    441435
    442         /*
    443          * For now, we don't bother to remember dev_handle, dev_phone or
    444          * dev_buffer in some data structure. We use global variables because we
    445          * know there will be at most one mount on this file system.
    446          * Of course, this is a huge TODO item.
    447          */
    448         dev_buffer = mmap(NULL, BS_SIZE, PROTO_READ | PROTO_WRITE,
    449             MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
    450        
    451         if (!dev_buffer) {
    452                 ipc_answer_0(rid, ENOMEM);
    453                 return;
    454         }
    455 
    456         dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
    457             DEVMAP_CONNECT_TO_DEVICE, dev_handle);
    458 
    459         if (dev_phone < 0) {
    460                 munmap(dev_buffer, BS_SIZE);
    461                 ipc_answer_0(rid, dev_phone);
    462                 return;
    463         }
    464 
    465         rc = ipc_share_out_start(dev_phone, dev_buffer,
    466             AS_AREA_READ | AS_AREA_WRITE);
     436        /* initialize libblock */
     437        rc = block_init(dev_handle, BS_SIZE, BS_BLOCK * BS_SIZE, BS_SIZE);
    467438        if (rc != EOK) {
    468                 munmap(dev_buffer, BS_SIZE);
    469                 ipc_answer_0(rid, rc);
    470                 return;
    471         }
    472 
     439                ipc_answer_0(rid, 0);
     440                return;
     441        }
     442
     443        /* get the buffer with the boot sector */
     444        bs = block_bb_get(dev_handle);
     445       
    473446        /* Read the number of root directory entries. */
    474         bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    475         bps = uint16_t_le2host(FAT_BS(bb)->bps);
    476         rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max);
    477         block_put(bb);
     447        bps = uint16_t_le2host(bs->bps);
     448        rde = uint16_t_le2host(bs->root_ent_max);
    478449
    479450        if (bps != BS_SIZE) {
    480                 munmap(dev_buffer, BS_SIZE);
     451                block_fini(dev_handle);
    481452                ipc_answer_0(rid, ENOTSUP);
    482453                return;
    … …  
    485456        rc = fat_idx_init_by_dev_handle(dev_handle);
    486457        if (rc != EOK) {
    487                 munmap(dev_buffer, BS_SIZE);
     458                block_fini(dev_handle);
    488459                ipc_answer_0(rid, rc);
    489460                return;
    … …  
    493464        fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t));
    494465        if (!rootp) {
    495                 munmap(dev_buffer, BS_SIZE);
     466                block_fini(dev_handle);
    496467                fat_idx_fini_by_dev_handle(dev_handle);
    497468                ipc_answer_0(rid, ENOMEM);
    … …  
    502473        fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0);
    503474        if (!ridxp) {
    504                 munmap(dev_buffer, BS_SIZE);
     475                block_fini(dev_handle);
    505476                free(rootp);
    506477                fat_idx_fini_by_dev_handle(dev_handle);
    … …  
    540511        off_t pos = (off_t)IPC_GET_ARG3(*request);
    541512        fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
     513        fat_bs_t *bs;
    542514        uint16_t bps;
    543515        size_t bytes;
    544         block_t *bb, *b;
     516        block_t *b;
    545517
    546518        if (!nodep) {
    … …  
    558530        }
    559531
    560         bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    561         bps = uint16_t_le2host(FAT_BS(bb)->bps);
     532        bs = block_bb_get(dev_handle);
     533        bps = uint16_t_le2host(bs->bps);
    562534
    563535        if (nodep->type == FAT_FILE) {
    … …  
    568540                 */
    569541                bytes = min(len, bps - pos % bps);
    570                 b = fat_block_get(bb->data, nodep, pos / bps);
     542                b = fat_block_get(bs, nodep, pos / bps);
    571543                (void) ipc_data_read_finalize(callid, b->data + pos % bps,
    572544                    bytes);
    … …  
    592564                        off_t o;
    593565
    594                         b = fat_block_get(bb->data, nodep, bnum);
     566                        b = fat_block_get(bs, nodep, bnum);
    595567                        for (o = pos % (bps / sizeof(fat_dentry_t));
    596568                            o < bps / sizeof(fat_dentry_t);
    … …  
    615587miss:
    616588                fat_node_put(nodep);
    617                 block_put(bb);
    618589                ipc_answer_0(callid, ENOENT);
    619590                ipc_answer_1(rid, ENOENT, 0);
    … …  
    625596
    626597        fat_node_put(nodep);
    627         block_put(bb);
    628598        ipc_answer_1(rid, EOK, (ipcarg_t)bytes);
    629599}
    … …  
    635605        off_t pos = (off_t)IPC_GET_ARG3(*request);
    636606        fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index);
     607        fat_bs_t *bs;
    637608        size_t bytes;
    638         block_t *b, *bb;
     609        block_t *b;
    639610        uint16_t bps;
    640611        unsigned spc;
    … …  
    671642        bytes = min(len, bps - pos % bps);
    672643
    673         bb = block_get(dev_handle, BS_BLOCK, BS_SIZE);
    674         bps = uint16_t_le2host(FAT_BS(bb)->bps);
    675         spc = FAT_BS(bb)->spc;
     644        bs = block_bb_get(dev_handle);
     645        bps = uint16_t_le2host(bs->bps);
     646        spc = bs->spc;
    676647       
    677648        boundary = ROUND_UP(nodep->size, bps * spc);
    … …  
    683654                 * next block size boundary.
    684655                 */
    685                 fat_fill_gap(bb->data, nodep, FAT_CLST_RES0, pos);
    686                 b = fat_block_get(bb->data, nodep, pos / bps);
     656                fat_fill_gap(bs, nodep, FAT_CLST_RES0, pos);
     657                b = fat_block_get(bs, nodep, pos / bps);
    687658                (void) ipc_data_write_finalize(callid, b->data + pos % bps,
    688659                    bytes);
    … …  
    694665                }
    695666                fat_node_put(nodep);
    696                 block_put(bb);
    697667                ipc_answer_1(rid, EOK, bytes); 
    698668                return;
    … …  
    709679                    bps * spc;
    710680                /* create an independent chain of nclsts clusters in all FATs */
    711                 status = fat_alloc_clusters(bb->data, dev_handle, nclsts, &mcl,
     681                status = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl,
    712682                    &lcl);
    713683                if (status != EOK) {
    714684                        /* could not allocate a chain of nclsts clusters */
    715685                        fat_node_put(nodep);
    716                         block_put(bb);
    717686                        ipc_answer_0(callid, status);
    718687                        ipc_answer_0(rid, status);
    … …  
    720689                }
    721690                /* zero fill any gaps */
    722                 fat_fill_gap(bb->data, nodep, mcl, pos);
    723                 b = _fat_block_get(bb->data, dev_handle, lcl,
     691                fat_fill_gap(bs, nodep, mcl, pos);
     692                b = _fat_block_get(bs, dev_handle, lcl,
    724693                    (pos / bps) % spc);
    725694                (void) ipc_data_write_finalize(callid, b->data + pos % bps,
    … …  
    731700                 * node's cluster chain.
    732701                 */
    733                 fat_append_clusters(bb->data, nodep, mcl);
     702                fat_append_clusters(bs, nodep, mcl);
    734703                nodep->size = pos + bytes;
    735704                nodep->dirty = true;            /* need to sync node */
    736705                fat_node_put(nodep);
    737                 block_put(bb);
    738706                ipc_answer_1(rid, EOK, bytes);
    739707                return;
Note: See TracChangeset for help on using the changeset viewer.