Index: uspace/srv/bd/ata_bd/ata_bd.c =================================================================== --- uspace/srv/bd/ata_bd/ata_bd.c (revision 2f636b696bc3e13b7d55b312b309e8bb6dec217f) +++ uspace/srv/bd/ata_bd/ata_bd.c (revision 029d94a7573cb36792681beeab6a72eb15027e06) @@ -62,4 +62,5 @@ #include #include +#include #include "ata_bd.h" @@ -86,14 +87,16 @@ static int ata_bd_init(void); static void ata_bd_connection(ipc_callid_t iid, ipc_call_t *icall); -static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size, +static int ata_bd_read_blocks(int disk_id, uint64_t ba, size_t cnt, void *buf); -static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt, +static int ata_bd_write_blocks(int disk_id, uint64_t ba, size_t cnt, + const void *buf); +static int ata_bd_read_block(int disk_id, uint64_t ba, size_t cnt, void *buf); -static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt, +static int ata_bd_write_block(int disk_id, uint64_t ba, size_t cnt, const void *buf); static int disk_init(disk_t *d, int disk_id); static int drive_identify(int drive_id, void *buf); static void disk_print_summary(disk_t *d); -static int coord_calc(disk_t *d, uint64_t blk_idx, block_coord_t *bc); +static int coord_calc(disk_t *d, uint64_t ba, block_coord_t *bc); static void coord_sc_program(const block_coord_t *bc, uint16_t scnt); static int wait_status(unsigned set, unsigned n_reset, uint8_t *pstatus, @@ -228,6 +231,6 @@ int flags; int retval; - off_t idx; - size_t size; + uint64_t ba; + size_t cnt; int disk_id, i; @@ -270,15 +273,27 @@ ipc_answer_0(callid, EOK); return; - case BD_READ_BLOCK: - case BD_WRITE_BLOCK: - idx = IPC_GET_ARG1(call); - size = IPC_GET_ARG2(call); - if (size > comm_size) { - retval = EINVAL; + case BD_READ_BLOCKS: + ba = MERGE_LOUP32(IPC_GET_ARG1(call), + IPC_GET_ARG2(call)); + cnt = IPC_GET_ARG3(call); + if (cnt * block_size > comm_size) { + retval = ELIMIT; break; } - retval = ata_bd_rdwr(disk_id, method, idx, - size, fs_va); + retval = ata_bd_read_blocks(disk_id, ba, cnt, fs_va); break; + case BD_WRITE_BLOCKS: + ba = MERGE_LOUP32(IPC_GET_ARG1(call), + IPC_GET_ARG2(call)); + cnt = IPC_GET_ARG3(call); + if (cnt * block_size > comm_size) { + retval = ELIMIT; + break; + } + retval = ata_bd_write_blocks(disk_id, ba, cnt, fs_va); + break; + case BD_GET_BLOCK_SIZE: + ipc_answer_1(callid, EOK, block_size); + continue; default: retval = EINVAL; @@ -373,40 +388,37 @@ } -/** Transfer a logical block from/to the device. - * - * @param disk_id Device index (0 or 1) - * @param method @c BD_READ_BLOCK or @c BD_WRITE_BLOCK - * @param blk_idx Index of the first block. - * @param size Size of the logical block. - * @param buf Data buffer. - * - * @return EOK on success, EIO on error. - */ -static int ata_bd_rdwr(int disk_id, ipcarg_t method, off_t blk_idx, size_t size, - void *buf) -{ +/** Read multiple blocks from the device. */ +static int ata_bd_read_blocks(int disk_id, uint64_t ba, size_t cnt, + void *buf) { + int rc; - size_t now; - - while (size > 0) { - now = size < block_size ? size : block_size; - if (now != block_size) - return EINVAL; - - if (method == BD_READ_BLOCK) - rc = ata_bd_read_block(disk_id, blk_idx, 1, buf); - else - rc = ata_bd_write_block(disk_id, blk_idx, 1, buf); - + + while (cnt > 0) { + rc = ata_bd_read_block(disk_id, ba, 1, buf); if (rc != EOK) return rc; + ++ba; + --cnt; buf += block_size; - blk_idx++; - - if (size > block_size) - size -= block_size; - else - size = 0; + } + + return EOK; +} + +/** Write multiple blocks to the device. */ +static int ata_bd_write_blocks(int disk_id, uint64_t ba, size_t cnt, + const void *buf) { + + int rc; + + while (cnt > 0) { + rc = ata_bd_write_block(disk_id, ba, 1, buf); + if (rc != EOK) + return rc; + + ++ba; + --cnt; + buf += block_size; } @@ -466,11 +478,11 @@ * * @param disk_id Device index (0 or 1) - * @param blk_idx Index of the first block. - * @param blk_cnt Number of blocks to transfer. + * @param ba Address the first block. + * @param cnt Number of blocks to transfer. * @param buf Buffer for holding the data. * * @return EOK on success, EIO on error. */ -static int ata_bd_read_block(int disk_id, uint64_t blk_idx, size_t blk_cnt, +static int ata_bd_read_block(int disk_id, uint64_t ba, size_t blk_cnt, void *buf) { @@ -486,5 +498,5 @@ /* Compute block coordinates. */ - if (coord_calc(d, blk_idx, &bc) != EOK) + if (coord_calc(d, ba, &bc) != EOK) return EINVAL; @@ -541,11 +553,11 @@ * * @param disk_id Device index (0 or 1) - * @param blk_idx Index of the first block. - * @param blk_cnt Number of blocks to transfer. + * @param ba Address of the first block. + * @param cnt Number of blocks to transfer. * @param buf Buffer holding the data to write. * * @return EOK on success, EIO on error. */ -static int ata_bd_write_block(int disk_id, uint64_t blk_idx, size_t blk_cnt, +static int ata_bd_write_block(int disk_id, uint64_t ba, size_t cnt, const void *buf) { @@ -560,5 +572,5 @@ /* Compute block coordinates. */ - if (coord_calc(d, blk_idx, &bc) != EOK) + if (coord_calc(d, ba, &bc) != EOK) return EINVAL; @@ -620,5 +632,5 @@ * @return EOK on success or EINVAL if block index is past end of device. */ -static int coord_calc(disk_t *d, uint64_t blk_idx, block_coord_t *bc) +static int coord_calc(disk_t *d, uint64_t ba, block_coord_t *bc) { uint64_t c; @@ -626,5 +638,5 @@ /* Check device bounds. */ - if (blk_idx >= d->blocks) + if (ba >= d->blocks) return EINVAL; @@ -634,6 +646,6 @@ case am_chs: /* Compute CHS coordinates. */ - c = blk_idx / (d->geom.heads * d->geom.sectors); - idx = blk_idx % (d->geom.heads * d->geom.sectors); + c = ba / (d->geom.heads * d->geom.sectors); + idx = ba % (d->geom.heads * d->geom.sectors); bc->cyl_lo = c & 0xff; @@ -645,18 +657,18 @@ case am_lba28: /* Compute LBA-28 coordinates. */ - bc->c0 = blk_idx & 0xff; /* bits 0-7 */ - bc->c1 = (blk_idx >> 8) & 0xff; /* bits 8-15 */ - bc->c2 = (blk_idx >> 16) & 0xff; /* bits 16-23 */ - bc->h = (blk_idx >> 24) & 0x0f; /* bits 24-27 */ + bc->c0 = ba & 0xff; /* bits 0-7 */ + bc->c1 = (ba >> 8) & 0xff; /* bits 8-15 */ + bc->c2 = (ba >> 16) & 0xff; /* bits 16-23 */ + bc->h = (ba >> 24) & 0x0f; /* bits 24-27 */ break; case am_lba48: /* Compute LBA-48 coordinates. */ - bc->c0 = blk_idx & 0xff; /* bits 0-7 */ - bc->c1 = (blk_idx >> 8) & 0xff; /* bits 8-15 */ - bc->c2 = (blk_idx >> 16) & 0xff; /* bits 16-23 */ - bc->c3 = (blk_idx >> 24) & 0xff; /* bits 24-31 */ - bc->c4 = (blk_idx >> 32) & 0xff; /* bits 32-39 */ - bc->c5 = (blk_idx >> 40) & 0xff; /* bits 40-47 */ + bc->c0 = ba & 0xff; /* bits 0-7 */ + bc->c1 = (ba >> 8) & 0xff; /* bits 8-15 */ + bc->c2 = (ba >> 16) & 0xff; /* bits 16-23 */ + bc->c3 = (ba >> 24) & 0xff; /* bits 24-31 */ + bc->c4 = (ba >> 32) & 0xff; /* bits 32-39 */ + bc->c5 = (ba >> 40) & 0xff; /* bits 40-47 */ bc->h = 0; break; Index: uspace/srv/bd/file_bd/file_bd.c =================================================================== --- uspace/srv/bd/file_bd/file_bd.c (revision 2f636b696bc3e13b7d55b312b309e8bb6dec217f) +++ uspace/srv/bd/file_bd/file_bd.c (revision 029d94a7573cb36792681beeab6a72eb15027e06) @@ -51,8 +51,9 @@ #include #include +#include #define NAME "file_bd" -static size_t comm_size; +static const size_t block_size = 512; static FILE *img; @@ -62,6 +63,6 @@ static int file_bd_init(const char *fname); static void file_bd_connection(ipc_callid_t iid, ipc_call_t *icall); -static int file_bd_read(off_t blk_idx, size_t size, void *buf); -static int file_bd_write(off_t blk_idx, size_t size, void *buf); +static int file_bd_read_blocks(uint64_t ba, size_t cnt, void *buf); +static int file_bd_write_blocks(uint64_t ba, size_t cnt, const void *buf); int main(int argc, char **argv) @@ -120,8 +121,9 @@ ipc_call_t call; ipcarg_t method; + size_t comm_size; int flags; int retval; - off_t idx; - size_t size; + uint64_t ba; + size_t cnt; /* Answer the IPC_M_CONNECT_ME_TO call. */ @@ -149,17 +151,27 @@ ipc_answer_0(callid, EOK); return; - case BD_READ_BLOCK: - case BD_WRITE_BLOCK: - idx = IPC_GET_ARG1(call); - size = IPC_GET_ARG2(call); - if (size > comm_size) { - retval = EINVAL; + case BD_READ_BLOCKS: + ba = MERGE_LOUP32(IPC_GET_ARG1(call), + IPC_GET_ARG2(call)); + cnt = IPC_GET_ARG3(call); + if (cnt * block_size > comm_size) { + retval = ELIMIT; break; } - if (method == BD_READ_BLOCK) - retval = file_bd_read(idx, size, fs_va); - else - retval = file_bd_write(idx, size, fs_va); + retval = file_bd_read_blocks(ba, cnt, fs_va); break; + case BD_WRITE_BLOCKS: + ba = MERGE_LOUP32(IPC_GET_ARG1(call), + IPC_GET_ARG2(call)); + cnt = IPC_GET_ARG3(call); + if (cnt * block_size > comm_size) { + retval = ELIMIT; + break; + } + retval = file_bd_write_blocks(ba, cnt, fs_va); + break; + case BD_GET_BLOCK_SIZE: + ipc_answer_1(callid, EOK, block_size); + continue; default: retval = EINVAL; @@ -170,5 +182,6 @@ } -static int file_bd_read(off_t blk_idx, size_t size, void *buf) +/** Read blocks from the device. */ +static int file_bd_read_blocks(uint64_t ba, size_t cnt, void *buf) { size_t n_rd; @@ -176,6 +189,6 @@ fibril_mutex_lock(&dev_lock); - fseek(img, blk_idx * size, SEEK_SET); - n_rd = fread(buf, 1, size, img); + fseek(img, ba * block_size, SEEK_SET); + n_rd = fread(buf, block_size, cnt, img); if (ferror(img)) { @@ -186,11 +199,12 @@ fibril_mutex_unlock(&dev_lock); - if (n_rd < size) - return EINVAL; /* Read beyond end of disk */ + if (n_rd < cnt) + return EINVAL; /* Read beyond end of device */ return EOK; } -static int file_bd_write(off_t blk_idx, size_t size, void *buf) +/** Write blocks to the device. */ +static int file_bd_write_blocks(uint64_t ba, size_t cnt, const void *buf) { size_t n_wr; @@ -198,8 +212,8 @@ fibril_mutex_lock(&dev_lock); - fseek(img, blk_idx * size, SEEK_SET); - n_wr = fread(buf, 1, size, img); - - if (ferror(img) || n_wr < size) { + fseek(img, ba * block_size, SEEK_SET); + n_wr = fread(buf, block_size, cnt, img); + + if (ferror(img) || n_wr < cnt) { fibril_mutex_unlock(&dev_lock); return EIO; /* Write error */ Index: uspace/srv/bd/gxe_bd/gxe_bd.c =================================================================== --- uspace/srv/bd/gxe_bd/gxe_bd.c (revision 2f636b696bc3e13b7d55b312b309e8bb6dec217f) +++ uspace/srv/bd/gxe_bd/gxe_bd.c (revision 029d94a7573cb36792681beeab6a72eb15027e06) @@ -47,4 +47,5 @@ #include #include +#include #include @@ -97,10 +98,10 @@ static int gxe_bd_init(void); static void gxe_bd_connection(ipc_callid_t iid, ipc_call_t *icall); -static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size, +static int gxe_bd_read_blocks(int disk_id, uint64_t ba, unsigned cnt, void *buf); -static int gxe_bd_read_block(int disk_id, uint64_t offset, size_t size, - void *buf); -static int gxe_bd_write_block(int disk_id, uint64_t offset, size_t size, +static int gxe_bd_write_blocks(int disk_id, uint64_t ba, unsigned cnt, const void *buf); +static int gxe_bd_read_block(int disk_id, uint64_t ba, void *buf); +static int gxe_bd_write_block(int disk_id, uint64_t ba, const void *buf); int main(int argc, char **argv) @@ -163,6 +164,6 @@ int flags; int retval; - off_t idx; - size_t size; + uint64_t ba; + unsigned cnt; int disk_id, i; @@ -185,4 +186,9 @@ if (!ipc_share_out_receive(&callid, &comm_size, &flags)) { + ipc_answer_0(callid, EHANGUP); + return; + } + + if (comm_size < block_size) { ipc_answer_0(callid, EHANGUP); return; @@ -205,15 +211,27 @@ ipc_answer_0(callid, EOK); return; - case BD_READ_BLOCK: - case BD_WRITE_BLOCK: - idx = IPC_GET_ARG1(call); - size = IPC_GET_ARG2(call); - if (size > comm_size) { - retval = EINVAL; + case BD_READ_BLOCKS: + ba = MERGE_LOUP32(IPC_GET_ARG1(call), + IPC_GET_ARG2(call)); + cnt = IPC_GET_ARG3(call); + if (cnt * block_size > comm_size) { + retval = ELIMIT; break; } - retval = gx_bd_rdwr(disk_id, method, idx * size, - size, fs_va); + retval = gxe_bd_read_blocks(disk_id, ba, cnt, fs_va); break; + case BD_WRITE_BLOCKS: + ba = MERGE_LOUP32(IPC_GET_ARG1(call), + IPC_GET_ARG2(call)); + cnt = IPC_GET_ARG3(call); + if (cnt * block_size > comm_size) { + retval = ELIMIT; + break; + } + retval = gxe_bd_write_blocks(disk_id, ba, cnt, fs_va); + break; + case BD_GET_BLOCK_SIZE: + ipc_answer_1(callid, EOK, block_size); + continue; default: retval = EINVAL; @@ -224,43 +242,55 @@ } -static int gx_bd_rdwr(int disk_id, ipcarg_t method, off_t offset, size_t size, - void *buf) -{ +/** Read multiple blocks from the device. */ +static int gxe_bd_read_blocks(int disk_id, uint64_t ba, unsigned cnt, + void *buf) { + int rc; - size_t now; - - while (size > 0) { - now = size < block_size ? size : block_size; - - if (method == BD_READ_BLOCK) - rc = gxe_bd_read_block(disk_id, offset, now, buf); - else - rc = gxe_bd_write_block(disk_id, offset, now, buf); - + + while (cnt > 0) { + rc = gxe_bd_read_block(disk_id, ba, buf); if (rc != EOK) return rc; + ++ba; + --cnt; buf += block_size; - offset += block_size; - - if (size > block_size) - size -= block_size; - else - size = 0; - } - - return EOK; -} - -static int gxe_bd_read_block(int disk_id, uint64_t offset, size_t size, - void *buf) + } + + return EOK; +} + +/** Write multiple blocks to the device. */ +static int gxe_bd_write_blocks(int disk_id, uint64_t ba, unsigned cnt, + const void *buf) { + + int rc; + + while (cnt > 0) { + rc = gxe_bd_write_block(disk_id, ba, buf); + if (rc != EOK) + return rc; + + ++ba; + --cnt; + buf += block_size; + } + + return EOK; +} + +/** Read a block from the device. */ +static int gxe_bd_read_block(int disk_id, uint64_t ba, void *buf) { uint32_t status; + uint64_t byte_addr; size_t i; uint32_t w; + byte_addr = ba * block_size; + fibril_mutex_lock(&dev_lock[disk_id]); - pio_write_32(&dev->offset_lo, (uint32_t) offset); - pio_write_32(&dev->offset_hi, offset >> 32); + pio_write_32(&dev->offset_lo, (uint32_t) byte_addr); + pio_write_32(&dev->offset_hi, byte_addr >> 32); pio_write_32(&dev->disk_id, disk_id); pio_write_32(&dev->control, CTL_READ_START); @@ -272,5 +302,5 @@ } - for (i = 0; i < size; i++) { + for (i = 0; i < block_size; i++) { ((uint8_t *) buf)[i] = w = pio_read_8(&dev->buffer[i]); } @@ -280,17 +310,21 @@ } -static int gxe_bd_write_block(int disk_id, uint64_t offset, size_t size, - const void *buf) +/** Write a block to the device. */ +static int gxe_bd_write_block(int disk_id, uint64_t ba, const void *buf) { uint32_t status; + uint64_t byte_addr; size_t i; - for (i = 0; i < size; i++) { + byte_addr = ba * block_size; + + fibril_mutex_lock(&dev_lock[disk_id]); + + for (i = 0; i < block_size; i++) { pio_write_8(&dev->buffer[i], ((const uint8_t *) buf)[i]); } - fibril_mutex_lock(&dev_lock[disk_id]); - pio_write_32(&dev->offset_lo, (uint32_t) offset); - pio_write_32(&dev->offset_hi, offset >> 32); + pio_write_32(&dev->offset_lo, (uint32_t) byte_addr); + pio_write_32(&dev->offset_hi, byte_addr >> 32); pio_write_32(&dev->disk_id, disk_id); pio_write_32(&dev->control, CTL_WRITE_START); Index: uspace/srv/bd/rd/rd.c =================================================================== --- uspace/srv/bd/rd/rd.c (revision 2f636b696bc3e13b7d55b312b309e8bb6dec217f) +++ uspace/srv/bd/rd/rd.c (revision 029d94a7573cb36792681beeab6a72eb15027e06) @@ -55,11 +55,18 @@ #include #include +#include #define NAME "rd" -/** Pointer to the ramdisk's image. */ +/** Pointer to the ramdisk's image */ static void *rd_addr; -/** Size of the ramdisk. */ +/** Size of the ramdisk */ static size_t rd_size; + +/** Block size */ +static const size_t block_size = 512; + +static int rd_read_blocks(uint64_t ba, size_t cnt, void *buf); +static int rd_write_blocks(uint64_t ba, size_t cnt, const void *buf); /** @@ -82,7 +89,7 @@ int retval; void *fs_va = NULL; - off_t offset; - size_t block_size; - size_t maxblock_size; + uint64_t ba; + size_t cnt; + size_t comm_size; /* @@ -95,6 +102,6 @@ */ int flags; - if (ipc_share_out_receive(&callid, &maxblock_size, &flags)) { - fs_va = as_get_mappable_page(maxblock_size); + if (ipc_share_out_receive(&callid, &comm_size, &flags)) { + fs_va = as_get_mappable_page(comm_size); if (fs_va) { (void) ipc_share_out_finalize(callid, fs_va); @@ -123,48 +130,27 @@ ipc_answer_0(callid, EOK); return; - case BD_READ_BLOCK: - offset = IPC_GET_ARG1(call); - block_size = IPC_GET_ARG2(call); - if (block_size > maxblock_size) { - /* - * Maximum block size exceeded. - */ + case BD_READ_BLOCKS: + ba = MERGE_LOUP32(IPC_GET_ARG1(call), + IPC_GET_ARG2(call)); + cnt = IPC_GET_ARG3(call); + if (cnt * block_size > comm_size) { retval = ELIMIT; break; } - if (offset * block_size > rd_size - block_size) { - /* - * Reading past the end of the device. - */ + retval = rd_read_blocks(ba, cnt, fs_va); + break; + case BD_WRITE_BLOCKS: + ba = MERGE_LOUP32(IPC_GET_ARG1(call), + IPC_GET_ARG2(call)); + cnt = IPC_GET_ARG3(call); + if (cnt * block_size > comm_size) { retval = ELIMIT; break; } - fibril_rwlock_read_lock(&rd_lock); - memcpy(fs_va, rd_addr + offset * block_size, block_size); - fibril_rwlock_read_unlock(&rd_lock); - retval = EOK; + retval = rd_write_blocks(ba, cnt, fs_va); break; - case BD_WRITE_BLOCK: - offset = IPC_GET_ARG1(call); - block_size = IPC_GET_ARG2(call); - if (block_size > maxblock_size) { - /* - * Maximum block size exceeded. - */ - retval = ELIMIT; - break; - } - if (offset * block_size > rd_size - block_size) { - /* - * Writing past the end of the device. - */ - retval = ELIMIT; - break; - } - fibril_rwlock_write_lock(&rd_lock); - memcpy(rd_addr + offset * block_size, fs_va, block_size); - fibril_rwlock_write_unlock(&rd_lock); - retval = EOK; - break; + case BD_GET_BLOCK_SIZE: + ipc_answer_1(callid, EOK, block_size); + continue; default: /* @@ -181,4 +167,34 @@ } +/** Read blocks from the device. */ +static int rd_read_blocks(uint64_t ba, size_t cnt, void *buf) +{ + if ((ba + cnt) * block_size > rd_size) { + /* Reading past the end of the device. */ + return ELIMIT; + } + + fibril_rwlock_read_lock(&rd_lock); + memcpy(buf, rd_addr + ba * block_size, block_size * cnt); + fibril_rwlock_read_unlock(&rd_lock); + + return EOK; +} + +/** Write blocks to the device. */ +static int rd_write_blocks(uint64_t ba, size_t cnt, const void *buf) +{ + if ((ba + cnt) * block_size > rd_size) { + /* Writing past the end of the device. */ + return ELIMIT; + } + + fibril_rwlock_write_lock(&rd_lock); + memcpy(rd_addr + ba * block_size, buf, block_size * cnt); + fibril_rwlock_write_unlock(&rd_lock); + + return EOK; +} + /** Prepare the ramdisk image for operation. */ static bool rd_init(void) Index: uspace/srv/fs/fat/fat_ops.c =================================================================== --- uspace/srv/fs/fat/fat_ops.c (revision 2f636b696bc3e13b7d55b312b309e8bb6dec217f) +++ uspace/srv/fs/fat/fat_ops.c (revision 029d94a7573cb36792681beeab6a72eb15027e06) @@ -833,5 +833,5 @@ /* prepare the boot block */ - rc = block_bb_read(dev_handle, BS_BLOCK * BS_SIZE, BS_SIZE); + rc = block_bb_read(dev_handle, BS_BLOCK); if (rc != EOK) { block_fini(dev_handle); Index: uspace/srv/fs/tmpfs/tmpfs_dump.c =================================================================== --- uspace/srv/fs/tmpfs/tmpfs_dump.c (revision 2f636b696bc3e13b7d55b312b309e8bb6dec217f) +++ uspace/srv/fs/tmpfs/tmpfs_dump.c (revision 029d94a7573cb36792681beeab6a72eb15027e06) @@ -47,5 +47,5 @@ #include -#define TMPFS_BLOCK_SIZE 1024 +#define TMPFS_COMM_SIZE 1024 struct rdentry { @@ -69,5 +69,5 @@ if (block_seqread(dev, bufpos, buflen, pos, &entry, - sizeof(entry), TMPFS_BLOCK_SIZE) != EOK) + sizeof(entry)) != EOK) return false; @@ -89,5 +89,5 @@ if (block_seqread(dev, bufpos, buflen, pos, fname, - entry.len, TMPFS_BLOCK_SIZE) != EOK) { + entry.len) != EOK) { ops->destroy(fn); free(fname); @@ -105,5 +105,5 @@ if (block_seqread(dev, bufpos, buflen, pos, &size, - sizeof(size), TMPFS_BLOCK_SIZE) != EOK) + sizeof(size)) != EOK) return false; @@ -117,5 +117,5 @@ nodep->size = size; if (block_seqread(dev, bufpos, buflen, pos, nodep->data, - size, TMPFS_BLOCK_SIZE) != EOK) + size) != EOK) return false; @@ -133,5 +133,5 @@ if (block_seqread(dev, bufpos, buflen, pos, fname, - entry.len, TMPFS_BLOCK_SIZE) != EOK) { + entry.len) != EOK) { ops->destroy(fn); free(fname); @@ -166,5 +166,5 @@ int rc; - rc = block_init(dev, TMPFS_BLOCK_SIZE); + rc = block_init(dev, TMPFS_COMM_SIZE); if (rc != EOK) return false; @@ -175,6 +175,5 @@ char tag[6]; - if (block_seqread(dev, &bufpos, &buflen, &pos, tag, 5, - TMPFS_BLOCK_SIZE) != EOK) + if (block_seqread(dev, &bufpos, &buflen, &pos, tag, 5) != EOK) goto error; Index: uspace/srv/part/mbr_part/Makefile =================================================================== --- uspace/srv/part/mbr_part/Makefile (revision 029d94a7573cb36792681beeab6a72eb15027e06) +++ uspace/srv/part/mbr_part/Makefile (revision 029d94a7573cb36792681beeab6a72eb15027e06) @@ -0,0 +1,78 @@ +# +# Copyright (c) 2006 Martin Decky +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR +# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF +# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +## Setup toolchain +# + + +LIBC_PREFIX = ../../../lib/libc +SOFTINT_PREFIX = ../../../lib/softint +LIBBLOCK_PREFIX = ../../../lib/libblock + +include $(LIBC_PREFIX)/Makefile.toolchain + +CFLAGS += -I$(LIBBLOCK_PREFIX) +LIBS = $(LIBBLOCK_PREFIX)/libblock.a $(LIBC_PREFIX)/libc.a + +## Sources +# + +OUTPUT = mbr_part +SOURCES = \ + mbr_part.c + +OBJECTS := $(addsuffix .o,$(basename $(SOURCES))) + +.PHONY: all clean depend disasm + +all: $(OUTPUT) $(OUTPUT).disasm + +-include Makefile.depend + +clean: + -rm -f $(OUTPUT) $(OUTPUT).map $(OUTPUT).disasm Makefile.depend $(OBJECTS) + +depend: + $(CC) $(DEFS) $(CFLAGS) -M $(SOURCES) > Makefile.depend + +$(OUTPUT): $(OBJECTS) $(LIBS) + $(LD) -T $(LIBC_PREFIX)/arch/$(UARCH)/_link.ld $(OBJECTS) $(LIBS) $(LFLAGS) -o $@ -Map $(OUTPUT).map + +disasm: $(OUTPUT).disasm + +$(OUTPUT).disasm: $(OUTPUT) + $(OBJDUMP) -d $< > $@ + +%.o: %.S + $(CC) $(DEFS) $(AFLAGS) $(CFLAGS) -D__ASM__ -c $< -o $@ + +%.o: %.s + $(AS) $(AFLAGS) $< -o $@ + +%.o: %.c + $(CC) $(DEFS) $(CFLAGS) -c $< -o $@ Index: uspace/srv/part/mbr_part/mbr_part.c =================================================================== --- uspace/srv/part/mbr_part/mbr_part.c (revision 029d94a7573cb36792681beeab6a72eb15027e06) +++ uspace/srv/part/mbr_part/mbr_part.c (revision 029d94a7573cb36792681beeab6a72eb15027e06) @@ -0,0 +1,495 @@ +/* + * Copyright (c) 2009 Jiri Svoboda + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup bd + * @{ + */ + +/** + * @file + * @brief PC MBR partition driver + * + * Handles the PC MBR partitioning scheme. Uses a block device + * and provides one for each partition. + * + * Limitations: + * + * Only works with boot records using LBA. CHS-only records are not + * supported. Maximum number of partitions is fixed. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define NAME "mbr_part" + +enum { + /** Number of primary partition records */ + N_PRIMARY = 4, + + /** Boot record signature */ + BR_SIGNATURE = 0xAA55, +}; + +enum ptype { + /** Extended partition */ + PT_EXTENDED = 0x05 +}; + +/** Partition */ +typedef struct part { + /** Primary partition entry is in use */ + bool present; + /** Address of first block */ + bn_t start_addr; + /** Number of blocks */ + bn_t length; + /** Device representing the partition (outbound device) */ + dev_handle_t dev; + /** Points to next partition structure. */ + struct part *next; +} part_t; + +/** Structure of a partition table entry */ +typedef struct { + uint8_t status; + /** CHS of fist block in partition */ + uint8_t first_chs[3]; + /** Partition type */ + uint8_t ptype; + /** CHS of last block in partition */ + uint8_t last_chs[3]; + /** LBA of first block in partition */ + uint32_t first_lba; + /** Number of blocks in partition */ + uint32_t length; +} __attribute__((packed)) pt_entry_t; + +/** Structure of a boot-record block */ +typedef struct { + /* Area for boot code */ + uint8_t code_area[440]; + + /* Optional media ID */ + uint32_t media_id; + + uint16_t pad0; + + /** Partition table entries */ + pt_entry_t pte[N_PRIMARY]; + + /** Boot record block signature (@c BR_SIGNATURE) */ + uint16_t signature; +} __attribute__((packed)) br_block_t; + + +static size_t block_size; + +/** Partitioned device (inbound device) */ +static dev_handle_t indev_handle; + +/** List of partitions. This structure is an empty head. */ +static part_t plist_head; + +static int mbr_init(const char *dev_name); +static int mbr_part_read(void); +static part_t *mbr_part_new(void); +static void mbr_pte_to_part(uint32_t base, const pt_entry_t *pte, part_t *part); +static void mbr_connection(ipc_callid_t iid, ipc_call_t *icall); +static int mbr_bd_read(part_t *p, uint64_t ba, size_t cnt, void *buf); +static int mbr_bd_write(part_t *p, uint64_t ba, size_t cnt, const void *buf); +static int mbr_bsa_translate(part_t *p, uint64_t ba, size_t cnt, uint64_t *gba); + +int main(int argc, char **argv) +{ + printf(NAME ": PC MBR partition driver\n"); + + if (argc != 2) { + printf("Expected one argument (device name).\n"); + return -1; + } + + if (mbr_init(argv[1]) != EOK) + return -1; + + printf(NAME ": Accepting connections\n"); + task_retval(0); + async_manager(); + + /* Not reached */ + return 0; +} + +static int mbr_init(const char *dev_name) +{ + int rc; + int i; + char *name; + dev_handle_t dev; + uint64_t size_mb; + part_t *part; + + rc = devmap_device_get_handle(dev_name, &indev_handle, 0); + if (rc != EOK) { + printf(NAME ": could not resolve device `%s'.\n", dev_name); + return rc; + } + + rc = block_init(indev_handle, 2048); + if (rc != EOK) { + printf(NAME ": could not init libblock.\n"); + return rc; + } + + /* Determine and verify block size. */ + + rc = block_get_bsize(indev_handle, &block_size); + if (rc != EOK) { + printf(NAME ": error getting block size.\n"); + return rc; + } + + if (block_size < 512 || (block_size % 512) != 0) { + printf(NAME ": invalid block size %d.\n"); + return ENOTSUP; + } + + /* Read in partition records. */ + rc = mbr_part_read(); + if (rc != EOK) + return rc; + + /* Register the driver with device mapper. */ + rc = devmap_driver_register(NAME, mbr_connection); + if (rc != EOK) { + printf(NAME ": Unable to register driver.\n"); + return rc; + } + + /* + * Create partition devices. + */ + i = 0; + part = plist_head.next; + + while (part != NULL) { + /* Skip absent partitions. */ + if (!part->present) { + part = part->next; + ++i; + continue; + } + + asprintf(&name, "%sp%d", dev_name, i); + if (name == NULL) + return ENOMEM; + + rc = devmap_device_register(name, &dev); + if (rc != EOK) { + devmap_hangup_phone(DEVMAP_DRIVER); + printf(NAME ": Unable to register device %s.\n", name); + return rc; + } + + size_mb = (part->length * block_size + 1024 * 1024 - 1) + / (1024 * 1024); + printf(NAME ": Registered device %s: %llu blocks %llu MB.\n", + name, part->length, size_mb); + + part->dev = dev; + free(name); + + part = part->next; + ++i; + } + + return EOK; +} + +/** Read in partition records. */ +static int mbr_part_read(void) +{ + int i, rc; + br_block_t *brb; + uint16_t sgn; + uint32_t ba; + part_t *ext_part, cp; + uint32_t base; + part_t *prev, *p; + + brb = malloc(sizeof(br_block_t)); + if (brb == NULL) { + printf(NAME ": Failed allocating memory.\n"); + return ENOMEM; + } + + /* + * Read primary partition entries. + */ + + rc = block_read_direct(indev_handle, 0, 1, brb); + if (rc != EOK) { + printf(NAME ": Failed reading MBR block.\n"); + return rc; + } + + sgn = uint16_t_le2host(brb->signature); + if (sgn != BR_SIGNATURE) { + printf(NAME ": Invalid boot record signature 0x%04X.\n", sgn); + return EINVAL; + } + + ext_part = NULL; + plist_head.next = NULL; + prev = &plist_head; + + for (i = 0; i < N_PRIMARY; ++i) { + p = mbr_part_new(); + if (p == NULL) + return ENOMEM; + + mbr_pte_to_part(0, &brb->pte[i], p); + prev->next = p; + prev = p; + + if (brb->pte[i].ptype == PT_EXTENDED) { + p->present = false; + ext_part = p; + } + } + + if (ext_part == NULL) + return EOK; + + printf("Extended partition found.\n"); + + /* + * Read extended partition entries. + */ + + cp.start_addr = ext_part->start_addr; + cp.length = ext_part->length; + base = ext_part->start_addr; + + do { + /* + * Addressing in the EBR chain is relative to the beginning + * of the extended partition. + */ + ba = cp.start_addr; + rc = block_read_direct(indev_handle, ba, 1, brb); + if (rc != EOK) { + printf(NAME ": Failed reading EBR block at %u.\n", ba); + return rc; + } + + sgn = uint16_t_le2host(brb->signature); + if (sgn != BR_SIGNATURE) { + printf(NAME ": Invalid boot record signature 0x%04X " + " in EBR at %u.\n", sgn, ba); + return EINVAL; + } + + p = mbr_part_new(); + if (p == NULL) + return ENOMEM; + + /* First PTE is the logical partition itself. */ + mbr_pte_to_part(base, &brb->pte[0], p); + prev->next = p; + prev = p; + + /* Second PTE describes next chain element. */ + mbr_pte_to_part(base, &brb->pte[1], &cp); + } while (cp.present); + + return EOK; +} + +/** Allocate a new @c part_t structure. */ +static part_t *mbr_part_new(void) +{ + return malloc(sizeof(part_t)); +} + +/** Parse partition table entry. */ +static void mbr_pte_to_part(uint32_t base, const pt_entry_t *pte, part_t *part) +{ + uint32_t sa, len; + + sa = uint32_t_le2host(pte->first_lba); + len = uint32_t_le2host(pte->length); + + part->start_addr = base + sa; + part->length = len; + + part->present = (sa != 0 || len != 0) ? true : false; + part->dev = 0; + part->next = NULL; +} + +static void mbr_connection(ipc_callid_t iid, ipc_call_t *icall) +{ + size_t comm_size; + void *fs_va = NULL; + ipc_callid_t callid; + ipc_call_t call; + ipcarg_t method; + dev_handle_t dh; + int flags; + int retval; + uint64_t ba; + size_t cnt; + part_t *part; + + /* Get the device handle. */ + dh = IPC_GET_ARG1(*icall); + + /* + * Determine which partition device is the client connecting to. + * A linear search is not terribly fast, but we only do this + * once for each connection. + */ + part = plist_head.next; + while (part != NULL && part->dev != dh) + part = part->next; + + if (part == NULL) { + ipc_answer_0(iid, EINVAL); + return; + } + + assert(part->present == true); + + /* Answer the IPC_M_CONNECT_ME_TO call. */ + ipc_answer_0(iid, EOK); + + if (!ipc_share_out_receive(&callid, &comm_size, &flags)) { + ipc_answer_0(callid, EHANGUP); + return; + } + + fs_va = as_get_mappable_page(comm_size); + if (fs_va == NULL) { + ipc_answer_0(callid, EHANGUP); + return; + } + + (void) ipc_share_out_finalize(callid, fs_va); + + while (1) { + callid = async_get_call(&call); + method = IPC_GET_METHOD(call); + switch (method) { + case IPC_M_PHONE_HUNGUP: + /* The other side has hung up. */ + ipc_answer_0(callid, EOK); + return; + case BD_READ_BLOCKS: + ba = MERGE_LOUP32(IPC_GET_ARG1(call), + IPC_GET_ARG2(call)); + cnt = IPC_GET_ARG3(call); + if (cnt * block_size > comm_size) { + retval = ELIMIT; + break; + } + retval = mbr_bd_read(part, ba, cnt, fs_va); + break; + case BD_WRITE_BLOCKS: + ba = MERGE_LOUP32(IPC_GET_ARG1(call), + IPC_GET_ARG2(call)); + cnt = IPC_GET_ARG3(call); + if (cnt * block_size > comm_size) { + retval = ELIMIT; + break; + } + retval = mbr_bd_write(part, ba, cnt, fs_va); + break; + case BD_GET_BLOCK_SIZE: + ipc_answer_1(callid, EOK, block_size); + continue; + + default: + retval = EINVAL; + break; + } + ipc_answer_0(callid, retval); + } +} + +/** Read blocks from partition. */ +static int mbr_bd_read(part_t *p, uint64_t ba, size_t cnt, void *buf) +{ + uint64_t gba; + + if (mbr_bsa_translate(p, ba, cnt, &gba) != EOK) + return ELIMIT; + + return block_read_direct(indev_handle, gba, cnt, buf); +} + +/** Write blocks to partition. */ +static int mbr_bd_write(part_t *p, uint64_t ba, size_t cnt, const void *buf) +{ + uint64_t gba; + + if (mbr_bsa_translate(p, ba, cnt, &gba) != EOK) + return ELIMIT; + + return block_write_direct(indev_handle, gba, cnt, buf); +} + +/** Translate block segment address with range checking. */ +static int mbr_bsa_translate(part_t *p, uint64_t ba, size_t cnt, uint64_t *gba) +{ + if (ba + cnt > p->length) + return ELIMIT; + + *gba = p->start_addr + ba; + return EOK; +} + +/** + * @} + */