vfs学习-sysfs

/*
 * 一、说明
 * 	sysfs与设备、驱动相关。系统将驱动的层级结构通过sysfs以
 * 文件系统的形式展现给用户。在驱动方面涉及到的概念有kobject,
 * kset,bus,device_driver,device,class等等；而在文件系统方面
 * 涉及到的概念有inode,dentry,super_block,vfsmount等虚拟文件
 * 系统方面的内容。既然sysfs也是一种文件系统，就必须提供虚拟
 * 文件系统相关的数据结构。
 * 各方面内容:用户-访问文件系统->VFS-访问实际文件系统->sysfs
 * --映射到->driver体系
 */
/*
 * 二、sysfs文件系统的加载
 */

 
 //sysfs的mount//
 /*
  * 调用过程
  * start_kernel(/init/main.c)->vfs_caches_init(/fs/dcache.c)->
  * mnt_init(/fs/namespace.c)->sysfs_init
  * 在start_kernel中两个函数是文件系统初始化相关的:
  * vfs_caches_init_early(),vfs_caches_init(totalram_pages)
  */
  
  
 /*
  * /fs/sysfs/mount.c
  * 几个全局变量
  */
/*
 * 静态，本文件内函数用,vfsmount代表一个加载的文件系统  
 * 这是sysfs的源头,sysfs_mnt 可找到其根dentry,进而可找到inode,超级块等结构
 * 生成这个结构的过程就是生成inode dentry super_block并使其相关联的过程。
 */
static struct vfsmount *sysfs_mnt;
//sysfs的sysfs_dirent缓存cache
struct kmem_cache *sysfs_dir_cachep;
//sysfs的super_block默认操作
static const struct super_operations sysfs_ops = {
    .statfs         = simple_statfs,
    .drop_inode     = generic_delete_inode,
    .evict_inode    = sysfs_evict_inode,
 };
/*
 * sysfs的根sysfs_dirent结构，此结构是联系kobject层级体系和vfs层级体系的桥梁
 * 而sysfs_root对应的就是vfs中的根,即/sys/目录
 */
struct sysfs_dirent sysfs_root = {
    .s_name         = "",
    .s_count        = ATOMIC_INIT(1),
    .s_flags        = SYSFS_DIR | (KOBJ_NS_TYPE_NONE << SYSFS_NS_TYPE_SHIFT),
    .s_mode         = S_IFDIR | S_IRUGO | S_IXUGO,
    .s_ino          = 1,
};
 /*
  * sysfs的type,用来注册sysfs文件系统的全局变量,静态的，本文件内函数使用维护
  */
 static struct file_system_type sysfs_fs_type = {
    .name           = "sysfs",
    .mount          = sysfs_mount,
    .kill_sb        = sysfs_kill_sb,
}
//初始化sysfs///
目标:生成static struct vfsmount *sysfs_mnt//

 int __init sysfs_init(void)
{
	int err = -ENOMEM;
	//cache缓存申请
	sysfs_dir_cachep = kmem_cache_create("sysfs_dir_cache",
			      sizeof(struct sysfs_dirent),
			      0, 0, NULL);
	if (!sysfs_dir_cachep)
		goto out;
	/*
	 * 备用存储设备初始化(bdi),用来存储数据的设备 
	 */
	err = sysfs_inode_init();
	if (err)
		goto out_err;
	/*
	 * 注册文件系统，就是将sysfs_fs_type对应的文件系统加入到内核全局变量
	 * file_system中,它定义在:/fs/filesystems.c文件中，是个静态的，只本文件
	 * 相关函数维护和访问
	 * static struct file_system_type *file_systems;
	 *
	 * 传入的参数是静态全局变量sysfs_fs_type
	 */
	err = register_filesystem(&sysfs_fs_type);
	if (!err) {
		/*
		 * /include/linux/fs.h中定义:
		 * #define kern_mount(type) kern_mount_data(type, NULL)
		 * 本函数最终目的是将文件系统的 vfsmount结构 sysfs_mnt存储起来
		 * 核心就是取到这个结构的值,以备后用
		 *
		 * 传入的参数是静态全局变量sysfs_fs_type
		 */
		sysfs_mnt = kern_mount(&sysfs_fs_type);
		if (IS_ERR(sysfs_mnt)) {
		printk(KERN_ERR "sysfs: could not mount!\n");
		err = PTR_ERR(sysfs_mnt);
		sysfs_mnt = NULL;
		unregister_filesystem(&sysfs_fs_type);
		goto out_err;
		}
	} else
		goto out_err;
out:
	return err;
out_err:
	kmem_cache_destroy(sysfs_dir_cachep);
	sysfs_dir_cachep = NULL;
	goto out;
}
/mount vfsmount生成
/*
 * /fs/namespace.c中定义:
 * 调用vfs_kern_mount进一步处理
 *
 * 传入的参数是静态全局变量sysfs_fs_type,data=NULL
 */
struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
{
    struct vfsmount *mnt;
    mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
    if (!IS_ERR(mnt)) {
        real_mount(mnt)->mnt_ns = MNT_NS_INTERNAL;
    }
    return mnt;
}
 
/*
 * vfsmount与mount结构:前者是后者的一个成员，都有dentry结构 vfsmount.dentry
 * mount.mnt_mountpoint都指向子文件系统(sysfs)的根dentry
 *
 * /fs/namespace.c中定义
 *参数:
 * type=sysfs_fs_type
 * flags=MS_KERNMOUNT
 * name= type->name=sysfs_fs_type->name="sysfs"
 * data=NULL
 * 
 * 本函数是取得struct vfsmount结构。但需要加载sysfs以取得sysfs的根dentry.
 * 将根dentry与要返回的vfsmount联系起来。
 * 申请了一个mount,它体内有一个内嵌的vfsmount(不是指针型的)，回头将它返回
 * 也就是说返回的vfsmount是mount的一个成员结构,通过vfsmount就能找到mount
 */ 

struct vfsmount * 
vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
 {
    struct mount *mnt;
	struct dentry *root;
 
	if (!type)
		return ERR_PTR(-ENODEV);
	//申请一个struct mount结构
	mnt = alloc_vfsmnt(name);
	if (!mnt)
		return ERR_PTR(-ENOMEM);
 
	if (flags & MS_KERNMOUNT)
		mnt->mnt.mnt_flags = MNT_INTERNAL;
	//得到本文件系统的根dentry
	root = mount_fs(type, flags, name, data);
	if (IS_ERR(root)) {
		free_vfsmnt(mnt);
		return ERR_CAST(root);
	}
 
	mnt->mnt.mnt_root = root;
	mnt->mnt.mnt_sb = root->d_sb;
	mnt->mnt_mountpoint = mnt->mnt.mnt_root;
	mnt->mnt_parent = mnt;
	br_write_lock(&vfsmount_lock);
	//mount结构通过mnt_instance连接到超级块的s_mounts字段
	list_add_tail(&mnt->mnt_instance, &root->d_sb->s_mounts);
	br_write_unlock(&vfsmount_lock);
	return &mnt->mnt;
 }
/*
 * /fs/super.c中定义
 * 参数:
 * type=sysfs_fs_type
 * flags=MS_KERNMOUNT
 * name= type->name=sysfs_fs_type->name="sysfs"
 * data=NULL
 *
 * 函数功能：
 * 根据type加载文件系统并返回它的root dentry
 */
 struct dentry *
