nilfs2: implement calculation of free inodes count
Subsystems (2)
Vyacheslav Dubeyko
maintainerPATCH v4 1/1 nilfs2: implement calculation of free inodes count
Hi Ryusuke,
This is fourth version of the patch. I reworked representation of mi_desc_blocks_count because I think that using this field is good solution for calculation of max entries count.
By the way, I see that it is used atomic_t type for representation of inodes_count and blocks_count fields in nilfs_root structure. Maybe it makes sense to rework representation of these fields too. What do you think?
v3->v4
* The desc_blocks value is represented by unsigned long type.
* The nilfs_palloc_count_desc_blocks() method is simplified.
* The mi_desc_blocks_count field of nilfs_mdt_info structure is represented as atomic64_t for the case of CONFIG_64BIT and as atomic_t for other cases.
v2->v3
* Trivial BUG_ON checks were removed.
* Whole calculation algorithm was moved into nilfs_palloc_count_max_entries() method.
* Improve error processing in the code.
* The nilfs_palloc_mdt_file_can_grow() method was simplified.
* The nilfs_ifile_count_free_inodes() method was simplified.
v1->v2
* Change __statfs_word on u64 type.
* Rename nilfs_count_free_inodes() into nilfs_ifile_count_free_inodes() method.
* Introduce auxiliary functions: nilfs_palloc_count_max_entries(), nilfs_palloc_count_desc_blocks(), nilfs_palloc_mdt_file_can_grow().
* Rework processing of returned error from nilfs_ifile_count_free_inodes() in nilfs_statfs().
With the best regards,
Vyacheslav Dubeyko.
---
From: Vyacheslav Dubeyko <[email protected]>
Subject: [PATCH v4] nilfs2: implement calculation of free inodes count
Currently, NILFS2 returns 0 as free inodes count (f_ffree) and current used inodes count as total file nodes in file system (f_files):
df -i
Filesystem Inodes IUsed IFree IUse% Mounted on/dev/loop0 2 2 0 100% /mnt/nilfs2
This patch implements real calculation of free inodes count. First of all, it is calculated total file nodes in file system as (desc_blocks_count * groups_per_desc_block * entries_per_group). Then, it is calculated free inodes count as difference the total file nodes and used inodes count. As a result, we have such output for NILFS2:
df -i
Filesystem Inodes IUsed IFree IUse% Mounted on/dev/loop0 4194304 2114701 2079603 51% /mnt/nilfs2
--- fs/nilfs2/alloc.c | 78 +++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/nilfs2/alloc.h | 2 ++ fs/nilfs2/ifile.c | 22 +++++++++++++++ fs/nilfs2/ifile.h | 2 +- fs/nilfs2/mdt.h | 26 ++++++++++++++++++ fs/nilfs2/super.c | 25 +++++++++++++++-- 6 files changed, 152 insertions(+), 3 deletions(-)
fs/nilfs2/alloc.c +78 -0
@@ -80,6 +80,13 @@ int nilfs_palloc_init_blockgroup(struct inode *inode, unsigned entry_size) mi->mi_blocks_per_group +1 ;/* Number of blocks per descriptor including the descriptor block */ +nilfs_mdt_set_desc_blocks (mi,1 ); +/* +* The field mi_desc_blocks_count is used for +* storing knowledge about current count of +* desciptor blocks. Initially, it is initialized +* by one. +*/ return 0 ; }
@@ -398,6 +405,77 @@ nilfs_palloc_rest_groups_in_desc_block(const struct inode *inode, }/** +* nilfs_palloc_count_desc_blocks - count descriptor blocks number +* @inode: inode of metadata file using this allocator +* @desc_blocks: descriptor blocks number [out] +*/ +static int nilfs_palloc_count_desc_blocks (struct inode *inode, +unsigned long *desc_blocks) +{ +unsigned long blknum; +int ret; + + ret =nilfs_bmap_last_key (NILFS_I (inode)->i_bmap, &blknum); +if (likely (!ret)) + *desc_blocks =DIV_ROUND_UP ( + blknum,NILFS_MDT (inode)->mi_blocks_per_desc_block); +return ret; +} + +/** +* nilfs_palloc_mdt_file_can_grow - check potential opportunity for +* MDT file growing +* @inode: inode of metadata file using this allocator +* @desc_blocks: known current descriptor blocks count +*/ +static inline bool nilfs_palloc_mdt_file_can_grow (struct inode *inode, +unsigned long desc_blocks) +{ +return (nilfs_palloc_groups_per_desc_block (inode) * desc_blocks) < +nilfs_palloc_groups_count (inode); +} + +/** +* nilfs_palloc_count_max_entries - count max number of entries that can be +* described by descriptor blocks count +* @inode: inode of metadata file using this allocator +* @nused: current number of used entries +* @nmaxp: max number of entries [out] +*/ +int nilfs_palloc_count_max_entries (struct inode *inode,u64 nused,u64 *nmaxp) +{ +unsigned long desc_blocks; +u64 entries_per_desc_block, nmax; +int err; + + desc_blocks =nilfs_mdt_read_desc_blocks (NILFS_MDT (inode)); + entries_per_desc_block = (u64 )nilfs_palloc_entries_per_group (inode) * +nilfs_palloc_groups_per_desc_block (inode); + + nmax = entries_per_desc_block * desc_blocks; +if (nused >= nmax) { + err =nilfs_palloc_count_desc_blocks (inode, &desc_blocks); +if (unlikely (err)) +return err; + + nmax = entries_per_desc_block * desc_blocks; +if (nused == nmax && +nilfs_palloc_mdt_file_can_grow (inode, + desc_blocks)) { + nmax += entries_per_desc_block; + ++desc_blocks; + } + +nilfs_mdt_set_desc_blocks (NILFS_MDT (inode), desc_blocks); + +if (nused > nmax) +return -ERANGE ; + } + *nmaxp = nmax; +return 0 ; +} + +/** * nilfs_palloc_prepare_alloc_entry - prepare to allocate a persistent object * @inode: inode of metadata file using this allocator * @req: nilfs_palloc_req structure exchanged for the allocation
fs/nilfs2/alloc.h +2 -0
@@ -48,6 +48,8 @@ int nilfs_palloc_get_entry_block(struct inode *, __u64, int,void *nilfs_palloc_block_get_entry (const struct inode *,__u64 ,const struct buffer_head *,void *); +int nilfs_palloc_count_max_entries (struct inode *,u64 ,u64 *); +/** * nilfs_palloc_req - persistent allocator request and reply * @pr_entry_nr: entry number (vblocknr or inode number)
fs/nilfs2/ifile.c +22 -0
@@ -160,6 +160,28 @@ int nilfs_ifile_get_inode_block(struct inode *ifile, ino_t ino, }/** +* nilfs_ifile_count_free_inodes - calculate free inodes count +* @ifile: ifile inode +* @nmaxinodes: current maximum of available inodes count [out] +* @nfreeinodes: free inodes count [out] +*/ +int nilfs_ifile_count_free_inodes (struct inode *ifile, +u64 *nmaxinodes,u64 *nfreeinodes) +{ +u64 nused; +int err; + + *nmaxinodes =0 ; + *nfreeinodes =0 ; + + nused =atomic_read (&NILFS_I (ifile)->i_root->inodes_count); + err =nilfs_palloc_count_max_entries (ifile, nused, nmaxinodes); +if (likely (!err)) + *nfreeinodes = *nmaxinodes - nused; +return err; +} + +/** * nilfs_ifile_read - read or get ifile inode * @sb: super block instance * @root: root object
fs/nilfs2/ifile.h +1 -1
@@ -48,7 +48,7 @@ static inline void nilfs_ifile_unmap_inode(struct inode *ifile, ino_t ino,int nilfs_ifile_create_inode (struct inode *,ino_t *,struct buffer_head **);int nilfs_ifile_delete_inode (struct inode *,ino_t );int nilfs_ifile_get_inode_block (struct inode *,ino_t ,struct buffer_head **); - +int nilfs_ifile_count_free_inodes (struct inode *,u64 *,u64 *);int nilfs_ifile_read (struct super_block *sb,struct nilfs_root *root,size_t inode_size,struct nilfs_inode *raw_inode,struct inode **inodep);
fs/nilfs2/mdt.h +26 -0
@@ -53,6 +53,7 @@ struct nilfs_shadow_map {* @mi_shadow: shadow of bmap and page caches * @mi_blocks_per_group: number of blocks in a group * @mi_blocks_per_desc_block: number of blocks per descriptor block +* @mi_desc_blocks_count: number of descriptor blocks */ struct nilfs_mdt_info {struct rw_semaphore mi_sem;
@@ -64,8 +65,33 @@ struct nilfs_mdt_info {struct nilfs_shadow_map *mi_shadow;unsigned long mi_blocks_per_group;unsigned long mi_blocks_per_desc_block; +#ifdef CONFIG_64BIT +atomic64_t mi_desc_blocks_count; +#else +atomic_t mi_desc_blocks_count; +#endif /* CONFIG_64BIT */ }; +static inline +void nilfs_mdt_set_desc_blocks (struct nilfs_mdt_info *mi,unsigned long value) +{ +#ifdef CONFIG_64BIT +atomic64_set (&mi->mi_desc_blocks_count, value); +#else +atomic_set (&mi->mi_desc_blocks_count, value); +#endif +} + +static inline +unsigned long nilfs_mdt_read_desc_blocks (struct nilfs_mdt_info *mi) +{ +#ifdef CONFIG_64BIT +return atomic64_read (&mi->mi_desc_blocks_count); +#else +return atomic_read (&mi->mi_desc_blocks_count); +#endif +} +static inline struct nilfs_mdt_info *NILFS_MDT (const struct inode *inode) {return inode->i_private;
fs/nilfs2/super.c +23 -2
@@ -609,6 +609,7 @@ static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf)unsigned long overhead;unsigned long nrsvblocks;sector_t nfreeblocks; +u64 nmaxinodes, nfreeinodes;int err;/*
@@ -633,14 +634,34 @@ static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf)if (unlikely (err))return err; + err =nilfs_ifile_count_free_inodes (root->ifile, + &nmaxinodes, &nfreeinodes); +if (unlikely (err)) { +printk (KERN_WARNING +"NILFS warning: fail to count free inodes: err %d.\n" , + err); +if (err == -ERANGE ) { +/* +* If nilfs_palloc_count_max_entries() returns +* -ERANGE error code then we simply treat +* curent inodes count as maximum possible and +* zero as free inodes value. +*/ + nmaxinodes =atomic_read (&root->inodes_count); + nfreeinodes =0 ; + err =0 ; + }else +return err; + } + buf->f_type =NILFS_SUPER_MAGIC ; buf->f_bsize = sb->s_blocksize; buf->f_blocks = blocks - overhead; buf->f_bfree = nfreeblocks; buf->f_bavail = (buf->f_bfree >= nrsvblocks) ? (buf->f_bfree - nrsvblocks) :0 ; - buf->f_files =atomic_read (&root->inodes_count); - buf->f_ffree =0 ;/* nilfs_count_free_inodes(sb); */ + buf->f_files = nmaxinodes; + buf->f_ffree = nfreeinodes; buf->f_namelen =NILFS_NAME_LEN ; buf->f_fsid.val[0 ] = (u32 )id; buf->f_fsid.val[1 ] = (u32)(id >>32 );
Signature · 1 line
1.7.9.5
Ryusuke Konishi
NAKQuoted 5 lines · Vyacheslav Dubeyko
Hi Ryusuke,
This is fourth version of the patch. I reworked representation of
mi_desc_blocks_countbecause I think that using this field is good solution for calculation of max entries count.
Nack.
Please stop switching atomic_t and atomic64_t in nilfs with heavy use of ifdef macros and inline functions. It is seriously hurting the readability and simplicity of source code.
Consider using "atomic_long_t", and please try to keep the patch simple.
In my opinion, mi_desc_blocks_count is no longer needed because nilfs_bmap_last_key is not so heavy. But, I don't deny adding this counter.
Quoted 4 lines
By the way, I see that it is used
atomic_ttype for representation ofinodes_countandblocks_countfields innilfs_rootstructure. Maybe it makes sense to rework representation of these fields too. What do you think?
Yes, looks like they should be replaced with atomic_long_t type counters (with a separate patch, of course).
Regards,
Ryusuke Konishi
Quoted 122 lines
v3->v4
* Thedesc_blocksvalue is represented by unsigned long type.
* Thenilfs_palloc_count_desc_blocks()method is simplified.
* Themi_desc_blocks_countfield ofnilfs_mdt_infostructure is represented asatomic64_tfor the case ofCONFIG_64BITand asatomic_tfor other cases.
v2->v3
* TrivialBUG_ONchecks were removed.
* Whole calculation algorithm was moved intonilfs_palloc_count_max_entries()method.
* Improve error processing in the code.
* Thenilfs_palloc_mdt_file_can_grow()method was simplified.
* Thenilfs_ifile_count_free_inodes()method was simplified.
v1->v2
* Change__statfs_wordon u64 type.
* Renamenilfs_count_free_inodes()intonilfs_ifile_count_free_inodes()method.
* Introduce auxiliary functions:nilfs_palloc_count_max_entries(),nilfs_palloc_count_desc_blocks(),nilfs_palloc_mdt_file_can_grow().
* Rework processing of returned error fromnilfs_ifile_count_free_inodes()innilfs_statfs().With the best regards,
Vyacheslav Dubeyko.
---
From: Vyacheslav Dubeyko <[email protected]>
Subject: [PATCH v4] nilfs2: implement calculation of free inodes countCurrently, NILFS2 returns 0 as free inodes count (
f_ffree) and current used inodes count as total file nodes in file system (f_files):df -i
Filesystem Inodes IUsed IFree IUse% Mounted on/dev/loop02 2 0 100%/mnt/nilfs2This patch implements real calculation of free inodes count. First of all, it is calculated total file nodes in file system as (
desc_blocks_count*groups_per_desc_block*entries_per_group). Then, it is calculated free inodes count as difference the total file nodes and used inodes count. As a result, we have such output for NILFS2:df -i
Filesystem Inodes IUsed IFree IUse% Mounted on/dev/loop04194304 2114701 2079603 51%/mnt/nilfs2Reported-by Clemens Eisserer <[email protected]>Signed-off-by Vyacheslav Dubeyko <[email protected]>Signed-off-by Ryusuke Konishi <[email protected]>Tested-by Vyacheslav Dubeyko <[email protected]>--- fs/nilfs2/alloc.c | 78 +++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/nilfs2/alloc.h | 2 ++ fs/nilfs2/ifile.c | 22 +++++++++++++++ fs/nilfs2/ifile.h | 2 +- fs/nilfs2/mdt.h | 26 ++++++++++++++++++ fs/nilfs2/super.c | 25 +++++++++++++++-- 6 files changed, 152 insertions(+), 3 deletions(-)fs/nilfs2/alloc.c +45
-0@@ -80,6 +80,13 @@ int nilfs_palloc_init_blockgroup(struct inode *inode, unsigned entry_size) mi->mi_blocks_per_group +1 ;/* Number of blocks per descriptor including the descriptor block */ +nilfs_mdt_set_desc_blocks (mi,1 ); +/* +* The field mi_desc_blocks_count is used for +* storing knowledge about current count of +* desciptor blocks. Initially, it is initialized +* by one. +*/ return 0 ; }@@ -398,6 +405,77 @@ nilfs_palloc_rest_groups_in_desc_block(const struct inode *inode, }/** +* nilfs_palloc_count_desc_blocks - count descriptor blocks number +* @inode: inode of metadata file using this allocator +* @desc_blocks: descriptor blocks number [out] +*/ +static int nilfs_palloc_count_desc_blocks (struct inode *inode, +unsigned long *desc_blocks) +{ +unsigned long blknum; +int ret; + + ret =nilfs_bmap_last_key (NILFS_I (inode)->i_bmap, &blknum); +if (likely (!ret)) + *desc_blocks =DIV_ROUND_UP ( + blknum,NILFS_MDT (inode)->mi_blocks_per_desc_block); +return ret; +} + +/** +* nilfs_palloc_mdt_file_can_grow - check potential opportunity for +* MDT file growing +* @inode: inode of metadata file using this allocator +* @desc_blocks: known current descriptor blocks count +*/ +static inline bool nilfs_palloc_mdt_file_can_grow (struct inode *inode, +unsigned long desc_blocks) +{ +return (nilfs_palloc_groups_per_desc_block (inode) * desc_blocks) < +nilfs_palloc_groups_count (inode); +} + +/** +* nilfs_palloc_count_max_entries - count max number of entries that can be +* described by descriptor blocks count +* @inode: inode of metadata file using this allocator +* @nused: current number of used entries +* @nmaxp: max number of entries [out] +*/ +int nilfs_palloc_count_max_entries (struct inode *inode,u64 nused,u64 *nmaxp)
fs/nilfs2/alloc.c nilfs_palloc_rest_groups_in_desc_block(const struct inode *inode, · line 455
Quoted 10 lines
fs/nilfs2/alloc.c +10
-0+{ +unsigned long desc_blocks; +u64 entries_per_desc_block, nmax; +int err; + + desc_blocks =nilfs_mdt_read_desc_blocks (NILFS_MDT (inode)); + entries_per_desc_block = (u64 )nilfs_palloc_entries_per_group (inode) * +nilfs_palloc_groups_per_desc_block (inode); + + nmax = entries_per_desc_block * desc_blocks;
<snip>
--
To unsubscribe from this list: send the line "unsubscribe linux-nilfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html