Commit | Line | Data |
---|---|---|
28fb4e59 BA |
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 | ||
a21b7f0c NE |
87 | if (!copy_from_iter_full(kbuf, len, from)) { |
88 | kfree(kbuf); | |
28fb4e59 | 89 | return -EFAULT; |
a21b7f0c | 90 | } |
28fb4e59 BA |
91 | |
92 | ret = qrtr_endpoint_post(&tun->ep, kbuf, len); | |
93 | ||
a21b7f0c | 94 | kfree(kbuf); |
28fb4e59 BA |
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"); |