Chinaunix

标题: linux 自旋锁! [打印本页]

作者: shuiyu123 时间: 2009-03-15 16:35
标题: linux 自旋锁!
我写一个简单的驱动程序!
要验证一下自旋锁的功能!在没有释放锁的情况下,理说其它的线程应该是获取不到这个锁的!
可是为什么,下面这个程序却能执行关闭文件?(在下面修改后的程序里面.故意打开文件的时候,获取了锁,而不放.应该在关闭的时候应该是进程给挂起了!可是程序还是执行下去了,而且完成了相同的操作)
前辈给于指教!!谢谢!
驱动码:

spinlock_t lock=SPIN_LOCK_UNLOCKED;
static int file_count;
static int signel_open(struct inode *inode,struct file *file )
{ printk("get lock\n");
  spin_lock(lock);
  if(file_count)
      { spin_unlock(lock);
      return -EBUSY;
       }
  file_count++;
  spin_unlock(lock);
  return 0;
 
      }
static int signel_close(struct inode *inode,struct file *file)
{ file_count--;
  return 0;
     }

以下是修改后的,没有加入spin_unlock();
static int signel_open(struct inode *inode,struct file *file )
{ printk("get lock\n");
  spin_lock(lock);
  file_count++;
  return 0;
     }
static int signel_close(struct inode *inode,struct file *file)
{
   file_count--;
   return 0;
     }

#define DEV_NAME "/dev/signel"
int main()
{ int fd,ret;
  int a=01;
  fd=open(DEV_NAME,O_RDWR);
  if(fd<0)
      { printf("opened is fail!!\n");
       }
   else
       { printf("open is scuss!!!\n");
      printf("writr a=%d\n",a);
      write(fd,&a,sizeof(a));
    }
   close(fd);
   printf("closed the file!!\n");
}

[ 本帖最后由 dreamice 于 2009-3-15 17:38 编辑 ]

作者: dreamice 时间: 2009-03-15 17:41
标题: 回复 #1 shuiyu123 的帖子
关闭文件的时候，哪里有请求自旋锁？

作者: shuiyu123 时间: 2009-03-15 17:59
标题: 回复 #2 dreamice 的帖子
落了!!
static int signel_close(struct inode *inode,struct file *file)
{ spin_lock(lock);
file_count--;
return 0;
}
lock应该是个地址!&lock!没有写上! close进程就不挂起!

[ 本帖最后由 shuiyu123 于 2009-3-15 18:03 编辑 ]

作者: dreamice 时间: 2009-03-15 20:16
标题: 回复 #3 shuiyu123 的帖子
那这就对了，呵呵

作者: shuiyu123 时间: 2009-03-15 20:34
标题: 回复 #4 dreamice 的帖子
为什么close进程挂不起来?
dreamice !!!!

作者: dreamice 时间: 2009-03-15 21:21
标题: 回复 #5 shuiyu123 的帖子
spin_lock(&lock);
而且没有看到你的设备初始化

作者: shuiyu123 时间: 2009-03-15 21:36
标题: 回复 #6 dreamice 的帖子
我把代码全都贴出来! 先不看,不管write与read这两个是关于信号量,就看open close!程序就这些不知道是哪里出了问题
!把OPEN,CLOSE改成这样:
static int signel_open(struct inode *inode,struct file *file )
{ printk("get lock\n");
  spin_lock(&s_lock);    这里取锁,我不放掉!看到close里面能不能把进程给挂起!
  f_count++;
  return 0;
}
static int signel_close(struct inode *inode,struct file *file)
{ spin_lock(&s_lock); 在这里进程应该挂起才对!!
  f_count--;
  return 0;
   }
运行结果与下面的一样!
#define  DEV_NAME  "signel"
#define  DEV_ID 110
static int flags=0;
static DECLARE_WAIT_QUEUE_HEAD(in);
static int arry[4];
struct semaphore sem;
spinlock_t s_lock;  锁的声明!!!
static int f_count;
static int signel_open(struct inode *inode,struct file *file )
{ printk("get lock\n");
  spin_lock(&s_lock);
  if(f_count)
    { spin_unlock(&s_lock);
   return -EBUSY;
          }
  f_count++;
  spin_unlock(&s_lock);
  return 0;

   }
