seq_file文件的内核读取过程
2017-10-13 17:33
330 查看
转载自:seq_file文件的内核读取过程
在此表示感谢!
1 问题
seq_file只是在普通的文件read中加入了内核缓冲的功能,从而实现顺序多次遍历,读取大数据量的简单接口。seq_file一般只提供只读接口,在使用seq_file操作时,主要靠下述四个操作来完成内核自定义缓冲区的遍历的输出操作,其中pos作为遍历的iterator,在seq_read函数中被多次使用,用以定位当前从内核自定义链表中读取的当前位置,当多次读取时,pos非常重要,且pos总是遵循从0,1,2...end+1遍历的次序,其即必须作为遍历内核自定义链表的下标,也可以作为返回内容的标识。但是我在使用中仅仅将其作为返回内容的标示,并没有将其作为遍历链表的下标,从而导致返回数据量大时造成莫名奇妙的错误,注意:start返回的void*v如果非0,被show输出后,在作为参数传递给next函数,next可以对其修改,也可以忽略;当next或者start返回NULL时,在seq_open中控制路径到达seq_end。
2.0 struct seq_file结构体描述
2.2 普通文件struct file的读取函数为seq_read,完成seq_file的读取过程
正常情况下分两次完成:第一次执行执行seq_read时:start->show->next->show...->next->show->next->stop,此时返回内核自定义缓冲区所有内容,即copied
!=0,所以会有第二次读取操作
第二次执行seq_read时:由于此时内核自定义内容都返回,根据seq_file->index指示,所以执行start->stop,返回0,即copied=0,并退出seq_read操作
整体来看,用户态调用一次读操作,seq_file流程为:该函数调用struct seq_operations结构体顺序为:start->show->next->show...->next->show->next->stop->start->stop来读取顺序文件
2.3 将数据从自定义核心中拷贝到seq_file结构体的buf缓冲中的操作函数
个人见解部分:
1、seq_file 的buf是在seq_read时分配的,不是在seq_open
2、上述讲述的情况适用于链表式内存空间,且单个内存块大小不大于一页,如果是单个内存空间且大小大于一页则和上述流程稍有不同。其中不会是start->show->next->show...->next->show->next->stop这种流程,而是start->show,如果发现m->count大小为一页,则清空m->buff,再申请一页*2的空间,继续show,如果m->count大小仍和m->size一致,则继续上述流程,直到空间足够。
当然,这些只是个人理解,如有错误在所难免,还望各位指正。
在此表示感谢!
1 问题
seq_file只是在普通的文件read中加入了内核缓冲的功能,从而实现顺序多次遍历,读取大数据量的简单接口。seq_file一般只提供只读接口,在使用seq_file操作时,主要靠下述四个操作来完成内核自定义缓冲区的遍历的输出操作,其中pos作为遍历的iterator,在seq_read函数中被多次使用,用以定位当前从内核自定义链表中读取的当前位置,当多次读取时,pos非常重要,且pos总是遵循从0,1,2...end+1遍历的次序,其即必须作为遍历内核自定义链表的下标,也可以作为返回内容的标识。但是我在使用中仅仅将其作为返回内容的标示,并没有将其作为遍历链表的下标,从而导致返回数据量大时造成莫名奇妙的错误,注意:start返回的void*v如果非0,被show输出后,在作为参数传递给next函数,next可以对其修改,也可以忽略;当next或者start返回NULL时,在seq_open中控制路径到达seq_end。
struct seq_operations { void * (*start) (struct seq_file *m, loff_t *pos); void (*stop) (struct seq_file *m, void *v); void * (*next) (struct seq_file *m, void *v, loff_t *pos); int (*show) (struct seq_file *m, void *v); };2 seq_file操作细节
2.0 struct seq_file结构体描述
struct seq_file { char *buf; //在seq_open中分配,大小为4KB size_t size; //4096 size_t from; //struct file从seq_file中向用户态缓冲区拷贝时相对于buf的偏移地址 size_t count; //可以拷贝到用户态的字符数目 loff_t index; //从内核态向seq_file的内核态缓冲区buf中拷贝时start、next的处理的下标pos数值,即用户自定义遍历iter loff_t read_pos; //当前已拷贝到用户态的数据量大小,即struct file中拷贝到用户态的数据量 u64 version; struct mutex lock; //保护该seq_file的互斥锁结构 const struct seq_operations *op; //seq_start,seq_next,set_show,seq_stop函数结构体 void *private; }; *色为自定义内核相对于seq_file内核缓冲 *色为seq_file内核缓冲相对于用户态缓冲区2.1普通文件struct file的open函数建立seq_file于struct file即seq_file与struct seq_operation操作函数的连接关系
/** * seq_open - initialize sequential file * @file: file we initialize * @op: method table describing the sequence * * seq_open() sets @file, associating it with a sequence described * by @op. @op->start() sets the iterator up and returns the first * element of sequence. @op->stop() shuts it down. @op->next() * returns the next element of sequence. @op->show() prints element * into the buffer. In case of error ->start() and ->next() return * ERR_PTR(error). In the end of sequence they return %NULL. ->show() * returns 0 in case of success and negative number in case of error. * Returning SEQ_SKIP means "discard this element and move on". 如果初始化出现问题:start,next返回ERR_PTR 如果结束时出现问题:遍历结束时返回NULL 显示正确时,show返回0,如果显示错误则返回负值 */ int seq_open(struct file *file, const struct seq_operations *op) { struct seq_file *p = file->private_data; if (!p) { p = kmalloc(sizeof(*p), GFP_KERNEL); if (!p) return -ENOMEM; file->private_data = p; } memset(p, 0, sizeof(*p)); mutex_init(&p->lock); p->op = op; /* * Wrappers around seq_open(e.g. swaps_open) need to be * aware of this. If they set f_version themselves, they * should call seq_open first and then set f_version. */ file->f_version = 0; /* * seq_files support lseek() and pread(). They do not implement * write() at all, but we clear FMODE_PWRITE here for historical * reasons. * * If a client of seq_files a) implements file.write() and b) wishes to * support pwrite() then that client will need to implement its own * file.open() which calls seq_open() and then sets FMODE_PWRITE. */ file->f_mode &= ~FMODE_PWRITE; return 0; } EXPORT_SYMBOL(seq_open);
2.2 普通文件struct file的读取函数为seq_read,完成seq_file的读取过程
正常情况下分两次完成:第一次执行执行seq_read时:start->show->next->show...->next->show->next->stop,此时返回内核自定义缓冲区所有内容,即copied
!=0,所以会有第二次读取操作
第二次执行seq_read时:由于此时内核自定义内容都返回,根据seq_file->index指示,所以执行start->stop,返回0,即copied=0,并退出seq_read操作
整体来看,用户态调用一次读操作,seq_file流程为:该函数调用struct seq_operations结构体顺序为:start->show->next->show...->next->show->next->stop->start->stop来读取顺序文件
/** * seq_read - ->read() method for sequential files. * @file: the file to read from * @buf: the buffer to read to * @size: the maximum number of bytes to read * @ppos: the current position in the file * * Ready-made ->f_op->read() */ ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos) { struct seq_file *m = (struct seq_file *)file->private_data; size_t copied = 0; loff_t pos; size_t n; void *p; int err = 0; mutex_lock(&m->lock); /* Don't assume *ppos is where we left it */ if (unlikely(*ppos != m->read_pos)) //如果用户已经读取内容和seq_file中不一致,要将seq_file部分内容丢弃 { m->read_pos = *ppos; while ((err = traverse(m, *ppos)) == -EAGAIN) //如果是这样,首先通过seq_start,seq_show,seq_next,seq_show...seq_next,seq_show,seq_stop读取*pos大小内容到seq_file的buf中 ; if (err) { /* With prejudice... */ m->read_pos = 0; m->version = 0; m->index = 0; m->count = 0; goto Done; } } /* * seq_file->op->..m_start/m_stop/m_next may do special actions * or optimisations based on the file->f_version, so we want to * pass the file->f_version to those methods. * * seq_file->version is just copy of f_version, and seq_file * methods can treat it simply as file version. * It is copied in first and copied out after all operations. * It is convenient to have it as part of structure to avoid the * need of passing another argument to all the seq_file methods. */ m->version = file->f_version; /* grab buffer if we didn't have one */ if (!m->buf) 如果第一次读取seq_file,申请4K大小空间 { m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL); if (!m->buf) goto Enomem; } /* if not empty - flush it first */ if (m->count) //如果seq_file中已经有内容,可能在前面通过traverse考了部分内容 { n = min(m->count, size); err = copy_to_user(buf, m->buf + m->from, n); //拷贝到用户态 if (err) goto Efault; m->count -= n; m->from += n; size -= n; buf += n; copied += n; if (!m->count) //如果正好通过seq_序列操作拷贝了count个字节,从下个位置开始拷贝,不太清楚,traverse函数中,m->index已经增加过了,这里还要加? m->index++; if (!size) goto Done; } /* we need at least one record in buffer */ pos = m->index; //假设该函数从这里开始执行,pos=0,当第二次执行时,pos =上次遍历的最后下标 + 1 >0,所以在start中,需要对pos非0特殊处理 p = m->op->start(m, &pos); //p为seq_start返回的字符串指针,pos=0; while (1) { err = PTR_ERR(p); if (!p || IS_ERR(p)) //如果通过start或next遍历出错,即返回的p出错,则退出循环,一般情况下,在第二次seq_open时,通过start即出错[pos变化],退出循环 break; err = m->op->show(m, p); //将p所指的内容显示到seq_file结构的buf缓冲区中 if (err < 0) //如果通过show输出出错,退出循环,此时表明buf已经溢出 break; if (unlikely(err)) //如果seq_show返回正常[即seq_file的buf未溢出,则返回0],此时将m->count设置为0,要将m->count设置为0 m->count = 0; if (unlikely(!m->count)) //一般情况下,m->count==0,所以该判定返回false,#define unlikely(x) __builtin_expect(!!(x), 0)用于分支预测,提高系统流水效率 { p = m->op->next(m, p, &pos); m->index = pos; continue; } if (m->count < m->size) //一般情况下,经过seq_start->seq_show到达这里[基本上是这一种情况],或者在err!=0 [即show出错] && m->count != 0时到达这里 goto Fill; m->op->stop(m, p); kfree(m->buf); m->buf = kmalloc(m->size <<= 1, GFP_KERNEL); if (!m->buf) goto Enomem; m->count = 0; m->version = 0; pos = m->index; p = m->op->start(m, &pos); } m->op->stop(m, p); 正常情况下,进入到这里,此时已经将所有的seq_file文件拷贝到buf中,且buf未溢出,这说明seq序列化操作返回的内容比较少,少于4KB m->count = 0; goto Done; Fill: /* they want more? let's try to get some more */ while (m->count < size) { size_t offs = m->count; loff_t next = pos; p = m->op->next(m, p, &next); //一般情况在上面的while循环中只经历了seq_start和seq_show函数,然后进入到这里,在这个循环里,执行下面循环: if (!p || IS_ERR(p)) //如果seq_file的buf未满: seq_next,seq_show,....seq_next->跳出 { //如果seq_file的buf满了:则offs表示了未满前最大的读取量,此时p返回自定义结构内容的指针,但是后面show时候只能拷贝了该 err = PTR_ERR(p); //内容的一部分,导致m->cont == m->size判断成立,从而m->count回滚到本次拷贝前,后面的pos++表示下次从下一个开始拷贝 break; } err = m->op->show(m, p); //我遇到的实际问题是show后,直接到stop,所以从这里退出了,应该是seq_file的buf填满导致的问题,这里肯定是m->count == m->size if (m->count == m->size || err) //如果seq_file的buf满: seq_next,seq_show,....seq_next,seq_show->跳出 { m->count = offs; if (likely(err <= 0)) break; } pos = next; } m->op->stop(m, p); 最后执行seq_stop函数 n = min(m->count, size); err = copy_to_user(buf, m->buf, n); //将最多size大小的内核缓冲区内容拷贝到用户态缓冲区buf中 if (err) goto Efault; copied += n; m->count -= n; if (m->count) 如果本次给用户态没拷贝完,比如seq_file中count=100,但是n=10,即拷贝了前10个,则下次从10位置开始拷贝,这种情况一般不会出现 m->from = n; else //一般情况下,pos++,下次遍历时从next中的下一个开始,刚开始时,让seq_func遍历指针递减,但是每次以k退出后,下次继续从k递减,原来是这里++了,所以遍历最好让指针递增 pos++; m->index = pos; Done: if (!copied) copied = err; //copied = 0 else { *ppos += copied; m->read_pos += copied; } file->f_version = m->version; mutex_unlock(&m->lock); return copied; //返回拷贝的字符数目,将copied个字符内容从seq_file的buf中拷贝到用户的buf中 Enomem: err = -ENOMEM; goto Done; Efault: err = -EFAULT; goto Done; }
我的情况是:
执行流程为:... next->show->stop->start->stop->start->stop,这种问题出现是因为,在某次调用show过程中发现seq_file的buf满了,此时m->count回退到调用前,然后调用stop函数,由于stop内容非常小,所以可以填入seq_file的buf,从而完成第一次fill_buf操作时,顺带有stop信息,操作完之后,此时pos=0,由于在seq_read末尾将其++,导致seq_file->index=1,然后第二次进入到seq_read中,此时可能出现err,导致该函数以非0返回,第3次时,才返回0.
2.3 将数据从自定义核心中拷贝到seq_file结构体的buf缓冲中的操作函数
int seq_printf(struct seq_file *m, const char *f, ...) { va_list args; int len; if (m->count < m->size) { va_start(args, f); len = vsnprintf(m->buf + m->count, m->size - m->count, f, args); va_end(args); if (m->count + len < m->size) { m->count += len; return 0; //成功返回0,此时buf未满 } } m->count = m->size; return -1; //如果buf缓冲已满,或者给buf输出后,导致buf溢出,返回-1 }
个人见解部分:
1、seq_file 的buf是在seq_read时分配的,不是在seq_open
2、上述讲述的情况适用于链表式内存空间,且单个内存块大小不大于一页,如果是单个内存空间且大小大于一页则和上述流程稍有不同。其中不会是start->show->next->show...->next->show->next->stop这种流程,而是start->show,如果发现m->count大小为一页,则清空m->buff,再申请一页*2的空间,继续show,如果m->count大小仍和m->size一致,则继续上述流程,直到空间足够。
当然,这些只是个人理解,如有错误在所难免,还望各位指正。
相关文章推荐
- seq_file文件的内核读取过程
- seq_file文件的内核读取过程
- seq_file文件的内核读取过程
- kernel module编程(八):读取proc文件之seq_file
- Linux内核学习笔记之seq_file接口创建可读写proc文件
- proc文件系统创建实例三( seq file 文件系统的创建过程,非结构化信息显示)
- 读取proc文件之seq_file
- 读取proc文件之seq_file
- linux 读取proc文件之seq_file浅析1
- kernel module编程(八):读取proc文件之seq_file
- Linux序列文件(seq_file)接口的内核实现
- 读取proc文件之seq_file
- 以当前默认file encoding读取文件然后以utf-8写入新文件
- php读取网络文件 curl, fsockopen ,file_get_contents 几个方法的效率对比
- 在 Linux 下用户空间与内核空间数据交换的方式,第 2 部分: procfs、seq_file、debugfs和relayfs
- 自动读取图片文件过程中文件名编号自动连接及编号增加问题
- 读取spring的文件上传excel文件内容(CommonsMultipartFile)
- 用户空间与内核空间数据交换的方式------seq_file
- 进程间通信:使用file-mapping kernel object(文件映射内核对象)
- File文件上传使用虚拟路径详细过程