2.4.5 用户空间inotify机制

int fd = inotify_init (); 　//创建inotify机制文件描述符
//添加一个watch，path 是被监视的目标的路径，mask 是事件掩码，wd是watch描述符
int wd = inotify_add_watch (fd, path, mask);　
//buf是一个inotify_event 结构的数组指针，BUF_LEN指定要读取的总长度，buf不小于 BUF_LEN
size_t len = read (fd, buf, BUF_LEN);  //读取多个事件，文件描述符 fd 上使用 select() 或poll()
int ret = inotify_rm_watch (fd, wd);　//删除一个 watch
close(fd);

$cat inotify_usespace.c
#include 
#include 
#include 

char * monitored_files[] = { 
"./tmp_file", 
"./tmp_dir", 
"/mnt/sda3/windows_file" 
}; 

struct wd_name { 
int wd; 
char * name; 
}; 

#define WD_NUM 3 
struct wd_name wd_array[WD_NUM];  //用于存储文件路径名和watch描述符

//inotify机制事件对应说明数组
char * event_array[] = { 
"File was accessed", 
"File was modified", 
"File attributes were changed", 
"writtable file closed", 
"Unwrittable file closed", 
"File was opened", 
"File was moved from X", 
"File was moved to Y", 
"Subfile was created", 
"Subfile was deleted", 
"Self was deleted", 
"Self was moved", 
"", 
"Backing fs was unmounted", 
"Event queued overflowed", 
"File was ignored" 
}; 
#define EVENT_NUM 16 
#define MAX_BUF_SIZE 1024 

int main(void) 
{ 
int fd; 
int wd; 
char buffer[1024]; 
char * offset = NULL; 
struct inotify_event * event; 
int len, tmp_len; 
char strbuf[16]; 
int i = 0; 

fd = inotify_init(); 
if (fd < 0) { 
printf("Fail to initialize inotify.\n"); 
exit(-1); 
 
} 
for (i=0; i< WD_NUM; i++) {
wd_array[i].name = monitored_files[i];  //存入文件路径名
//给路径wd_array[i].name添加一个watch，监视所有事件，wd为返回的watch描述符
wd = inotify_add_watch(fd, wd_array[i].name, IN_ALL_EVENTS); 
if (wd < 0) { 
printf("Can't add watch for %s.\n", wd_array[i].name); 
exit(-1); 
} 

wd_array[i].wd = wd; 
} 

while(len = read(fd, buffer, MAX_BUF_SIZE)) { //读取多个事件
offset = buffer; 
printf("Some event happens, len = %d.\n", len);  //打印实际读取的长度
event = (struct inotify_event *)buffer; //得到事件

while (((char *)event - buffer) < len) { 
if (event-> mask & IN_ISDIR) { //目录
memcpy(strbuf, "Direcotory", 11);  
//“Direcotory”字符串长度为11
} 
else { 
memcpy(strbuf, "File", 5); 
//“File”字符串长度为5，包括后面加一个空格
} 
printf("Object type: %s\n", strbuf); 

for (i=0; i< WD_NUM; i++) {
if (event-> wd != wd_array[i].wd)
continue; 
printf("Object name: %s\n", wd_array[i].name); 
//打印文件路径名
break; 
} 

printf("Event mask: %08X\n", event-> mask);  //打印事件掩码
for (i=0; i< EVENT_NUM ; i++) {
if (event_array[i][0] == '\0') 
//空字符串行，说明事件对应说明不存在
continue; 
//将事件掩码的位匹配数组成员，如：00000020，即100000，对应i为5
if (event-> mask & (1 << i)) {
printf("Event: %s\n", event_array[i]); 　
//打印事件对应的说明字符串
} 
} 

tmp_len = sizeof(struct inotify_event) + event-> len; 
event = (struct inotify_event *)(offset + tmp_len);  //得到下一个事件
offset += tmp_len; 
} 
} 
}

$gcc -o inotify_userspace -I . inotify_usersapce.c

Some event happens, len = 48.
Object type: File 
Object name: ./tmp_file 
Event mask: 00000020 
Event: File was opened 
Object type: File 
Object name: ./tmp_file 
Event mask: 00000001 
Event: File was accessed 
Object type: File 
Object name: ./tmp_file 
Event mask: 00000010 
Event: Unwrittable file closed 

struct inotify_user_watch {
struct inotify_device*dev;/*可以看作设备，含有链表，用于将事件传递回用户空间*/
struct inotify_watchwdata;/*inotify机制的watch（监视实例）*/
};

