Changeset 7858bc5f in mainline


Ignore:
Timestamp:
2008-10-28T15:40:19Z (16 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.

Location:
uspace
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/libblock/libblock.c

    r5cf723b r7858bc5f  
    3939#include "../../srv/vfs/vfs.h"
    4040#include "../../srv/rd/rd.h"
     41#include <ipc/devmap.h>
     42#include <ipc/services.h>
    4143#include <errno.h>
     44#include <sys/mman.h>
    4245#include <async.h>
    4346#include <ipc/ipc.h>
     
    4548#include <assert.h>
    4649
     50static int dev_phone = -1;              /* FIXME */
     51static void *dev_buffer = NULL;         /* FIXME */
     52static size_t dev_buffer_len = 0;       /* FIXME */
     53static void *bblock = NULL;             /* FIXME */
     54
     55int
     56block_init(dev_handle_t dev_handle, size_t com_size, off_t bb_off,
     57    size_t bb_size)
     58{
     59        int rc;
     60
     61        bblock = malloc(bb_size);
     62        if (!bblock)
     63                return ENOMEM;
     64        dev_buffer_len = com_size;
     65        dev_buffer = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE,
     66            MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
     67        if (!dev_buffer) {
     68                free(bblock);
     69                return ENOMEM;
     70        }
     71        dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
     72            DEVMAP_CONNECT_TO_DEVICE, dev_handle);
     73
     74        if (dev_phone < 0) {
     75                free(bblock);
     76                munmap(dev_buffer, com_size);
     77                return dev_phone;
     78        }
     79
     80        rc = ipc_share_out_start(dev_phone, dev_buffer,
     81            AS_AREA_READ | AS_AREA_WRITE);
     82        if (rc != EOK) {
     83                ipc_hangup(dev_phone);
     84                free(bblock);
     85                munmap(dev_buffer, com_size);
     86                return rc;
     87        }
     88        off_t bufpos = 0;
     89        size_t buflen = 0;
     90        if (!block_read(dev_handle, &bufpos, &buflen, &bb_off,
     91            bblock, bb_size, bb_size)) {
     92                ipc_hangup(dev_phone);
     93                free(bblock);
     94                munmap(dev_buffer, com_size);
     95                return EIO;     /* XXX real error code */
     96        }
     97        return EOK;
     98}
     99
     100void block_fini(dev_handle_t dev_handle)
     101{
     102        /* XXX */
     103        free(bblock);
     104        munmap(dev_buffer, dev_buffer_len);
     105        ipc_hangup(dev_phone);
     106}
     107
     108void *block_bb_get(dev_handle_t dev_handle)
     109{
     110        /* XXX */
     111        return bblock;
     112}
     113
    47114/** Read data from a block device.
    48115 *
    49  * @param phone         Phone to be used to communicate with the device.
    50  * @param buffer        Communication buffer shared with the device.
     116 * @param dev_handle    Device handle of the block device.
    51117 * @param bufpos        Pointer to the first unread valid offset within the
    52118 *                      communication buffer.
     
    60126 * @return              True on success, false on failure.
    61127 */
    62 bool blockread(int phone, void *buffer, off_t *bufpos, size_t *buflen,
    63     off_t *pos, void *dst, size_t size, size_t block_size)
     128bool
     129block_read(int dev_handle, off_t *bufpos, size_t *buflen, off_t *pos, void *dst,
     130    size_t size, size_t block_size)
    64131{
    65132        off_t offset = 0;
     
    79146                         * destination buffer.
    80147                         */
    81                         memcpy(dst + offset, buffer + *bufpos, rd);
     148                        memcpy(dst + offset, dev_buffer + *bufpos, rd);
    82149                        offset += rd;
    83150                        *bufpos += rd;
     
    89156                        /* Refill the communication buffer with a new block. */
    90157                        ipcarg_t retval;
    91                         int rc = async_req_2_1(phone, RD_READ_BLOCK,
     158                        int rc = async_req_2_1(dev_phone, RD_READ_BLOCK,
    92159                            *pos / block_size, block_size, &retval);
    93160                        if ((rc != EOK) || (retval != EOK))
     
    101168        return true;
    102169}
    103 
    104 int dev_phone = -1;             /* FIXME */
    105 void *dev_buffer = NULL;        /* FIXME */
    106170
    107171block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs)
     
    127191        b->size = bs;
    128192
    129         if (!blockread(dev_phone, dev_buffer, &bufpos, &buflen, &pos, b->data,
     193        if (!block_read(dev_handle, &bufpos, &buflen, &pos, b->data,
    130194            bs, bs)) {
    131195                free(b->data);
  • uspace/lib/libblock/libblock.h

    r5cf723b r7858bc5f  
    6868} block_t;
    6969
    70 extern int dev_phone;           /* FIXME */
    71 extern void *dev_buffer;        /* FIXME */
     70extern int block_init(dev_handle_t, size_t, off_t, size_t);
     71extern void block_fini(dev_handle_t);
     72extern void *block_bb_get(dev_handle_t);
    7273
    7374extern block_t *block_get(dev_handle_t, off_t, size_t);
    7475extern void block_put(block_t *);
    7576
    76 extern bool blockread(int, void *, off_t *, size_t *, off_t *, void *, size_t,
    77     size_t);
     77extern bool block_read(int, off_t *, size_t *, off_t *, void *, size_t, size_t);
    7878
    7979#endif
  • uspace/lib/libc/include/errno.h

    r5cf723b r7858bc5f  
    4747#define ERANGE          (-263)
    4848#define EXDEV           (-264)
     49#define EIO             (-265)
    4950
    5051#endif
  • uspace/srv/fs/fat/Makefile

    r5cf723b r7858bc5f  
    3939
    4040LIBS = \
    41         $(LIBC_PREFIX)/libc.a \
    4241        $(LIBFS_PREFIX)/libfs.a \
    43         $(LIBBLOCK_PREFIX)/libblock.a
     42        $(LIBBLOCK_PREFIX)/libblock.a \
     43        $(LIBC_PREFIX)/libc.a
    4444
    4545## Sources
  • uspace/srv/fs/fat/fat.h

    r5cf723b r7858bc5f  
    122122} __attribute__ ((packed)) fat_bs_t;
    123123
    124 #define FAT_BS(b)               ((fat_bs_t *)((b)->data))
    125 
    126124typedef enum {
    127125        FAT_INVALID,
  • 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;
  • uspace/srv/fs/tmpfs/Makefile

    r5cf723b r7858bc5f  
    3939
    4040LIBS = \
    41         $(LIBC_PREFIX)/libc.a \
    4241        $(LIBFS_PREFIX)/libfs.a \
    43         $(LIBBLOCK_PREFIX)/libblock.a
     42        $(LIBBLOCK_PREFIX)/libblock.a \
     43        $(LIBC_PREFIX)/libc.a
    4444
    4545## Sources
  • uspace/srv/fs/tmpfs/tmpfs_dump.c

    r5cf723b r7858bc5f  
    3939#include "tmpfs.h"
    4040#include "../../vfs/vfs.h"
    41 #include <ipc/ipc.h>
    42 #include <async.h>
    4341#include <errno.h>
    4442#include <stdlib.h>
     
    4745#include <as.h>
    4846#include <libblock.h>
    49 #include <ipc/services.h>
    50 #include <ipc/devmap.h>
    51 #include <sys/mman.h>
    5247#include <byteorder.h>
    5348
     
    6055
    6156static bool
    62 tmpfs_restore_recursion(int phone, void *block, off_t *bufpos, size_t *buflen,
    63     off_t *pos, tmpfs_dentry_t *parent)
     57tmpfs_restore_recursion(int dev, off_t *bufpos, size_t *buflen, off_t *pos,
     58    tmpfs_dentry_t *parent)
    6459{
    6560        struct rdentry entry;
     
    7166                uint32_t size;
    7267               
    73                 if (!blockread(phone, block, bufpos, buflen, pos, &entry,
    74                     sizeof(entry), TMPFS_BLOCK_SIZE))
     68                if (!block_read(dev, bufpos, buflen, pos, &entry, sizeof(entry),
     69                    TMPFS_BLOCK_SIZE))
    7570                        return false;
    7671               
     
    9186                        }
    9287                       
    93                         if (!blockread(phone, block, bufpos, buflen, pos, fname,
     88                        if (!block_read(dev, bufpos, buflen, pos, fname,
    9489                            entry.len, TMPFS_BLOCK_SIZE)) {
    9590                                ops->destroy((void *) node);
     
    106101                        free(fname);
    107102                       
    108                         if (!blockread(phone, block, bufpos, buflen, pos, &size,
     103                        if (!block_read(dev, bufpos, buflen, pos, &size,
    109104                            sizeof(size), TMPFS_BLOCK_SIZE))
    110105                                return false;
     
    117112                       
    118113                        node->size = size;
    119                         if (!blockread(phone, block, bufpos, buflen, pos,
    120                             node->data, size, TMPFS_BLOCK_SIZE))
     114                        if (!block_read(dev, bufpos, buflen, pos, node->data,
     115                            size, TMPFS_BLOCK_SIZE))
    121116                                return false;
    122117                       
     
    133128                        }
    134129                       
    135                         if (!blockread(phone, block, bufpos, buflen, pos, fname,
    136                             entry.len, TMPFS_BLOCK_SIZE)) {
     130                        if (!block_read(dev, bufpos, buflen, pos,
     131                            fname, entry.len, TMPFS_BLOCK_SIZE)) {
    137132                                ops->destroy((void *) node);
    138133                                free(fname);
     
    148143                        free(fname);
    149144                       
    150                         if (!tmpfs_restore_recursion(phone, block, bufpos,
    151                             buflen, pos, node))
     145                        if (!tmpfs_restore_recursion(dev, bufpos, buflen, pos,
     146                            node))
    152147                                return false;
    153148                       
     
    164159{
    165160        libfs_ops_t *ops = &tmpfs_libfs_ops;
     161        int rc;
    166162
    167         void *block = mmap(NULL, TMPFS_BLOCK_SIZE,
    168             PROTO_READ | PROTO_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);
    169        
    170         if (block == NULL)
    171                 return false;
    172        
    173         int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
    174             DEVMAP_CONNECT_TO_DEVICE, dev);
    175 
    176         if (phone < 0) {
    177                 munmap(block, TMPFS_BLOCK_SIZE);
    178                 return false;
    179         }
    180        
    181         if (ipc_share_out_start(phone, block, AS_AREA_READ | AS_AREA_WRITE) !=
    182             EOK)
    183                 goto error;
     163        rc = block_init(dev, TMPFS_BLOCK_SIZE, 0, 0);
     164        if (rc != EOK)
     165                return false;
    184166       
    185167        off_t bufpos = 0;
     
    188170       
    189171        char tag[6];
    190         if (!blockread(phone, block, &bufpos, &buflen, &pos, tag, 5,
     172        if (!block_read(dev, &bufpos, &buflen, &pos, tag, 5,
    191173            TMPFS_BLOCK_SIZE))
    192174                goto error;
     
    196178                goto error;
    197179       
    198         if (!tmpfs_restore_recursion(phone, block, &bufpos, &buflen, &pos,
     180        if (!tmpfs_restore_recursion(dev, &bufpos, &buflen, &pos,
    199181            ops->root_get(dev)))
    200182                goto error;
    201183               
    202         ipc_hangup(phone);
    203         munmap(block, TMPFS_BLOCK_SIZE);
     184        block_fini(dev);
    204185        return true;
    205186       
    206187error:
    207         ipc_hangup(phone);
    208         munmap(block, TMPFS_BLOCK_SIZE);
     188        block_fini(dev);
    209189        return false;
    210190}
Note: See TracChangeset for help on using the changeset viewer.