Linux内核源代码情景分析-设备文件系统devfs

标签：

    我们以前多次讲过到，以主设备号/次设备号为基础的设备文件管理方式是有根本性的缺点的。这种从Unix早期一直沿用下来的方案一方面给设备号的管理带来了麻烦，一方面也破坏了/dev目录结构。Unix/Linux系统中的所有目录的结构都是层次的，惟独/dev目录是"平面"的。这不光是风格的问题，也直接影响着访问的效率和管理的方便与否。

    那么理想中的/dev目录应该是什么样的呢？首先，它应该是层次的、树状的。其次，它的规模应该是可伸缩的，而且不受数量的限制(例如256个主设备号)。还有，/dev目录中的内容应该反映系统当前在设备驱动方面的实际情形。例如，这样一套方案就是比较理想的：

    1、系统加电之初/dev目录为空。

    2、系统在初始化阶段扫描并枚举所有连接着的设备，就像对PCI总线的扫描枚举一样。每找到一项设备就分门别类地在/dev目录下创建起子目录，然后以设备的序号作为最底层的节点名，例如"/dev/ide/hd/1"，”/dev/ide/floppy/1“等等。

    3、以后，每插入一个设备，或安装一个可安装模块，就由内核在/dev子树中增加一个或几个节点。

    4、反之，如果关闭或拆除一个设备，或拆除一个可安装模块，就由内核在/dev子树中删去相应的节点。

    5、还得与原来的方案兼容。

    其实设备文件系统devfs，和特殊文件系统/proc思路基本一样。

    一、文件系统类型devfs_fs_type的定义如下：

static DECLARE_FSTYPE (devfs_fs_type, DEVFS_NAME, devfs_read_super, FS_SINGLE);

struct file_system_type devfs_fs_type = {
        name:       "devfs",
        read_super: devfs_read_super,
        fs_flags:   FS_SINGLE,
        owner:      THIS_MODULE,
}

int __init init_devfs_fs (void)
{
    int err;

    printk ("%s: v%s Richard Gooch (rgooch@atnf.csiro.au)\n",
	    DEVFS_NAME, DEVFS_VERSION);
#ifdef CONFIG_DEVFS_DEBUG
    devfs_debug = devfs_debug_init;
    printk ("%s: devfs_debug: 0x%0x\n", DEVFS_NAME, devfs_debug);
#endif
    printk ("%s: boot_options: 0x%0x\n", DEVFS_NAME, boot_options);
    err = register_filesystem (&devfs_fs_type);//向系统登记文件系统类型devfs_fs_type
    if (!err)
    {
	struct vfsmount *devfs_mnt = kern_mount (&devfs_fs_type);//初始安装特殊文件系统devfs
	err = PTR_ERR (devfs_mnt);
	if ( !IS_ERR (devfs_mnt) ) err = 0;
    }
    return err;
}

struct vfsmount *kern_mount(struct file_system_type *type)
{
	kdev_t dev = get_unnamed_dev();
	struct super_block *sb;
	struct vfsmount *mnt;
	if (!dev)
		return ERR_PTR(-EMFILE);
	sb = read_super(dev, NULL, type, 0, NULL, 0);
	if (!sb) {
		put_unnamed_dev(dev);
		return ERR_PTR(-EINVAL);
	}
	mnt = add_vfsmnt(NULL, sb->s_root, NULL);
	if (!mnt) {
		kill_super(sb, 0);
		return ERR_PTR(-ENOMEM);
	}
	type->kern_mnt = mnt;//重点
	return mnt;
}

static struct super_block * read_super(kdev_t dev, struct block_device *bdev,
				       struct file_system_type *type, int flags,
				       void *data, int silent)
{
	struct super_block * s;
	s = get_empty_super();
	if (!s)
		goto out;
	s->s_dev = dev;
	s->s_bdev = bdev;
	s->s_flags = flags;
	s->s_dirt = 0;
	sema_init(&s->s_vfs_rename_sem,1);
	sema_init(&s->s_nfsd_free_path_sem,1);
	s->s_type = type;
	sema_init(&s->s_dquot.dqio_sem, 1);
	sema_init(&s->s_dquot.dqoff_sem, 1);
	s->s_dquot.flags = 0;
	lock_super(s);
	if (!type->read_super(s, data, silent))//devfs_read_super
		goto out_fail;
	unlock_super(s);
	/* tell bdcache that we are going to keep this one */
	if (bdev)
		atomic_inc(&bdev->bd_count);
out:
	return s;

out_fail:
	s->s_dev = 0;
	s->s_bdev = 0;
	s->s_type = NULL;
	unlock_super(s);
	return NULL;
}

