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
 12struct qrtr_tun {
 13	struct qrtr_endpoint ep;
 14
 15	struct sk_buff_head queue;
 16	wait_queue_head_t readq;
 17};
 18
 19static 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
 31static 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
 49static 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
 75static 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
 98static __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
111static 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
129static 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
138static struct miscdevice qrtr_tun_miscdev = {
139	MISC_DYNAMIC_MINOR,
140	"qrtr-tun",
141	&qrtr_tun_ops,
142};
143
144static 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
155static void __exit qrtr_tun_exit(void)
156{
157	misc_deregister(&qrtr_tun_miscdev);
158}
159
160module_init(qrtr_tun_init);
161module_exit(qrtr_tun_exit);
162
163MODULE_DESCRIPTION("Qualcomm IPC Router TUN device");
164MODULE_LICENSE("GPL v2");