mount_fs(struct file_system_type *type, int flags, const char *name, void *data)
{
	struct dentry *root;
	struct super_block *sb;
	char *secdata = NULL;
	int error = -ENOMEM;

	if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
		secdata = alloc_secdata();
		if (!secdata)
			goto out;

		error = security_sb_copy_data(data, secdata);
		if (error)
			goto out_free_secdata;
	}
	/*
	 * 调用type的mount函数,.
	 * 即sysfs_fs_type->mount=sysfs_mount()[/fs/sysfs/mount.c]
	 * 整个过程像是这样:对VFS来说，它只要知道文件系统相关信息，并存储起来
	 * 且vfs调用自己定义好的接口来实现mount(其它操作也一样),具体功能
	 * 由具体的文件系统自己定义，只要接口保持一致就行。
	 * 对sysfs来说,它提供具体相关结构的生成，还得靠自己的函数。这些结构
	 * 包括dentry..super_block..mount..vfsmount等，只是把这些信息放在了
	 * 文件系统类型sysfs_fs_type中，等待VFS体系来调用罢了。说白了自己让别人
	 * 管自己，最后还是自己劳动。
	 */
	 
	root = type->mount(type, flags, name, data);
	if (IS_ERR(root)) {
		error = PTR_ERR(root);
		goto out_free_secdata;
	}
	sb = root->d_sb;
	BUG_ON(!sb);
	WARN_ON(!sb->s_bdi);
	WARN_ON(sb->s_bdi == &default_backing_dev_info);
	sb->s_flags |= MS_BORN;

	error = security_sb_kern_mount(sb, flags, secdata);
	if (error)
		goto out_sb; 
	......
	up_write(&sb->s_umount);
	free_secdata(secdata);
	return root;
out_sb:
	dput(root);
	deactivate_locked_super(sb);
out_free_secdata:
	free_secdata(secdata);
out:
	return ERR_PTR(error);
}
 
/*
 * /fs/sysfs/mount.c
 *
 * fs_type=sysfs_fs_type
 * flags=MS_KERNMOUNT
 * dev_name= type->name=sysfs_fs_type->name="sysfs"
 * data=NULL
 *
 * 函数功能:
 * 加载sysfs文件系统，并返回sysfs的root dentry
 * sb = sget取得super_block
 * sysfs_fill_super(sb填充sb,并组织与sb相关的根inode dentry以及与
 * 根dirent sysfs_root关联起来
 * 最后将根dentry返回
 */
static struct dentry *sysfs_mount(struct file_system_type *fs_type,
	int flags, const char *dev_name, void *data)
{
	struct sysfs_super_info *info;
	enum kobj_ns_type type;
	struct super_block *sb;
	int error;

	info = kzalloc(sizeof(*info), GFP_KERNEL);
	if (!info)
		 return ERR_PTR(-ENOMEM);
	//命名空间相关
	for (type = KOBJ_NS_TYPE_NONE; type < KOBJ_NS_TYPES; type++)
		 info->ns[type] = kobj_ns_grab_current(type);
	
	//查询取得，或新创建一个super_block	
	sb = sget(fs_type, sysfs_test_super, sysfs_set_super, flags, info);
	if (IS_ERR(sb) || sb->s_fs_info != info)
		 free_sysfs_super_info(info);
	if (IS_ERR(sb))
		 return ERR_CAST(sb);
	if (!sb->s_root) {
		//新创建的sb,s_root肯定为空,则需要填充super_block
		 error = sysfs_fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
		 if (error) {
			 deactivate_locked_super(sb);
			 return ERR_PTR(error);
		 }
		 sb->s_flags |= MS_ACTIVE;
	}

	return dget(sb->s_root);
}

//超级块生成
/*
 * 在/fs/super.c中定义:
 * fs_type=sysfs_fs_type
 * sysfs_test_super
 * sysfs_set_super
 * flags=MS_KERNMOUNT
 * data=NULL
 *
 * 函数功能:
 * 在type的super_blocks列表中查找或新创建一个属于type的super_block
 */
struct super_block *sget(struct file_system_type *type,
			 int (*test)(struct super_block *,void *),
			 int (*set)(struct super_block *,void *),
			 int flags,
			 void *data)
 {
	 struct super_block *s = NULL;
	 struct hlist_node *node;
	 struct super_block *old;
	 int err;
 
 retry:
	spin_lock(&sb_lock);
	if (test) {
		hlist_for_each_entry(old, node, &type->fs_supers, s_instances) {
		//test不断失败,直到循环结束,old是迭代指针,列表是type->fs_supers
			 if (!test(old, data))
				 continue;
			 if (!grab_super(old))
				 goto retry;
			 if (s) {
				 up_write(&s->s_umount);
				 destroy_super(s);
				 s = NULL;
			 }
			 down_write(&old->s_umount);
			 if (unlikely(!(old->s_flags & MS_BORN))) {
				 deactivate_locked_super(old);
				 goto retry;
			 }
			 return old;
		 }
	 }
	 //新建的话，s肯定是null
	 if (!s) {
		 spin_unlock(&sb_lock);
		 //申请一个空super_block
		 s = alloc_super(type, flags);
		 if (!s)
			 return ERR_PTR(-ENOMEM);
		 goto retry;
	 }
	//设置好s的数据
	err = set(s, data);
	 if (err) {
		 spin_unlock(&sb_lock);
		 up_write(&s->s_umount);
		 destroy_super(s);
		 return ERR_PTR(err);
	 }
	//设置type,名称,并添加到全系统全局变量super_blocks中去
	s->s_type = type;
	strlcpy(s->s_id, type->name, sizeof(s->s_id));
	 list_add_tail(&s->s_list, &super_blocks);
	 hlist_add_head(&s->s_instances, &type->fs_supers);
	 spin_unlock(&sb_lock);
	 get_filesystem(type);
	 //内存管理
	 register_shrinker(&s->s_shrink);
	 return s;
 }
/*
 * 定义在:/fs/sysfs/mount.c
 * super_block=申请的那个超级块
 * data=NULL
 * silent=flags & MS_SILENT ? 1 : 0
 *
 * 函数功能:
 * 给sysfs的super_block填充内容; 根据super_block和sysfs_root这个根dirent
 * 生成根dentry root的inode。最终将 super_block sysfs_root root dentry 
 * inode 关联起来，就是将VFS需要的那几项组织起来。虽然返回super_block，
 * 但与super_block相关的内容都处理好了。
 */ 
static int sysfs_fill_super(struct super_block *sb, void *data, int silent)
  {
	struct inode *inode;
	struct dentry *root;
  
	sb->s_blocksize = PAGE_CACHE_SIZE;
	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
	sb->s_magic = SYSFS_MAGIC;
	sb->s_op = &sysfs_ops;
	sb->s_time_gran = 1;
  
	/* get root inode, initialize and unlock it */
	mutex_lock(&sysfs_mutex);
	//生成根dentry root的inode
	inode = sysfs_get_inode(sb, &sysfs_root);
	mutex_unlock(&sysfs_mutex);
	if (!inode) {
		  pr_debug("sysfs: could not get root inode\n");
		  return -ENOMEM;
	}
  
	//根据根inode生成根 dentry
	root = d_make_root(inode);
	if (!root) {
		  pr_debug("%s: could not get root dentry!\n",__func__);
		  return -ENOMEM;
	}
	root->d_fsdata = &sysfs_root;
	sb->s_root = root;
	sb->s_d_op = &sysfs_dentry_ops;
	return 0;
  }
  
///由全局变量sysfs_dirent sysfs_root生成inode///
 /*
  * /fs/sysfs/inode.c
  * 参数: 
  * sb=sysfs的那个super_block
  * sysfs_dirent=sysfs_root
  *
  * 函数功能:
  * 由sysfs_dirent生成一个inode
  * 再看看sysfs_root的定义(/fs/sysfs/mount.c)
  *	  struct sysfs_dirent sysfs_root = {
  *		.s_name         = "",
  *		.s_count        = ATOMIC_INIT(1),
  *		.s_flags        = SYSFS_DIR | (KOBJ_NS_TYPE_NONE << SYSFS_NS_TYPE_SHIFT),
  *		.s_mode         = S_IFDIR | S_IRUGO | S_IXUGO,
  *		.s_ino          = 1,
  *	};
  */
  struct inode * sysfs_get_inode(struct super_block *sb, struct sysfs_dirent *sd)
 {
    struct inode *inode;
	//由一个加载的文件系统获得一个inode,由上可知传进去的s_ino=1
    inode = iget_locked(sb, sd->s_ino);
    if (inode && (inode->i_state & I_NEW))
        sysfs_init_inode(sd, inode); //初始化这个inode
        return inode;
 }
 /*
  * 静态全局变量,inode hash列表,inode_hashtable[hash]是一个相同hash值=hash的列表
  */
 static struct hlist_head *inode_hashtable __read_mostly;
 
