cramfs: generate unique inode number for better inode cache usage
PATCH 1/1 cramfs: generate unique inode number for better inode cache usage
From: Stefani Seibold <[email protected]>
This is second version, hope this is less ugly code :-)
This patch generates a unique inode numbers for any entries in the cram file system. For files which did not contain data's (device nodes, fifos and sockets) the offset of the directory entry inside the cramfs plus 1 will be used as inode number.
The + 1 for the inode will it make possible to distinguish between a file which contains no data and files which has data, the later one has a inode value where the lower two bits are always 0.
It also reimplement the behavoir to set the size and the number of block to 0 for special file, which is the right value for empty files, devices, fifos and sockets
As a little benefit it will be also more compatible which older mkcramfs, because it will never use the cramfs_inode->offset for creating a inode number for special files.
The patch is aginst 2.6.37-rc5
Please apply it.
Thanks,
Stefani
--- fs/cramfs/inode.c | 85 ++++++++++++++++++++++++++++++++++------------------ 1 files changed, 55 insertions(+), 30 deletions(-)
fs/cramfs/inode.c +55 -30
@@ -36,16 +36,29 @@ static DEFINE_MUTEX(read_mutex);/* These two macros may change in future, to provide better st_ino semantics. */ -#define CRAMINO (x) (((x)->offset && (x)->size)?(x)->offset<<2:1) +#define CRAMINO_UNIQ (x) ((x) + 1)#define OFFSET (x) ((x)->i_ino) -static void setup_inode (struct inode *inode,struct cramfs_inode * cramfs_inode) +static unsigned long cramino (struct cramfs_inode * cino, +unsigned int offset) +{ +if (!cino->offset) +return CRAMINO_UNIQ (offset); +if (!cino->size) +return CRAMINO_UNIQ (offset); + +return cino->offset <<2 ; +} + +static void setup_inode (struct inode *inode,struct cramfs_inode * cramfs_inode,u32 size) {static struct timespec zerotime; inode->i_mode = cramfs_inode->mode; inode->i_uid = cramfs_inode->uid; - inode->i_size = cramfs_inode->size; - inode->i_blocks = (cramfs_inode->size -1 ) /512 +1 ; +if (size) { + inode->i_size = size; + inode->i_blocks = (size -1 ) /512 +1 ; + } inode->i_gid = cramfs_inode->gid;/* Struct copy intentional */ inode->i_mtime = inode->i_atime = inode->i_ctime = zerotime;
@@ -53,36 +66,41 @@ static void setup_inode(struct inode *inode, struct cramfs_inode * cramfs_inode)but it's the best we can do without reading the directory contents. 1 yields the right result in GNU find, even without -noleaf option. */ -if (S_ISREG (inode->i_mode)) { - inode->i_fop = &generic_ro_fops; - inode->i_data.a_ops = &cramfs_aops; - }else if (S_ISDIR (inode->i_mode)) { - inode->i_op = &cramfs_dir_inode_operations; - inode->i_fop = &cramfs_directory_operations; - }else if (S_ISLNK (inode->i_mode)) { - inode->i_op = &page_symlink_inode_operations; - inode->i_data.a_ops = &cramfs_aops; - }else { -init_special_inode (inode, inode->i_mode, -old_decode_dev (cramfs_inode->size)); - } +unlock_new_inode (inode); }static struct inode *get_cramfs_inode (struct super_block *sb, -struct cramfs_inode * cramfs_inode) +struct cramfs_inode * cramfs_inode,unsigned int offset) {struct inode *inode; -if (CRAMINO (cramfs_inode) ==1 ) { - inode =new_inode (sb); -if (inode) { - inode->i_ino =1 ; -setup_inode (inode, cramfs_inode); + +if (S_ISREG (cramfs_inode->mode)) { + inode =iget_locked (sb,cramino (cramfs_inode, offset)); +if (inode && (inode->i_state &I_NEW )) { + inode->i_fop = &generic_ro_fops; + inode->i_data.a_ops = &cramfs_aops; +setup_inode (inode, cramfs_inode, cramfs_inode->size); + } + }else if (S_ISDIR (cramfs_inode->mode)) { + inode =iget_locked (sb,cramino (cramfs_inode, offset)); +if (inode && (inode->i_state &I_NEW )) { + inode->i_op = &cramfs_dir_inode_operations; + inode->i_fop = &cramfs_directory_operations; +setup_inode (inode, cramfs_inode, cramfs_inode->size); + } + }else if (S_ISLNK (cramfs_inode->mode)) { + inode =iget_locked (sb,cramino (cramfs_inode, offset)); +if (inode && (inode->i_state &I_NEW )) { + inode->i_op = &page_symlink_inode_operations; + inode->i_data.a_ops = &cramfs_aops; +setup_inode (inode, cramfs_inode, cramfs_inode->size); } }else { - inode =iget_locked (sb,CRAMINO (cramfs_inode)); + inode =iget_locked (sb,CRAMINO_UNIQ (offset));if (inode && (inode->i_state &I_NEW )) { -setup_inode (inode, cramfs_inode); -unlock_new_inode (inode); +init_special_inode (inode, cramfs_inode->mode, +old_decode_dev (cramfs_inode->size)); +setup_inode (inode, cramfs_inode,0 ); } }return inode;
@@ -265,6 +283,9 @@ static int cramfs_fill_super(struct super_block *sb, void *data, int silent)printk (KERN_ERR "cramfs: root is not a directory\n" ); goto out; } +/* correct strange, hard-coded permissions of mkcramfs */ + super.root.mode |= (S_IRUSR |S_IXUSR |S_IRGRP |S_IXGRP |S_IROTH |S_IXOTH ); + root_offset = super.root.offset <<2 ;if (super.flags &CRAMFS_FLAG_FSID_VERSION_2 ) { sbi->size=super.size;
@@ -289,7 +310,7 @@ static int cramfs_fill_super(struct super_block *sb, void *data, int silent)/* Set it all up.. */ sb->s_op = &cramfs_ops; - root =get_cramfs_inode (sb, &super.root); + root =get_cramfs_inode (sb, &super.root,0 );if (!root) goto out; sb->s_root =d_alloc_root (root);
@@ -365,8 +386,11 @@ static int cramfs_readdir(struct file *filp, void *dirent, filldir_t filldir)*/ namelen = de->namelen <<2 ;memcpy (buf, name, namelen); - ino =CRAMINO (de); mode = de->mode; +if (S_ISREG (mode) ||S_ISDIR (mode) ||S_ISLNK (mode)) + ino =cramino (de,OFFSET (inode) + offset); +else + ino =CRAMINO_UNIQ (OFFSET (inode) + offset);mutex_unlock (&read_mutex); nextoffset = offset +sizeof (*de) + namelen;for (;;) {
@@ -404,8 +428,9 @@ static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, sstruct cramfs_inode *de;char *name;int namelen, retval; +int dir_off =OFFSET (dir) + offset; - de =cramfs_read (dir->i_sb,OFFSET (dir) + offset,sizeof (*de)+CRAMFS_MAXPATHLEN ); + de =cramfs_read (dir->i_sb, dir_off,sizeof (*de)+CRAMFS_MAXPATHLEN ); name = (char *)(de+1 );/* Try to take advantage of sorted directories */
@@ -436,7 +461,7 @@ static struct dentry * cramfs_lookup(struct inode *dir, struct dentry *dentry, sif (!retval) {struct cramfs_inode entry = *de;mutex_unlock (&read_mutex); -d_add (dentry,get_cramfs_inode (dir->i_sb, &entry)); +d_add (dentry,get_cramfs_inode (dir->i_sb, &entry, dir_off));return NULL ; }/* else (retval < 0) */
Signature · 1 line
1.7.3.3
Why do you repeat that
inode = iget_locked(sb, cramino(cramfs_inode, offset));
if (inode && (inode->i_state & I_NEW)) {so many times?
Wouldn't it be nicer to just do it once at the top?
Linus
Quoted 8 lines · Linus Torvalds
Why do you repeat that
inode =
iget_locked(sb, cramino(cramfs_inode, offset)); if (inode && (inode->i_state&I_NEW)) {so many times?
Wouldn't it be nicer to just do it once at the top?
Oh, and I think it's probably nicer to then do the if-statements as a
switch (cram_inode->mode & S_IFMT) {
case S_IFREG:
..but what I objected to in the previous patch was doing it multiple times, and moving the nice separate helper function into the caller.
So I _think_ you should be able to just do something like this:
ino = cramino(cramfs_inode, offset);
switch (cram_inode->mode & S_IFMT) {
case S_IFREG:
fops = generic_ro_fops;
aops = &cramfs_aops;
break;
case S_IFDIR:
...
default:
ino = CRAMINO_UNIQ(offset);
}
inode = iget_locked(sb, ino);
if (inode && (inode->i_state & I_NEW)) {
inode->i_ops = iops;
inode->i_fops = fops;
inode->i_data.a_ops = aops;
setup_inode(inode, cramfs_inode, cramfs_inode->size);
}or whatever?
Linus
Am Dienstag, den 14.12.2010, 15:43 -0800 schrieb Linus Torvalds:
Quoted 9 lines
Quoted 7 lines · Linus Torvalds
Why do you repeat that
inode = iget_locked(sb, cramino(cramfs_inode, offset)); if (inode && (inode->i_state & I_NEW)) {so many times?
Quoted 8 lines
Quoted 1 line
Wouldn't it be nicer to just do it once at the top?
Oh, and I think it's probably nicer to then do the if-statements as a
switch (cram_inode->mode & S_IFMT) { case S_IFREG: ..
This is easy to fix.
Quoted 15 lines
but what I objected to in the previous patch was doing it multiple times, and moving the nice separate helper function into the caller.
So I _think_ you should be able to just do something like this:
ino = cramino(cramfs_inode, offset); switch (cram_inode->mode & S_IFMT) { case S_IFREG: fops = generic_ro_fops; aops = &cramfs_aops; break; case S_IFDIR: ... default: ino = CRAMINO_UNIQ(offset);
Quoted 9 lines
}
inode = iget_locked(sb, ino);
if (inode && (inode->i_state & I_NEW)) {
inode->i_ops = iops;
inode->i_fops = fops;
inode->i_data.a_ops = aops;
setup_inode(inode, cramfs_inode, cramfs_inode->size);
}No, it makes no sense, for following reasons:
- Why pre-setup variables like iops, fops and aops which are in the most cases not needed? Because the inode is still in the cache.
- Each branch is a little bit different.
- The default branch is completly different, because in this case the init_special_inode() will be called, which sets the inode->fop.
What do you think about this solution:
static void setup_inode(struct inode *inode, struct cramfs_inode * cramfs_inode)
{
static struct timespec zerotime;
inode->i_mode = cramfs_inode->mode;
inode->i_uid = cramfs_inode->uid;
/* if the lower 2 bits are zero, the inode contains data */
if (!(inode->i_ino & 3)) {
inode->i_size = size;
inode->i_blocks = (size - 1) / 512 + 1;
}
inode->i_gid = cramfs_inode->gid;
/* Struct copy intentional */
inode->i_mtime = inode->i_atime = inode->i_ctime = zerotime;
/* inode->i_nlink is left 1 - arguably wrong for directories,
but it's the best we can do without reading the directory
contents. 1 yields the right result in GNU find, even
without -noleaf option. */
unlock_new_inode(inode);
}static struct inode *get_cramfs_inode(struct super_block *sb,
struct cramfs_inode * cramfs_inode, unsigned int offset)
{
struct inode *inode;
switch (cram_inode->mode & S_IFMT) {
case S_IFREG:
inode = iget_locked(sb, cramino(cramfs_inode, offset));
if (inode && (inode->i_state & I_NEW)) {
inode->i_fop = &generic_ro_fops;
inode->i_data.a_ops = &cramfs_aops;
setup_inode(inode, cramfs_inode);
}
break;
case S_IFDIR:
inode = iget_locked(sb, cramino(cramfs_inode, offset));
if (inode && (inode->i_state & I_NEW)) {
inode->i_op = &cramfs_dir_inode_operations;
inode->i_fop = &cramfs_directory_operations;
setup_inode(inode, cramfs_inode);
}
break;
case S_IFLNK:
inode = iget_locked(sb, cramino(cramfs_inode, offset));
if (inode && (inode->i_state & I_NEW)) {
inode->i_op = &page_symlink_inode_operations;
inode->i_data.a_ops = &cramfs_aops;
setup_inode(inode, cramfs_inode);
}
break;
default:
inode = iget_locked(sb, CRAMINO_UNIQ(offset));
if (inode && (inode->i_state & I_NEW)) {
init_special_inode(inode, cramfs_inode->mode,
old_decode_dev(cramfs_inode->size));
setup_inode(inode, cramfs_inode);
}
break;
}
return inode;
}- Stefani
Quoted 65 lines · Stefani Seibold
No, it makes no sense, for following reasons:
- Why pre-setup variables like iops, fops and aops which are in the most cases not needed? Because the inode is still in the cache.
- Each branch is a little bit different.
- The default branch is completly different, because in this case the
init_special_inode()will be called, which sets theinode->fop.What do you think about this solution:
static void
setup_inode(struct inode *inode, struct cramfs_inode * cramfs_inode){
static struct timespec zerotime;
inode->i_mode =cramfs_inode->mode;
inode->i_uid =cramfs_inode->uid;
/* if the lower 2 bits are zero, the inode contains data */ if (!(inode->i_ino & 3)) {
inode->i_size = size;
inode->i_blocks = (size - 1) / 512 + 1;
}
inode->i_gid =cramfs_inode->gid;
/* Struct copy intentional */
inode->i_mtime =inode->i_atime=inode->i_ctime= zerotime; /*inode->i_nlinkis left 1 - arguably wrong for directories, but it's the best we can do without reading the directory contents. 1 yields the right result in GNU find, even without -noleaf option. */
unlock_new_inode(inode);
}static struct inode *get_cramfs_inode(struct
super_block*sb, structcramfs_inode*cramfs_inode, unsigned int offset) {
struct inode *inode;switch (
cram_inode->mode&S_IFMT) {
caseS_IFREG:
inode =iget_locked(sb, cramino(cramfs_inode, offset)); if (inode && (inode->i_state&I_NEW)) {inode->i_fop=&generic_ro_fops;inode->i_data.a_ops=&cramfs_aops;setup_inode(inode, cramfs_inode);
}
break;
caseS_IFDIR:
inode =iget_locked(sb, cramino(cramfs_inode, offset)); if (inode && (inode->i_state&I_NEW)) {inode->i_op=&cramfs_dir_inode_operations;inode->i_fop=&cramfs_directory_operations;setup_inode(inode, cramfs_inode);
}
break;
caseS_IFLNK:
inode =iget_locked(sb, cramino(cramfs_inode, offset)); if (inode && (inode->i_state&I_NEW)) {inode->i_op=&page_symlink_inode_operations;inode->i_data.a_ops=&cramfs_aops;setup_inode(inode, cramfs_inode);
}
break;
default:
inode =iget_locked(sb, CRAMINO_UNIQ(offset)); if (inode && (inode->i_state&I_NEW)) {
Quoted 8 lines
init_special_inode(inode,
cramfs_inode->mode,old_decode_dev(cramfs_inode->size));setup_inode(inode, cramfs_inode); }
break;
}
return inode;
}
I think Linus is after something like this:
static struct inode *get_cramfs_inode(struct super_block *sb, struct cramfs_inode * cramfs_inode, unsigned int offset)
{
struct inode *inode;
unsigned long ino;
switch (cram_inode->mode & S_IFMT) {
case S_IFREG:
case S_IFDIR:
case S_IFLNK:
ino = cramino(cramfs_inode, offset);
break;
default:
ino = CRAMINO_UNIQ(offset);
break;
}
inode = iget_locked(sb, ino);
if (!inode)
return ERR_PTR(-ENOMEM);
if (!(inode->i_state & I_NEW))
return inode;
switch (cram_inode->mode & S_IFMT) {
case S_IFREG:
inode->i_fop = &generic_ro_fops;
inode->i_data.a_ops = &cramfs_aops;
setup_inode(inode, cramfs_inode);
break;
case S_IFDIR:
inode->i_op = &cramfs_dir_inode_operations;
inode->i_fop = &cramfs_directory_operations;
setup_inode(inode, cramfs_inode);
break;
case S_IFLNK:
inode->i_op = &page_symlink_inode_operations;
inode->i_data.a_ops = &cramfs_aops;
setup_inode(inode, cramfs_inode);
break;
default:
init_special_inode(inode, cramfs_inode->mode,
old_decode_dev(cramfs_inode->size));
setup_inode(inode, cramfs_inode);
break;
}
return inode;
}You should optimize for the in-cache case.
Quoted 2 lines · Pekka Enberg
I think Linus is after something like this:
That works for me, but I hate the double "switch()" statement checking the same thing.
Why is the camino() function not just doing something like
static unsigned int cramino(struct cramfs_inode *ino, unsigned intdirent_offset)
{
unsigned int data_offset = ino->offset;
return data_offset ? data_offset << 2 : dirent_offset+1;}
and we can get rid of all the cruddy CRAMINO_UNIQ() and testing of the mode entirely for that path.
That, together with Pekka's approach seems nice, simple and clean.
Linus
Zitat von Linus Torvalds <[email protected]>:
Quoted 14 lines · Pekka Enberg
Quoted 2 lines
I think Linus is after something like this:
That works for me, but I hate the double "
switch()" statement checking the same thing.Why is the
camino()function not just doing something likestatic unsigned int cramino(struct
cramfs_inode*ino, unsigned intdirent_offset){ unsigned int data_offset = ino->offset; return data_offset ? data_offset << 2 : dirent_offset+1;
Quoted 9 lines
}
and we can get rid of all the cruddy
CRAMINO_UNIQ()and testing of the mode entirely for that path.That, together with Pekka's approach seems nice, simple and clean.
Linus
Pekka's approach is not problem. But the "cruddy" CRAMINO_UNIQ() is exact what is needed. In your orginal design of cramfs there is no way to give entries with no data an unique inode number.
So for not to waste the inode cache and do useless lookups it it necessary to distinguish between entries with data and entries with no data. The later one need a special handling to create a unique inode number depending on the index of the directory entry inside the cramfs image.
I try my best to make best out of of the old cramfs design and fix the issues of this filesystem.
- Stefani
Quoted 4 lines · On Wed, Dec 15, 2010 at 8:31 AM, <[email protected]> wrote:
Pekka's approach is not problem. But the "cruddy"
CRAMINO_UNIQ()is exact what is needed. In your orginal design of cramfs there is no way to give entries with no data an unique inode number.
Umm. And my cramino() did exactly that. If it has a data pointer, it uses that, otherwise it uses the directory offset.
It just doesn't care about the mode of the file.
(feel free to test the size too, for that matter - that's what the old code does)
IOW, it uses the old CRAMINO() approach, except instead of "1" for the non-offset case, it uses "dirent_offset+1"
Linus
Am Mittwoch, den 15.12.2010, 08:45 -0800 schrieb Linus Torvalds:
Quoted 9 lines · On Wed, Dec 15, 2010 at 8:31 AM, <[email protected]> wrote:
Quoted 4 lines
Pekka's approach is not problem. But the "cruddy"
CRAMINO_UNIQ()is exact what is needed. In your orginal design of cramfs there is no way to give entries with no data an unique inode number.Umm. And my
cramino()did exactly that. If it has a data pointer, it uses that, otherwise it uses the directory offset.
The current implementation does it not.
Quoted 2 lines
It just doesn't care about the mode of the file.
Right, but there are a buggy cramfs tools (which can create images for different endian target or create on the fly devices nodes and so on) out there, which set the offset of the cramfs_inode to a value not equal
0. This works well with older kernel like 2.6.12 but during the evolution of the kernel this was broken.
I will resend a cleaned up patch. Hope you will apply it ;-)
Stefani