LDD3 read notes Chapter 6

Asynchronous Notification

user space:
1) fcntl, F_SETOWN 命令, 设置自己为owner, filp->f_owner保存这个进程id
2) F_SETFL fcntl命令设置FASYNC标记

这样新的数据到达时, 文件将向这个注册的进程(进程组,如果是负值)发送SIGIO信号.

signal(SIGIO, &input_handler); /* dummy sample; sigaction( ) is better */
fcntl(STDIN_FILENO, F_SETOWN, getpid( ));
oflags = fcntl(STDIN_FILENO, F_GETFL);
fcntl(STDIN_FILENO, F_SETFL, oflags | FASYNC);

应用程序一般仅假设sokets和tty才有这个异步通知能力.但是同时监测多个文件,还是需要poll/select来查询哪个文件发生了变动.

The Driver’s Point of View

1. When F_SETOWN is invoked, nothing happens, except that a value is assigned to filp->f_owner
2. app调用 F_SETFL 设置 FASYNC的时候, driver的fasync被调用.
3. 数据到达后,向注册的进程(进程组)发送SIGIO signal.

具体的, kernel给driver提供了统一的方法来管理
*<linux/fs.h>
*struct fasync_struct
*int fasync_helper(int fd, struct file *filp,int mode, struct fasync_struct **fa); //处理FASYNC的变化, 就最后一个参数driver提供, 其他的直接用fasync的就成.
void kill_fasync(struct fasync_struct **fa, int sig, int band); //sig一般是SIGIO, band 一般是POLL_IN

static int scull_p_fasync(int fd, struct file *filp, int mode)
{
struct scull_pipe *dev = filp->private_data;
return fasync_helper(fd, filp, mode, &dev->async_queue);
}

当数据到达的时候:(对scull是在wite中)
if (dev->async_queue)
    kill_fasync(&dev->async_queue, SIGIO, POLL_IN); //如果是wire可用通知,当然要换成POLL_OUT

最后在realease中调用如下函数,清除注册的进程:
/* remove this filp from the asynchronously notified filp's */
    scull_p_fasync(-1, filp, 0);  /*一般在filp->f_flags 设置了 FASYNC才调用这个函数, 不过直接调用也没有关系*/

The llseek Implementation
llseek 同时实现lseek and llseek系统调用. 系统默认的实现是修改filp->f_pos, 如果觉得不够可以自己实现一个.
loff_t scull_llseek(struct file *filp, loff_t off, int whence)
{
  struct scull_dev *dev = filp->private_data;
  loff_t newpos;
  switch(whence) {
     case 0: /* SEEK_SET */
        newpos = off;
        break;
     case 1: /* SEEK_CUR */
        newpos = filp->f_pos + off;
        break;
      case 2: /* SEEK_END */
          newpos = dev->size + off;
          break;
      default: /* can't happen */
          return -EINVAL;
   }
   if (newpos < 0) return -EINVAL;
   filp->f_pos = newpos;
   return newpos;
}

如果不支持seek:
*<linux/fs.h>.
*在open 中调用int nonseekable_open(struct inode *inode; struct file *filp);
*把你的llseek指针设置为:no_llseek


Access Control on a Device File

tty就很典型, 需要只有一个user, 但是改owenr的方式似乎不是那么好:open前需要root来修改owner, 挺怪.

Single-Open Devices

static atomic_t scull_s_available = ATOMIC_INIT(1);
static int scull_s_open(struct inode *inode, struct file *filp)
{
   struct scull_dev *dev = &scull_s_device; /* device information */
   if (! atomic_dec_and_test (&scull_s_available)) {
        atomic_inc(&scull_s_available);
        return -EBUSY; /* already open */
   }
    /* then, everything else is copied from the bare scull device */
    if ( (filp->f_flags & O_ACCMODE) = = O_WRONLY)
                 scull_trim(dev);
    filp->private_data = dev;
    return 0; /* success */
}
The release call, on the other hand, marks the device as no longer busy:
static int scull_s_release(struct inode *inode, struct file *filp)
{
     atomic_inc(&scull_s_available); /* release the device */
     return 0;
}

Restricting Access to a Single User at a Time
spin_lock(&scull_u_lock);

if (scull_u_count &&
   (scull_u_owner != current->uid) && /* allow user */
   (scull_u_owner != current->euid) && /* allow whoever did su */
       !capable(CAP_DAC_OVERRIDE)) { /* still allow root */
                spin_unlock(&scull_u_lock);
                 return -EBUSY; /* -EPERM would confuse the user */
 }

if (scull_u_count = = 0)
   scull_u_owner = current->uid; /* grab it */

scull_u_count++;
spin_unlock(&scull_u_lock);

static int scull_u_release(struct inode *inode, struct file *filp)
{
   spin_lock(&scull_u_lock);
   scull_u_count--; /* nothing else */
   spin_unlock(&scull_u_lock);
   return 0;
}

Blocking open as an Alternative to EBUSY

spin_lock(&scull_w_lock);
while (! scull_w_available( )) {
   spin_unlock(&scull_w_lock);
   if (filp->f_flags & O_NONBLOCK) return -EAGAIN;
   if (wait_event_interruptible (scull_w_wait, scull_w_available( )))
       return -ERESTARTSYS; /* tell the fs layer to handle it */
    spin_lock(&scull_w_lock);
}
if (scull_w_count = = 0)
scull_w_owner = current->uid; /* grab it */
scull_w_count++;
spin_unlock(&scull_w_lock);

static int scull_w_release(struct inode *inode, struct file *filp)
{
   int temp;
   spin_lock(&scull_w_lock);
   scull_w_count--;
   temp = scull_w_count;
   spin_unlock(&scull_w_lock);
   if (temp = = 0)
      wake_up_interruptible_sync(&scull_w_wait); /* awake other uid's , 非常符合sync的要求*/
   return 0;
}

这个实现对于cp/tar之类不太好, 应为他们不能加上O_nonblock参数, 等待的话很损害交互性, user更愿意看到device busy之类的消息. 这时可以实现多个设备文件,采用不动的访问策略.

Cloning the Device on open
比如tty. 这里 /dev/scullpriv就是这样一个设备. 可以很容易更改判断的key来得到不通策略. 这里用tyy.