/*
 * /fs/inode.c:
 * 参数:
 * sb=sysfs的超级块
 * ino=sysfs_root.s_ino=1
 * 
 * 函数功能:
 * 从一个加载的文件系统中申请一个inode出来
 * 用到静态全局变量inode_hashtable
 */
struct inode *iget_locked(struct super_block *sb, unsigned long ino)
{
	struct hlist_head *head = inode_hashtable + hash(sb, ino);
	struct inode *inode;
	//@@@@第一次锁申请
	spin_lock(&inode_hash_lock);
	//1号inode还没生成,当然找不到了
	inode = find_inode_fast(sb, head, ino);
	//@@@@第一次锁释放
	spin_unlock(&inode_hash_lock);
	if (inode) {
		wait_on_inode(inode);
		return inode;
	}
	//生成1号inode,申请inode空间并初始化
	inode = alloc_inode(sb);
	if (inode) {
		struct inode *old;
		//@@@@第二次锁申请
		spin_lock(&inode_hash_lock);
		/*
		 * 因为在两次加锁中间可能有别人申请了本号码的inode,
		 * 所以再查找一次
		 */
		old = find_inode_fast(sb, head, ino);
		if (!old) {
			//如果没找到,就用我们刚才申请的的inode
			inode->i_ino = ino;
			spin_lock(&inode->i_lock);
			//设置状态
			inode->i_state = I_NEW;
			hlist_add_head(&inode->i_hash, head);
			spin_unlock(&inode->i_lock);
			inode_sb_list_add(inode);
			spin_unlock(&inode_hash_lock);

			/* Return the locked inode with I_NEW set, the
			 * caller is responsible for filling in the contents
			 */
			return inode;
		}
		
		/*
		 * Uhhuh, somebody else created the same inode under
		 * us. Use the old inode instead of the one we just
		 * allocated.
		 * 执行到这里说明有别人在两锁中间申请了本号码的inode
		 * 则把我们申请的释放掉，然后用别人的那个(old)
		 */
		spin_unlock(&inode_hash_lock);
		destroy_inode(inode);
		inode = old;
		wait_on_inode(inode);
	}
	return inode;
}

/*
 * 在fs/sysfs/inode.c中:
 */

  static const struct address_space_operations sysfs_aops = {
          .readpage       = simple_readpage,
          .write_begin    = simple_write_begin,
          .write_end      = simple_write_end,
  };
  
  static struct backing_dev_info sysfs_backing_dev_info = {
          .name           = "sysfs",
          .ra_pages       = 0,    /* No readahead */
          .capabilities   = BDI_CAP_NO_ACCT_AND_WRITEBACK,
  };
  
  static const struct inode_operations sysfs_inode_operations ={
          .permission     = sysfs_permission,
          .setattr        = sysfs_setattr,
          .getattr        = sysfs_getattr,
          .setxattr       = sysfs_setxattr,
  };

/*
 * 在fs/sysfs/inode.c中:
 * 参数
 * sd=sysfs_root
 * inode=与sysfs_root对应的1号inode
 * 功能:初始化inode
  
 * 再看看sysfs_root的定义(/fs/sysfs/mount.c)
 *	  struct sysfs_dirent sysfs_root = {
 *		.s_name         = "",
 *		.s_count        = ATOMIC_INIT(1),
 *		.s_flags        = SYSFS_DIR | (KOBJ_NS_TYPE_NONE << SYSFS_NS_TYPE_SHIFT),
 *		.s_mode         = S_IFDIR | S_IRUGO | S_IXUGO,
 *		.s_ino          = 1,
 *	};
 */
 static void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)
 {
	struct bin_attribute *bin_attr;
	/*
	 * i_private字段存储inode与文件系统相关的信息,在sysfs中存储的是sysfs_dirent结构
	 */
	inode->i_private = sysfs_get(sd);
	inode->i_mapping->a_ops = &sysfs_aops;
	inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;
	inode->i_op = &sysfs_inode_operations;
 
	set_default_inode_attr(inode, sd->s_mode);
	sysfs_refresh_inode(sd, inode);
 
	/* initialize inode according to type */
	switch (sysfs_type(sd)) {
	case SYSFS_DIR:
		/*
		 * sysfs_root的s_flags是SYSFS_DIR,所以i_op和i_fop指向相应位置
		 */
		 inode->i_op = &sysfs_dir_inode_operations;
		 inode->i_fop = &sysfs_dir_operations;
		 break;
	case SYSFS_KOBJ_ATTR:
		 inode->i_size = PAGE_SIZE;
		 inode->i_fop = &sysfs_file_operations;
		 break;
	case SYSFS_KOBJ_BIN_ATTR:
		 bin_attr = sd->s_bin_attr.bin_attr;
		 inode->i_size = bin_attr->size;
		 inode->i_fop = &bin_fops;
		 break;
	case SYSFS_KOBJ_LINK:
		 inode->i_op = &sysfs_symlink_inode_operations;
		 break;
	default:
		 BUG();
	}
 
	unlock_new_inode(inode);
 }

/由sysfs_root dirent对应的inode生成dentry///

/*
 * /fs/dcache.c:
 * 参数:sysfs_root dirent对应的inode
 * 功能:生成对应的dentry
 */
struct dentry *d_make_root(struct inode *root_inode)
{
	struct dentry *res = NULL;

	if (root_inode) {
		//name变量="/"
		static const struct qstr name = QSTR_INIT("/", 1);
		//在sb中申请出一个dentry
		res = __d_alloc(root_inode->i_sb, &name);
		if (res)
			//用inode信息初始化,使之与root_inode关联
			d_instantiate(res, root_inode);
		else
			iput(root_inode);
	}
	return res;
}

/*
 * /fs/dcache.c:
 * 从文件系统申请一个dentry
 */
struct dentry *__d_alloc(struct super_block *sb, const struct qstr *name)
{
	struct dentry *dentry;
	char *dname;
	//内存申请
	dentry = kmem_cache_alloc(dentry_cache, GFP_KERNEL);
	if (!dentry)
		return NULL;
	//名称串内存申请
	dentry->d_iname[DNAME_INLINE_LEN-1] = 0;
	if (name->len > DNAME_INLINE_LEN-1) {
		dname = kmalloc(name->len + 1, GFP_KERNEL);
		if (!dname) {
			kmem_cache_free(dentry_cache, dentry); 
			return NULL;
		}
	} else  {
		dname = dentry->d_iname;
	}       
	//名字复制
	dentry->d_name.len = name->len;
	dentry->d_name.hash = name->hash;
	memcpy(dname, name->name, name->len);
	dname[name->len] = 0;

	/* Make sure we always see the terminating NUL character */
	smp_wmb();
	//名字指针赋值
	dentry->d_name.name = dname;
	//下面是各种初始化
	dentry->d_count = 1;
	dentry->d_flags = 0;
	spin_lock_init(&dentry->d_lock);
	seqcount_init(&dentry->d_seq);
	dentry->d_inode = NULL;
	dentry->d_parent = dentry;
	dentry->d_sb = sb;
	dentry->d_op = NULL;
	dentry->d_fsdata = NULL;
	INIT_HLIST_BL_NODE(&dentry->d_hash);
	INIT_LIST_HEAD(&dentry->d_lru);
	INIT_LIST_HEAD(&dentry->d_subdirs);
	INIT_HLIST_NODE(&dentry->d_alias);
	INIT_LIST_HEAD(&dentry->d_u.d_child);
	d_set_d_op(dentry, dentry->d_sb->s_d_op);

	this_cpu_inc(nr_dentry);

	return dentry;
}

