linux2.6内核ppp分析

1 简介

ppp协议（点到点协议），在拨号网络中应用比较广泛，逐渐在替代slip协议。

ppp数据包格式为：| 协议码 | 载荷   |填充符

ppp主要有四类协议码：

   1 0x0001 - 0x3fff 网络层协议（ipv4,ipv6,ipx,appletalk）
   
   2 0x4001 - 0x7fff 无网络层协议参与的小载荷量传输（低整流量）
   
   3 0x8001 - 0xbfff 用于配置网络层的子协议（网络控制协议，如ipcp）
   
   4 0xc001 - 0xffff 用于建立ppp连接的子协议（链路层控制协议，如lcp,pap,chap）
   
2 ppp协议实现的结构

   网络应用程序
   
   ip/tcp协议栈
   
   ppp网络协议 -|
            |—— ppp内核实现
   ppp连线规程 -|
   
   调制解调器
   
   pppd 是应用进程，通过子符设备和ppp内核通信。
   
3 ppp收发数据过程

   a 发送数据 
   
       ppp 协议发送数据有两种途径：一种是网络协议栈发送 ，另一种是pppd直接发送控制协议数据
       
   b 接收数据
   
       ppp连线规程解收到数据后，根据数据类型：如果是协商协议数据，则放到子符设备队列等待pppd读取；如果是网络层数据，则调用netif_rx入网络栈。
       
4 代码分析

a 初始化ppp设备，ppp字符主设备号为108

static struct file_operations ppp_device_fops = {
   .owner        = THIS_MODULE,
   .read        = ppp_read, 
   .write        = ppp_write,
   .poll        = ppp_poll,
   .ioctl        = ppp_ioctl,
   .open        = ppp_open,
   .release    = ppp_release
};

#define PPP_MAJOR    108

static int __init ppp_init(void)
{
   int err;

   /* 注册字符设备，设备名称是ppp */
   err = register_chrdev(PPP_MAJOR, "ppp", &ppp_device_fops);
   if (!err) {
       /* 创建udev */
       ppp_class = class_create(THIS_MODULE, "ppp");
       if (IS_ERR(ppp_class)) {
           err = PTR_ERR(ppp_class);
           goto out_chrdev;
       }
       class_device_create(ppp_class, NULL, MKDEV(PPP_MAJOR, 0), NULL, "ppp");
   }

out:
   if (err)
       printk(KERN_ERR "failed to register PPP device (%d)/n", err);
   return err;

out_chrdev:
   unregister_chrdev(PPP_MAJOR, "ppp");
   goto out;
}

class_create用途是做什么的？

从linux内核2.6的某个版本之后，devfs不复存在，udev成为devfs的替代，udev是应用层的东东
加入对udev的支持很简单，在驱动初始化的代码里调用class_create为该设备创建一个class，再为每个设备调用class_device_create创建对应的设备。大致用法如下：

  struct class *myclass = class_create(THIS_MODULE, "my_device_driver");
  class_device_create(myclass, NULL, MKDEV(major_num, 0), NULL, "my_device");

这样的module被加载时，udev daemon就会自动在/dev下创建my_device设备文件

/* 字符设备ppp的file结构：
* ---------------------
* |   ....       |
*----------------------
* |   f_op       |
*----------------------
* |   ....       |
*----------------------
* |   private_data |----------> struct ppp_file
*----------------------

struct ppp_file {
   enum {
       INTERFACE=1, CHANNEL
   }        kind;
   struct sk_buff_head xq;        /* pppd transmit queue */
   struct sk_buff_head rq;        /* receive queue for pppd */
   wait_queue_head_t rwait;    /* for poll on reading /dev/ppp */
   atomic_t    refcnt;        /* # refs (incl /dev/ppp attached) */
   int        hdrlen;        /* space to leave for headers */
   int        index;        /* interface unit / channel number */
   int        dead;        /* unit/channel has been shut down */
};   

struct ppp {
   struct ppp_file    file;        /* stuff for read/write/poll 0 */
   struct file    *owner;        /* file that owns this unit 48 */
   ...
};

struct channel {
   struct ppp_file    file;        /* stuff for read/write/poll */
   struct list_head list;        /* link in all/new_channels list */
   struct ppp_channel *chan;    /* public channel data structure */
   struct rw_semaphore chan_sem;    /* protects `chan' during chan ioctl */
   spinlock_t    downl;        /* protects `chan', file.xq dequeue */
   struct ppp    *ppp;        /* ppp unit we're connected to */
   struct list_head clist;        /* link in list of channels per unit */
   rwlock_t    upl;        /* protects `ppp' */
    ...
};

