[fake patch] un-inline sysfs_get_kobject and release_sysfs_dirent

From: Adam J. Richter (adam_at_yggdrasil.com)
Date: 12/09/04

  • Next message: Vivek Goyal: "Re: Figuring out physical memory regions from a kernel module"
    Date:	Wed, 8 Dec 2004 21:26:32 -0800
    To: maneesh@in.ibm.com
    
    

    Hi Maneesh,

            The following fake patch against a heavily hacked
    linux-2.6.10-rc2-bk16, which moves sysfs_get_kobject and release_sysfs_dirent
    from fs/sysfs/sysfs.h as inline functions to .c files as non-inline
    functions. These routines are big enough, that they should not be
    inline functions. Although my previous patches have contributed
    to this, I believe that the routines were still big enough that making
    them non-inline would be justified even without any of my previous
    patches.

            There were no changes to the contents of the functions other
    than making them non-inline, although a previous patch that I posted
    added SYSFS_ATTR_GROUP, which resulted in a change to sysfs_get_kobject
    which affects this patch, as does my change to avoid allocating
    the "s_children" field for non-directories.

            I am posting this patch now to simplify my patch for
    unpinning sysfs directories, which I expect to post in about
    an hour. I am posting it against 2.6.10-rc2-bk16 for consistency
    with my stream of patches from a few days ago, which this patch
    is based on. After posting the patch for unpinning sysfs directories,
    I expect to update to the latest snapshot, and I will then
    be able to regenerate patches against that if that would be
    helpful.

                        __ ______________
    Adam J. Richter \ /
    adam@yggdrasil.com | g g d r a s i l

    Signed-off-by: Adam J. Richter <adam@yggdrasil.com>

    diff -u linux/fs/sysfs.old/dir.c linux/fs/sysfs/dir.c
    --- linux/fs/sysfs.old/dir.c 2004-12-03 12:04:45.000000000 +0800
    +++ linux/fs/sysfs/dir.c 2004-12-09 13:14:03.000000000 +0800
    @@ -57,6 +57,20 @@
             return sd;
     }
     
    +void release_sysfs_dirent(struct sysfs_dirent * sd)
    +{
    + if (sd->s_type & SYSFS_KOBJ_LINK) {
    + struct sysfs_symlink * sl = sd->s_element;
    + kfree(sl->link_name);
    + kobject_put(sl->target_kobj);
    + kfree(sl);
    + }
    + if (sysfs_type_dir(sd->s_type))
    + kmem_cache_free(sysfs_dir_cachep, to_sysfs_dir(sd));
    + else
    + kmem_cache_free(sysfs_dirent_cachep, sd);
    +}
    +
     int sysfs_make_dirent(struct sysfs_dir * parent_sd, struct dentry * dentry,
                             void * element, umode_t mode, int type)
     {
    diff -u linux/fs/sysfs.old/inode.c linux/fs/sysfs/inode.c
    --- linux/fs/sysfs.old/inode.c 2004-12-03 12:04:45.000000000 +0800
    +++ linux/fs/sysfs/inode.c 2004-12-09 13:14:21.000000000 +0800
    @@ -164,4 +164,24 @@
             up(&dir->d_inode->i_sem);
     }
     
    +struct kobject *sysfs_get_kobject(struct dentry *dentry)
    +{
    + struct kobject * kobj = NULL;
     
    + spin_lock(&dcache_lock);
    + if (!d_unhashed(dentry)) {
    + struct sysfs_dirent * sd = dentry->d_fsdata;
    + if (sd->s_type == SYSFS_ATTR_GROUP) {
    + sd = dentry->d_parent->d_fsdata;
    + BUG_ON(sd->s_type != SYSFS_DIR);
    + }
    + if (sd->s_type & SYSFS_KOBJ_LINK) {
    + struct sysfs_symlink * sl = sd->s_element;
    + kobj = kobject_get(sl->target_kobj);
    + } else
    + kobj = kobject_get(sd->s_element);
    + }
    + spin_unlock(&dcache_lock);
    +
    + return kobj;
    +}
    diff -u linux/fs/sysfs.old/sysfs.h linux/fs/sysfs/sysfs.h
    --- linux/fs/sysfs.old/sysfs.h 2004-12-03 12:04:45.000000000 +0800
    +++ linux/fs/sysfs/sysfs.h 2004-12-09 13:09:40.000000000 +0800
    @@ -98,41 +98,8 @@
             return ((struct bin_attribute *) sd->s_element);
     }
     
    -static inline struct kobject *sysfs_get_kobject(struct dentry *dentry)
    -{
    - struct kobject * kobj = NULL;
    -
    - spin_lock(&dcache_lock);
    - if (!d_unhashed(dentry)) {
    - struct sysfs_dirent * sd = dentry->d_fsdata;
    - if (sd->s_type == SYSFS_ATTR_GROUP) {
    - sd = dentry->d_parent->d_fsdata;
    - BUG_ON(sd->s_type != SYSFS_DIR);
    - }
    - if (sd->s_type & SYSFS_KOBJ_LINK) {
    - struct sysfs_symlink * sl = sd->s_element;
    - kobj = kobject_get(sl->target_kobj);
    - } else
    - kobj = kobject_get(sd->s_element);
    - }
    - spin_unlock(&dcache_lock);
    -
    - return kobj;
    -}
    -
    -static inline void release_sysfs_dirent(struct sysfs_dirent * sd)
    -{
    - if (sd->s_type & SYSFS_KOBJ_LINK) {
    - struct sysfs_symlink * sl = sd->s_element;
    - kfree(sl->link_name);
    - kobject_put(sl->target_kobj);
    - kfree(sl);
    - }
    - if (sysfs_type_dir(sd->s_type))
    - kmem_cache_free(sysfs_dir_cachep, to_sysfs_dir(sd));
    - else
    - kmem_cache_free(sysfs_dirent_cachep, sd);
    -}
    +extern struct kobject *sysfs_get_kobject(struct dentry *dentry);
    +extern void release_sysfs_dirent(struct sysfs_dirent * sd);
     
     static inline void sysfs_put(struct sysfs_dirent * sd)
     {
    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/


  • Next message: Vivek Goyal: "Re: Figuring out physical memory regions from a kernel module"

    Relevant Pages

    • Re: [ANNOUNCE] pahole and other DWARF2 utilities
      ... Poke-a-Hole is a tool to find out holes in structures, ... Each inline expansion of an inlinable subroutine is represented by a ... Each such entry should be a direct child of the entry that represents ...
      (Linux-Kernel)
    • Re: Semantics of Inline vs non-Inline
      ... The question still remains concerning the semantics of inline vs ... all since the application can not control the compiler ... that if the semantics are to be the same for inline and non-inline ...
      (comp.lang.ada)
    • Re: inline and macro
      ... Hi, inline fuctions and macros shoud be equally fast (actually, ... I prefer inline functions to macros, ... The compiler may or may not inline a function declared inline. ...
      (microsoft.public.vc.language)
    • [10 PATCHES] inline functions to avoid stack overflow
      ... Here I'm sending 10 patches to inline various functions. ... To give you some understanding of sparc64, every function there uses big stack frame. ... So, on sparc64, if you have a simple function that passes arguments to other function it still takes 192 byte --- regardless of how simple the function is. ... In this series of patches, I found 10 such functions and turned them to inlines, saving 1920 bytes. ...
      (Linux-Kernel)
    • Re: [PATCH] deinline large functions in sock.h
      ... > Included are two patches. ... > First patch simply does such a move. ... > inline int f_inlined ... send the line "unsubscribe linux-kernel" in ...
      (Linux-Kernel)