/*
 * 最终生成了使vfsmount sysfs_mnt=mount.mnt这个全局变量得到赋值后
 * 以后要找sysfs便可从sysfs_mnt找。因为它是静态的，所以它的值是由
 * 模块内函数维护的。VFS对一个文件系统要求的inode_root,dentry_root,
 * super_block等都可以从这个变量找到。
 * 具体的inode和dentry是在sysfs_lookup时才生成的，没有事先生成。先
 * 操作dirent的层次，最后返回基于dirent的dentry
 * 
 *  
 */
 /*
  * 三、设备驱动模块kobject等
  */  
 
 /*
  * 关系:
  * kset:
  * 	向下：指向子节点链表 kset->list
  * 	自己：kobj对应,因此kobject不是个指针,所以本kobj能定位到自己的kset
  * 	向上: kobj->parent,kobj->kset(父级kset)
  * kobject:
  *		向上: kobject->parent
  * 	横向: entry链入兄弟链表，进入父kset的list字段
  *	sysfs_dirent:
  * 	向上: parent,
  *		向下: s_dir.children(只能是目录)
  * 	横向: s_rb
  *
  * 
  *	kobject->sd 指向对应的sysfs_dirent结构
  * sysfs_dirent->s_ino指向对应的inode号
  * inode->i_private存储其对应的sysfs_dirent结构
  * dentry->d_fsdata指向对应的sysfs_dirent结构
  * inode->i_dentry指向对应dentry列表
  * dentry->d_inode指向对应的inode
  *
  *     kset{kobject}
  *       ^  7
  *       |/
  *       v
  *     kobject---->sysfs_dirent<------>inode 
  *                                       ^1
  *                                       | 
  *                                   	  v n	
  *                 sysfs_dirent<------dentry
  */
 
 /*
 * kset 是管理kobject的集合，自身体内含有一个kobject，是kset所包含
 * 子kobject集合的父亲。kset还可以包含其它的kset(kset->kobj->kset?)
 */  
 
struct kset {//在sysfs目录结构中，kset是个目录
    struct list_head 	list;//子层kobject链表
    spinlock_t 			list_lock;
    struct 	kobject 	kobj;//本层kobject,代表sysfs目录结构中的自己
    const struct kset_uevent_ops *uevent_ops;
};
 
 
 
struct kobject {
    const char              *name;//设备名
    struct list_head        entry;//链入kset(兄弟链)
    struct kobject          *parent;//父对象
    struct kset             *kset;//本对象所属的kset(父集链)
    struct kobj_type        *ktype;//对象类型描述符
    /*
	 * dentry,inode相关字段，组成sysfs文件系统层级关系
	 * 每个sysfs节点有一个sysfs_dirent结构
	 */
	struct sysfs_dirent     *sd;
    struct kref             kref;//引用计数
    unsigned int state_initialized:1;
    unsigned int state_in_sysfs:1;//说明本节点在sysfs中有对应
    unsigned int state_add_uevent_sent:1;
    unsigned int state_remove_uevent_sent:1;
    unsigned int uevent_suppress:1;
};
/*
 * kobject与vfs关联
 * inode->i_private存储其对应的sysfs_dirent结构
 * sysfs_dirent.s_ino对应inode节点号
 * 向上有parent,向下(只能是目录)有s_dir.children
 * 横向兄弟有s_rb
 * 这样就形成了一个层级结构
 */
struct sysfs_dirent {
	atomic_t                s_count;
	atomic_t                s_active;
	#ifdef CONFIG_DEBUG_LOCK_ALLOC
		struct lockdep_map      dep_map;
	#endif
	struct sysfs_dirent     *s_parent;//父节点
	const char              *s_name;
	//兄弟节点,链入父节点的s_dir.children字段
	struct rb_node          s_rb;
	union {
		struct completion       *completion;
		struct sysfs_dirent     *removed_list;
	} u;
	const void              *s_ns; /* namespace tag */
	unsigned int            s_hash; /* ns + name hash */
	union {
		struct sysfs_elem_dir           s_dir;//目录级联用
		struct sysfs_elem_symlink       s_symlink;
		struct sysfs_elem_attr          s_attr;
		struct sysfs_elem_bin_attr      s_bin_attr;
	};
	/*
	 * s_flags表明在sysfs中的类型
	 * SYSFS_DIR,SYSFS_KOBJ_ATTR, SYSFS_KOBJ_BIN_ATTR,SYSFS_KOBJ_LINK
	 */
	unsigned short          s_flags;
	umode_t                 s_mode;
	unsigned int            s_ino;//对应的inode节点id号
	struct sysfs_inode_attrs *s_iattr;
};


/*
 * sysfs_dirent与dentry的关联,dentry的层次与kobject相同
 * kobject形成设备、驱动层次,而dentry负责在stsfs中将这个
 * 层次以文件的形式展示出来
 * 在v3.6.2/fs/sysfs/inode.c中
 * sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)
 * 根据sysfs_dirent生成inode
 */
dentry->d_fsdata是void指针，指向sysfs_dirent

struct kobj_type {
    void (*release)(struct kobject *kobj);//资源释放
    const struct sysfs_ops *sysfs_ops;//操作
    struct attribute **default_attrs;//默认属性
    const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
    const void *(*namespace)(struct kobject *kobj);
};
struct sysfs_ops {
	//用户读取数据
    ssize_t (*show)(struct kobject *, struct attribute *,char *);
	//用户写入数据
    ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t);
    const void *(*namespace)(struct kobject *, const struct attribute *);
};
//在http://lxr.linux.no/linux+v3.6.2/include/linux/kobject.h中:
extern const struct sysfs_ops kobj_sysfs_ops;

//在http://lxr.linux.no/linux+v3.6.2/lib/kobject.c中:
const struct sysfs_ops kobj_sysfs_ops = {
    .show   = kobj_attr_show,
    .store  = kobj_attr_store,
};
 
struct attribute {
    const char  *name;//sysfs目录中的文件名
    umode_t      mode;
#ifdef CONFIG_DEBUG_LOCK_ALLOC
    bool                    ignore_lockdep:1;
    struct lock_class_key   *key;
    struct lock_class_key   skey;
#endif
};

/*
 * 每个bus_type对应/sys/bus下一个子目录,如/sys/bus/pci
 * 每个子目录下有两个目录devices,drivers; 前者表示总线上所有设备; 
 * 后者表示与该总线相"关联"的所有驱动程序。另外就是几个处理函数。
 * 
	
 * 一些结构:
 * bus_type 
		->device *dev_root;
 * device
		->device*parent指向父设备
		->kobj
		->type设备类型
		->bus总线
		->device_driver *driver申请本结构的驱动程序
		->class设备的class
 * device_driver
		->bus_type *bus指向bus
 * class
		->dev_kobj代表class链入层级关系
  
 */  
  
struct bus_type {//系统总线结构
	const char              *name;//名称
	const char              *dev_name;//设备名
	struct device           *dev_root;//默认根设备
	struct bus_attribute    *bus_attrs;//默认总线属性
	struct device_attribute *dev_attrs;//总线上默认设备属性
	struct driver_attribute *drv_attrs;//总线上默认设备驱动属性
	int (*match)(struct device *dev, struct device_driver *drv);
	int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
	int (*probe)(struct device *dev);
	int (*remove)(struct device *dev);
	void (*shutdown)(struct device *dev);
	int (*suspend)(struct device *dev, pm_message_t state);
	int (*resume)(struct device *dev);
	const struct dev_pm_ops *pm;
	struct iommu_ops *iommu_ops;
	struct subsys_private *p;//驱动抽象中:bus私有数据
};
  
/*
 *  http://lxr.linux.no/linux+v3.6.2/drivers/base/base.h中:
 *  subsys_private,driver_private,device_private
 */  
struct subsys_private {
	struct kset subsys;//回指定义本subsys的kset
	struct kset *devices_kset;//device目录
	struct list_head interfaces;
	struct mutex mutex;
	struct kset *drivers_kset;//driver目录？
	struct klist klist_devices;//用来遍历devices_kset
	struct klist klist_drivers;//用来遍历drivers_kset
	//本bus有事件的话，就会通知本链上函数
	struct blocking_notifier_head bus_notifier;
	unsigned int drivers_autoprobe:1;
	struct bus_type *bus;//本结构所相关的bus_type
	struct kset glue_dirs;
	struct class *class;//本结构相关的class
};

struct driver_private {
	struct kobject kobj;
	struct klist klist_devices;
	struct klist_node knode_bus;
	struct module_kobject *mkobj;
	struct device_driver *driver;
};
struct device_private {
	struct klist klist_children;
	struct klist_node knode_parent;
	struct klist_node knode_driver;
	struct klist_node knode_bus;
	struct list_head deferred_probe;
	void *driver_data;
	struct device *device;
};



