void parse_susp_rock_ridge_plcl(struct rrii_dir_record *dir, u32_t block) { struct inode *rep_inode; struct buf *bp; struct iso9660_dir_record *dir_rec; struct dir_extent extent; struct inode_dir_entry dummy_dir_entry; size_t dummy_offset = 0; /* Check if inode wasn't already parsed. */ rep_inode = inode_cache_get(block); if (rep_inode != NULL) { rep_inode->i_refcount++; dir->reparented_inode = rep_inode; return; } /* Peek ahead to build extent for read_inode. */ if (lmfs_get_block(&bp, fs_dev, block, NORMAL) != OK) return; dir_rec = (struct iso9660_dir_record*)b_data(bp); extent.location = block; extent.length = dir_rec->data_length_l / v_pri.logical_block_size_l; if (dir_rec->data_length_l % v_pri.logical_block_size_l) extent.length++; extent.next = NULL; lmfs_put_block(bp); memset(&dummy_dir_entry, 0, sizeof(struct inode_dir_entry)); read_inode(&dummy_dir_entry, &extent, &dummy_offset); free(dummy_dir_entry.r_name); dir->reparented_inode = dummy_dir_entry.i_node; }
struct buf* read_extent_block(struct dir_extent *e, size_t block) { size_t block_id = get_extent_absolute_block_id(e, block); if (block_id == 0 || block_id >= v_pri.volume_space_size_l) return NULL; return lmfs_get_block(fs_dev, block_id, NORMAL); }
int readblock(int b, int blocksize, u32_t seed, char *data) { struct buf *bp; assert(blocksize == curblocksize); if(!(bp = lmfs_get_block(MYDEV, b, NORMAL))) { e(30); return 0; } memcpy(data, bp->data, blocksize); lmfs_put_block(bp, FULL_DATA_BLOCK); return blocksize; }
int readblock(int b, int blocksize, u32_t seed, char *data) { struct buf *bp; int r; assert(blocksize == curblocksize); if ((r = lmfs_get_block(&bp, MYDEV, b, NORMAL)) != 0) { e(30); return 0; } memcpy(data, bp->data, blocksize); lmfs_put_block(bp); return blocksize; }
/*===========================================================================* * lmfs_readahead * *===========================================================================*/ void lmfs_readahead(dev_t dev, block64_t base_block, unsigned int nblocks, size_t last_size) { /* Read ahead 'nblocks' blocks starting from the block 'base_block' on device * 'dev'. The number of blocks must be between 1 and LMFS_MAX_PREFETCH, * inclusive. All blocks have the file system's block size, possibly except the * last block in the range, which is of size 'last_size'. The caller must * ensure that none of the blocks in the range are already in the cache. * However, the caller must also not rely on all or even any of the blocks to * be present in the cache afterwards--failures are (deliberately!) ignored. */ static noxfer_buf_ptr_t bufq[LMFS_MAX_PREFETCH]; /* static for size only */ struct buf *bp; unsigned int count; int r; assert(nblocks >= 1 && nblocks <= LMFS_MAX_PREFETCH); for (count = 0; count < nblocks; count++) { if (count == nblocks - 1) r = lmfs_get_partial_block(&bp, dev, base_block + count, NO_READ, last_size); else r = lmfs_get_block(&bp, dev, base_block + count, NO_READ); if (r != OK) break; /* We could add a flag that makes the get_block() calls fail if the * block is already in the cache, but it is not a major concern if it * is: we just perform a useless read in that case. However, if the * block is cached *and* dirty, we are about to lose its new contents. */ assert(lmfs_isclean(bp)); bufq[count] = bp; } rw_scattered(dev, bufq, count, READING); }
/* * Prefetch up to "nblocks" blocks on "dev" starting from block number "block". * Stop early when either the I/O request fills up or when a block is already * found to be in the cache. The latter is likely to happen often, since this * function is called before getting each block for reading. Prefetching is a * strictly best-effort operation, and may fail silently. * TODO: limit according to the number of available buffers. */ static void block_prefetch(dev_t dev, block_t block, block_t nblocks) { struct buf *bp, *bufs[NR_IOREQS]; unsigned int count; for (count = 0; count < nblocks; count++) { bp = lmfs_get_block(dev, block + count, PREFETCH); assert(bp != NULL); if (lmfs_dev(bp) != NO_DEV) { lmfs_put_block(bp, FULL_DATA_BLOCK); break; } bufs[count] = bp; } if (count > 0) lmfs_rw_scattered(dev, bufs, count, READING); }
/* * Perform block I/O, on "dev", starting from offset "pos", for a total of * "bytes" bytes. Reading, writing, and peeking are highly similar, and thus, * this function implements all of them. The "call" parameter indicates the * call type (one of FSC_READ, FSC_WRITE, FSC_PEEK). For read and write calls, * "data" will identify the user buffer to use; for peek calls, "data" is set * to NULL. In all cases, this function returns the number of bytes * successfully transferred, 0 on end-of-file conditions, and a negative error * code if no bytes could be transferred due to an error. Dirty data is not * flushed immediately, and thus, a successful write only indicates that the * data have been taken in by the cache (for immediate I/O, a character device * would have to be used, but MINIX3 no longer supports this), which may be * follwed later by silent failures, including undetected end-of-file cases. * In particular, write requests may or may not return 0 (EOF) immediately when * writing at or beyond the block device's size. i Since block I/O takes place * at block granularity, block-unaligned writes have to read a block from disk * before updating it, and that is the only possible source of actual I/O * errors for write calls. * TODO: reconsider the buffering-only approach, or see if we can at least * somehow throw accurate EOF errors without reading in each block first. */ ssize_t lmfs_bio(dev_t dev, struct fsdriver_data * data, size_t bytes, off_t pos, int call) { block_t block, blocks_left; size_t block_size, off, block_off, chunk; struct buf *bp; int r, write, how; if (dev == NO_DEV) return EINVAL; block_size = lmfs_fs_block_size(); write = (call == FSC_WRITE); assert(block_size > 0); /* FIXME: block_t is 32-bit, so we have to impose a limit here. */ if (pos < 0 || pos / block_size > UINT32_MAX || bytes > SSIZE_MAX) return EINVAL; off = 0; block = pos / block_size; block_off = (size_t)(pos % block_size); blocks_left = howmany(block_off + bytes, block_size); lmfs_reset_rdwt_err(); r = OK; for (off = 0; off < bytes; off += chunk) { chunk = block_size - block_off; if (chunk > bytes - off) chunk = bytes - off; /* * For read requests, help the block driver form larger I/O * requests. */ if (!write) block_prefetch(dev, block, blocks_left); /* * Do not read the block from disk if we will end up * overwriting all of its contents. */ how = (write && chunk == block_size) ? NO_READ : NORMAL; bp = lmfs_get_block(dev, block, how); assert(bp); r = lmfs_rdwt_err(); if (r == OK && data != NULL) { assert(lmfs_dev(bp) != NO_DEV); if (write) { r = fsdriver_copyin(data, off, (char *)bp->data + block_off, chunk); /* * Mark the block as dirty even if the copy * failed, since the copy may in fact have * succeeded partially. This is an interface * issue that should be resolved at some point, * but for now we do not want the cache to be * desynchronized from the disk contents. */ lmfs_markdirty(bp); } else r = fsdriver_copyout(data, off, (char *)bp->data + block_off, chunk); } lmfs_put_block(bp, FULL_DATA_BLOCK); if (r != OK) break; block++; block_off = 0; blocks_left--; } /* * If we were not able to do any I/O, return the error (or EOF, even * for writes). Otherwise, return how many bytes we did manage to * transfer. */ if (r != OK && off == 0) return (r == END_OF_FILE) ? 0 : r; return off; }
int parse_susp(struct rrii_dir_record *dir, char *buffer) { /* Parse fundamental SUSP entries */ char susp_signature[2]; u8_t susp_length; u8_t susp_version; u32_t ca_block_nr; u32_t ca_offset; u32_t ca_length; struct buf *ca_bp; susp_signature[0] = buffer[0]; susp_signature[1] = buffer[1]; susp_length = *((u8_t*)buffer + 2); susp_version = *((u8_t*)buffer + 3); if ((susp_signature[0] == 'C') && (susp_signature[1] == 'E') && (susp_length >= 28) && (susp_version >= 1)) { /* * Continuation area, perform a recursion. * * FIXME: Currently we're parsing only first logical block of a * continuation area, and infinite recursion is not checked. */ ca_block_nr = *((u32_t*)(buffer + 4)); ca_offset = *((u32_t*)(buffer + 12)); ca_length = *((u32_t*)(buffer + 20)); /* Truncate continuation area to fit one logical block. */ if (ca_offset >= v_pri.logical_block_size_l) { return EINVAL; } if (ca_offset + ca_length > v_pri.logical_block_size_l) { ca_length = v_pri.logical_block_size_l - ca_offset; } ca_bp = lmfs_get_block(fs_dev, ca_block_nr, NORMAL); if (ca_bp == NULL) { return EINVAL; } parse_susp_buffer(dir, b_data(ca_bp) + ca_offset, ca_length); lmfs_put_block(ca_bp, FULL_DATA_BLOCK); return OK; } else if ((susp_signature[0] == 'P') && (susp_signature[1] == 'D')) { /* Padding, skip. */ return OK; } else if ((susp_signature[0] == 'S') && (susp_signature[1] == 'P')) { /* Ignored, skip. */ return OK; } else if ((susp_signature[0] == 'S') && (susp_signature[1] == 'T')) { /* Terminator entry, stop processing. */ return(ECANCELED); } else if ((susp_signature[0] == 'E') && (susp_signature[1] == 'R')) { /* Ignored, skip. */ return OK; } else if ((susp_signature[0] == 'E') && (susp_signature[1] == 'S')) { /* Ignored, skip. */ return OK; } /* Not a SUSP fundamental entry. */ return EINVAL; }