projects/linux·blob uaccess-cleanups · refs

304 lines · 7.8 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * cfg80211 debugfs
4 *
5 * Copyright 2009 Luis R. Rodriguez <[email protected]>
6 * Copyright 2007 Johannes Berg <[email protected]>
7 * Copyright (C) 2023 Intel Corporation
8 */
9
10#include <linux/slab.h>
11#include "core.h"
12#include "debugfs.h"
13
14#define DEBUGFS_READONLY_FILE(name, buflen, fmt, value...) \
15static ssize_t name## _read(struct file *file, char __user *userbuf, \
16 size_t count, loff_t *ppos) \
17{ \
18 struct wiphy *wiphy = file->private_data; \
19 char buf[buflen]; \
20 int res; \
21 \
22 res = scnprintf(buf, buflen, fmt "\n", ##value); \
23 return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
24} \
25 \
26static const struct file_operations name## _ops = { \
27 .read = name## _read, \
28 .open = simple_open, \
29 .llseek = generic_file_llseek, \
30}
31
32#define DEBUGFS_RADIO_READONLY_FILE(name, buflen, fmt, value...) \
33static ssize_t name## _read(struct file *file, char __user *userbuf, \
34 size_t count, loff_t *ppos) \
35{ \
36 struct wiphy_radio_cfg *radio_cfg = file->private_data; \
37 char buf[buflen]; \
38 int res; \
39 \
40 res = scnprintf(buf, buflen, fmt "\n", ##value); \
41 return simple_read_from_buffer(userbuf, count, ppos, buf, res); \
42} \
43 \
44static const struct file_operations name## _ops = { \
45 .read = name## _read, \
46 .open = simple_open, \
47 .llseek = generic_file_llseek, \
48}
49
50DEBUGFS_READONLY_FILE(rts_threshold, 20, "%d",
51 wiphy->rts_threshold);
52DEBUGFS_READONLY_FILE(fragmentation_threshold, 20, "%d",
53 wiphy->frag_threshold);
54DEBUGFS_READONLY_FILE(short_retry_limit, 20, "%d",
55 wiphy->retry_short);
56DEBUGFS_READONLY_FILE(long_retry_limit, 20, "%d",
57 wiphy->retry_long);
58
59DEBUGFS_RADIO_READONLY_FILE(radio_rts_threshold, 20, "%d",
60 radio_cfg->rts_threshold);
61
62static int ht_print_chan(struct ieee80211_channel *chan,
63 char *buf, int buf_size, int offset)
64{
65 if (WARN_ON(offset > buf_size))
66 return 0;
67
68 if (chan->flags & IEEE80211_CHAN_DISABLED)
69 return scnprintf(buf + offset,
70 buf_size - offset,
71 "%d Disabled\n",
72 chan->center_freq);
73
74 return scnprintf(buf + offset,
75 buf_size - offset,
76 "%d HT40 %c%c\n",
77 chan->center_freq,
78 (chan->flags & IEEE80211_CHAN_NO_HT40MINUS) ?
79 ' ' : '-',
80 (chan->flags & IEEE80211_CHAN_NO_HT40PLUS) ?
81 ' ' : '+');
82}
83
84static ssize_t ht40allow_map_read(struct file *file,
85 char __user *user_buf,
86 size_t count, loff_t *ppos)
87{
88 struct wiphy *wiphy = file->private_data;
89 char *buf;
90 unsigned int offset = 0, buf_size = PAGE_SIZE, i;
91 enum nl80211_band band;
92 struct ieee80211_supported_band *sband;
93 ssize_t r;
94
95 buf = kzalloc(buf_size, GFP_KERNEL);
96 if (!buf)
97 return -ENOMEM;
98
99 for (band = 0; band < NUM_NL80211_BANDS; band++) {
100 sband = wiphy->bands[band];
101 if (!sband)
102 continue;
103 for (i = 0; i < sband->n_channels; i++)
104 offset += ht_print_chan(&sband->channels[i],
105 buf, buf_size, offset);
106 }
107
108 r = simple_read_from_buffer(user_buf, count, ppos, buf, offset);
109
110 kfree(buf);
111
112 return r;
113}
114
115static const struct file_operations ht40allow_map_ops = {
116 .read = ht40allow_map_read,
117 .open = simple_open,
118 .llseek = default_llseek,
119};
120
121#define DEBUGFS_ADD(name) \
122 debugfs_create_file(#name, 0444, phyd, &rdev->wiphy, &name## _ops)
123
124#define DEBUGFS_RADIO_ADD(name, radio_idx) \
125 debugfs_create_file(#name, 0444, radiod, \
126 &rdev->wiphy.radio_cfg[radio_idx], \
127 &name## _ops)
128
129void cfg80211_debugfs_rdev_add(struct cfg80211_registered_device *rdev)
130{
131 struct dentry *phyd = rdev->wiphy.debugfsdir;
132 struct dentry *radiod;
133 u8 i;
134
135 DEBUGFS_ADD(rts_threshold);
136 DEBUGFS_ADD(fragmentation_threshold);
137 DEBUGFS_ADD(short_retry_limit);
138 DEBUGFS_ADD(long_retry_limit);
139 DEBUGFS_ADD(ht40allow_map);
140
141 for (i = 0; i < rdev->wiphy.n_radio; i++) {
142 radiod = rdev->wiphy.radio_cfg[i].radio_debugfsdir;
143 DEBUGFS_RADIO_ADD(radio_rts_threshold, i);
144 }
145}
146
147struct debugfs_read_work {
148 struct wiphy_work work;
149 ssize_t (*handler)(struct wiphy *wiphy,
150 struct file *file,
151 char *buf,
152 size_t count,
153 void *data);
154 struct wiphy *wiphy;
155 struct file *file;
156 char *buf;
157 size_t bufsize;
158 void *data;
159 ssize_t ret;
160 struct completion completion;
161};
162
163static void wiphy_locked_debugfs_read_work(struct wiphy *wiphy,
164 struct wiphy_work *work)
165{
166 struct debugfs_read_work *w = container_of(work, typeof(*w), work);
167
168 w->ret = w->handler(w->wiphy, w->file, w->buf, w->bufsize, w->data);
169 complete(&w->completion);
170}
171
172static void wiphy_locked_debugfs_read_cancel(struct dentry *dentry,
173 void *data)
174{
175 struct debugfs_read_work *w = data;
176
177 wiphy_work_cancel(w->wiphy, &w->work);
178 complete(&w->completion);
179}
180
181ssize_t wiphy_locked_debugfs_read(struct wiphy *wiphy, struct file *file,
182 char *buf, size_t bufsize,
183 char __user *userbuf, size_t count,
184 loff_t *ppos,
185 ssize_t (*handler)(struct wiphy *wiphy,
186 struct file *file,
187 char *buf,
188 size_t bufsize,
189 void *data),
190 void *data)
191{
192 struct debugfs_read_work work = {
193 .handler = handler,
194 .wiphy = wiphy,
195 .file = file,
196 .buf = buf,
197 .bufsize = bufsize,
198 .data = data,
199 .ret = -ENODEV,
200 .completion = COMPLETION_INITIALIZER_ONSTACK(work.completion),
201 };
202 struct debugfs_cancellation cancellation = {
203 .cancel = wiphy_locked_debugfs_read_cancel,
204 .cancel_data = &work,
205 };
206
207 /* don't leak stack data or whatever */
208 memset(buf, 0, bufsize);
209
210 wiphy_work_init(&work.work, wiphy_locked_debugfs_read_work);
211 wiphy_work_queue(wiphy, &work.work);
212
213 debugfs_enter_cancellation(file, &cancellation);
214 wait_for_completion(&work.completion);
215 debugfs_leave_cancellation(file, &cancellation);
216
217 if (work.ret < 0)
218 return work.ret;
219
220 if (WARN_ON(work.ret > bufsize))
221 return -EINVAL;
222
223 return simple_read_from_buffer(userbuf, count, ppos, buf, work.ret);
224}
225EXPORT_SYMBOL_GPL(wiphy_locked_debugfs_read);
226
227struct debugfs_write_work {
228 struct wiphy_work work;
229 ssize_t (*handler)(struct wiphy *wiphy,
230 struct file *file,
231 char *buf,
232 size_t count,
233 void *data);
234 struct wiphy *wiphy;
235 struct file *file;
236 char *buf;
237 size_t count;
238 void *data;
239 ssize_t ret;
240 struct completion completion;
241};
242
243static void wiphy_locked_debugfs_write_work(struct wiphy *wiphy,
244 struct wiphy_work *work)
245{
246 struct debugfs_write_work *w = container_of(work, typeof(*w), work);
247
248 w->ret = w->handler(w->wiphy, w->file, w->buf, w->count, w->data);
249 complete(&w->completion);
250}
251
252static void wiphy_locked_debugfs_write_cancel(struct dentry *dentry,
253 void *data)
254{
255 struct debugfs_write_work *w = data;
256
257 wiphy_work_cancel(w->wiphy, &w->work);
258 complete(&w->completion);
259}
260
261ssize_t wiphy_locked_debugfs_write(struct wiphy *wiphy,
262 struct file *file, char *buf, size_t bufsize,
263 const char __user *userbuf, size_t count,
264 ssize_t (*handler)(struct wiphy *wiphy,
265 struct file *file,
266 char *buf,
267 size_t count,
268 void *data),
269 void *data)
270{
271 struct debugfs_write_work work = {
272 .handler = handler,
273 .wiphy = wiphy,
274 .file = file,
275 .buf = buf,
276 .count = count,
277 .data = data,
278 .ret = -ENODEV,
279 .completion = COMPLETION_INITIALIZER_ONSTACK(work.completion),
280 };
281 struct debugfs_cancellation cancellation = {
282 .cancel = wiphy_locked_debugfs_write_cancel,
283 .cancel_data = &work,
284 };
285
286 /* mostly used for strings so enforce NUL-termination for safety */
287 if (count >= bufsize)
288 return -EINVAL;
289
290 memset(buf, 0, bufsize);
291
292 if (copy_from_user(buf, userbuf, count))
293 return -EFAULT;
294
295 wiphy_work_init(&work.work, wiphy_locked_debugfs_write_work);
296 wiphy_work_queue(wiphy, &work.work);
297
298 debugfs_enter_cancellation(file, &cancellation);
299 wait_for_completion(&work.completion);
300 debugfs_leave_cancellation(file, &cancellation);
301
302 return work.ret;
303}
304EXPORT_SYMBOL_GPL(wiphy_locked_debugfs_write);