/*
 * kset代表一个目录,它体内的kobject与sysfs关联
 * 子kobject代表sysfs中的一个文件
 * subsys_private与bus对应,subsys_private体内有两个子kset代表两个子目录
 * devices与drivers。 
 * device_private与device结构对应,而device体内有kobject，代表一个设备
 * driver_private与device_driver对应,driver_private有kobject代表一个驱动
 *
 * 分了3类东西，
 * 第1类在include/linux/kobject.h中，是kset,kobject,sysfs_dirent(与sysfs关联)
 * 第2类在include/linux/device.h中,  是bus_type,device,device_driver,class
 * 第3类在drivers/base/base.h中,是subsys_private,driver_private,device_private
 * 1在抽象，2是设备，3是驱动
 * 	kset含有kobject:
		->kobj	本层
		->list  子层
	bus的subsys_private有两个kset
		->devices_kset 总线上的设备集合
		->drivers_kset 总线相关的驱动集合
		
	device有个kobject
		->kobj 本设备对象的kobject
	driver_private有个kobject
		->kobj 本驱动对象的kobject
 *
 */

/*
 * 二、过程
 * 
 * 一些全局变量
 *　/drivers/base/core.c:
	struct kset *devices_kset;系统内所有设备,对应/sys/devices/
	/drivers/base/bus.c:
	这里的两个是静态的，说明只在本文件中有效，也就是只有用本文件中的函数
	才能访问。
	static struct kset *bus_kset;系统内所有总线,对应/sys/bus/
	static struct kset *system_kset;所有子系统,对应/sys/devices/system
	
	
	start_kernel->rest_init-创建进程->kernel_init(pid=1)->do_basic_setup
	->driver_init[v3.6.2/drivers/base/init.c]->buses_init
	实际上在driver_init时就涉及许多设备驱动相关的初始化
 */
void __init driver_init(void)
{
	devtmpfs_init();
	devices_init();//设备初始化
	buses_init();//这就是总线初始化
	classes_init();
	firmware_init();
	hypervisor_init();
	platform_bus_init();
	cpu_dev_init();
	memory_dev_init();
}
/*
 * /sys/是sysfs的根,下面的函数就是在根下放几个目录:/sys/devices/,/sys/dev/,
 * /sys/dev/block/和/sys/dev/char/这几个目录都是"设备(device)相关"的。
 */
int __init devices_init(void)
{
	devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
	if (!devices_kset)
		return -ENOMEM;
	dev_kobj = kobject_create_and_add("dev", NULL);
	if (!dev_kobj)
		goto dev_kobj_err;
	sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
	if (!sysfs_dev_block_kobj)
		goto block_kobj_err;
	sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
	if (!sysfs_dev_char_kobj)
		goto char_kobj_err;
	return 0;
char_kobj_err:
	kobject_put(sysfs_dev_block_kobj);
block_kobj_err:
	kobject_put(dev_kobj);
dev_kobj_err:
	kset_unregister(devices_kset);
	return -ENOMEM;
}


/*
 * 与上面函数类似，此函数功能是创添加了/sys/bus/和/sys/devices/system/
 */
int __init buses_init(void)
{	
//最后一个参数是parent_kobj,就是父节点的kobject,null就直接挂根上/sys/bus/
	bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);
	if (!bus_kset)
		return -ENOMEM;
	//父节点为devices_kset->kobj,所以是在/sys/devices/下挂着
	system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
	if (!system_kset)
		return -ENOMEM;
	return 0;
}
/*
 * 顺便提下subsys_system_register函数,在/drivers/base/bus.c中有一句：
 * EXPORT_SYMBOL_GPL(subsys_system_register);说明它是被其它模块调用的
 * 一个subsys跟一个总线相关。所以此函数调用bus_register来注册一种类型
 * 的总线bus_type
 * int subsys_system_register(struct bus_type *subsys,
 *								const struct attribute_group **groups)
 * 子系统没理解好，子系统注册时用的就是bus_type，一个bus就是
 * 一个子系统，一个子系统又可包含更广泛的概念？看代码好像是注册一个
 * subsystem就是注册一个bus,因为调用了bus_register
 */

添加dir///
/*
 * 添加kobject对应就是在sysfs添加一个目录,即/sys/xxx/,用函数:
 * 在v3.6.2/lib/kobject.c:
 * kset_create_and_add->kset_register->kobject_add_internal
 * 在kset_create_and_add里会创建一个kset并将它与父级kobject链起来。然后
 * 再调用kset_register将本kobject加入sysfs并发送通知事件。
 */
 
static int kobject_add_internal(struct kobject *kobj)
{
 	int error = 0;
 	struct kobject *parent; 	
 	if (!kobj)return -ENOENT; 	
 	if (!kobj->name || !kobj->name[0]) { 	    
 	    return -EINVAL;
 	}
 	//父级kobject引用++,父kobj可能不存在
 	parent = kobject_get(kobj->parent); 	
 	//若kset存在且父节点没取到，再从kset里取一次
 	if (kobj->kset) {
 	    if (!parent)
 	        parent = kobject_get(&kobj->kset->kobj);
 	        kobj_kset_join(kobj);
 	        kobj->parent = parent;
 	} 	
	......
 	error = create_dir(kobj);
 	if (error) {
 	    kobj_kset_leave(kobj);
 	    kobject_put(parent);
 	    kobj->parent = NULL;	    
	    ......
	} else
	    kobj->state_in_sysfs = 1;	
	    return error;
	}
/*
 * 从create_dir这个函数开始就进入了sysfs流程
 */
static int create_dir(struct kobject *kobj)
{
    int error = 0;
    error = sysfs_create_dir(kobj);
    if (!error) {
        error = populate_dir(kobj);
        if (error)
            sysfs_remove_dir(kobj);
        }
    return error;
}
/*
 * 在v3.6.2/fs/sysfs/dir.c中：
 * int sysfs_create_dir(struct kobject * kobj)
 * 
 * sysfs_create_dir - create a directory for an object.
 * @kobj:          object we're creating directory for. 
 * /sys/ 目录是根，对应的dirent是变量sysfs_root,定义在
 *  /fs/sysfs/mount.c#L35
 *	struct sysfs_dirent sysfs_root = {
 *	  .s_name         = "",
 *	  .s_count        = ATOMIC_INIT(1),
 *	  .s_flags        = SYSFS_DIR | (KOBJ_NS_TYPE_NONE << SYSFS_NS_TYPE_SHIFT),
 *	  .s_mode         = S_IFDIR | S_IRUGO | S_IXUGO,
 *	  .s_ino          = 1,
 * };
 * sysfs的级联体系是基于dirent的,设备驱动模型的级联体系是基于kobjet和kset的。
 * 在驱动那边kobject和kset的层级被组织好了。
 * 当需要"显示"到sysfs时,就调用sysfs_create_dir类似的sysfs函数来创建目录(或文件)
 * 如果一个kobject父级为空，说明它是最顶端的，即/sys/下的，把它的父级dirent设置
 * 为sysfs_root
 *  
 * 
 * 而dentry的root("/"目录)是VFS的d_make_root(inode)生成的(/fs/dcache.c),而这个
 * inode也是根据sysfs_root生成的。
 *
 * 硬件<---设备驱动体系----sysfs体系----VFS体系--->用户:
 *           kobject   --     dirent --     dentry(动态生成)
 *  设备驱动层级: 以kobject为基础,最上层kobject是几个全局变量
 * 	 				如devices_set,bus_set,system_set等 
 *	sysfs层级:以dirent为基础，最上层是sysfs_root,全局变量
 *	VFS层级:以dentry为基础,最上层的是由sysfs_root和vfs函数d_make_root生成的，像
 * 			其它文件系统一样，存储在super_block里
 *
 *  
 * 
 */
 int sysfs_create_dir(struct kobject * kobj)
 {
	enum kobj_ns_type type;
	struct sysfs_dirent *parent_sd, *sd;
	const void *ns = NULL;
	int error = 0;
    BUG_ON(!kobj);
	//如果父kobj不存在就用根,直接挂到/sys/
	if (kobj->parent)
		parent_sd = kobj->parent->sd;
	else
		parent_sd = &sysfs_root;
 
	if (!parent_sd)
		return -ENOENT;
 
	if (sysfs_ns_type(parent_sd))
		ns = kobj->ktype->namespace(kobj);
	type = sysfs_read_ns_type(kobj);
 
	error = create_dir(kobj, parent_sd, type, ns, kobject_name(kobj), &sd);
	if (!error)
		kobj->sd = sd;
	return error;
 }
 
