net/qrtr/tun.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright (c) 2018, Linaro Ltd */
0003
0004 #include <linux/miscdevice.h>
0005 #include <linux/module.h>
0006 #include <linux/poll.h>
0007 #include <linux/skbuff.h>
0008 #include <linux/uaccess.h>
0009
0010 #include "qrtr.h"
0011
0012 struct qrtr_tun {
0013     struct qrtr_endpoint ep;
0014
0015     struct sk_buff_head queue;
0016     wait_queue_head_t readq;
0017 };
0018
0019 static int qrtr_tun_send(struct qrtr_endpoint *ep, struct sk_buff *skb)
0020 {
0021     struct qrtr_tun *tun = container_of(ep, struct qrtr_tun, ep);
0022
0023     skb_queue_tail(&tun->queue, skb);
0024
0025     /* wake up any blocking processes, waiting for new data */
0026     wake_up_interruptible(&tun->readq);
0027
0028     return 0;
0029 }
0030
0031 static int qrtr_tun_open(struct inode *inode, struct file *filp)
0032 {
0033     struct qrtr_tun *tun;
0034     int ret;
0035
0036     tun = kzalloc(sizeof(*tun), GFP_KERNEL);
0037     if (!tun)
0038         return -ENOMEM;
0039
0040     skb_queue_head_init(&tun->queue);
0041     init_waitqueue_head(&tun->readq);
0042
0043     tun->ep.xmit = qrtr_tun_send;
0044
0045     filp->private_data = tun;
0046
0047     ret = qrtr_endpoint_register(&tun->ep, QRTR_EP_NID_AUTO);
0048     if (ret)
0049         goto out;
0050
0051     return 0;
0052
0053 out:
0054     filp->private_data = NULL;
0055     kfree(tun);
0056     return ret;
0057 }
0058
0059 static ssize_t qrtr_tun_read_iter(struct kiocb *iocb, struct iov_iter *to)
0060 {
0061     struct file *filp = iocb->ki_filp;
0062     struct qrtr_tun *tun = filp->private_data;
0063     struct sk_buff *skb;
0064     int count;
0065
0066     while (!(skb = skb_dequeue(&tun->queue))) {
0067         if (filp->f_flags & O_NONBLOCK)
0068             return -EAGAIN;
0069
0070         /* Wait until we get data or the endpoint goes away */
0071         if (wait_event_interruptible(tun->readq,
0072                          !skb_queue_empty(&tun->queue)))
0073             return -ERESTARTSYS;
0074     }
0075
0076     count = min_t(size_t, iov_iter_count(to), skb->len);
0077     if (copy_to_iter(skb->data, count, to) != count)
0078         count = -EFAULT;
0079
0080     kfree_skb(skb);
0081
0082     return count;
0083 }
0084
0085 static ssize_t qrtr_tun_write_iter(struct kiocb *iocb, struct iov_iter *from)
0086 {
0087     struct file *filp = iocb->ki_filp;
0088     struct qrtr_tun *tun = filp->private_data;
0089     size_t len = iov_iter_count(from);
0090     ssize_t ret;
0091     void *kbuf;
0092
0093     if (!len)
0094         return -EINVAL;
0095
0096     if (len > KMALLOC_MAX_SIZE)
0097         return -ENOMEM;
0098
0099     kbuf = kzalloc(len, GFP_KERNEL);
0100     if (!kbuf)
0101         return -ENOMEM;
0102
0103     if (!copy_from_iter_full(kbuf, len, from)) {
0104         kfree(kbuf);
0105         return -EFAULT;
0106     }
0107
0108     ret = qrtr_endpoint_post(&tun->ep, kbuf, len);
0109
0110     kfree(kbuf);
0111     return ret < 0 ? ret : len;
0112 }
0113
0114 static __poll_t qrtr_tun_poll(struct file *filp, poll_table *wait)
0115 {
0116     struct qrtr_tun *tun = filp->private_data;
0117     __poll_t mask = 0;
0118
0119     poll_wait(filp, &tun->readq, wait);
0120
0121     if (!skb_queue_empty(&tun->queue))
0122         mask |= EPOLLIN | EPOLLRDNORM;
0123
0124     return mask;
0125 }
0126
0127 static int qrtr_tun_release(struct inode *inode, struct file *filp)
0128 {
0129     struct qrtr_tun *tun = filp->private_data;
0130
0131     qrtr_endpoint_unregister(&tun->ep);
0132
0133     /* Discard all SKBs */
0134     skb_queue_purge(&tun->queue);
0135
0136     kfree(tun);
0137
0138     return 0;
0139 }
0140
0141 static const struct file_operations qrtr_tun_ops = {
0142     .owner = THIS_MODULE,
0143     .open = qrtr_tun_open,
0144     .poll = qrtr_tun_poll,
0145     .read_iter = qrtr_tun_read_iter,
0146     .write_iter = qrtr_tun_write_iter,
0147     .release = qrtr_tun_release,
0148 };
0149
0150 static struct miscdevice qrtr_tun_miscdev = {
0151     MISC_DYNAMIC_MINOR,
0152     "qrtr-tun",
0153     &qrtr_tun_ops,
0154 };
0155
0156 static int __init qrtr_tun_init(void)
0157 {
0158     int ret;
0159
0160     ret = misc_register(&qrtr_tun_miscdev);
0161     if (ret)
0162         pr_err("failed to register Qualcomm IPC Router tun device\n");
0163
0164     return ret;
0165 }
0166
0167 static void __exit qrtr_tun_exit(void)
0168 {
0169     misc_deregister(&qrtr_tun_miscdev);
0170 }
0171
0172 module_init(qrtr_tun_init);
0173 module_exit(qrtr_tun_exit);
0174
0175 MODULE_DESCRIPTION("Qualcomm IPC Router TUN device");
0176 MODULE_LICENSE("GPL v2");