static struct super_block *devfs_read_super (struct super_block *sb,
					     void *data, int silent)
{
    struct inode *root_inode = NULL;

    if (get_root_entry () == NULL) goto out_no_root;
    atomic_set (&fs_info.devfsd_overrun_count, 0);
    init_waitqueue_head (&fs_info.devfsd_wait_queue);
    init_waitqueue_head (&fs_info.revalidate_wait_queue);
    fs_info.sb = sb;
    sb->u.generic_sbp = &fs_info;
    sb->s_blocksize = 1024;
    sb->s_blocksize_bits = 10;
    sb->s_magic = DEVFS_SUPER_MAGIC;
    sb->s_op = &devfs_sops;
    if ( ( root_inode = get_vfs_inode (sb, root_entry, NULL) ) == NULL )//为devfs的根节点创建一个inode数据结构
	goto out_no_root;
    sb->s_root = d_alloc_root (root_inode);//为devfs的根节点创建一个dentry数据结构，这个节点也叫"/"，并保存在sb->s_root中
    if (!sb->s_root) goto out_no_root;
#ifdef CONFIG_DEVFS_DEBUG
    if (devfs_debug & DEBUG_DISABLED)
	printk ("%s: read super, made devfs ptr: %p\n",
		DEVFS_NAME, sb->u.generic_sbp);
#endif
    return sb;

out_no_root:
    printk ("devfs_read_super: get root inode failed\n");
    if (root_inode) iput (root_inode);
    return NULL;
}

struct devfs_entry
{
    void *info;
    union 
    {
	struct directory_type dir;
	struct fcb_type fcb;
	struct symlink_type symlink;
	struct fifo_type fifo;
    }
    u;
    struct devfs_entry *prev;    /*  Previous entry in the parent directory  */
    struct devfs_entry *next;    /*  Next entry in the parent directory      */
    struct devfs_entry *parent;  /*  The parent directory                    */
    struct devfs_entry *slave;   /*  Another entry to unregister             */
    struct devfs_inode inode;
    umode_t mode;
    unsigned short namelen;  /*  I think 64k+ filenames are a way off...  */
    unsigned char registered:1;
    unsigned char show_unreg:1;
    unsigned char hide:1;
    unsigned char no_persistence:1;
    char name[1];            /*  This is just a dummy: the allocated array is
				 bigger. This is NULL-terminated  */
}

struct file_type
{
    unsigned long size;
};

struct device_type
{
    unsigned short major;
    unsigned short minor;
};

struct fcb_type  /*  File, char, block type  */
{
    uid_t default_uid;
    gid_t default_gid;
    void *ops;
    union 
    {
	struct file_type file;
	struct device_type device;
    }
    u;
    unsigned char auto_owner:1;
    unsigned char aopen_notify:1;
    unsigned char removable:1;  /*  Belongs in device_type, but save space   */
    unsigned char open:1;       /*  Not entirely correct                     */
};

   内核中还有个数据结构fs_info，代码如下：

struct fs_info      /*  This structure is for each mounted devfs  */
{
    unsigned int num_inodes;    /*  Number of inodes created         */
    unsigned int table_size;    //数组当前的大小
    struct devfs_entry **table;  //指向了一个devfs_entry指针数组
    struct super_block *sb;
    volatile struct devfsd_buf_entry *devfsd_buffer;
    volatile unsigned int devfsd_buf_in;
    volatile unsigned int devfsd_buf_out;
    volatile int devfsd_sleeping;
    volatile int devfsd_buffer_in_use;
    volatile struct task_struct *devfsd_task;
    volatile struct file *devfsd_file;
    volatile unsigned long devfsd_event_mask;
    atomic_t devfsd_overrun_count;
    wait_queue_head_t devfsd_wait_queue;
    wait_queue_head_t revalidate_wait_queue;
};

   介绍完这些数据结构后，我们回到devfs_read_super，继续看get_root_entry，代码如下：

static struct devfs_entry *get_root_entry (void)
{
    struct devfs_entry *new;

