Index: uspace/lib/libblock/libblock.c =================================================================== --- uspace/lib/libblock/libblock.c (revision 5cf723b0f447edb54b15926eb1388300785f7859) +++ uspace/lib/libblock/libblock.c (revision 7858bc5ff895eb1e87b5c19c5e2ca2a23717133a) @@ -39,5 +39,8 @@ #include "../../srv/vfs/vfs.h" #include "../../srv/rd/rd.h" +#include +#include #include +#include #include #include @@ -45,8 +48,71 @@ #include +static int dev_phone = -1; /* FIXME */ +static void *dev_buffer = NULL; /* FIXME */ +static size_t dev_buffer_len = 0; /* FIXME */ +static void *bblock = NULL; /* FIXME */ + +int +block_init(dev_handle_t dev_handle, size_t com_size, off_t bb_off, + size_t bb_size) +{ + int rc; + + bblock = malloc(bb_size); + if (!bblock) + return ENOMEM; + dev_buffer_len = com_size; + dev_buffer = mmap(NULL, com_size, PROTO_READ | PROTO_WRITE, + MAP_ANONYMOUS | MAP_PRIVATE, 0, 0); + if (!dev_buffer) { + free(bblock); + return ENOMEM; + } + dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, + DEVMAP_CONNECT_TO_DEVICE, dev_handle); + + if (dev_phone < 0) { + free(bblock); + munmap(dev_buffer, com_size); + return dev_phone; + } + + rc = ipc_share_out_start(dev_phone, dev_buffer, + AS_AREA_READ | AS_AREA_WRITE); + if (rc != EOK) { + ipc_hangup(dev_phone); + free(bblock); + munmap(dev_buffer, com_size); + return rc; + } + off_t bufpos = 0; + size_t buflen = 0; + if (!block_read(dev_handle, &bufpos, &buflen, &bb_off, + bblock, bb_size, bb_size)) { + ipc_hangup(dev_phone); + free(bblock); + munmap(dev_buffer, com_size); + return EIO; /* XXX real error code */ + } + return EOK; +} + +void block_fini(dev_handle_t dev_handle) +{ + /* XXX */ + free(bblock); + munmap(dev_buffer, dev_buffer_len); + ipc_hangup(dev_phone); +} + +void *block_bb_get(dev_handle_t dev_handle) +{ + /* XXX */ + return bblock; +} + /** Read data from a block device. * - * @param phone Phone to be used to communicate with the device. - * @param buffer Communication buffer shared with the device. + * @param dev_handle Device handle of the block device. * @param bufpos Pointer to the first unread valid offset within the * communication buffer. @@ -60,6 +126,7 @@ * @return True on success, false on failure. */ -bool blockread(int phone, void *buffer, off_t *bufpos, size_t *buflen, - off_t *pos, void *dst, size_t size, size_t block_size) +bool +block_read(int dev_handle, off_t *bufpos, size_t *buflen, off_t *pos, void *dst, + size_t size, size_t block_size) { off_t offset = 0; @@ -79,5 +146,5 @@ * destination buffer. */ - memcpy(dst + offset, buffer + *bufpos, rd); + memcpy(dst + offset, dev_buffer + *bufpos, rd); offset += rd; *bufpos += rd; @@ -89,5 +156,5 @@ /* Refill the communication buffer with a new block. */ ipcarg_t retval; - int rc = async_req_2_1(phone, RD_READ_BLOCK, + int rc = async_req_2_1(dev_phone, RD_READ_BLOCK, *pos / block_size, block_size, &retval); if ((rc != EOK) || (retval != EOK)) @@ -101,7 +168,4 @@ return true; } - -int dev_phone = -1; /* FIXME */ -void *dev_buffer = NULL; /* FIXME */ block_t *block_get(dev_handle_t dev_handle, off_t offset, size_t bs) @@ -127,5 +191,5 @@ b->size = bs; - if (!blockread(dev_phone, dev_buffer, &bufpos, &buflen, &pos, b->data, + if (!block_read(dev_handle, &bufpos, &buflen, &pos, b->data, bs, bs)) { free(b->data); Index: uspace/lib/libblock/libblock.h =================================================================== --- uspace/lib/libblock/libblock.h (revision 5cf723b0f447edb54b15926eb1388300785f7859) +++ uspace/lib/libblock/libblock.h (revision 7858bc5ff895eb1e87b5c19c5e2ca2a23717133a) @@ -68,12 +68,12 @@ } block_t; -extern int dev_phone; /* FIXME */ -extern void *dev_buffer; /* FIXME */ +extern int block_init(dev_handle_t, size_t, off_t, size_t); +extern void block_fini(dev_handle_t); +extern void *block_bb_get(dev_handle_t); extern block_t *block_get(dev_handle_t, off_t, size_t); extern void block_put(block_t *); -extern bool blockread(int, void *, off_t *, size_t *, off_t *, void *, size_t, - size_t); +extern bool block_read(int, off_t *, size_t *, off_t *, void *, size_t, size_t); #endif Index: uspace/lib/libc/include/errno.h =================================================================== --- uspace/lib/libc/include/errno.h (revision 5cf723b0f447edb54b15926eb1388300785f7859) +++ uspace/lib/libc/include/errno.h (revision 7858bc5ff895eb1e87b5c19c5e2ca2a23717133a) @@ -47,4 +47,5 @@ #define ERANGE (-263) #define EXDEV (-264) +#define EIO (-265) #endif Index: uspace/srv/fs/fat/Makefile =================================================================== --- uspace/srv/fs/fat/Makefile (revision 5cf723b0f447edb54b15926eb1388300785f7859) +++ uspace/srv/fs/fat/Makefile (revision 7858bc5ff895eb1e87b5c19c5e2ca2a23717133a) @@ -39,7 +39,7 @@ LIBS = \ - $(LIBC_PREFIX)/libc.a \ $(LIBFS_PREFIX)/libfs.a \ - $(LIBBLOCK_PREFIX)/libblock.a + $(LIBBLOCK_PREFIX)/libblock.a \ + $(LIBC_PREFIX)/libc.a ## Sources Index: uspace/srv/fs/fat/fat.h =================================================================== --- uspace/srv/fs/fat/fat.h (revision 5cf723b0f447edb54b15926eb1388300785f7859) +++ uspace/srv/fs/fat/fat.h (revision 7858bc5ff895eb1e87b5c19c5e2ca2a23717133a) @@ -122,6 +122,4 @@ } __attribute__ ((packed)) fat_bs_t; -#define FAT_BS(b) ((fat_bs_t *)((b)->data)) - typedef enum { FAT_INVALID, Index: uspace/srv/fs/fat/fat_ops.c =================================================================== --- uspace/srv/fs/fat/fat_ops.c (revision 5cf723b0f447edb54b15926eb1388300785f7859) +++ uspace/srv/fs/fat/fat_ops.c (revision 7858bc5ff895eb1e87b5c19c5e2ca2a23717133a) @@ -76,5 +76,6 @@ static void fat_node_sync(fat_node_t *node) { - block_t *bb, *b; + block_t *b; + fat_bs_t *bs; fat_dentry_t *d; uint16_t bps; @@ -83,10 +84,10 @@ assert(node->dirty); - bb = block_get(node->idx->dev_handle, BS_BLOCK, BS_SIZE); - bps = uint16_t_le2host(FAT_BS(bb)->bps); + bs = block_bb_get(node->idx->dev_handle); + bps = uint16_t_le2host(bs->bps); dps = bps / sizeof(fat_dentry_t); /* Read the block that contains the dentry of interest. */ - b = _fat_block_get(bb->data, node->idx->dev_handle, node->idx->pfc, + b = _fat_block_get(bs, node->idx->dev_handle, node->idx->pfc, (node->idx->pdi * sizeof(fat_dentry_t)) / bps); @@ -100,5 +101,4 @@ b->dirty = true; /* need to sync block */ block_put(b); - block_put(bb); } @@ -109,5 +109,6 @@ static void *fat_node_get_core(fat_idx_t *idxp) { - block_t *bb, *b; + block_t *b; + fat_bs_t *bs; fat_dentry_t *d; fat_node_t *nodep = NULL; @@ -162,10 +163,10 @@ fat_node_initialize(nodep); - bb = block_get(idxp->dev_handle, BS_BLOCK, BS_SIZE); - bps = uint16_t_le2host(FAT_BS(bb)->bps); + bs = block_bb_get(idxp->dev_handle); + bps = uint16_t_le2host(bs->bps); dps = bps / sizeof(fat_dentry_t); /* Read the block that contains the dentry of interest. */ - b = _fat_block_get(bb->data, idxp->dev_handle, idxp->pfc, + b = _fat_block_get(bs, idxp->dev_handle, idxp->pfc, (idxp->pdi * sizeof(fat_dentry_t)) / bps); assert(b); @@ -184,5 +185,5 @@ * size of the directory by walking the FAT. */ - nodep->size = bps * _fat_blcks_get(bb->data, idxp->dev_handle, + nodep->size = bps * _fat_blcks_get(bs, idxp->dev_handle, uint16_t_le2host(d->firstc), NULL); } else { @@ -195,5 +196,4 @@ block_put(b); - block_put(bb); /* Link the idx structure with the node structure. */ @@ -254,4 +254,5 @@ static void *fat_match(void *prnt, const char *component) { + fat_bs_t *bs; fat_node_t *parentp = (fat_node_t *)prnt; char name[FAT_NAME_LEN + 1 + FAT_EXT_LEN + 1]; @@ -261,13 +262,13 @@ unsigned blocks; fat_dentry_t *d; - block_t *bb, *b; + block_t *b; futex_down(&parentp->idx->lock); - bb = block_get(parentp->idx->dev_handle, BS_BLOCK, BS_SIZE); - bps = uint16_t_le2host(FAT_BS(bb)->bps); + bs = block_bb_get(parentp->idx->dev_handle); + bps = uint16_t_le2host(bs->bps); dps = bps / sizeof(fat_dentry_t); blocks = parentp->size / bps; for (i = 0; i < blocks; i++) { - b = fat_block_get(bb->data, parentp, i); + b = fat_block_get(bs, parentp, i); for (j = 0; j < dps; j++) { d = ((fat_dentry_t *)b->data) + j; @@ -277,5 +278,4 @@ case FAT_DENTRY_LAST: block_put(b); - block_put(bb); futex_up(&parentp->idx->lock); return NULL; @@ -304,5 +304,4 @@ */ block_put(b); - block_put(bb); return NULL; } @@ -310,5 +309,4 @@ futex_up(&idx->lock); block_put(b); - block_put(bb); return node; } @@ -316,5 +314,4 @@ block_put(b); } - block_put(bb); futex_up(&parentp->idx->lock); @@ -342,9 +339,10 @@ static bool fat_has_children(void *node) { + fat_bs_t *bs; fat_node_t *nodep = (fat_node_t *)node; unsigned bps; unsigned dps; unsigned blocks; - block_t *bb, *b; + block_t *b; unsigned i, j; @@ -353,6 +351,6 @@ futex_down(&nodep->idx->lock); - bb = block_get(nodep->idx->dev_handle, BS_BLOCK, BS_SIZE); - bps = uint16_t_le2host(FAT_BS(bb)->bps); + bs = block_bb_get(nodep->idx->dev_handle); + bps = uint16_t_le2host(bs->bps); dps = bps / sizeof(fat_dentry_t); @@ -362,5 +360,5 @@ fat_dentry_t *d; - b = fat_block_get(bb->data, nodep, i); + b = fat_block_get(bs, nodep, i); for (j = 0; j < dps; j++) { d = ((fat_dentry_t *)b->data) + j; @@ -370,5 +368,4 @@ case FAT_DENTRY_LAST: block_put(b); - block_put(bb); futex_up(&nodep->idx->lock); return false; @@ -376,10 +373,8 @@ case FAT_DENTRY_VALID: block_put(b); - block_put(bb); futex_up(&nodep->idx->lock); return true; } block_put(b); - block_put(bb); futex_up(&nodep->idx->lock); return true; @@ -387,5 +382,4 @@ block_put(b); } - block_put(bb); futex_up(&nodep->idx->lock); @@ -435,48 +429,25 @@ { dev_handle_t dev_handle = (dev_handle_t) IPC_GET_ARG1(*request); - block_t *bb; + fat_bs_t *bs; uint16_t bps; uint16_t rde; int rc; - /* - * For now, we don't bother to remember dev_handle, dev_phone or - * dev_buffer in some data structure. We use global variables because we - * know there will be at most one mount on this file system. - * Of course, this is a huge TODO item. - */ - dev_buffer = mmap(NULL, BS_SIZE, PROTO_READ | PROTO_WRITE, - MAP_ANONYMOUS | MAP_PRIVATE, 0, 0); - - if (!dev_buffer) { - ipc_answer_0(rid, ENOMEM); - return; - } - - dev_phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, - DEVMAP_CONNECT_TO_DEVICE, dev_handle); - - if (dev_phone < 0) { - munmap(dev_buffer, BS_SIZE); - ipc_answer_0(rid, dev_phone); - return; - } - - rc = ipc_share_out_start(dev_phone, dev_buffer, - AS_AREA_READ | AS_AREA_WRITE); + /* initialize libblock */ + rc = block_init(dev_handle, BS_SIZE, BS_BLOCK * BS_SIZE, BS_SIZE); if (rc != EOK) { - munmap(dev_buffer, BS_SIZE); - ipc_answer_0(rid, rc); - return; - } - + ipc_answer_0(rid, 0); + return; + } + + /* get the buffer with the boot sector */ + bs = block_bb_get(dev_handle); + /* Read the number of root directory entries. */ - bb = block_get(dev_handle, BS_BLOCK, BS_SIZE); - bps = uint16_t_le2host(FAT_BS(bb)->bps); - rde = uint16_t_le2host(FAT_BS(bb)->root_ent_max); - block_put(bb); + bps = uint16_t_le2host(bs->bps); + rde = uint16_t_le2host(bs->root_ent_max); if (bps != BS_SIZE) { - munmap(dev_buffer, BS_SIZE); + block_fini(dev_handle); ipc_answer_0(rid, ENOTSUP); return; @@ -485,5 +456,5 @@ rc = fat_idx_init_by_dev_handle(dev_handle); if (rc != EOK) { - munmap(dev_buffer, BS_SIZE); + block_fini(dev_handle); ipc_answer_0(rid, rc); return; @@ -493,5 +464,5 @@ fat_node_t *rootp = (fat_node_t *)malloc(sizeof(fat_node_t)); if (!rootp) { - munmap(dev_buffer, BS_SIZE); + block_fini(dev_handle); fat_idx_fini_by_dev_handle(dev_handle); ipc_answer_0(rid, ENOMEM); @@ -502,5 +473,5 @@ fat_idx_t *ridxp = fat_idx_get_by_pos(dev_handle, FAT_CLST_ROOTPAR, 0); if (!ridxp) { - munmap(dev_buffer, BS_SIZE); + block_fini(dev_handle); free(rootp); fat_idx_fini_by_dev_handle(dev_handle); @@ -540,7 +511,8 @@ off_t pos = (off_t)IPC_GET_ARG3(*request); fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index); + fat_bs_t *bs; uint16_t bps; size_t bytes; - block_t *bb, *b; + block_t *b; if (!nodep) { @@ -558,6 +530,6 @@ } - bb = block_get(dev_handle, BS_BLOCK, BS_SIZE); - bps = uint16_t_le2host(FAT_BS(bb)->bps); + bs = block_bb_get(dev_handle); + bps = uint16_t_le2host(bs->bps); if (nodep->type == FAT_FILE) { @@ -568,5 +540,5 @@ */ bytes = min(len, bps - pos % bps); - b = fat_block_get(bb->data, nodep, pos / bps); + b = fat_block_get(bs, nodep, pos / bps); (void) ipc_data_read_finalize(callid, b->data + pos % bps, bytes); @@ -592,5 +564,5 @@ off_t o; - b = fat_block_get(bb->data, nodep, bnum); + b = fat_block_get(bs, nodep, bnum); for (o = pos % (bps / sizeof(fat_dentry_t)); o < bps / sizeof(fat_dentry_t); @@ -615,5 +587,4 @@ miss: fat_node_put(nodep); - block_put(bb); ipc_answer_0(callid, ENOENT); ipc_answer_1(rid, ENOENT, 0); @@ -625,5 +596,4 @@ fat_node_put(nodep); - block_put(bb); ipc_answer_1(rid, EOK, (ipcarg_t)bytes); } @@ -635,6 +605,7 @@ off_t pos = (off_t)IPC_GET_ARG3(*request); fat_node_t *nodep = (fat_node_t *)fat_node_get(dev_handle, index); + fat_bs_t *bs; size_t bytes; - block_t *b, *bb; + block_t *b; uint16_t bps; unsigned spc; @@ -671,7 +642,7 @@ bytes = min(len, bps - pos % bps); - bb = block_get(dev_handle, BS_BLOCK, BS_SIZE); - bps = uint16_t_le2host(FAT_BS(bb)->bps); - spc = FAT_BS(bb)->spc; + bs = block_bb_get(dev_handle); + bps = uint16_t_le2host(bs->bps); + spc = bs->spc; boundary = ROUND_UP(nodep->size, bps * spc); @@ -683,6 +654,6 @@ * next block size boundary. */ - fat_fill_gap(bb->data, nodep, FAT_CLST_RES0, pos); - b = fat_block_get(bb->data, nodep, pos / bps); + fat_fill_gap(bs, nodep, FAT_CLST_RES0, pos); + b = fat_block_get(bs, nodep, pos / bps); (void) ipc_data_write_finalize(callid, b->data + pos % bps, bytes); @@ -694,5 +665,4 @@ } fat_node_put(nodep); - block_put(bb); ipc_answer_1(rid, EOK, bytes); return; @@ -709,10 +679,9 @@ bps * spc; /* create an independent chain of nclsts clusters in all FATs */ - status = fat_alloc_clusters(bb->data, dev_handle, nclsts, &mcl, + status = fat_alloc_clusters(bs, dev_handle, nclsts, &mcl, &lcl); if (status != EOK) { /* could not allocate a chain of nclsts clusters */ fat_node_put(nodep); - block_put(bb); ipc_answer_0(callid, status); ipc_answer_0(rid, status); @@ -720,6 +689,6 @@ } /* zero fill any gaps */ - fat_fill_gap(bb->data, nodep, mcl, pos); - b = _fat_block_get(bb->data, dev_handle, lcl, + fat_fill_gap(bs, nodep, mcl, pos); + b = _fat_block_get(bs, dev_handle, lcl, (pos / bps) % spc); (void) ipc_data_write_finalize(callid, b->data + pos % bps, @@ -731,9 +700,8 @@ * node's cluster chain. */ - fat_append_clusters(bb->data, nodep, mcl); + fat_append_clusters(bs, nodep, mcl); nodep->size = pos + bytes; nodep->dirty = true; /* need to sync node */ fat_node_put(nodep); - block_put(bb); ipc_answer_1(rid, EOK, bytes); return; Index: uspace/srv/fs/tmpfs/Makefile =================================================================== --- uspace/srv/fs/tmpfs/Makefile (revision 5cf723b0f447edb54b15926eb1388300785f7859) +++ uspace/srv/fs/tmpfs/Makefile (revision 7858bc5ff895eb1e87b5c19c5e2ca2a23717133a) @@ -39,7 +39,7 @@ LIBS = \ - $(LIBC_PREFIX)/libc.a \ $(LIBFS_PREFIX)/libfs.a \ - $(LIBBLOCK_PREFIX)/libblock.a + $(LIBBLOCK_PREFIX)/libblock.a \ + $(LIBC_PREFIX)/libc.a ## Sources Index: uspace/srv/fs/tmpfs/tmpfs_dump.c =================================================================== --- uspace/srv/fs/tmpfs/tmpfs_dump.c (revision 5cf723b0f447edb54b15926eb1388300785f7859) +++ uspace/srv/fs/tmpfs/tmpfs_dump.c (revision 7858bc5ff895eb1e87b5c19c5e2ca2a23717133a) @@ -39,6 +39,4 @@ #include "tmpfs.h" #include "../../vfs/vfs.h" -#include -#include #include #include @@ -47,7 +45,4 @@ #include #include -#include -#include -#include #include @@ -60,6 +55,6 @@ static bool -tmpfs_restore_recursion(int phone, void *block, off_t *bufpos, size_t *buflen, - off_t *pos, tmpfs_dentry_t *parent) +tmpfs_restore_recursion(int dev, off_t *bufpos, size_t *buflen, off_t *pos, + tmpfs_dentry_t *parent) { struct rdentry entry; @@ -71,6 +66,6 @@ uint32_t size; - if (!blockread(phone, block, bufpos, buflen, pos, &entry, - sizeof(entry), TMPFS_BLOCK_SIZE)) + if (!block_read(dev, bufpos, buflen, pos, &entry, sizeof(entry), + TMPFS_BLOCK_SIZE)) return false; @@ -91,5 +86,5 @@ } - if (!blockread(phone, block, bufpos, buflen, pos, fname, + if (!block_read(dev, bufpos, buflen, pos, fname, entry.len, TMPFS_BLOCK_SIZE)) { ops->destroy((void *) node); @@ -106,5 +101,5 @@ free(fname); - if (!blockread(phone, block, bufpos, buflen, pos, &size, + if (!block_read(dev, bufpos, buflen, pos, &size, sizeof(size), TMPFS_BLOCK_SIZE)) return false; @@ -117,6 +112,6 @@ node->size = size; - if (!blockread(phone, block, bufpos, buflen, pos, - node->data, size, TMPFS_BLOCK_SIZE)) + if (!block_read(dev, bufpos, buflen, pos, node->data, + size, TMPFS_BLOCK_SIZE)) return false; @@ -133,6 +128,6 @@ } - if (!blockread(phone, block, bufpos, buflen, pos, fname, - entry.len, TMPFS_BLOCK_SIZE)) { + if (!block_read(dev, bufpos, buflen, pos, + fname, entry.len, TMPFS_BLOCK_SIZE)) { ops->destroy((void *) node); free(fname); @@ -148,6 +143,6 @@ free(fname); - if (!tmpfs_restore_recursion(phone, block, bufpos, - buflen, pos, node)) + if (!tmpfs_restore_recursion(dev, bufpos, buflen, pos, + node)) return false; @@ -164,22 +159,9 @@ { libfs_ops_t *ops = &tmpfs_libfs_ops; + int rc; - void *block = mmap(NULL, TMPFS_BLOCK_SIZE, - PROTO_READ | PROTO_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0); - - if (block == NULL) - return false; - - int phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAP, - DEVMAP_CONNECT_TO_DEVICE, dev); - - if (phone < 0) { - munmap(block, TMPFS_BLOCK_SIZE); - return false; - } - - if (ipc_share_out_start(phone, block, AS_AREA_READ | AS_AREA_WRITE) != - EOK) - goto error; + rc = block_init(dev, TMPFS_BLOCK_SIZE, 0, 0); + if (rc != EOK) + return false; off_t bufpos = 0; @@ -188,5 +170,5 @@ char tag[6]; - if (!blockread(phone, block, &bufpos, &buflen, &pos, tag, 5, + if (!block_read(dev, &bufpos, &buflen, &pos, tag, 5, TMPFS_BLOCK_SIZE)) goto error; @@ -196,15 +178,13 @@ goto error; - if (!tmpfs_restore_recursion(phone, block, &bufpos, &buflen, &pos, + if (!tmpfs_restore_recursion(dev, &bufpos, &buflen, &pos, ops->root_get(dev))) goto error; - ipc_hangup(phone); - munmap(block, TMPFS_BLOCK_SIZE); + block_fini(dev); return true; error: - ipc_hangup(phone); - munmap(block, TMPFS_BLOCK_SIZE); + block_fini(dev); return false; }