root/net/qrtr/tun.c

DEFINITIONS

1. qrtr_tun_send
2. qrtr_tun_open
3. qrtr_tun_read_iter
4. qrtr_tun_write_iter
5. qrtr_tun_poll
6. qrtr_tun_release
7. qrtr_tun_init
8. qrtr_tun_exit

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2018, Linaro Ltd */
   3 
   4 #include <linux/miscdevice.h>
   5 #include <linux/module.h>
   6 #include <linux/poll.h>
   7 #include <linux/skbuff.h>
   8 #include <linux/uaccess.h>
   9 
  10 #include "qrtr.h"
  11 
  12 struct qrtr_tun {
  13         struct qrtr_endpoint ep;
  14 
  15         struct sk_buff_head queue;
  16         wait_queue_head_t readq;
  17 };
  18 
  19 static int qrtr_tun_send(struct qrtr_endpoint *ep, struct sk_buff *skb)
  20 {
  21         struct qrtr_tun *tun = container_of(ep, struct qrtr_tun, ep);
  22 
  23         skb_queue_tail(&tun->queue, skb);
  24 
  25         /* wake up any blocking processes, waiting for new data */
  26         wake_up_interruptible(&tun->readq);
  27 
  28         return 0;
  29 }
  30 
  31 static int qrtr_tun_open(struct inode *inode, struct file *filp)
  32 {
  33         struct qrtr_tun *tun;
  34 
  35         tun = kzalloc(sizeof(*tun), GFP_KERNEL);
  36         if (!tun)
  37                 return -ENOMEM;
  38 
  39         skb_queue_head_init(&tun->queue);
  40         init_waitqueue_head(&tun->readq);
  41 
  42         tun->ep.xmit = qrtr_tun_send;
  43 
  44         filp->private_data = tun;
  45 
  46         return qrtr_endpoint_register(&tun->ep, QRTR_EP_NID_AUTO);
  47 }
  48 
  49 static ssize_t qrtr_tun_read_iter(struct kiocb *iocb, struct iov_iter *to)
  50 {
  51         struct file *filp = iocb->ki_filp;
  52         struct qrtr_tun *tun = filp->private_data;
  53         struct sk_buff *skb;
  54         int count;
  55 
  56         while (!(skb = skb_dequeue(&tun->queue))) {
  57                 if (filp->f_flags & O_NONBLOCK)
  58                         return -EAGAIN;
  59 
  60                 /* Wait until we get data or the endpoint goes away */
  61                 if (wait_event_interruptible(tun->readq,
  62                                              !skb_queue_empty(&tun->queue)))
  63                         return -ERESTARTSYS;
  64         }
  65 
  66         count = min_t(size_t, iov_iter_count(to), skb->len);
  67         if (copy_to_iter(skb->data, count, to) != count)
  68                 count = -EFAULT;
  69 
  70         kfree_skb(skb);
  71 
  72         return count;
  73 }
  74 
  75 static ssize_t qrtr_tun_write_iter(struct kiocb *iocb, struct iov_iter *from)
  76 {
  77         struct file *filp = iocb->ki_filp;
  78         struct qrtr_tun *tun = filp->private_data;
  79         size_t len = iov_iter_count(from);
  80         ssize_t ret;
  81         void *kbuf;
  82 
  83         kbuf = kzalloc(len, GFP_KERNEL);
  84         if (!kbuf)
  85                 return -ENOMEM;
  86 
  87         if (!copy_from_iter_full(kbuf, len, from)) {
  88                 kfree(kbuf);
  89                 return -EFAULT;
  90         }
  91 
  92         ret = qrtr_endpoint_post(&tun->ep, kbuf, len);
  93 
  94         kfree(kbuf);
  95         return ret < 0 ? ret : len;
  96 }
  97 
  98 static __poll_t qrtr_tun_poll(struct file *filp, poll_table *wait)
  99 {
 100         struct qrtr_tun *tun = filp->private_data;
 101         __poll_t mask = 0;
 102 
 103         poll_wait(filp, &tun->readq, wait);
 104 
 105         if (!skb_queue_empty(&tun->queue))
 106                 mask |= EPOLLIN | EPOLLRDNORM;
 107 
 108         return mask;
 109 }
 110 
 111 static int qrtr_tun_release(struct inode *inode, struct file *filp)
 112 {
 113         struct qrtr_tun *tun = filp->private_data;
 114         struct sk_buff *skb;
 115 
 116         qrtr_endpoint_unregister(&tun->ep);
 117 
 118         /* Discard all SKBs */
 119         while (!skb_queue_empty(&tun->queue)) {
 120                 skb = skb_dequeue(&tun->queue);
 121                 kfree_skb(skb);
 122         }
 123 
 124         kfree(tun);
 125 
 126         return 0;
 127 }
 128 
 129 static const struct file_operations qrtr_tun_ops = {
 130         .owner = THIS_MODULE,
 131         .open = qrtr_tun_open,
 132         .poll = qrtr_tun_poll,
 133         .read_iter = qrtr_tun_read_iter,
 134         .write_iter = qrtr_tun_write_iter,
 135         .release = qrtr_tun_release,
 136 };
 137 
 138 static struct miscdevice qrtr_tun_miscdev = {
 139         MISC_DYNAMIC_MINOR,
 140         "qrtr-tun",
 141         &qrtr_tun_ops,
 142 };
 143 
 144 static int __init qrtr_tun_init(void)
 145 {
 146         int ret;
 147 
 148         ret = misc_register(&qrtr_tun_miscdev);
 149         if (ret)
 150                 pr_err("failed to register Qualcomm IPC Router tun device\n");
 151 
 152         return ret;
 153 }
 154 
 155 static void __exit qrtr_tun_exit(void)
 156 {
 157         misc_deregister(&qrtr_tun_miscdev);
 158 }
 159 
 160 module_init(qrtr_tun_init);
 161 module_exit(qrtr_tun_exit);
 162 
 163 MODULE_DESCRIPTION("Qualcomm IPC Router TUN device");
 164 MODULE_LICENSE("GPL v2");