static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
		enum kobj_ns_type type, const void *ns, const char *name,
		struct sysfs_dirent **p_sd)
{
	//S_IFDIR表示目录?
	umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
	struct sysfs_addrm_cxt acxt;
	struct sysfs_dirent *sd;
	int rc;	
	//申请一个dirent
	sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
	if (!sd)
		return -ENOMEM;
	
	sd->s_flags |= (type << SYSFS_NS_TYPE_SHIFT);
	sd->s_ns = ns;
	//本节点是个目录,其kobj记录在s_dir成员中(联合体)
	sd->s_dir.kobj = kobj;
	
	/* link in */
	sysfs_addrm_start(&acxt, parent_sd);
	rc = sysfs_add_one(&acxt, sd);//添加
	sysfs_addrm_finish(&acxt);
	
	if (rc == 0)
		*p_sd = sd;
	else
		sysfs_put(sd);
	
	return rc;
}
//向父级dirent 添加一个dirent 
int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
 {
    int ret;
	//添加内部函数
    ret = __sysfs_add_one(acxt, sd);
    if (ret == -EEXIST) {
        ......
    } 
    return ret;
 }
 
 
int __sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
{
    struct sysfs_inode_attrs *ps_iattr;
	int ret;
 
	if (!!sysfs_ns_type(acxt->parent_sd) != !!sd->s_ns) {
		 WARN(1, KERN_WARNING "sysfs: ns %s in '%s' for '%s'\n",
			 sysfs_ns_type(acxt->parent_sd)? "required": "invalid",
			 acxt->parent_sd->s_name, sd->s_name);
		 return -EINVAL;
	}
	//21位的二元组[ns,name]的hash值(是个UINT)
	sd->s_hash = sysfs_name_hash(sd->s_ns, sd->s_name);
	//设置父级dirent
	sd->s_parent = sysfs_get(acxt->parent_sd);
	//本dirent的兄弟链接
	ret = sysfs_link_sibling(sd);
	if (ret)
		return ret;
 
	 /* Update timestamps on the parent */
	ps_iattr = acxt->parent_sd->s_iattr;
	if (ps_iattr) {
		struct iattr *ps_iattrs = &ps_iattr->ia_iattr;
		ps_iattrs->ia_ctime = ps_iattrs->ia_mtime = CURRENT_TIME;
	}
 
	return 0;
 }

struct sysfs_elem_dir {
	struct kobject *kobj;
    unsigned long   subdirs;//本目录子目录数
    struct rb_root  children;//子目录的红黑树
};
//兄弟节点是一个红黑树链接的(rbtree) 
static int sysfs_link_sibling(struct sysfs_dirent *sd)
{
	//s_dir 是 sysfs_elem_dir 结构
    struct rb_node **node = &sd->s_parent->s_dir.children.rb_node;
    struct rb_node *parent = NULL;
	//如果将被添加的是一个目录,则父目录的子目录数+=1
    if (sysfs_type(sd) == SYSFS_DIR)
        sd->s_parent->s_dir.subdirs++;
	//红黑树遍历，找到合适位置
    while (*node) {
        struct sysfs_dirent *pos;
        int result;
 
        pos = to_sysfs_dirent(*node);
        parent = *node;
        result = sysfs_sd_compare(sd, pos);
        if (result < 0)
            node = &pos->s_rb.rb_left;
        else if (result > 0)
            node = &pos->s_rb.rb_right;
        else
            return -EEXIST;
    }
    /* add new node and rebalance the tree */
	rb_link_node(&sd->s_rb, parent, node);
    rb_insert_color(&sd->s_rb, &sd->s_parent->s_dir.children);    
    return 0;
 }
 添加file
 
 /*
  * 添加kobject就是往某个"目录"下添加一个"文件"
  * v3.6.2/include/linux/device.h#L117
  */
 #define bus_register(subsys)                    \
 ({                                              \
          static struct lock_class_key __key;     \
          __bus_register(subsys, &__key); \
 })
 /*
  * 内部函数定义在:
  * v3.6.2/drivers/base/bus.c#L923
  */
  
 int __bus_register(struct bus_type *bus, struct lock_class_key *key)
 {
        int retval;
        struct subsys_private *priv;
		//申请一个结构
        priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
        if (!priv)
                 return -ENOMEM;
		//与bus联系起来
         priv->bus = bus;
         bus->p = priv;
 
         BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
		//设置bus的名字,如"USB"
        retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
        if (retval)
            goto out;
		/*
		 * 前面说过,bus_kset指的是/sys/bus/目录; 一个kobj.kset指的是本
		 * kobj的父级目录,所以下面这句就是本bus的父目录是/sys/bus/,若为
		 * USB,则最终形成/sys/bus/usb/
		 * /
        priv->subsys.kobj.kset = bus_kset;
        priv->subsys.kobj.ktype = &bus_ktype;
        priv->drivers_autoprobe = 1;
		//此函数上面说过，添加一个kset目录,即添加/sys/bus/usb/
        retval = kset_register(&priv->subsys);
        if (retval)
            goto out;
		//为本目录(/sys/bus/usb/)添加一个属性文件
        retval = bus_create_file(bus, &bus_attr_uevent);
        if (retval)
            goto bus_uevent_fail;
		//每个总线目录下有个 /devices和/drivers目录
         priv->devices_kset = kset_create_and_add("devices", NULL,
                                                  &priv->subsys.kobj);
         if (!priv->devices_kset) {
                 retval = -ENOMEM;
                 goto bus_devices_fail;
         }
 
         priv->drivers_kset = kset_create_and_add("drivers", NULL,
                                                  &priv->subsys.kobj);
         if (!priv->drivers_kset) {
                 retval = -ENOMEM;
                 goto bus_drivers_fail;
         }
		
        INIT_LIST_HEAD(&priv->interfaces);
        __mutex_init(&priv->mutex, "subsys mutex", key);
        klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
        klist_init(&priv->klist_drivers, NULL, NULL);
 
        retval = add_probe_files(bus);
        if (retval)
            goto bus_probe_files_fail;
 
        retval = bus_add_attrs(bus);
        if (retval)
            goto bus_attrs_fail;
 
        pr_debug("bus: '%s': registered\n", bus->name);
        return 0;
 
 bus_attrs_fail:
         remove_probe_files(bus);
 bus_probe_files_fail:
         kset_unregister(bus->p->drivers_kset);
 bus_drivers_fail:
         kset_unregister(bus->p->devices_kset);
 bus_devices_fail:
         bus_remove_file(bus, &bus_attr_uevent);
 bus_uevent_fail:
         kset_unregister(&bus->p->subsys);
 out:
         kfree(bus->p);
         bus->p = NULL;
         return retval;
 }
 /*
  * v3.6.2/drivers/base/bus.c#L127
  */
int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)
{
    int error;
    if (bus_get(bus)) {
        error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr);
        bus_put(bus);
    } else
    error = -EINVAL;
    return error;
 }
 //v3.6.2/fs/sysfs/file.c#L571
 int sysfs_create_file(struct kobject * kobj, const struct attribute * attr)
 {
    BUG_ON(!kobj || !kobj->sd || !attr);
	//kobj是usb目录的那个kobj
    return sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR); 
 }
 //v3.6.2/fs/sysfs/file.c#L558
