linux驅動學習---loff_t 字段的迷惑

驅動模塊中有一個file結構體。該結構體中有一個 loff_t 字段 用來維護當前讀寫位置。此回就拿loff_t這個字段來開刀。下面展示一個字符設備的驅動代碼，來自《Linux設備驅動開發詳解》-宋寶華一書

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/uaccess.h>

#define GLOBALMEM_SIZE    0x1000    /*全局內存最大4K字節*/
#define MEM_CLEAR 0x1  /*清0全局內存*/
#define GLOBALMEM_MAJOR 0    /*預設的globalmem的主設備號*/

static globalmem_major = GLOBALMEM_MAJOR;
/*globalmem設備結構體*/
struct globalmem_dev                                     
{                                                        
  struct cdev cdev; /*cdev結構體*/                       
  unsigned char mem[GLOBALMEM_SIZE]; /*全局內存*/     
  struct semaphore sem; /*並發控制用的信號量*/    
};

struct globalmem_dev *globalmem_devp; /*設備結構體指針*/

/*文件打開函數*/
int globalmem_open(struct inode *inode, struct file *filp)
{
  /*將設備結構體指針賦值給文件私有數據指針*/
  filp->private_data = globalmem_devp;
  return 0;
}

/*文件釋放函數*/
int globalmem_release(struct inode *inode, struct file *filp)
{
  return 0;
}

/* ioctl設備控制函數 */
static int globalmem_ioctl(struct inode *inodep, struct file *filp, unsigned
  int cmd, unsigned long arg)
{
  struct globalmem_dev *dev = filp->private_data; /*獲得設備結構體指針*/

  switch (cmd)
  {
    case MEM_CLEAR:
      if (down_interruptible(&dev->sem))
      {
        return  - ERESTARTSYS;
      }
      memset(dev->mem, 0, GLOBALMEM_SIZE);
      up(&dev->sem); //釋放信號量

      printk(KERN_INFO "globalmem is set to zero\n");
      break;

    default:
      return  - EINVAL;
  }
  return 0;
}

/*讀函數*/
static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size,
  loff_t *ppos)
{
  unsigned long p =  *ppos;
  unsigned int count = size;
  int ret = 0;
  struct globalmem_dev *dev = filp->private_data; /*獲得設備結構體指針*/

  /*分析和獲取有效的寫長度*/
  if (p >= GLOBALMEM_SIZE)
    return count ?  - ENXIO: 0;
  if (count > GLOBALMEM_SIZE - p)
    count = GLOBALMEM_SIZE - p;

  if (down_interruptible(&dev->sem))
  {
    return  - ERESTARTSYS;
  }

  /*內核空間->用戶空間*/
  if (copy_to_user(buf, (void*)(dev->mem + p), count))
  {
    ret =  - EFAULT;
  }
  else
  {
    *ppos += count;
    ret = count;

    printk(KERN_INFO "read %d bytes(s) from %d\n", count, p);
  }
  up(&dev->sem); //釋放信號量

  return ret;
}

/*寫函數*/
static ssize_t globalmem_write(struct file *filp, const char __user *buf,
  size_t size, loff_t *ppos)
{
  unsigned long p = *ppos;
  unsigned int count = size;
  int ret = 0;

  struct globalmem_dev *dev = filp->private_data; /*獲得設備結構體指針*/

  /*分析和獲取有效的寫長度*/
  if (p >= GLOBALMEM_SIZE)
    return count ?  - ENXIO: 0;
  if (count > GLOBALMEM_SIZE - p)
    count = GLOBALMEM_SIZE - p;

  if (down_interruptible(&dev->sem))//獲得信號量
  {
    return  - ERESTARTSYS;
  }
  /*用戶空間->內核空間*/

     
  if (copy_from_user(dev->mem + p, buf, count))
    ret =  - EFAULT;
  else
  {
     *ppos +=count;
    ret = count;

    printk(KERN_INFO "written %d bytes(s) from %d\n", count, p);
  }
  up(&dev->sem); //釋放信號量
  return ret;
}

/* seek文件定位函數 */
static loff_t globalmem_llseek(struct file *filp, loff_t offset, int orig)
{
  loff_t ret = 0;
  switch (orig)
  {
    case 0:   /*相對文件開始位置偏移*/
      if (offset < 0)
      {
        ret =  - EINVAL;
        break;
      }
      if ((unsigned int)offset > GLOBALMEM_SIZE)
      {
        ret =  - EINVAL;
        break;
      }
      filp->f_pos = (unsigned int)offset;
      ret = filp->f_pos;
      break;
    case 1:   /*相對文件當前位置偏移*/
      if ((filp->f_pos + offset) > GLOBALMEM_SIZE)
      {
        ret =  - EINVAL;
        break;
      }
      if ((filp->f_pos + offset) < 0)
      {
        ret =  - EINVAL;
        break;
      }
      filp->f_pos += offset;
      ret = filp->f_pos;
      break;
    default:
      ret =  - EINVAL;
      break;
  }
  return ret;
}