static int signel_write(struct file *file,const char __user * buf,size_t count,loff_t *off)
{ printk("%i,%s\n",current->pid,current->comm);
  flags=1;
  if(down_interruptible(&sem))
       { return -ERESTARTSYS;
          }
  printk("write data....!!!\n");
  if(copy_from_user(&arry,buf,count))
    { up(&sem);
   return -EFAULT;
       }
  wake_up_interruptible(&in);
  up(&sem);
  return count;
}
static int signel_read(struct file *file,char __user * buf,size_t count,loff_t *off)
{  printk ("%i,%s\n",current->pid,current->comm);
if(wait_event_interruptible(in,flags!=0))
   { return -ERESTARTSYS;
         }
if(down_interruptible(&sem))
{ return -ERESTARTSYS;
      }
flags=0;
printk("read data....!!!\n");
if(copy_to_user(buf,&arry,count))
   { up(&sem);
   return  -EFAULT;
      }
up(&sem);
return count;
}
static int signel_close(struct inode *inode,struct file *file)
{ f_count--;
  return 0;
   }
static struct file_operations signel_test = {
.write = signel_write,
.read = signel_read,
.open = signel_open,
.release = signel_close,
};
static int __init init_signel(void)
{ int ret;
  sema_init(&sem,1); /* 或者用init_MUTEX(&sem) 初始化并声明为互斥（实际上也就是将信号量为“1”也就是它互斥模式）*/
  spin_lock_init(&s_lock);  锁的初始化!!!!!
  ret=register_chrdev(DEV_ID,DEV_NAME,&signel_test);
  if(ret<0)
    { printk("registre is fail!!\n");
   return ret;
      }
else
   { printk("registre is scuss!!\n");
   devfs_mk_cdev(MKDEV(DEV_ID,0),S_IFCHR | S_IRUSR | S_IWUSR,"signel");
   return 0;
         }
return 0;
   }
static void __exit exit_signel(void)
{ unregister_chrdev(DEV_ID,DEV_NAME);
  devfs_remove(DEV_NAME);
   }

[ 本帖最后由 shuiyu123 于 2009-3-15 21:42 编辑 ]

作者: dreamice 时间: 2009-03-15 21:40
你看一下close()的返回值，如果close返回非0，那就说明调用close出了错了。

作者: shuiyu123 时间: 2009-03-15 22:28
标题: 回复 #8 dreamice 的帖子
返回一个"0"把OPEN,CLOSE改成这样:
static int signel_open(struct inode *inode,struct file *file )
{ printk("get lock\n");
  spin_lock(&s_lock);    这里取锁,我不放掉!看到close里面能不能把进程给挂起!
  f_count++;
  return 0;
}
static int signel_close(struct inode *inode,struct file *file)
{ spin_lock(&s_lock); 在这里进程应该挂起才对!!
  f_count--;
  return 0;
   }
应该返回一个非"0"那是才是对的!
运行结果返回一个"0",这里应该是不会出现返回一个"0"值如果改成这样的话!
int main()
{ int fd,ret;
  int a=01;
  fd=open(DEV_NAME,O_RDWR);
  if(fd<0)
    { printf("opened is fail!!\n");
       }
else
   { printf("open is scuss!!!\n");
   printf("writr a=%d\n",a);
   write(fd,&a,sizeof(a));
}
ret=close(fd);
   if(ret)
       { printf("the process is hanging,ret=%d\n",ret);  返回一个非"0"进程就挂起!
          }
   else
   { printf("the file is closed,ret=%d\n",ret); 返回"0"打印file关闭!
          }

作者: ingdxdy 时间: 2009-03-16 00:11
标题: 回复 #1 shuiyu123 的帖子
自旋锁，本质上讲，是专门为多处理器架构设计的，当然支持抢夺式进程调度的内核在单处理器上也可以使用自旋锁。如果在一个非抢占式单处理器的系统中进入自旋，那么这个自旋将永远无法退出，因为没有其他进程可以打断当前这个自旋的进程（注意自旋简单的说，底层实现为一个无限循环）。基于这个原因，自选操作在非抢占式单处理器系统中被优化为nothing，即不执行任何操作，除非使用自旋锁时涉及到中断例程。
注意：
1. 自旋锁底层实现为一个整型，通过设计其为0或1表示锁释放或者锁定。
2. 基于以上说明，自旋锁可能被优化为不执行任何操作。
3. 你是否发现你执行锁定，再锁定都在同一个main进程中。
4. 参考LDD3第五章内容。

作者: dreamice 时间: 2009-03-16 08:50

原帖由 ingdxdy 于 2009-3-16 00:11 发表
自旋锁，本质上讲，是专门为多处理器架构设计的，当然支持抢夺式进程调度的内核在单处理器上也可以使用自旋锁。如果在一个非抢占式单处理器的系统中进入自旋，那么这个自旋将永远无法退出，因为没有其他进程可以 ...

对了，你测试的可能是单处理器

作者: shuiyu123 时间: 2009-03-18 11:10
标题: 回复 #10 ingdxdy 的帖子
说到点子上了！谢谢提醒！

欢迎光临 Chinaunix (http://bbs.chinaunix.net/)