int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
                    int type)
 {
	//dir_sd指的是usb目录
    return sysfs_add_file_mode(dir_sd, attr, type, attr->mode);
 }
 
 
 int sysfs_add_file_mode(struct sysfs_dirent *dir_sd,
                         const struct attribute *attr, int type, umode_t amode)
 {
	 umode_t mode = (amode & S_IALLUGO) | S_IFREG;
	 struct sysfs_addrm_cxt acxt;
	 struct sysfs_dirent *sd;
	 const void *ns;
	 int rc;
	
	 rc = sysfs_attr_ns(dir_sd->s_dir.kobj, attr, &ns);
	 if (rc)
		 return rc;
	//目录下文件所用的那个dirent
	sd = sysfs_new_dirent(attr->name, mode, type);
	if (!sd)
		return -ENOMEM;
 
	sd->s_ns = ns;
	sd->s_attr.attr = (void *)attr;
	sysfs_dirent_init_lockdep(sd);
 
	sysfs_addrm_start(&acxt, dir_sd);
	//这里与前面相同了，就是在dirent结构体系中加入一个元素
	rc = sysfs_add_one(&acxt, sd);
	sysfs_addrm_finish(&acxt);
 
	 if (rc)
		 sysfs_put(sd);
 
	 return rc;
 }
 
 //文件系统mount过程
 /*
  * struct path
  * /include/linux/path.h
  */
  struct path {
         struct vfsmount *mnt;
           struct dentry *dentry;
  };
  /*
   * /fs/namespace.c中的系统调用定义
   * SYSCALL_DEFINE5(mount, char __user *, dev_name, char __user *, dir_name,
   *              char __user *, type, unsigned long, flags, void __user *, data)
   * 系统调用mount有5个参数,此函数最后是调用do_mount完成mount任务
   */
long do_mount(char *dev_name, char *dir_name, char *type_page,
                  unsigned long flags, void *data_page)
{
	......
	//取得挂载点的path结构信息,应该是根文件系统目录
	retval = kern_path(dir_name, LOOKUP_FOLLOW, &path);
	......
	//如果是新加载的文件系统,执行这里
	retval = do_new_mount(&path, type_page, flags, mnt_flags,
					dev_name, data_page)
} 
 
 
 1916/*
1917 * create a new mount for userspace and request it to be added into the
1918 * namespace's tree
1919 */
1920static int do_new_mount(struct path *path, char *type, int flags,
1921                        int mnt_flags, char *name, void *data)
1922{
1923        struct vfsmount *mnt;
1924        int err;
1925
1926        if (!type)
1927                return -EINVAL;
1928
1929        /* we need capabilities... */
1930        if (!capable(CAP_SYS_ADMIN))
1931                return -EPERM;
1932		//加载type字串指定的文件系统,过程与rootfs类似
1933        mnt = do_kern_mount(type, flags, name, data);
1934        if (IS_ERR(mnt))
1935                return PTR_ERR(mnt);
1936		//将mnt挂载到path指定的路径上
1937        err = do_add_mount(real_mount(mnt), path, mnt_flags);
1938        if (err)
1939                mntput(mnt);
1940        return err;
1941}
 
 
/*
 * 功能:
 * 	将newmnt文件系统加载到path指定的vfs路径上
 * 参数:
 * 	newmnt:刚才加载的文件系统
 * 	path:newmnt需要加载到的vfs路径
 * 说明:
 * 	因为path可能加载了别的文件系统(顶层是rootfs,子层是别的),所以要进入到最
 *  内层(最后加载的文件系统)锁住上层mnt
 * add a mount into a namespace's mount tree
 */
1878static int do_add_mount(struct mount *newmnt, struct path *path, int mnt_flags)
1879{
1880        int err;
1881
1882        mnt_flags &= ~(MNT_SHARED | MNT_WRITE_HOLD | MNT_INTERNAL);
1883
1884        err = lock_mount(path);
1885        if (err)
1886                return err;
1887
1888        err = -EINVAL;
1889        if (unlikely(!check_mnt(real_mount(path->mnt)))) {
1890                /* that's acceptable only for automounts done in private ns */
1891                if (!(mnt_flags & MNT_SHRINKABLE))
1892                        goto unlock;
1893                /* ... and for those we'd better have mountpoint still alive */
1894                if (!real_mount(path->mnt)->mnt_ns)
1895                        goto unlock;
1896        }
1897
1898        /* Refuse the same filesystem on the same mount point */
1899        err = -EBUSY;
1900        if (path->mnt->mnt_sb == newmnt->mnt.mnt_sb &&
1901            path->mnt->mnt_root == path->dentry)
1902                goto unlock;
1903
1904        err = -EINVAL;
1905        if (S_ISLNK(newmnt->mnt.mnt_root->d_inode->i_mode))
1906                goto unlock;
1907
1908        newmnt->mnt.mnt_flags = mnt_flags;
1909        err = graft_tree(newmnt, path);
1910
1911unlock:
1912        unlock_mount(path);
1913        return err;
1914}
//锁住父mount/ 
 /*
  * 将path指定的最内层mnt锁住,path可能加载了多个文件系统，所以要进入
  * 到最内层的
  */
 
1543static int lock_mount(struct path *path)
1544{
1545        struct vfsmount *mnt;
1546retry:
1547        mutex_lock(&path->dentry->d_inode->i_mutex);
1548        if (unlikely(cant_mount(path->dentry))) {
1549                mutex_unlock(&path->dentry->d_inode->i_mutex);
1550                return -ENOENT;
1551        }
1552        down_write(&namespace_sem);
			//查找path对应的第一个子mnt
1553        mnt = lookup_mnt(path);
			//一直向下一层找,直到下层没有了(llokup_mnt返回0
1554        if (likely(!mnt))
1555                return 0;
			/*
			 * 找到了本层的子层mnt,释放命名空间锁本层inode锁
			 * 释放路径锁。然后迭代:让path指向子层mnt,和dentry
			 * 再retry
			 */
1556        up_write(&namespace_sem);
1557        mutex_unlock(&path->dentry->d_inode->i_mutex);
1558        path_put(path);
1559        path->mnt = mnt;
1560        path->dentry = dget(mnt->mnt_root);
1561        goto retry;
1562}
 
 
/*
 575 * lookup_mnt - Return the first child mount mounted at path
 576 */
  590struct vfsmount *lookup_mnt(struct path *path)
 591{
 592        struct mount *child_mnt;
 593
 594        br_read_lock(&vfsmount_lock);
 595        child_mnt = __lookup_mnt(path->mnt, path->dentry, 1);
 596        if (child_mnt) {
 597                mnt_add_count(child_mnt, 1);
 598                br_read_unlock(&vfsmount_lock);
 599                return &child_mnt->mnt;
 600        } else {
 601                br_read_unlock(&vfsmount_lock);
 602                return NULL;
 603        }
 604}
 
 
 
/*
 * 根据dir指示返回mnt的第一个或最后一个子mnt  
 * mount_hashtable[hash(mnt, dentry)]的值是一个链表,存储着相同hash值的mnt
 * 根据代码大概是,某一个path对应一对mnt dentry,在此path挂载的话,会有mnt1,
 * dentry1,再在此path挂载的话,会有mnt2,dentry2并且其父是mnt1,dentry1而并不
 * 是mnt和dentry。那意味着hash表项中(&p->mnt_parent->mnt == mnt && 
 * p->mnt_mountpoint == dentry)只能成立一次。也就是说同一挂载点的mnt,dentry
 * 只可能有一个儿子。(这块不明白)
 */
 553struct mount *__lookup_mnt(struct vfsmount *mnt, struct dentry *dentry,
 554                              int dir)
 555{
 556        struct list_head *head = mount_hashtable + hash(mnt, dentry);
 557        struct list_head *tmp = head;
 558        struct mount *p, *found = NULL;
 559
 560        for (;;) {
					//顺着来还是倒着来
 561                tmp = dir ? tmp->next : tmp->prev;
 562                p = NULL;
 563                if (tmp == head)
 564                        break;
 565                p = list_entry(tmp, struct mount, mnt_hash);
					//确定一下关系，因为hash有可能冲突
 566                if (&p->mnt_parent->mnt == mnt && p->mnt_mountpoint == dentry) {
 567                        found = p;
 568                        break;
 569                }
 570        }
 571        return found;
 572}
 //嫁接子mount到父mount上//
 
 
1570static int graft_tree(struct mount *mnt, struct path *path)
1571{
1572        if (mnt->mnt.mnt_sb->s_flags & MS_NOUSER)
1573                return -EINVAL;
1574
1575        if (S_ISDIR(path->dentry->d_inode->i_mode) !=
1576              S_ISDIR(mnt->mnt.mnt_root->d_inode->i_mode))
1577                return -ENOTDIR;
1578
1579        if (d_unlinked(path->dentry))
1580                return -ENOENT;
1581
1582        return attach_recursive_mnt(mnt, path, NULL);
1583}
 
 
 
 
path walk//

 
 
 
 
 
 
 
 
 
 
