From 0314acfb2d68447dfa1b0b33aa4c25b1cbfa85d3 Mon Sep 17 00:00:00 2001 From: David van Moolenbroek Date: Sat, 28 Mar 2015 00:45:28 +0000 Subject: [PATCH] libminixfs: miscellaneous API cleanup Mostly removal of unused parameters from calls. Change-Id: I0eb7b568265d1669492d958e78b9e69d7cf6fc05 --- minix/fs/ext2/balloc.c | 12 ++-- minix/fs/ext2/buf.h | 25 +------- minix/fs/ext2/ialloc.c | 4 +- minix/fs/ext2/inode.c | 2 +- minix/fs/ext2/link.c | 4 +- minix/fs/ext2/mount.c | 2 +- minix/fs/ext2/open.c | 2 +- minix/fs/ext2/path.c | 6 +- minix/fs/ext2/proto.h | 2 +- minix/fs/ext2/read.c | 14 ++--- minix/fs/ext2/stadir.c | 3 +- minix/fs/ext2/write.c | 15 +++-- minix/fs/isofs/inode.c | 10 +-- minix/fs/isofs/read.c | 2 +- minix/fs/isofs/stadir.c | 4 +- minix/fs/isofs/super.c | 2 +- minix/fs/isofs/susp.c | 2 +- minix/fs/mfs/buf.h | 33 ++-------- minix/fs/mfs/inode.c | 2 +- minix/fs/mfs/link.c | 4 +- minix/fs/mfs/mount.c | 2 +- minix/fs/mfs/open.c | 2 +- minix/fs/mfs/path.c | 6 +- minix/fs/mfs/proto.h | 2 +- minix/fs/mfs/read.c | 12 ++-- minix/fs/mfs/stadir.c | 3 +- minix/fs/mfs/stats.c | 9 ++- minix/fs/mfs/super.c | 12 ++-- minix/fs/mfs/write.c | 9 ++- minix/include/minix/libminixfs.h | 27 +++----- minix/lib/libminixfs/bio.c | 4 +- minix/lib/libminixfs/cache.c | 103 ++++++++++++++++++------------- minix/lib/libminixfs/minixfs.h | 4 -- minix/tests/test72.c | 12 ++-- 34 files changed, 155 insertions(+), 202 deletions(-) delete mode 100644 minix/lib/libminixfs/minixfs.h diff --git a/minix/fs/ext2/balloc.c b/minix/fs/ext2/balloc.c index 947e9f538..fd1e18505 100644 --- a/minix/fs/ext2/balloc.c +++ b/minix/fs/ext2/balloc.c @@ -228,11 +228,11 @@ struct inode *rip; /* used for preallocation */ rip->i_prealloc_count = EXT2_PREALLOC_BLOCKS - 1; lmfs_markdirty(bp); - put_block(bp, MAP_BLOCK); + put_block(bp); gd->free_blocks_count -= EXT2_PREALLOC_BLOCKS; sp->s_free_blocks_count -= EXT2_PREALLOC_BLOCKS; - lmfs_blockschange(sp->s_dev, -EXT2_PREALLOC_BLOCKS); + lmfs_blockschange(-EXT2_PREALLOC_BLOCKS); group_descriptors_dirty = 1; return block; } @@ -253,11 +253,11 @@ struct inode *rip; /* used for preallocation */ check_block_number(block, sp, gd); lmfs_markdirty(bp); - put_block(bp, MAP_BLOCK); + put_block(bp); gd->free_blocks_count--; sp->s_free_blocks_count--; - lmfs_blockschange(sp->s_dev, -1); + lmfs_blockschange(-1); group_descriptors_dirty = 1; if (update_bsearch && block != -1 && block != NO_BLOCK) { @@ -319,11 +319,11 @@ void free_block(struct super_block *sp, bit_t bit_returned) panic("Tried to free unused block %d", bit_returned); lmfs_markdirty(bp); - put_block(bp, MAP_BLOCK); + put_block(bp); gd->free_blocks_count++; sp->s_free_blocks_count++; - lmfs_blockschange(sp->s_dev, 1); + lmfs_blockschange(1); group_descriptors_dirty = 1; diff --git a/minix/fs/ext2/buf.h b/minix/fs/ext2/buf.h index b700f735a..f1ffe1065 100644 --- a/minix/fs/ext2/buf.h +++ b/minix/fs/ext2/buf.h @@ -1,31 +1,12 @@ -/* Buffer (block) cache. To acquire a block, a routine calls get_block(), - * telling which block it wants. The block is then regarded as "in use" - * and has its 'b_count' field incremented. All the blocks that are not - * in use are chained together in an LRU list, with 'front' pointing - * to the least recently used block, and 'rear' to the most recently used - * block. A reverse chain, using the field b_prev is also maintained. - * Usage for LRU is measured by the time the put_block() is done. The second - * parameter to put_block() can violate the LRU order and put a block on the - * front of the list, if it will probably not be needed soon. If a block - * is modified, the modifying routine must set b_dirt to DIRTY, so the block - * will eventually be rewritten to the disk. - */ - #ifndef EXT2_BUF_H #define EXT2_BUF_H -#include - union fsdata_u { - char b__data[1]; /* ordinary user data */ -/* indirect block */ - block_t b__ind[1]; -/* bit map block */ - bitchunk_t b__bitmap[1]; + char b__data[1]; /* ordinary user data */ + block_t b__ind[1]; /* indirect block */ + bitchunk_t b__bitmap[1]; /* bit map block */ }; -/* A block is free if b_dev == NO_DEV. */ - /* These defs make it possible to use to bp->b_data instead of bp->b.b__data */ #define b_data(bp) ((union fsdata_u *) bp->data)->b__data #define b_ind(bp) ((union fsdata_u *) bp->data)->b__ind diff --git a/minix/fs/ext2/ialloc.c b/minix/fs/ext2/ialloc.c index 967a3d216..97f6bcf76 100644 --- a/minix/fs/ext2/ialloc.c +++ b/minix/fs/ext2/ialloc.c @@ -181,7 +181,7 @@ int is_dir; /* inode will be a directory if it is TRUE */ } lmfs_markdirty(bp); - put_block(bp, MAP_BLOCK); + put_block(bp); gd->free_inodes_count--; sp->s_free_inodes_count--; @@ -233,7 +233,7 @@ static void free_inode_bit(struct super_block *sp, bit_t bit_returned, panic("Tried to free unused inode %d", bit_returned); lmfs_markdirty(bp); - put_block(bp, MAP_BLOCK); + put_block(bp); gd->free_inodes_count++; sp->s_free_inodes_count++; diff --git a/minix/fs/ext2/inode.c b/minix/fs/ext2/inode.c index 783ae793c..72592e61a 100644 --- a/minix/fs/ext2/inode.c +++ b/minix/fs/ext2/inode.c @@ -341,7 +341,7 @@ void rw_inode( icopy(rip, dip, rw_flag, TRUE); - put_block(bp, INODE_BLOCK); + put_block(bp); rip->i_dirt = IN_CLEAN; } diff --git a/minix/fs/ext2/link.c b/minix/fs/ext2/link.c index a2069c73d..7890f7b23 100644 --- a/minix/fs/ext2/link.c +++ b/minix/fs/ext2/link.c @@ -181,7 +181,7 @@ ssize_t fs_rdlink(ino_t ino_nr, struct fsdriver_data *data, size_t bytes) if (bytes > rip->i_size) bytes = rip->i_size; r = fsdriver_copyout(data, 0, link_text, bytes); - put_block(bp, DIRECTORY_BLOCK); + put_block(bp); if (r == OK) r = bytes; } @@ -652,5 +652,5 @@ off_t len; panic("zeroblock_range: len too long: %lld", len); memset(b_data(bp) + offset, 0, len); lmfs_markdirty(bp); - put_block(bp, FULL_DATA_BLOCK); + put_block(bp); } diff --git a/minix/fs/ext2/mount.c b/minix/fs/ext2/mount.c index 6b9db4207..f2c619904 100644 --- a/minix/fs/ext2/mount.c +++ b/minix/fs/ext2/mount.c @@ -88,7 +88,7 @@ int fs_mount(dev_t dev, unsigned int flags, struct fsdriver_node *root_node, return(EINVAL); } - lmfs_set_blocksize(superblock->s_block_size, major(fs_dev)); + lmfs_set_blocksize(superblock->s_block_size); /* Get the root inode of the mounted file system. */ if ( (root_ip = get_inode(fs_dev, ROOT_INODE)) == NULL) { diff --git a/minix/fs/ext2/open.c b/minix/fs/ext2/open.c index cb4714b6b..31145d599 100644 --- a/minix/fs/ext2/open.c +++ b/minix/fs/ext2/open.c @@ -185,7 +185,7 @@ int fs_slink(ino_t dir_nr, char *name, uid_t uid, gid_t gid, } } - put_block(bp, DIRECTORY_BLOCK); /* put_block() accepts NULL. */ + put_block(bp); /* put_block() accepts NULL. */ if(r != OK) { sip->i_links_count = NO_LINK; diff --git a/minix/fs/ext2/path.c b/minix/fs/ext2/path.c index cac197b94..0fb0c3711 100644 --- a/minix/fs/ext2/path.c +++ b/minix/fs/ext2/path.c @@ -216,7 +216,7 @@ int ftype; /* used when ENTER and INCOMPAT_FILETYPE */ *numb = (ino_t) conv4(le_CPU, dp->d_ino); } assert(lmfs_dev(bp) != NO_DEV); - put_block(bp, DIRECTORY_BLOCK); + put_block(bp); return(r); } @@ -252,7 +252,7 @@ int ftype; /* used when ENTER and INCOMPAT_FILETYPE */ /* The whole block has been searched or ENTER has a free slot. */ assert(lmfs_dev(bp) != NO_DEV); if (e_hit) break; /* e_hit set if ENTER can be performed now */ - put_block(bp, DIRECTORY_BLOCK); /* otherwise, continue searching dir */ + put_block(bp); /* otherwise, continue searching dir */ } /* The whole directory has now been searched. */ @@ -302,7 +302,7 @@ int ftype; /* used when ENTER and INCOMPAT_FILETYPE */ dp->d_file_type = EXT2_FT_UNKNOWN; } lmfs_markdirty(bp); - put_block(bp, DIRECTORY_BLOCK); + put_block(bp); ldir_ptr->i_update |= CTIME | MTIME; /* mark mtime for update later */ ldir_ptr->i_dirt = IN_DIRTY; diff --git a/minix/fs/ext2/proto.h b/minix/fs/ext2/proto.h index 5f237c64a..9573c49c8 100644 --- a/minix/fs/ext2/proto.h +++ b/minix/fs/ext2/proto.h @@ -2,7 +2,7 @@ #define EXT2_PROTO_H #define get_block(d, n, t) lmfs_get_block(d, n, t) -#define put_block(n, t) lmfs_put_block(n, t) +#define put_block(n) lmfs_put_block(n) /* Function prototypes. */ diff --git a/minix/fs/ext2/read.c b/minix/fs/ext2/read.c index 2e4afd408..28d1f73c2 100644 --- a/minix/fs/ext2/read.c +++ b/minix/fs/ext2/read.c @@ -10,6 +10,7 @@ #include "inode.h" #include "super.h" #include +#include #include @@ -193,8 +194,7 @@ int *completed; /* number of bytes copied */ lmfs_markdirty(bp); } - n = (off + chunk == block_size ? FULL_DATA_BLOCK : PARTIAL_DATA_BLOCK); - put_block(bp, n); + put_block(bp); return(r); } @@ -262,7 +262,7 @@ int opportunistic; excess = block_pos - triple_ind_s; mindex = excess / addr_in_block2; b = rd_indir(bp, mindex); /* num of double ind block */ - put_block(bp, INDIRECT_BLOCK); /* release triple ind block */ + put_block(bp); /* release triple ind block */ excess = excess % addr_in_block2; } if (b == NO_BLOCK) return(NO_BLOCK); @@ -273,7 +273,7 @@ int opportunistic; ASSERT(lmfs_dev(bp) == rip->i_dev); mindex = excess / addr_in_block; b = rd_indir(bp, mindex); /* num of single ind block */ - put_block(bp, INDIRECT_BLOCK); /* release double ind block */ + put_block(bp); /* release double ind block */ mindex = excess % addr_in_block; /* index into single ind blk */ } if (b == NO_BLOCK) return(NO_BLOCK); @@ -284,7 +284,7 @@ int opportunistic; ASSERT(lmfs_dev(bp) != NO_DEV); ASSERT(lmfs_dev(bp) == rip->i_dev); b = rd_indir(bp, mindex); - put_block(bp, INDIRECT_BLOCK); /* release single ind block */ + put_block(bp); /* release single ind block */ return(b); } @@ -439,7 +439,7 @@ unsigned bytes_ahead; /* bytes beyond position for immediate use */ } if (lmfs_dev(bp) != NO_DEV) { /* Oops, block already in the cache, get out. */ - put_block(bp, FULL_DATA_BLOCK); + put_block(bp); break; } } @@ -558,7 +558,7 @@ ssize_t fs_getdents(ino_t ino_nr, struct fsdriver_data *data, size_t bytes, } } - put_block(bp, DIRECTORY_BLOCK); + put_block(bp); if (done) break; } diff --git a/minix/fs/ext2/stadir.c b/minix/fs/ext2/stadir.c index 8045a53f7..233705fcb 100644 --- a/minix/fs/ext2/stadir.c +++ b/minix/fs/ext2/stadir.c @@ -75,12 +75,11 @@ int fs_statvfs(struct statvfs *st) /*===========================================================================* * blockstats * *===========================================================================*/ -void fs_blockstats(u64_t *blocks, u64_t *free, u64_t *used) +void fs_blockstats(u64_t *blocks, u64_t *free) { struct super_block *sp = get_super(fs_dev); *blocks = sp->s_blocks_count; *free = sp->s_free_blocks_count; - *used = *blocks - *free; } diff --git a/minix/fs/ext2/write.c b/minix/fs/ext2/write.c index 638bf4e42..b0d007105 100644 --- a/minix/fs/ext2/write.c +++ b/minix/fs/ext2/write.c @@ -131,7 +131,7 @@ int op; /* special actions */ /* Create the double indirect block. */ if ( (b2 = alloc_block(rip, rip->i_bsearch) ) == NO_BLOCK) { /* Release triple ind blk. */ - put_block(bp_tindir, INDIRECT_BLOCK); + put_block(bp_tindir); ext2_debug("failed to allocate dblock near %d\n", rip->i_block[0]); return(ENOSPC); } @@ -174,8 +174,8 @@ int op; /* special actions */ if (b1 == NO_BLOCK && !(op & WMAP_FREE)) { if ( (b1 = alloc_block(rip, rip->i_bsearch) ) == NO_BLOCK) { /* Release dbl and triple indirect blks. */ - put_block(bp_dindir, INDIRECT_BLOCK); - put_block(bp_tindir, INDIRECT_BLOCK); + put_block(bp_dindir); + put_block(bp_tindir); ext2_debug("failed to allocate dblock near %d\n", rip->i_block[0]); return(ENOSPC); } @@ -228,7 +228,7 @@ int op; /* special actions */ /* b1 equals NO_BLOCK only when we are freeing up the indirect block. */ if(b1 != NO_BLOCK) lmfs_markdirty(bp); - put_block(bp, INDIRECT_BLOCK); + put_block(bp); } /* If the single indirect block isn't there (or was just freed), @@ -256,8 +256,8 @@ int op; /* special actions */ rip->i_block[EXT2_TIND_BLOCK] = NO_BLOCK; } - put_block(bp_dindir, INDIRECT_BLOCK); /* release double indirect blk */ - put_block(bp_tindir, INDIRECT_BLOCK); /* release triple indirect blk */ + put_block(bp_dindir); /* release double indirect blk */ + put_block(bp_tindir); /* release triple indirect blk */ return(OK); } @@ -368,8 +368,7 @@ void zero_block(bp) register struct buf *bp; /* pointer to buffer to zero */ { /* Zero a block. */ - ASSERT(lmfs_bytes(bp) > 0); ASSERT(bp->data); - memset(b_data(bp), 0, (size_t) lmfs_bytes(bp)); + memset(b_data(bp), 0, lmfs_fs_block_size()); lmfs_markdirty(bp); } diff --git a/minix/fs/isofs/inode.c b/minix/fs/isofs/inode.c index 1bcaf5f1e..1e4474bac 100644 --- a/minix/fs/isofs/inode.c +++ b/minix/fs/isofs/inode.c @@ -155,7 +155,7 @@ static struct buf* fetch_inode(struct dir_extent *extent, size_t *offset) break; } - lmfs_put_block(bp, FULL_DATA_BLOCK); + lmfs_put_block(bp); bp = read_extent_block(extent, *offset / v_pri.logical_block_size_l); } @@ -180,7 +180,7 @@ int read_inode(struct inode *i_node, struct dir_extent *extent, size_t offset, /* Parse basic ISO 9660 specs. */ if (check_dir_record(dir_rec, offset % v_pri.logical_block_size_l) != OK) { - lmfs_put_block(bp, FULL_DATA_BLOCK); + lmfs_put_block(bp); return EINVAL; } @@ -199,7 +199,7 @@ int read_inode(struct inode *i_node, struct dir_extent *extent, size_t offset, offset += dir_rec->length; read_inode_extents(i_node, dir_rec, extent, &offset); - lmfs_put_block(bp, FULL_DATA_BLOCK); + lmfs_put_block(bp); if (new_offset != NULL) *new_offset = offset; return OK; @@ -291,7 +291,7 @@ void read_inode_extents(struct inode *i, if (check_dir_record(dir_rec, *offset % v_pri.logical_block_size_l) != OK) { - lmfs_put_block(bp, FULL_DATA_BLOCK); + lmfs_put_block(bp); return; } @@ -322,7 +322,7 @@ void read_inode_extents(struct inode *i, if ((dir_rec->file_flags & D_NOT_LAST_EXTENT) == 0) done = TRUE; - lmfs_put_block(bp, FULL_DATA_BLOCK); + lmfs_put_block(bp); } } diff --git a/minix/fs/isofs/read.c b/minix/fs/isofs/read.c index 30d2e42e3..94ac59d00 100644 --- a/minix/fs/isofs/read.c +++ b/minix/fs/isofs/read.c @@ -44,7 +44,7 @@ ssize_t fs_read(ino_t ino_nr, struct fsdriver_data *data, size_t bytes, r = fsdriver_copyout(data, cum_io, b_data(bp)+off, chunk); - lmfs_put_block(bp, FULL_DATA_BLOCK); + lmfs_put_block(bp); if (r != OK) break; /* EOF reached. */ diff --git a/minix/fs/isofs/stadir.c b/minix/fs/isofs/stadir.c index 1f1978608..741f0b9d4 100644 --- a/minix/fs/isofs/stadir.c +++ b/minix/fs/isofs/stadir.c @@ -26,8 +26,8 @@ int fs_statvfs(struct statvfs *st) return OK; } -void fs_blockstats(u64_t *blocks, u64_t *free, u64_t *used) +void fs_blockstats(u64_t *blocks, u64_t *free) { - *used = *blocks = v_pri.volume_space_size_l; + *blocks = v_pri.volume_space_size_l; *free = 0; } diff --git a/minix/fs/isofs/super.c b/minix/fs/isofs/super.c index 4d55c3027..83d63ec8f 100644 --- a/minix/fs/isofs/super.c +++ b/minix/fs/isofs/super.c @@ -45,7 +45,7 @@ static int create_vol_pri_desc(struct iso9660_vol_pri_desc *vol_pri, char *buf, (vol_pri->file_struct_ver != 1)) return EINVAL; - lmfs_set_blocksize(vol_pri->logical_block_size_l, major(fs_dev)); + lmfs_set_blocksize(vol_pri->logical_block_size_l); /* Read root directory record. */ root_record = (struct iso9660_dir_record *)vol_pri->root_directory; diff --git a/minix/fs/isofs/susp.c b/minix/fs/isofs/susp.c index 2556a7020..a5fde0e27 100644 --- a/minix/fs/isofs/susp.c +++ b/minix/fs/isofs/susp.c @@ -50,7 +50,7 @@ int parse_susp(struct rrii_dir_record *dir, char *buffer) } parse_susp_buffer(dir, b_data(ca_bp) + ca_offset, ca_length); - lmfs_put_block(ca_bp, FULL_DATA_BLOCK); + lmfs_put_block(ca_bp); return OK; } diff --git a/minix/fs/mfs/buf.h b/minix/fs/mfs/buf.h index 9dbcb83e4..898095893 100644 --- a/minix/fs/mfs/buf.h +++ b/minix/fs/mfs/buf.h @@ -3,36 +3,14 @@ #include "clean.h" -/* Buffer (block) cache. To acquire a block, a routine calls get_block(), - * telling which block it wants. The block is then regarded as "in use" - * and has its 'b_count' field incremented. All the blocks that are not - * in use are chained together in an LRU list, with 'front' pointing - * to the least recently used block, and 'rear' to the most recently used - * block. A reverse chain, using the field b_prev is also maintained. - * Usage for LRU is measured by the time the put_block() is done. The second - * parameter to put_block() can violate the LRU order and put a block on the - * front of the list, if it will probably not be needed soon. If a block - * is modified, the modifying routine must set b_dirt to DIRTY, so the block - * will eventually be rewritten to the disk. - */ - -#include - union fsdata_u { - char b__data[1]; /* ordinary user data */ -/* directory block */ - struct direct b__dir[1]; -/* V2 indirect block */ - zone_t b__v2_ind[1]; -/* V2 inode block */ - d2_inode b__v2_ino[1]; -/* bit map block */ - bitchunk_t b__bitmap[1]; + char b__data[1]; /* ordinary user data */ + struct direct b__dir[1]; /* directory block */ + zone_t b__v2_ind[1]; /* V2 indirect block */ + d2_inode b__v2_ino[1]; /* V2 inode block */ + bitchunk_t b__bitmap[1]; /* bit map block */ }; -/* A block is free if b_dev == NO_DEV. */ - - /* These defs make it possible to use to bp->b_data instead of bp->b.b__data */ #define b_data(b) ((union fsdata_u *) b->data)->b__data #define b_dir(b) ((union fsdata_u *) b->data)->b__dir @@ -41,4 +19,3 @@ union fsdata_u { #define b_bitmap(b) ((union fsdata_u *) b->data)->b__bitmap #endif - diff --git a/minix/fs/mfs/inode.c b/minix/fs/mfs/inode.c index 7c5a60c83..65c5e3d65 100644 --- a/minix/fs/mfs/inode.c +++ b/minix/fs/mfs/inode.c @@ -405,7 +405,7 @@ int rw_flag; /* READING or WRITING */ assert(sp->s_version == V3); new_icopy(rip, dip2, rw_flag, sp->s_native); - put_block(bp, INODE_BLOCK); + put_block(bp); IN_MARKCLEAN(rip); } diff --git a/minix/fs/mfs/link.c b/minix/fs/mfs/link.c index a634e73da..b448cc8e0 100644 --- a/minix/fs/mfs/link.c +++ b/minix/fs/mfs/link.c @@ -168,7 +168,7 @@ ssize_t fs_rdlink(ino_t ino_nr, struct fsdriver_data *data, size_t bytes) if (bytes > rip->i_size) bytes = rip->i_size; r = fsdriver_copyout(data, 0, b_data(bp), bytes); - put_block(bp, DIRECTORY_BLOCK); + put_block(bp); if (r == OK) r = bytes; } @@ -629,7 +629,7 @@ off_t len; bytes = len; memset(b_data(bp) + offset, 0, bytes); MARKDIRTY(bp); - put_block(bp, FULL_DATA_BLOCK); + put_block(bp); pos += bytes; len -= bytes; diff --git a/minix/fs/mfs/mount.c b/minix/fs/mfs/mount.c index 544576f2c..4bb751d39 100644 --- a/minix/fs/mfs/mount.c +++ b/minix/fs/mfs/mount.c @@ -49,7 +49,7 @@ int fs_mount(dev_t dev, unsigned int flags, struct fsdriver_node *root_node, printf("MFS: WARNING: FS 0x%llx unclean, mounting readonly\n", fs_dev); } - lmfs_set_blocksize(superblock.s_block_size, major(fs_dev)); + lmfs_set_blocksize(superblock.s_block_size); /* Get the root inode of the mounted file system. */ if( (root_ip = get_inode(fs_dev, ROOT_INODE)) == NULL) { diff --git a/minix/fs/mfs/open.c b/minix/fs/mfs/open.c index 67c8225ae..314a45917 100644 --- a/minix/fs/mfs/open.c +++ b/minix/fs/mfs/open.c @@ -170,7 +170,7 @@ int fs_slink(ino_t dir_nr, char *name, uid_t uid, gid_t gid, } } - put_block(bp, DIRECTORY_BLOCK); /* put_block() accepts NULL. */ + put_block(bp); /* put_block() accepts NULL. */ if(r != OK) { sip->i_nlinks = NO_LINK; diff --git a/minix/fs/mfs/path.c b/minix/fs/mfs/path.c index 92328e748..2eae77e58 100644 --- a/minix/fs/mfs/path.c +++ b/minix/fs/mfs/path.c @@ -186,7 +186,7 @@ int flag; /* LOOK_UP, ENTER, DELETE or IS_EMPTY */ (int) dp->mfs_d_ino); } assert(lmfs_dev(bp) != NO_DEV); - put_block(bp, DIRECTORY_BLOCK); + put_block(bp); return(r); } @@ -200,7 +200,7 @@ int flag; /* LOOK_UP, ENTER, DELETE or IS_EMPTY */ /* The whole block has been searched or ENTER has a free slot. */ if (e_hit) break; /* e_hit set if ENTER can be performed now */ assert(lmfs_dev(bp) != NO_DEV); - put_block(bp, DIRECTORY_BLOCK); /* otherwise, continue searching dir */ + put_block(bp); /* otherwise, continue searching dir */ } /* The whole directory has now been searched. */ @@ -231,7 +231,7 @@ int flag; /* LOOK_UP, ENTER, DELETE or IS_EMPTY */ sp = ldir_ptr->i_sp; dp->mfs_d_ino = conv4(sp->s_native, (int) *numb); MARKDIRTY(bp); - put_block(bp, DIRECTORY_BLOCK); + put_block(bp); ldir_ptr->i_update |= CTIME | MTIME; /* mark mtime for update later */ IN_MARKDIRTY(ldir_ptr); if (new_slots > old_slots) { diff --git a/minix/fs/mfs/proto.h b/minix/fs/mfs/proto.h index b19663817..10f6707dc 100644 --- a/minix/fs/mfs/proto.h +++ b/minix/fs/mfs/proto.h @@ -3,7 +3,7 @@ /* Some shortcuts to functions in -lminixfs */ #define get_block(d, b, t) lmfs_get_block(d, b, t) -#define put_block(b, t) lmfs_put_block(b, t) +#define put_block(b) lmfs_put_block(b) /* Function prototypes. */ diff --git a/minix/fs/mfs/read.c b/minix/fs/mfs/read.c index 5b2d4acca..f5bdf149d 100644 --- a/minix/fs/mfs/read.c +++ b/minix/fs/mfs/read.c @@ -6,6 +6,7 @@ #include "inode.h" #include "super.h" #include +#include #include @@ -203,8 +204,7 @@ int *completed; /* number of bytes copied */ MARKDIRTY(bp); } - n = (off + chunk == block_size ? FULL_DATA_BLOCK : PARTIAL_DATA_BLOCK); - put_block(bp, n); + put_block(bp); return(r); } @@ -269,7 +269,7 @@ int opportunistic; /* if nonzero, only use cache for metadata */ ASSERT(lmfs_dev(bp) != NO_DEV); ASSERT(lmfs_dev(bp) == rip->i_dev); z = rd_indir(bp, index); /* z= zone for single*/ - put_block(bp, INDIRECT_BLOCK); /* release double ind block */ + put_block(bp); /* release double ind block */ excess = excess % nr_indirects; /* index into single ind blk */ } @@ -280,7 +280,7 @@ int opportunistic; /* if nonzero, only use cache for metadata */ if (bp == NULL) return NO_BLOCK; /* peeking failed */ z = rd_indir(bp, (int) excess); /* get block pointed to */ - put_block(bp, INDIRECT_BLOCK); /* release single indir blk */ + put_block(bp); /* release single indir blk */ if (z == NO_ZONE) return(NO_BLOCK); b = (block_t) ((z << scale) + boff); return(b); @@ -452,7 +452,7 @@ unsigned bytes_ahead; /* bytes beyond position for immediate use */ assert(bp->lmfs_count > 0); if (lmfs_dev(bp) != NO_DEV) { /* Oops, block already in the cache, get out. */ - put_block(bp, FULL_DATA_BLOCK); + put_block(bp); break; } } @@ -554,7 +554,7 @@ ssize_t fs_getdents(ino_t ino_nr, struct fsdriver_data *data, size_t bytes, } } - put_block(bp, DIRECTORY_BLOCK); + put_block(bp); if (done) break; } diff --git a/minix/fs/mfs/stadir.c b/minix/fs/mfs/stadir.c index 2d161cdbd..765e0ea87 100644 --- a/minix/fs/mfs/stadir.c +++ b/minix/fs/mfs/stadir.c @@ -84,13 +84,12 @@ int fs_statvfs(struct statvfs *st) { struct super_block *sp; int scale; - u64_t used; sp = get_super(fs_dev); scale = sp->s_log_zone_size; - fs_blockstats(&st->f_blocks, &st->f_bfree, &used); + fs_blockstats(&st->f_blocks, &st->f_bfree); st->f_bavail = st->f_bfree; st->f_bsize = sp->s_block_size << scale; diff --git a/minix/fs/mfs/stats.c b/minix/fs/mfs/stats.c index 7cf9fb83f..d45b92c3f 100644 --- a/minix/fs/mfs/stats.c +++ b/minix/fs/mfs/stats.c @@ -81,18 +81,18 @@ int map; /* IMAP (inode map) or ZMAP (zone map) */ if (b >= map_bits) break; } - put_block(bp, MAP_BLOCK); + put_block(bp); ++block; word = 0; } while (--bcount > 0); - return free_bits; /* no bit could be allocated */ + return free_bits; } /*===========================================================================* * blockstats * *===========================================================================*/ -void fs_blockstats(u64_t *blocks, u64_t *free, u64_t *used) +void fs_blockstats(u64_t *blocks, u64_t *free) { struct super_block *sp; @@ -102,8 +102,7 @@ void fs_blockstats(u64_t *blocks, u64_t *free, u64_t *used) assert(!sp->s_log_zone_size); *blocks = sp->s_zones; - *used = get_used_blocks(sp); - *free = *blocks - *used; + *free = *blocks - get_used_blocks(sp); return; } diff --git a/minix/fs/mfs/super.c b/minix/fs/mfs/super.c index 68543a4b3..f50df8425 100644 --- a/minix/fs/mfs/super.c +++ b/minix/fs/mfs/super.c @@ -93,14 +93,14 @@ bit_t origin; /* number of bit to start searching at */ k |= 1 << i; *wptr = (bitchunk_t) conv4(sp->s_native, (int) k); MARKDIRTY(bp); - put_block(bp, MAP_BLOCK); + put_block(bp); if(map == ZMAP) { used_blocks++; - lmfs_blockschange(sp->s_dev, 1); + lmfs_blockschange(1); } return(b); } - put_block(bp, MAP_BLOCK); + put_block(bp); if (++block >= (unsigned int) bit_blocks) /* last block, wrap around */ block = 0; word = 0; @@ -150,11 +150,11 @@ bit_t bit_returned; /* number of bit to insert into the map */ b_bitmap(bp)[word] = (bitchunk_t) conv4(sp->s_native, (int) k); MARKDIRTY(bp); - put_block(bp, MAP_BLOCK); + put_block(bp); if(map == ZMAP) { used_blocks--; - lmfs_blockschange(sp->s_dev, -1); + lmfs_blockschange(-1); } } @@ -238,7 +238,7 @@ static int rw_super(struct super_block *sp, int writing) sp->s_dev = save_dev; } - put_block(bp, FULL_DATA_BLOCK); + put_block(bp); lmfs_flushall(); return OK; diff --git a/minix/fs/mfs/write.c b/minix/fs/mfs/write.c index 3a87dd56f..0d27266e6 100644 --- a/minix/fs/mfs/write.c +++ b/minix/fs/mfs/write.c @@ -125,7 +125,7 @@ int op; /* special actions */ if (bp_dindir != NULL) MARKDIRTY(bp_dindir); if (z1 == NO_ZONE) { /* Release dbl indirect blk. */ - put_block(bp_dindir, INDIRECT_BLOCK); + put_block(bp_dindir); return(err_code); /* couldn't create single ind */ } } @@ -166,7 +166,7 @@ int op; /* special actions */ } /* z1 equals NO_ZONE only when we are freeing up the indirect block. */ if(z1 != NO_ZONE) MARKDIRTY(bp); - put_block(bp, INDIRECT_BLOCK); + put_block(bp); } /* If the single indirect block isn't there (or was just freed), @@ -179,7 +179,7 @@ int op; /* special actions */ rip->i_zone[zones+1] = NO_ZONE; } - put_block(bp_dindir, INDIRECT_BLOCK); /* release double indirect blk */ + put_block(bp_dindir); /* release double indirect blk */ return(OK); } @@ -311,9 +311,8 @@ void zero_block(bp) register struct buf *bp; /* pointer to buffer to zero */ { /* Zero a block. */ - ASSERT(lmfs_bytes(bp) > 0); ASSERT(bp->data); - memset(b_data(bp), 0, (size_t) lmfs_bytes(bp)); + memset(b_data(bp), 0, lmfs_fs_block_size()); MARKDIRTY(bp); } diff --git a/minix/include/minix/libminixfs.h b/minix/include/minix/libminixfs.h index badaf5a0f..e6094515a 100644 --- a/minix/include/minix/libminixfs.h +++ b/minix/include/minix/libminixfs.h @@ -31,31 +31,30 @@ void lmfs_markdirty(struct buf *bp); void lmfs_markclean(struct buf *bp); int lmfs_isclean(struct buf *bp); dev_t lmfs_dev(struct buf *bp); -int lmfs_bytes(struct buf *bp); int lmfs_bufs_in_use(void); int lmfs_nr_bufs(void); void lmfs_flushall(void); void lmfs_flushdev(dev_t dev); int lmfs_fs_block_size(void); -void lmfs_may_use_vmcache(int); -void lmfs_set_blocksize(int blocksize, int major); -void lmfs_reset_rdwt_err(void); -int lmfs_rdwt_err(void); +void lmfs_may_use_vmcache(int); +void lmfs_set_blocksize(int blocksize); +void lmfs_reset_rdwt_err(void); +int lmfs_rdwt_err(void); void lmfs_buf_pool(int new_nr_bufs); struct buf *lmfs_get_block(dev_t dev, block64_t block, int how); struct buf *lmfs_get_block_ino(dev_t dev, block64_t block, int how, ino_t ino, u64_t off); -void lmfs_put_block(struct buf *bp, int block_type); +void lmfs_put_block(struct buf *bp); void lmfs_free_block(dev_t dev, block64_t block); void lmfs_zero_block_ino(dev_t dev, ino_t ino, u64_t off); void lmfs_invalidate(dev_t device); void lmfs_rw_scattered(dev_t, struct buf **, int, int); void lmfs_setquiet(int q); -void lmfs_cache_reevaluate(dev_t dev); -void lmfs_blockschange(dev_t dev, int delta); +void lmfs_cache_reevaluate(void); +void lmfs_blockschange(int delta); /* calls that libminixfs does into fs */ -void fs_blockstats(u64_t *blocks, u64_t *free, u64_t *used); +void fs_blockstats(u64_t *blocks, u64_t *free); /* get_block arguments */ #define NORMAL 0 /* forces get_block to do disk read */ @@ -63,16 +62,6 @@ void fs_blockstats(u64_t *blocks, u64_t *free, u64_t *used); #define PREFETCH 2 /* tells get_block not to read or mark dev */ #define PEEK 3 /* returns NULL if not in cache or VM cache */ -/* When a block is released, the type of usage is passed to put_block(). */ -#define ONE_SHOT 0200 /* set if block not likely to be needed soon */ - -#define INODE_BLOCK 0 /* inode block */ -#define DIRECTORY_BLOCK 1 /* directory block */ -#define INDIRECT_BLOCK 2 /* pointer block */ -#define MAP_BLOCK 3 /* bit map */ -#define FULL_DATA_BLOCK 5 /* data, fully used */ -#define PARTIAL_DATA_BLOCK 6 /* data, partly used*/ - #define END_OF_FILE (-104) /* eof detected */ /* Block I/O helper functions. */ diff --git a/minix/lib/libminixfs/bio.c b/minix/lib/libminixfs/bio.c index 8f0b72aa4..b9b892d8f 100644 --- a/minix/lib/libminixfs/bio.c +++ b/minix/lib/libminixfs/bio.c @@ -66,7 +66,7 @@ block_prefetch(dev_t dev, block64_t block, unsigned int nblocks) assert(bp != NULL); if (lmfs_dev(bp) != NO_DEV) { - lmfs_put_block(bp, FULL_DATA_BLOCK); + lmfs_put_block(bp); break; } @@ -175,7 +175,7 @@ lmfs_bio(dev_t dev, struct fsdriver_data * data, size_t bytes, off_t pos, (char *)bp->data + block_off, chunk); } - lmfs_put_block(bp, FULL_DATA_BLOCK); + lmfs_put_block(bp); if (r != OK) break; diff --git a/minix/lib/libminixfs/cache.c b/minix/lib/libminixfs/cache.c index b4b5e180c..3b1aa0dce 100644 --- a/minix/lib/libminixfs/cache.c +++ b/minix/lib/libminixfs/cache.c @@ -18,6 +18,22 @@ #include #include +/* Buffer (block) cache. To acquire a block, a routine calls lmfs_get_block(), + * telling which block it wants. The block is then regarded as "in use" and + * has its reference count incremented. All the blocks that are not in use are + * chained together in an LRU list, with 'front' pointing to the least recently + * used block, and 'rear' to the most recently used block. A reverse chain is + * also maintained. Usage for LRU is measured by the time the put_block() is + * done. The second parameter to put_block() can violate the LRU order and put + * a block on the front of the list, if it will probably not be needed again. + * This is used internally only; the lmfs_put_block() API call has no second + * parameter. If a block is modified, the modifying routine must mark the + * block as dirty, so the block will eventually be rewritten to the disk. + */ + +/* Flags to put_block(). */ +#define ONE_SHOT 0x1 /* set if block will not be needed again */ + #define BUFHASH(b) ((unsigned int)((b) % nr_bufs)) #define MARKCLEAN lmfs_markclean @@ -30,7 +46,8 @@ static unsigned int bufs_in_use;/* # bufs currently in use (not on free list)*/ static void rm_lru(struct buf *bp); static void read_block(struct buf *); static void freeblock(struct buf *bp); -static void cache_heuristic_check(int major); +static void cache_heuristic_check(void); +static void put_block(struct buf *bp, int put_flags); static int vmcache = 0; /* are we using vm's secondary cache? (initially not) */ @@ -48,7 +65,7 @@ static int quiet = 0; void lmfs_setquiet(int q) { quiet = q; } static u32_t fs_bufs_heuristic(int minbufs, u32_t btotal, u64_t bfree, - int blocksize, dev_t majordev) + int blocksize) { struct vm_stats_info vsi; int bufs; @@ -96,7 +113,7 @@ static u32_t fs_bufs_heuristic(int minbufs, u32_t btotal, u64_t bfree, return bufs; } -void lmfs_blockschange(dev_t dev, int delta) +void lmfs_blockschange(int delta) { /* Change the number of allocated blocks by 'delta.' * Also accumulate the delta since the last cache re-evaluation. @@ -108,7 +125,7 @@ void lmfs_blockschange(dev_t dev, int delta) #define BANDKB (10*1024) /* recheck cache every 10MB change */ if(bitdelta*(int)fs_block_size/1024 > BANDKB || bitdelta*(int)fs_block_size/1024 < -BANDKB) { - lmfs_cache_reevaluate(dev); + lmfs_cache_reevaluate(); bitdelta = 0; } } @@ -133,11 +150,6 @@ dev_t lmfs_dev(struct buf *bp) return bp->lmfs_dev; } -int lmfs_bytes(struct buf *bp) -{ - return bp->lmfs_bytes; -} - static void free_unused_blocks(void) { struct buf *bp; @@ -414,7 +426,7 @@ struct buf *lmfs_get_block_ino(dev_t dev, block64_t block, int how, ino_t ino, if (how == PEEK) { bp->lmfs_dev = NO_DEV; - lmfs_put_block(bp, ONE_SHOT); + put_block(bp, ONE_SHOT); return NULL; } @@ -441,26 +453,20 @@ struct buf *lmfs_get_block_ino(dev_t dev, block64_t block, int how, ino_t ino, } /*===========================================================================* - * lmfs_put_block * + * put_block * *===========================================================================*/ -void lmfs_put_block( - struct buf *bp, /* pointer to the buffer to be released */ - int block_type /* INODE_BLOCK, DIRECTORY_BLOCK, or whatever */ -) +static void put_block(struct buf *bp, int put_flags) { -/* Return a block to the list of available blocks. Depending on 'block_type' +/* Return a block to the list of available blocks. Depending on 'put_flags' * it may be put on the front or rear of the LRU chain. Blocks that are - * expected to be needed again shortly (e.g., partially full data blocks) - * go on the rear; blocks that are unlikely to be needed again shortly - * (e.g., full data blocks) go on the front. Blocks whose loss can hurt - * the integrity of the file system (e.g., inode blocks) are written to - * disk immediately if they are dirty. + * expected to be needed again at some point go on the rear; blocks that are + * unlikely to be needed again at all go on the front. */ dev_t dev; uint64_t dev_off; int r, setflags; - if (bp == NULL) return; /* it is easier to check here than in caller */ + assert(bp != NULL); dev = bp->lmfs_dev; @@ -470,8 +476,8 @@ void lmfs_put_block( if (bp->lmfs_count != 0) return; /* block is still in use */ /* Put this block back on the LRU chain. */ - if (dev == NO_DEV || dev == DEV_RAM || (block_type & ONE_SHOT)) { - /* Block probably won't be needed quickly. Put it on front of chain. + if (dev == NO_DEV || dev == DEV_RAM || (put_flags & ONE_SHOT)) { + /* Block will not be needed again. Put it on front of chain. * It will be the next block to be evicted from the cache. */ bp->lmfs_prev = NULL; @@ -483,7 +489,7 @@ void lmfs_put_block( front = bp; } else { - /* Block probably will be needed quickly. Put it on rear of chain. + /* Block may be needed again. Put it on rear of chain. * It will not be evicted from the cache for a long time. */ bp->lmfs_prev = rear; @@ -502,7 +508,7 @@ void lmfs_put_block( if(vmcache && bp->lmfs_needsetcache && dev != NO_DEV) { assert(bp->data); - setflags = (block_type & ONE_SHOT) ? VMSF_ONCE : 0; + setflags = (put_flags & ONE_SHOT) ? VMSF_ONCE : 0; if ((r = vm_set_cacheblock(bp->data, dev, dev_off, bp->lmfs_inode, bp->lmfs_inode_offset, &bp->lmfs_flags, fs_block_size, setflags)) != OK) { @@ -522,10 +528,22 @@ void lmfs_put_block( * after, which could be a problem if VM already forgot the block and we are * expected to pass it to VM again, which then wouldn't happen. */ - if (block_type & ONE_SHOT) + if (put_flags & ONE_SHOT) bp->lmfs_dev = NO_DEV; } +/*===========================================================================* + * lmfs_put_block * + *===========================================================================*/ +void lmfs_put_block(struct buf *bp) +{ +/* User interface to put_block(). */ + + if (bp == NULL) return; /* for poorly written file systems */ + + put_block(bp, 0); +} + /*===========================================================================* * lmfs_free_block * *===========================================================================*/ @@ -621,14 +639,14 @@ void lmfs_zero_block_ino(dev_t dev, ino_t ino, u64_t ino_off) * TODO: tell VM that it is an all-zeroes block, so that VM can deduplicate * all such pages in its cache. */ - lmfs_put_block(bp, ONE_SHOT); + put_block(bp, ONE_SHOT); } -void lmfs_cache_reevaluate(dev_t dev) +void lmfs_cache_reevaluate(void) { - if(bufs_in_use == 0 && dev != NO_DEV) { + if (bufs_in_use == 0) { /* if the cache isn't in use any more, we could resize it. */ - cache_heuristic_check(major(dev)); + cache_heuristic_check(); } } @@ -876,7 +894,7 @@ void lmfs_rw_scattered( } if (rw_flag == READING) { bp->lmfs_dev = dev; /* validate block */ - lmfs_put_block(bp, PARTIAL_DATA_BLOCK); + lmfs_put_block(bp); } else { MARKCLEAN(bp); } @@ -891,7 +909,7 @@ void lmfs_rw_scattered( * give at this time. Don't forget to release those extras. */ while (bufqsize > 0) { - lmfs_put_block(*bufq++, PARTIAL_DATA_BLOCK); + lmfs_put_block(*bufq++); bufqsize--; } } @@ -952,15 +970,14 @@ static void cache_resize(unsigned int blocksize, unsigned int bufs) fs_block_size = blocksize; } -static void cache_heuristic_check(int major) +static void cache_heuristic_check(void) { int bufs, d; - u64_t btotal, bfree, bused; + u64_t btotal, bfree; - fs_blockstats(&btotal, &bfree, &bused); + fs_blockstats(&btotal, &bfree); - bufs = fs_bufs_heuristic(10, btotal, bfree, - fs_block_size, major); + bufs = fs_bufs_heuristic(10, btotal, bfree, fs_block_size); /* set the cache to the new heuristic size if the new one * is more than 10% off from the current one. @@ -975,16 +992,14 @@ static void cache_heuristic_check(int major) /*===========================================================================* * lmfs_set_blocksize * *===========================================================================*/ -void lmfs_set_blocksize(int new_block_size, int major) +void lmfs_set_blocksize(int new_block_size) { cache_resize(new_block_size, MINBUFS); - cache_heuristic_check(major); + cache_heuristic_check(); /* Decide whether to use seconday cache or not. - * Only do this if - * - it's available, and - * - use of it hasn't been disabled for this fs, and - * - our main FS device isn't a memory device + * Only do this if the block size is a multiple of the page size, and using + * the VM cache has been enabled for this FS. */ vmcache = 0; diff --git a/minix/lib/libminixfs/minixfs.h b/minix/lib/libminixfs/minixfs.h deleted file mode 100644 index 30d70b98a..000000000 --- a/minix/lib/libminixfs/minixfs.h +++ /dev/null @@ -1,4 +0,0 @@ -#define _SYSTEM - -#include /* common to all libraries */ -#include /* need task numbers + message types */ diff --git a/minix/tests/test72.c b/minix/tests/test72.c index 9e13f16dc..70552a1c7 100644 --- a/minix/tests/test72.c +++ b/minix/tests/test72.c @@ -53,7 +53,7 @@ dowriteblock(int b, int blocksize, u32_t seed, char *data) lmfs_markdirty(bp); - lmfs_put_block(bp, FULL_DATA_BLOCK); + lmfs_put_block(bp); return blocksize; } @@ -72,7 +72,7 @@ readblock(int b, int blocksize, u32_t seed, char *data) memcpy(data, bp->data, blocksize); - lmfs_put_block(bp, FULL_DATA_BLOCK); + lmfs_put_block(bp); return blocksize; } @@ -91,9 +91,9 @@ void testend(void) /* Fake some libminixfs client functions */ void -fs_blockstats(u64_t *total, u64_t *free, u64_t *used) +fs_blockstats(u64_t *total, u64_t *free) { - *total = *free = *used = 0; + *total = *free = 0; } static void allocate(int b) @@ -269,7 +269,7 @@ main(int argc, char *argv[]) for(p = 1; p <= 3; p++) { /* Do not update curblocksize until the cache is flushed. */ newblocksize = PAGE_SIZE*p; - lmfs_set_blocksize(newblocksize, MYMAJOR); + lmfs_set_blocksize(newblocksize); curblocksize = newblocksize; /* now it's safe to update */ lmfs_buf_pool(BLOCKS); if(dotest(curblocksize, BLOCKS, ITER)) e(n); @@ -282,7 +282,7 @@ main(int argc, char *argv[]) for(wss = 2; wss <= 3; wss++) { int wsblocks = 10*wss*wss*wss*wss*wss; for(cs = wsblocks/4; cs <= wsblocks*3; cs *= 1.5) { - lmfs_set_blocksize(PAGE_SIZE, MYMAJOR); + lmfs_set_blocksize(PAGE_SIZE); curblocksize = PAGE_SIZE; /* same as above */ lmfs_buf_pool(cs); if(dotest(curblocksize, wsblocks, ITER)) e(n); -- 2.44.0