struct ppp_channel {
   void        *private;    /* channel private data */
   struct ppp_channel_ops *ops;    /* operations for this channel */
   int        mtu;        /* max transmit packet size */
   int        hdrlen;        /* amount of headroom channel needs */
   void        *ppp;        /* opaque to channel */
   /* the following are not used at present */
   int        speed;        /* transfer rate (bytes/second) */
   int        latency;    /* overhead time in milliseconds */
};

static int ppp_open(struct net_device *dev)
{
   //分配hdlc设备对象
   hdlc_device *hdlc = dev_to_hdlc(dev);
   void *old_ioctl;
   int result;

   dev->priv = &hdlc->state.ppp.syncppp_ptr;
   hdlc->state.ppp.syncppp_ptr = &hdlc->state.ppp.pppdev;
   hdlc->state.ppp.pppdev.dev = dev;

   old_ioctl = dev->do_ioctl;
   hdlc->state.ppp.old_change_mtu = dev->change_mtu;
   sppp_attach(&hdlc->state.ppp.pppdev);
   /* sppp_attach nukes them. We don't need syncppp's ioctl */
   dev->do_ioctl = old_ioctl;
   hdlc->state.ppp.pppdev.sppp.pp_flags &= ~PP_CISCO;
   dev->type = ARPHRD_PPP;
   result = sppp_open(dev);
   if (result) {
       sppp_detach(dev);
       return result;
   }

   return 0;
}

static ssize_t ppp_read(struct file *file, char __user *buf,
           size_t count, loff_t *ppos)
{
   struct ppp_file *pf = file->private_data;
   
   //如果没有数据，则在该队列上等待 
   DECLARE_WAITQUEUE(wait, current);
   
   ssize_t ret;
   struct sk_buff *skb = NULL;

   ret = count;

   if (pf == 0)
       return -ENXIO;
   add_wait_queue(&pf->rwait, &wait);
   for (;;) {
       set_current_state(TASK_INTERRUPTIBLE);
       skb = skb_dequeue(&pf->rq);//获取数据
       if (skb)
           break;
           
       //队列中没有数据
       ret = 0;
       if (pf->dead)
           break;
       if (pf->kind == INTERFACE) { //网络设备
           /*
            * Return 0 (EOF) on an interface that has no
            * channels connected, unless it is looping
            * network traffic (demand mode).
            */
           struct ppp *ppp = PF_TO_PPP(pf);
           if (ppp->n_channels == 0
              && (ppp->flags & SC_LOOP_TRAFFIC) == 0)
               break;
       }
       ret = -EAGAIN;
       if (file->f_flags & O_NONBLOCK)
           break;
       ret = -ERESTARTSYS;
       
       //设置pending ，挂起当前进程
       if (signal_pending(current))
           break;
           
       //重新调度入栈
       schedule();
   }
   set_current_state(TASK_RUNNING);
   remove_wait_queue(&pf->rwait, &wait);

   if (skb == 0)
       goto out;

   ret = -EOVERFLOW;
   if (skb->len > count)
       goto outf;
   ret = -EFAULT;
   
   //copy数据到用户空间
   if (copy_to_user(buf, skb->data, skb->len))
       goto outf;
   ret = skb->len;

outf:
   kfree_skb(skb);
out:
   return ret;
}

//发送数据
static ssize_t ppp_write(struct file *file, const char __user *buf,
            size_t count, loff_t *ppos)
{
   struct ppp_file *pf = file->private_data;
   struct sk_buff *skb;
   ssize_t ret;

   if (pf == 0)
       return -ENXIO;
   ret = -ENOMEM;
   
   //分配skb
   skb = alloc_skb(count + pf->hdrlen, GFP_KERNEL);
   if (skb == 0)
       goto out;
   skb_reserve(skb, pf->hdrlen);
   ret = -EFAULT;
   
   //从用户空间copy数据
   if (copy_from_user(skb_put(skb, count), buf, count)) {
       kfree_skb(skb);
       goto out;
   }

   skb_queue_tail(&pf->xq, skb);

   switch (pf->kind) {
   case INTERFACE:
       ppp_xmit_process(PF_TO_PPP(pf)); //通过网络接口发送
       break;
   case CHANNEL:
       ppp_channel_push(PF_TO_CHANNEL(pf));//通过规程接口发送
       break;
   }

   ret = count;

out:
   return ret;
}

<待续>