static int link_path_walk(const char *name, struct nameidata *nd)
1714{
1715        struct path next;
1716        int err;
1717        
1718        while (*name=='/')
1719                name++;
1720        if (!*name)
1721                return 0;
1722
1723        /* At this point we know we have a real path component. */
1724        for(;;) {
1725                struct qstr this;
1726                long len;
1727                int type;
1728
1729                err = may_lookup(nd);
1730                if (err)
1731                        break;
1732
1733                len = hash_name(name, &this.hash);
1734                this.name = name;
1735                this.len = len;
1736
1737                type = LAST_NORM;
1738                if (name[0] == '.') switch (len) {
1739                        case 2:
1740                                if (name[1] == '.') {
1741                                        type = LAST_DOTDOT;
1742                                        nd->flags |= LOOKUP_JUMPED;
1743                                }
1744                                break;
1745                        case 1:
1746                                type = LAST_DOT;
1747                }
1748                if (likely(type == LAST_NORM)) {
1749                        struct dentry *parent = nd->path.dentry;
1750                        nd->flags &= ~LOOKUP_JUMPED;
1751                        if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
1752                                err = parent->d_op->d_hash(parent, nd->inode,
1753                                                           &this);
1754                                if (err < 0)
1755                                        break;
1756                        }
1757                }
1758
1759                if (!name[len])
1760                        goto last_component;
1761                /*
1762                 * If it wasn't NUL, we know it was '/'. Skip that
1763                 * slash, and continue until no more slashes.
1764                 */
1765                do {
1766                        len++;
1767                } while (unlikely(name[len] == '/'));
1768                if (!name[len])
1769                        goto last_component;
1770                name += len;
1771
1772                err = walk_component(nd, &next, &this, type, LOOKUP_FOLLOW);
1773                if (err < 0)
1774                        return err;
1775
1776                if (err) {
1777                        err = nested_symlink(&next, nd);
1778                        if (err)
1779                                return err;
1780                }
1781                if (can_lookup(nd->inode))
1782                        continue;
1783                err = -ENOTDIR; 
1784                break;
1785                /* here ends the main loop */
1786
1787last_component:
1788                nd->last = this;
1789                nd->last_type = type;
1790                return 0;
1791        }//for(;;)循环
1792        terminate_walk(nd);
1793        return err;
1794}
1795 
 
 
/*
 *	///opt/soft/abc.txt
 */

1713static int link_path_walk(const char *name, struct nameidata *nd)
1714{
1715        struct path next;
1716        int err;
1717        //去前导'/'=opt/soft/abc.txt,让name指向第一个分量开始处
1718        while (*name=='/')
1719                name++;
1720        if (!*name)
1721                return 0;
1722
1723        /* At this point we know we have a real path component. */
1724        for(;;) {//按name分量处理
1725                struct qstr this;//当前分量名,长度
1726                long len;
1727                int type;
1728				//inode 访问检查
1729                err = may_lookup(nd);
1730                if (err)
1731                        break;
1732				
1733                len = hash_name(name, &this.hash);//当前分量hash
1734                this.name = name;//当前分量开始处
1735                this.len = len;//当前分量长度
1736
1737                type = LAST_NORM;//上一个分量正常
1738                if (name[0] == '.') switch (len) {
1739                        case 2:
1740                                if (name[1] == '.') {
1741                                        type = LAST_DOTDOT;//上一分量是"点点"
1742                                        nd->flags |= LOOKUP_JUMPED;
1743                                }
1744                                break;
1745                        case 1:
1746                                type = LAST_DOT;//上一分量是"点"
1747                }
1748                if (likely(type == LAST_NORM)) {
1749                        struct dentry *parent = nd->path.dentry;
1750                        nd->flags &= ~LOOKUP_JUMPED;
1751                        if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
1752                                err = parent->d_op->d_hash(parent, nd->inode,
1753                                                           &this);
1754                                if (err < 0)
1755                                        break;
1756                        }
1757                }
1758				//*(name+len)==null表示 name即name分量是最后一个:xxx/name'\0'
1759                if (!name[len])
1760                        goto last_component;
1761                /*
1762                 * If it wasn't NUL, we know it was '/'. Skip that
1763                 * slash, and continue until no more slashes.
					 * 非null表示name后还有分量,那么过滤掉相应的'/'
1764                 */
1765                do {
1766                        len++;
1767                } while (unlikely(name[len] == '/'));
1768                if (!name[len])
1769                        goto last_component;
					//name指向下一个分量,说不定有下一次for循环
1770                name += len;
1771		//得到当前分量相关的dentry等数据结构存入nd,再循环处理下一分量
1772                err = walk_component(nd, &next, &this, type, LOOKUP_FOLLOW);
1773                if (err < 0)
1774                        return err;
1775
1776                if (err) {//err>0时，处理符号链接
1777                        err = nested_symlink(&next, nd);
1778                        if (err)
1779                                return err;
1780                }
					//err==0时,继续for循环,处理下一分量节点
1781                if (can_lookup(nd->inode))
1782                        continue;
1783                err = -ENOTDIR; 
1784                break;
1785                /* here ends the main loop */
1786
1787last_component:
					/*
					 * 到这里，this指向的是最后一个分量
					 * 到这里函数才能正确地退出，如果是
					 * break出去的则表示出错
					 */
1788                nd->last = this;
1789                nd->last_type = type;
1790                return 0;
1791        }
1792        terminate_walk(nd);
1793        return err;
1794}




/*
 *  主要是两种处理方法,一种是查cache，一种是慢速找，最终用到路径上倒数第
 *	二个节点的dentry(最后一个的父)相关的inode，然后调用inode->lookup根据
 *	设置的name找到相关的dentry
 *
 *	lookup_fast//rcu列表中查找
 *		__d_lookup_rcu
 *		__d_lookup
 *	lookup_slow
 *		__lookup_hash
 *			lookup_dcache
 *				d_lookup
 *					__d_lookup
 *			lookup_real
 *				dir->i_op->lookup//调用inode的lookup
 */
1475static inline int walk_component(struct nameidata *nd, struct path *path,
1476                struct qstr *name, int type, int follow)
1477{
1478        struct inode *inode;
1479        int err;
1480        /*
1481         * "." and ".." are special - ".." especially so because it has
1482         * to be able to know about the current root directory and
1483         * parent relationships.
1484         */
1485        if (unlikely(type != LAST_NORM))
1486                return handle_dots(nd, type);//点/点点的处理
1487        err = lookup_fast(nd, name, path, &inode);
1488        if (unlikely(err)) {
1489                if (err < 0)
1490                        goto out_err;
1491
1492                err = lookup_slow(nd, name, path);
1493                if (err < 0)
1494                        goto out_err;
1495
1496                inode = path->dentry->d_inode;
1497        }
1498        err = -ENOENT;
1499        if (!inode)
1500                goto out_path_put;
1501
1502        if (should_follow_link(inode, follow)) {
1503                if (nd->flags & LOOKUP_RCU) {
1504                        if (unlikely(unlazy_walk(nd, path->dentry))) {
1505                                err = -ECHILD;
1506                                goto out_err;
1507                        }
1508                }
1509                BUG_ON(inode != path->dentry->d_inode);
1510                return 1;
1511        }
			//path内容存入nd
1512        path_to_nameidata(path, nd);
1513        nd->inode = inode;
1514        return 0;
1515
1516out_path_put:
1517        path_to_nameidata(path, nd);
1518out_err:
1519        terminate_walk(nd);
1520        return err;
1521}
1522

/*
 * 总结:
 * 	粗略地看了下vfs。具体的fs只需提供相关结构的方法即可，vfs只是一个框架。
 *  具体fs满足vfs所需要的接口。比如，vfs查找路径，最终要生成一个dentry，
 *  而sysfs以硬件和dirent来级联，但用户调用sysfs的lookup时，sysfs需要根据
 *  当前的参数生成一个dentry。vfs不管sysfs内部如何实现。
 *  遗留问题:
 *	往同一个目录mount多次,其树状结构是什么样的
 *	路径查找中所使用的cache系统原理
 */