    /*  Always ensure the root is created  */
    if (root_entry != NULL) return root_entry;
    if ( ( root_entry = create_entry (NULL, NULL, 0) ) == NULL ) return NULL;//先创建devfs的根节点root_entry
    root_entry->registered = TRUE;
    root_entry->mode = S_IFDIR;
    /*  Force an inode update, because lookup() is never done for the root  */
    update_devfs_inode_from_entry (root_entry);
    /*  And create the entry for ".devfsd"  */
    if ( ( new = create_entry (root_entry, ".devfsd", 0) ) == NULL )//在devfs的根节点下创建一个节点".devfsd"。
	return NULL;
    new->registered = TRUE;
    new->u.fcb.u.device.major = next_devnum_char >> 8;////.devfsd是个fcb节点。在devfs中，设备号是由系统自动分配的，设备号在devfs中并不起着原来那么重要的作用
    new->u.fcb.u.device.minor = next_devnum_char & 0xff;
    ++next_devnum_char;
    new->mode = S_IFCHR | S_IRUSR | S_IWUSR;
    new->u.fcb.default_uid = 0;
    new->u.fcb.default_gid = 0;
    new->u.fcb.ops = &devfsd_fops;//ops指向devfsd_fops,代码在下面
    return root_entry;
}

static struct devfs_entry *create_entry (struct devfs_entry *parent,
					 const char *name,unsigned int namelen)
{
    struct devfs_entry *new, **table;

    /*  First ensure table size is enough  */
    if (fs_info.num_inodes >= fs_info.table_size)//目前num_inodes为0，table_size为0
    {
		if ( ( table = kmalloc (sizeof *table *
				(fs_info.table_size + INODE_TABLE_INC),
				GFP_KERNEL) ) == NULL ) return NULL;//分配最初的250个指针分配空间
		fs_info.table_size += INODE_TABLE_INC;//INODE_TABLE_INC为250
#ifdef CONFIG_DEVFS_DEBUG
		if (devfs_debug & DEBUG_I_CREATE)
		    printk ("%s: create_entry(): grew inode table to: %u entries\n",
			    DEVFS_NAME, fs_info.table_size);
#endif
		if (fs_info.table)//如果不是第一次分配空间，则还要把已经存在的数组复制到新的空间，并释放原有的空间
		{
		    memcpy (table, fs_info.table, sizeof *table *fs_info.num_inodes);
		    kfree (fs_info.table);
		}
		fs_info.table = table;//指向了一个devfs_entry指针数组
    }
    if ( name && (namelen < 1) ) namelen = strlen (name);
    if ( ( new = kmalloc (sizeof *new + namelen, GFP_KERNEL) ) == NULL )
	return NULL;
    /*  Magic: this will set the ctime to zero, thus subsequent lookups will
	trigger the call to <update_devfs_inode_from_entry>  */
    memset (new, 0, sizeof *new + namelen);
    new->parent = parent;
    if (name) memcpy (new->name, name, namelen);
    new->namelen = namelen;
    new->inode.ino = fs_info.num_inodes + FIRST_INODE;//FIRST_INODE为1，以后则逐次递增，设置了节点号
    new->inode.nlink = 1;
    fs_info.table[fs_info.num_inodes] = new;//更新devfs_entry指针数组
    ++fs_info.num_inodes;//递增
    if (parent == NULL) return new;
    new->prev = parent->u.dir.last;//将新的节点与父节点以及同一目录中的其它节点链接在一起
    /*  Insert into the parent directory‘s list of children  */
    if (parent->u.dir.first == NULL) parent->u.dir.first = new;
    else parent->u.dir.last->next = new;
    parent->u.dir.last = new;
    return new;
}

static struct file_operations devfsd_fops =
{
    read:    devfsd_read,
    ioctl:   devfsd_ioctl,
    release: devfsd_close,
};

static struct inode *get_vfs_inode (struct super_block *sb,
				    struct devfs_entry *de,
				    struct dentry *dentry)
{
    struct inode *inode;

    if (de->inode.dentry != NULL)
    {
	printk ("%s: get_vfs_inode(%u): old de->inode.dentry: %p \"%s\"  new dentry: %p \"%s\"\n",
		DEVFS_NAME, de->inode.ino,
		de->inode.dentry, de->inode.dentry->d_name.name,
		dentry, dentry->d_name.name);
	printk ("  old inode: %p\n", de->inode.dentry->d_inode);
	return NULL;
    }
    if ( ( inode = iget (sb, de->inode.ino) ) == NULL ) return NULL;//首先在inode结构的杂凑队列中查找，如果找不到就新创建一个
    de->inode.dentry = dentry;
    return inode;
}

struct dentry * d_alloc_root(struct inode * root_inode)
{
	struct dentry *res = NULL;

	if (root_inode) {
		res = d_alloc(NULL, &(const struct qstr) { "/", 1, 0 });
		if (res) {
			res->d_sb = root_inode->i_sb;
			res->d_parent = res;
			d_instantiate(res, root_inode);
		}
	}
	return res;
}

