1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33#include <linux/percpu.h>
34#include <linux/seq_file.h>
35#include <linux/slab.h>
36#include <linux/proc_fs.h>
37#include <linux/export.h>
38
39#include "rds.h"
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64struct rds_info_iterator {
65 struct page **pages;
66 void *addr;
67 unsigned long offset;
68};
69
70static DEFINE_SPINLOCK(rds_info_lock);
71static rds_info_func rds_info_funcs[RDS_INFO_LAST - RDS_INFO_FIRST + 1];
72
73void rds_info_register_func(int optname, rds_info_func func)
74{
75 int offset = optname - RDS_INFO_FIRST;
76
77 BUG_ON(optname < RDS_INFO_FIRST || optname > RDS_INFO_LAST);
78
79 spin_lock(&rds_info_lock);
80 BUG_ON(rds_info_funcs[offset]);
81 rds_info_funcs[offset] = func;
82 spin_unlock(&rds_info_lock);
83}
84EXPORT_SYMBOL_GPL(rds_info_register_func);
85
86void rds_info_deregister_func(int optname, rds_info_func func)
87{
88 int offset = optname - RDS_INFO_FIRST;
89
90 BUG_ON(optname < RDS_INFO_FIRST || optname > RDS_INFO_LAST);
91
92 spin_lock(&rds_info_lock);
93 BUG_ON(rds_info_funcs[offset] != func);
94 rds_info_funcs[offset] = NULL;
95 spin_unlock(&rds_info_lock);
96}
97EXPORT_SYMBOL_GPL(rds_info_deregister_func);
98
99
100
101
102
103
104void rds_info_iter_unmap(struct rds_info_iterator *iter)
105{
106 if (iter->addr) {
107 kunmap_atomic(iter->addr);
108 iter->addr = NULL;
109 }
110}
111
112
113
114
115void rds_info_copy(struct rds_info_iterator *iter, void *data,
116 unsigned long bytes)
117{
118 unsigned long this;
119
120 while (bytes) {
121 if (!iter->addr)
122 iter->addr = kmap_atomic(*iter->pages);
123
124 this = min(bytes, PAGE_SIZE - iter->offset);
125
126 rdsdebug("page %p addr %p offset %lu this %lu data %p "
127 "bytes %lu\n", *iter->pages, iter->addr,
128 iter->offset, this, data, bytes);
129
130 memcpy(iter->addr + iter->offset, data, this);
131
132 data += this;
133 bytes -= this;
134 iter->offset += this;
135
136 if (iter->offset == PAGE_SIZE) {
137 kunmap_atomic(iter->addr);
138 iter->addr = NULL;
139 iter->offset = 0;
140 iter->pages++;
141 }
142 }
143}
144EXPORT_SYMBOL_GPL(rds_info_copy);
145
146
147
148
149
150
151
152
153
154
155
156
157
158int rds_info_getsockopt(struct socket *sock, int optname, char __user *optval,
159 int __user *optlen)
160{
161 struct rds_info_iterator iter;
162 struct rds_info_lengths lens;
163 unsigned long nr_pages = 0;
164 unsigned long start;
165 rds_info_func func;
166 struct page **pages = NULL;
167 int ret;
168 int len;
169 int total;
170
171 if (get_user(len, optlen)) {
172 ret = -EFAULT;
173 goto out;
174 }
175
176
177 start = (unsigned long)optval;
178 if (len < 0 || len > INT_MAX - PAGE_SIZE + 1 || start + len < start) {
179 ret = -EINVAL;
180 goto out;
181 }
182
183
184 if (len == 0)
185 goto call_func;
186
187 nr_pages = (PAGE_ALIGN(start + len) - (start & PAGE_MASK))
188 >> PAGE_SHIFT;
189
190 pages = kmalloc_array(nr_pages, sizeof(struct page *), GFP_KERNEL);
191 if (!pages) {
192 ret = -ENOMEM;
193 goto out;
194 }
195 ret = pin_user_pages_fast(start, nr_pages, FOLL_WRITE, pages);
196 if (ret != nr_pages) {
197 if (ret > 0)
198 nr_pages = ret;
199 else
200 nr_pages = 0;
201 ret = -EAGAIN;
202 goto out;
203 }
204
205 rdsdebug("len %d nr_pages %lu\n", len, nr_pages);
206
207call_func:
208 func = rds_info_funcs[optname - RDS_INFO_FIRST];
209 if (!func) {
210 ret = -ENOPROTOOPT;
211 goto out;
212 }
213
214 iter.pages = pages;
215 iter.addr = NULL;
216 iter.offset = start & (PAGE_SIZE - 1);
217
218 func(sock, len, &iter, &lens);
219 BUG_ON(lens.each == 0);
220
221 total = lens.nr * lens.each;
222
223 rds_info_iter_unmap(&iter);
224
225 if (total > len) {
226 len = total;
227 ret = -ENOSPC;
228 } else {
229 len = total;
230 ret = lens.each;
231 }
232
233 if (put_user(len, optlen))
234 ret = -EFAULT;
235
236out:
237 if (pages)
238 unpin_user_pages(pages, nr_pages);
239 kfree(pages);
240
241 return ret;
242}
243