/*文件操作結構體*/
static const struct file_operations globalmem_fops =
{
  .owner = THIS_MODULE,
  .llseek = globalmem_llseek,
  .read = globalmem_read,
  .write = globalmem_write,
  .ioctl = globalmem_ioctl,
  .open = globalmem_open,
  .release = globalmem_release,
};

/*初始化並注冊cdev*/
static void globalmem_setup_cdev(struct globalmem_dev *dev, int index)
{
  int err, devno = MKDEV(globalmem_major, index);

  cdev_init(&dev->cdev, &globalmem_fops);
  dev->cdev.owner = THIS_MODULE;
  dev->cdev.ops = &globalmem_fops;
  err = cdev_add(&dev->cdev, devno, 1);
  if (err)
    printk(KERN_NOTICE "Error %d adding LED%d", err, index);
}

/*設備驅動模塊加載函數*/
int globalmem_init(void)
{
  int result;
  dev_t devno = MKDEV(globalmem_major, 0);

  /* 申請設備號*/
  if (globalmem_major)
    result = register_chrdev_region(devno, 1, "globalmem");
  else  /* 動態申請設備號 */
  {
    result = alloc_chrdev_region(&devno, 0, 1, "globalmem");
    globalmem_major = MAJOR(devno);
  }  
  if (result < 0)
    return result;
    
  /* 動態申請設備結構體的內存*/
  globalmem_devp = kmalloc(sizeof(struct globalmem_dev), GFP_KERNEL);
  if (!globalmem_devp)    /*申請失敗*/
  {
    result =  - ENOMEM;
    goto fail_malloc;
  }
  memset(globalmem_devp, 0, sizeof(struct globalmem_dev));
  
  globalmem_setup_cdev(globalmem_devp, 0);
  init_MUTEX(&globalmem_devp->sem);   /*初始化信號量*/  
  return 0;

  fail_malloc: unregister_chrdev_region(devno, 1);
  return result;
}

/*模塊卸載函數*/
void globalmem_exit(void)
{
  cdev_del(&globalmem_devp->cdev);   /*注銷cdev*/
  kfree(globalmem_devp);     /*釋放設備結構體內存*/
  unregister_chrdev_region(MKDEV(globalmem_major, 0), 1); /*釋放設備號*/
}

MODULE_AUTHOR("Song Baohua");
MODULE_LICENSE("Dual BSD/GPL");

module_param(globalmem_major, int, S_IRUGO);

module_init(globalmem_init);
module_exit(globalmem_exit);

我們編譯這個模塊，然后insmod,mknod 之后，我們便可以開始寫測試程序來測試這個字符設備了

下面是我的第一個測試代碼

#include<sys/types.h>
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>

int main()
{


    char buf[]="fuck gay";


    int dev_fd=open("/dev/globalmem_lock",O_RDWR | O_NONBLOCK);
    if(!write(dev_fd,buf,8))
        printf("write error");
    if(!write(dev_fd,buf,8))
        printf("write error");

    
    return 0;
    
}

 

我們編譯運行這個代碼，如下所示

我們用cat 查看這個設備時 發覺，fuck gayfuck gay已經被正確的輸入到設備中，

但是如果此時，我們用echo命令向這個設備寫進東西，發覺會覆蓋掉原先寫進的內容，如下所示：

對於這種情況的唯一解釋是，每個進程都維護着自己獨有的loff_t 字段，所以當echo命令向該設備寫時，是從0開始寫的

但是我又遇到了一個問題，至今無法解決。源於我又寫了個測試程序如下

#include<sys/types.h>
#include<stdio.h>
#include<unistd.h>
#include<fcntl.h>

int main()
{

    pid_t pid;
    char a[]="fuck";
    char b[]="hello";
        int dev_fd=open("/dev/globalmem_lock",O_RDWR | O_NONBLOCK);
        if( ( pid=fork() ) <0)
        printf("fork error\n");
        else if(pid==0)    
       {
        if(!write(dev_fd,b,8))
            printf("write error");
        sleep(3);
        if(!write(dev_fd,b,8))
            printf("write error");
           }
    else
       {    
        if(!write(dev_fd,a,8))
            printf("write error");
           }
        return 0;
    
}

編譯這個代碼 運行 ，然后cat 該設備，得到如下結果

父子進程仿佛是在同時維護着一個loff_t字段，令我不得其解啊。。求路過大神指導

 -----------------------------------------------------------------------------------

經過一些的指點后我才知道我這個問題很二，也是因為對前面的知識遺忘的比較多。對上面問題的解答是，父子進程是共享一個文件描述符表的，而不同的進程是獨享

一個文件描述符表，現在上傳兩張圖，一看便知道