写了一个内核模块 实现简单的类似ps命令.

albcamus

原帖由 xdkui 于 2005-12-26 17:44 发表


问下albcamus兄
你说这里要加锁是不是为了保护什么？为了保护static char buf[1024*8]缓冲吗？

不太明白 谢谢了

保护task链表。 多个CPU的机器上，假如别的CPU在更改它，你同时试图访问它，可能会出问题。

guotie

原帖由 richardhesidu 于 2005-12-24 11:02 发表


#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/init.h>
#include <linux/sched.h>

MODULE_LICENSE("GPL&quo ...

这个程序在我这里测试是有问题的。

具体问题在于有时候会出现乱码，有时候正常，而且有时候出现以下错误：
** glibc detected *** double free or corruption (out): 0x0804d8c8 ***

我的系统是LFS 2.6.13内核，这个问题已经困扰我很久了，如果还不能解决的话，就只有用seq file了

xdkui

原帖由 albcamus 于 2005-12-26 17:48 发表


保护task链表。 多个CPU的机器上，假如别的CPU在更改它，你同时试图访问它，可能会出问题。

不好意思，还是不太明白

    rwlock_t tasklist=RW_LOCK_UNLOCKED;

    if(offset >0)
        return 0;
    memset(buf,0,sizeof(buf));
    read_lock(&tasklist);
    for_each_process(p)   //遍例内核进程链表.

我的理解是：
1   for_each_process(p)的时候，如果别的cpu要改变task链表，该cpu也不会读取tasklist锁，所以不会被锁，仍会继续改变task链表。

2  这里tasklist锁只是为了保护buf缓冲，使其不会同时被写。而buf是static静态的，不是位于stack中，是全局的，所以需要保护。但如果在ps_read的时候buf是kmalloc分配的话，就不需要保护buf了。

请albcamus兄指教下，谢谢

albcamus

>>  for_each_process(p)的时候，如果别的cpu要改变task链表，该cpu也不会读取tasklist锁，所以不会被锁，仍会继续改变task链表。

是的。锁是这样一种机制，给哪些想要得到保护的人用的。 如果某个程序员不管共享数据会有多少个CPU在同事操作，就是不加锁而访问──那么，它一定访问得到，虽然结果未必是正确的。

richardhesidu

原帖由 guotie 于 2005-12-26 18:02 发表


这个程序在我这里测试是有问题的。

具体问题在于有时候会出现乱码，有时候正常，而且有时候出现以下错误：
** glibc detected *** double free or corruption (out): 0x0804d8c8 ***

我的系统是LFS 2. ...

把memset(buf,0,sizeof(buf));
改为memset(buf,0,1024*8 );
我在改楼主的程序的时候没有考虑buf的变化。

[ 本帖最后由 richardhesidu 于 2005-12-26 18:18 编辑 ]

richardhesidu

原帖由 guotie 于 2005-12-26 18:02 发表


这个程序在我这里测试是有问题的。

具体问题在于有时候会出现乱码，有时候正常，而且有时候出现以下错误：
** glibc detected *** double free or corruption (out): 0x0804d8c8 ***

我的系统是LFS 2. ...

这样会好一些：
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/init.h>
#include <linux/sched.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("xunil@bmy");

static int ps_read(char *page, char **start, off_t off,int count, int *eof, void *data)  
{
            int len = 0;
            struct task_struct *p;
            rwlock_t tasklist=RW_LOCK_UNLOCKED;

            read_lock(&tasklist);
            for_each_process(p)
                     len += sprintf(page+len,"%d\t\t%d\t\t\t%s\n",p->pid,p->parent->pid,p->comm);
            read_unlock(&tasklist);

            if (len <= off+count) *eof = 1;
            *start = page + off;
            len -= off;
            if (len>count) len = count;
            if (len<0) len = 0;
            return len;
}


static __init int ps_init(void)
{
            struct proc_dir_entry *entry;

            entry = create_proc_entry("_ps", 0444, &proc_root);
            if(entry == 0)
                    goto error;

           entry->mode = S_IFREG | 0444;
           entry->size = 0;
           entry->read_proc = ps_read;
           return 0;

error:
           printk(KERN_ERR "create_proc_entry() failed !\n");
           return -1;
}
static __exit void ps_cleanup(void)
{
            remove_proc_entry("_ps", &proc_root);
}

module_init(ps_init);
module_exit(ps_cleanup);

[ 本帖最后由 richardhesidu 于 2005-12-27 15:08 编辑 ]

xdkui

原帖由 albcamus 于 2005-12-26 18:09 发表
>>  for_each_process(p)的时候，如果别的cpu要改变task链表，该cpu也不会读取tasklist锁，所以不会被锁，仍会继续改变task链表。

是的。锁是这样一种机制，给哪些想要得到保护的人用的。 如果某个程序员 ...

albcamus兄，还是没有解释我的第一个理解阿。我的意思就是加了那个rwlock_t  tasklist锁，还是达不到保护task链表的目的阿。

那这里rwlock_t  tasklist锁到底是为了保护什么呢？
不好意思，还是没有理解清楚，

albcamus

我表达能力有限了。 如果每一个要访问tasklist的代码，都把访问动作用rwlock保护起来，那么就保护得住了。自旋锁、读写自旋锁、信号量、读写信号量都是这样的：只有大家都用，才能真正保护。

xdkui

原帖由 albcamus 于 2005-12-27 09:18 发表
我表达能力有限了。 如果每一个要访问tasklist的代码，都把访问动作用rwlock保护起来，那么就保护得住了。自旋锁、读写自旋锁、信号量、读写信号量都是这样的：只有大家都用，才能真正保护。

呵呵
不好意思   我再好好看看资料
谢谢了

guotie

原帖由 richardhesidu 于 2005-12-26 19:52 发表


这样会好一些：
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/init.h>
#include <linux/sched.h>

MODULE_LICEN ...

这不是问题的关键。

问题依旧。