struct inotify_device {
wait_queue_head_t wq;/* i/o 的等待队列*/
struct mutexev_mutex;/* 用于保护事件队列*/
struct mutexup_mutex;/*用于同步watch更新*/
struct list_head events;/*排队事件的链表*/
atomic_tcount;/*引用计数 */
struct user_struct*user;/*打开这个设备的用户*/
struct inotify_handle *ih;/*监视处理实例 */
unsigned intqueue_size;/*队列的大小 (bytes) */
unsigned intevent_count;/* 挂起事件的数量*/
unsigned intmax_events;/* 最大事件数*/
};

static const struct inotify_operations inotify_user_ops = {
.handle_event= inotify_dev_queue_event,
.destroy_watch= free_inotify_user_watch,
};

static int __init inotify_user_setup(void)
{
int ret;

ret = register_filesystem(&inotify_fs_type);//注册文件系统
if (unlikely(ret))
panic("inotify: register_filesystem returned %d!\n", ret);

inotify_mnt = kern_mount(&inotify_fs_type);  //挂接文件系统
if (IS_ERR(inotify_mnt))
panic("inotify: kern_mount ret %ld!\n", PTR_ERR(inotify_mnt));

inotify_max_queued_events = 16384;
inotify_max_user_instances = 128;
inotify_max_user_watches = 8192;

watch_cachep = kmem_cache_create("inotify_watch_cache",
 sizeof(struct inotify_user_watch),
 0, SLAB_PANIC, NULL, NULL);
event_cachep = kmem_cache_create("inotify_event_cache",
 sizeof(struct inotify_kernel_event),
 0, SLAB_PANIC, NULL, NULL);

return 0;
}

static struct file_system_type inotify_fs_type = {
.name           = "inotifyfs",//文件系统类型名
.get_sb         = inotify_get_sb,      //得到文件系统超级块
.kill_sb        = kill_anon_super,　//删除超级块
};

static int  inotify_get_sb(struct file_system_type *fs_type, int flags,
       const char *dev_name, void *data, struct vfsmount *mnt)
{
return get_sb_pseudo(fs_type, "inotify", NULL, 0xBAD1DEA, mnt);  //文件系统模数为0xBAD1DEA
}

.poll           = inotify_poll,   //从文件等待接收数据
.read           = inotify_read,   //从文件读取数据
.release        = inotify_release,　//释放描述符的各种结构实例所占空间
.unlocked_ioctl = inotify_ioctl,
.compat_ioctl= inotify_ioctl,
};

static ssize_t inotify_read(struct file *file, char __user *buf,
    size_t count, loff_t *pos)
{
size_t event_size = sizeof (struct inotify_event);
struct inotify_device *dev;
char __user *start;
int ret;
DEFINE_WAIT(wait);　//声明等待队列wait

start = buf;
dev = file->private_data;

while (1) {
int events;
　 //将dev->wq加入等待队列wait，设置当前进程状态为TASK_INTERRUPTIBLE状态
prepare_to_wait(&dev->wq, &wait, TASK_INTERRUPTIBLE);

mutex_lock(&dev->ev_mutex);
events = !list_empty(&dev->events);　//如果事件队列不为空
mutex_unlock(&dev->ev_mutex);
if (events) {//如果有事件存在，中断循环
ret = 0;
break;
}
　  //运行到这里，说明事件队列中不存在事件
if (file->f_flags & O_NONBLOCK) {　//如果是非阻塞标识，则返回
ret = -EAGAIN;
break;
}

if (signal_pending(current)) {　//如果当前进程是挂起状态，则中断循环
ret = -EINTR;
break;
}

schedule();//调度
}

finish_wait(&dev->wq, &wait);　//从等待中唤醒
if (ret)
return ret;

mutex_lock(&dev->ev_mutex);
while (1) {
struct inotify_kernel_event *kevent;

ret = buf - start;
if (list_empty(&dev->events))　//如果事件队列为空，跳出循环
break;

kevent = inotify_dev_get_event(dev);　//得到事件
if (event_size + kevent->event.len > count)
break;

if (copy_to_user(buf, &kevent->event, event_size)) {　
//将事件拷贝到用户空间的缓冲区buf中
ret = -EFAULT;
break;
}
buf += event_size;
count -= event_size;

if (kevent->name) {//将事件名拷贝到用户空间的缓冲区buf中
if (copy_to_user(buf, kevent->name, kevent->event.len)){ 
ret = -EFAULT;
break;
}
buf += kevent->event.len;
count -= kevent->event.len;
}

remove_kevent(dev, kevent);
}
mutex_unlock(&dev->ev_mutex);

return ret;
}