linux的机制和策略通信—debugfs

linux内核和用户通信方法中有一个叫做debugfs，它的作用类似于sysctl，但是是通过文件系统实现的，本文不准备再详细的说debugfs的实现，像前面seqfile那么详细的说，而是简单列出需要的代码做个纪念，证明今天（2009/2/19）我详细的读过了linux内核的debugfs。
#define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt)            /
static int __fops ## _open(struct inode *inode, struct file *file)      /
{                                                                       /
         __simple_attr_check_format(__fmt, 0ull);                       /
         return simple_attr_open(inode, file, __get, __set, __fmt);     /
}                                                                       /
static struct file_operations __fops = {                                /
         .owner   = THIS_MODULE,                                        /
         .open    = __fops ## _open,                                    /
         .release = simple_attr_close,                                  /
         .read    = simple_attr_read,                                   /
         .write   = simple_attr_write,                                  /
};
以上这个宏简直太帅了，它其实定义了debugfs的file_operations，因为debugfs不是通过一个file_operations来实现的，而是每一个数据类型一个，因此用到了上面的宏来为如此繁多的file_operations服务。
int simple_attr_open(struct inode *inode, struct file *file, u64 (*get)(void *), void (*set)(void *, u64), const char *fmt)
{
         struct simple_attr *attr;   //重要结构
         attr = kmalloc(sizeof(*attr), GFP_KERNEL);
         if (!attr)
                 return -ENOMEM;
         attr->get = get;
         attr->set = set;
         attr->data = inode->u.generic_ip;
         attr->fmt = fmt;
         mutex_init(&attr->mutex);
         file->private_data = attr;
         return nonseekable_open(inode, file);
}
这个debugfs_create_XX就是定义一个特定数据类型的变量，内核和用户通过该变量进行通信，每一个变量在用户空间挂载的debugfs挂载点路径下都会有一个文件，对该文件的操作就触发了用上面宏定义的file_operations的回调函数调用事件。
struct dentry *debugfs_create_u8(const char *name, mode_t mode, struct dentry *parent, u8 *value)
{
         return debugfs_create_file(name, mode, parent, value, &fops_u8);
}
struct dentry *debugfs_create_file(const char *name, mode_t mode, struct dentry *parent, void *data, const struct file_operations *fops)
{
         struct dentry *dentry = NULL;
         int error;
         error = simple_pin_fs(&debug_fs_type, &debugfs_mount, &debugfs_mount_count);
...
         error = debugfs_create_by_name(name, mode, parent, &dentry);
...
         if (dentry->d_inode) {
                 if (data)
                         dentry->d_inode->u.generic_ip = data;
                 if (fops)
                         dentry->d_inode->i_fop = fops;
         }
...
}
int simple_pin_fs(struct file_system_type *type, struct vfsmount **mount, int *count)
{
         struct vfsmount *mnt = NULL;
         spin_lock(&pin_fs_lock);
         if (unlikely(!*mount)) {
                 spin_unlock(&pin_fs_lock);
                 mnt = vfs_kern_mount(type, 0, type->name, NULL);
...
                 spin_lock(&pin_fs_lock);
                 if (!*mount)
                         *mount = mnt;
         }
...
         return 0;
}
下面的这个read函数就是那个宏定义的file_operations中的read，真正实现在attr中的get例程
ssize_t simple_attr_read(struct file *file, char __user *buf, size_t len, loff_t *ppos)
{
         struct simple_attr *attr;
         size_t size;
         ssize_t ret;
         attr = file->private_data;
         if (!attr->get)
                 return -EACCES;
         mutex_lock(&attr->mutex);
         if (*ppos)
                 size = strlen(attr->get_buf);
         else      
                 size = scnprintf(attr->get_buf, sizeof(attr->get_buf), attr->fmt,(unsigned long long)attr->get(attr->data));
         ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
         mutex_unlock(&attr->mutex);
         return ret;
}
最后来看看对于u8的file_operations是怎么实现的：
DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu/n");
static void debugfs_u8_set(void *data, u64 val)
{
         *(u8 *)data = val;
}
static u64 debugfs_u8_get(void *data)
{
         return *(u8 *)data;
}
看完了这一切后，我不禁感叹，linux中如此简单就可以实现一个机制，太妙了。前面的seqfile是自成体系的一套机制，它强调一种抽象的思想，而这个debugfs是用文件系统实现的，linux的vfs简直太强大了，这都要归功于file_operations结构体，它就是一个适配器，适配了上面统一的调用层和下面不同的文件系统，file_operations是机制，它的实现是策略，既然是策略，那它就可以随意实现了，于是你想实现一个内核机制的时候，文件系统总会帮你，也正是因为如此，一般的内核新机制都是在文件系统上实现的。