static struct vfsmount *add_vfsmnt(struct nameidata *nd,
				struct dentry *root,
				const char *dev_name)
{
	struct vfsmount *mnt;
	struct super_block *sb = root->d_inode->i_sb;
	char *name;

	mnt = kmalloc(sizeof(struct vfsmount), GFP_KERNEL);
	if (!mnt)
		goto out;
	memset(mnt, 0, sizeof(struct vfsmount));

	if (nd || dev_name)
		mnt->mnt_flags = MNT_VISIBLE;

	/* It may be NULL, but who cares? */
	if (dev_name) {
		name = kmalloc(strlen(dev_name)+1, GFP_KERNEL);
		if (name) {
			strcpy(name, dev_name);
			mnt->mnt_devname = name;
		}
	}
	mnt->mnt_owner = current->uid;
	atomic_set(&mnt->mnt_count,1);
	mnt->mnt_sb = sb;

	spin_lock(&dcache_lock);
	if (nd && !IS_ROOT(nd->dentry) && d_unhashed(nd->dentry))
		goto fail;
	mnt->mnt_root = dget(root);
	mnt->mnt_mountpoint = nd ? dget(nd->dentry) : dget(root);
	mnt->mnt_parent = nd ? mntget(nd->mnt) : mnt;

	if (nd) {
		list_add(&mnt->mnt_child, &nd->mnt->mnt_mounts);
		list_add(&mnt->mnt_clash, &nd->dentry->d_vfsmnt);
	} else {
		INIT_LIST_HEAD(&mnt->mnt_child);
		INIT_LIST_HEAD(&mnt->mnt_clash);
	}
	INIT_LIST_HEAD(&mnt->mnt_mounts);
	list_add(&mnt->mnt_instances, &sb->s_mounts);
	list_add(&mnt->mnt_list, vfsmntlist.prev);
	spin_unlock(&dcache_lock);
out:
	return mnt;
fail:
	spin_unlock(&dcache_lock);
	if (mnt->mnt_devname)
		kfree(mnt->mnt_devname);
	kfree(mnt);
	return NULL;
}

void __init mount_devfs_fs (void)
{
    int err;

    if ( (boot_options & OPTION_NOMOUNT) ) return;
    err = do_mount ("none", "/dev", "devfs", 0, "");
    if (err == 0) printk ("Mounted devfs on /dev\n");
    else printk ("Warning: unable to mount devfs, err: %d\n", err);
}

    可见，设备文件系统devfs的安装点是"/dev"。由于devfs_fs_type中的FS_SINGLE标志位为1，安装时会把保存在devfs_fs_type中的vfsmount结构指针安装到”/dev“节点上。

    do_mount请参考Linux内核源代码情景分析-文件系统的安装和Linux内核源代码情景分析-特殊文件系统/proc。 

    三、完成了devfs的安装以后，各种设备的驱动程序就可以通过devfs_register_chrdev或devfs_register_blkdev向devfs登记，从而在/dev目录下创建起相应的节点。

    1、通过devfs_register_chrdev向devfs登记一类设备的主设备号、设备号以及file_operations数据结构，建立起三者间的联系。主设备号可以是静态指定的，也可以要求devfs动态地分配。

    2、通过devfs_mk_dir建立目录节点

    3、通过devfs_register登记具体的设备，并在指定目录下建立叶节点

    上面三个过程类似于/proc特殊文件系统，创建proc节点以下的子节点的proc_dir_entry结构，代码如下：

void __init proc_root_init(void)
{
	proc_misc_init();
	proc_net = proc_mkdir("net", 0);
#ifdef CONFIG_SYSVIPC
	proc_mkdir("sysvipc", 0);
#endif
#ifdef CONFIG_SYSCTL
	proc_sys_root = proc_mkdir("sys", 0);
#endif
	proc_root_fs = proc_mkdir("fs", 0);
	proc_root_driver = proc_mkdir("driver", 0);
#if defined(CONFIG_SUN_OPENPROMFS) || defined(CONFIG_SUN_OPENPROMFS_MODULE)
	/* just give it a mountpoint */
	proc_mkdir("openprom", 0);
#endif
	proc_tty_init();
#ifdef CONFIG_PROC_DEVICETREE
	proc_device_tree_init();
#endif
	proc_bus = proc_mkdir("bus", 0);
}

Linux内核源代码情景分析-设备文件系统devfs

标签：

原文地址：http://blog.csdn.net/jltxgcy/article/details/45579257