projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ethtool: Fix potential kernel buffer overflow in ETHTOOL_GRXCLSRLALL
[deliverable/linux.git] / net / core / ethtool.c
CommitLineData
1da177e4
LT		 1/*
2 * net/core/ethtool.c - Ethtool ioctl handler
3 * Copyright (c) 2003 Matthew Wilcox <matthew@wil.cx>
4 *
5 * This file is where we call all the ethtool_ops commands to get
61a44b9c 6 * the information ethtool needs.
1da177e4 7 *
61a44b9c
MW		 8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
1da177e4
LT		 12 */
13
14#include <linux/module.h>
15#include <linux/types.h>
4fc268d2 16#include <linux/capability.h>
1da177e4
LT		 17#include <linux/errno.h>
18#include <linux/ethtool.h>
19#include <linux/netdevice.h>
d17792eb 20#include <linux/bitops.h>
97f8aefb 21#include <linux/uaccess.h>
5a0e3ad6 22#include <linux/slab.h>
1da177e4 23
4ec93edb 24/*
1da177e4
LT		 25 * Some useful ethtool_ops methods that're device independent.
26 * If we find that all drivers want to do the same thing here,
27 * we can turn these into dev_() function calls.
28 */
29
30u32 ethtool_op_get_link(struct net_device *dev)
31{
32 return netif_carrier_ok(dev) ? 1 : 0;
33}
97f8aefb 34EXPORT_SYMBOL(ethtool_op_get_link);
1da177e4 35
1896e61f
SS		 36u32 ethtool_op_get_rx_csum(struct net_device *dev)
37{
38 return (dev->features & NETIF_F_ALL_CSUM) != 0;
39}
8a729fce 40EXPORT_SYMBOL(ethtool_op_get_rx_csum);
1896e61f 41
1da177e4
LT		 42u32 ethtool_op_get_tx_csum(struct net_device *dev)
43{
8648b305 44 return (dev->features & NETIF_F_ALL_CSUM) != 0;
1da177e4 45}
8a729fce 46EXPORT_SYMBOL(ethtool_op_get_tx_csum);
1da177e4
LT		 47
48int ethtool_op_set_tx_csum(struct net_device *dev, u32 data)
49{
50 if (data)
51 dev->features |= NETIF_F_IP_CSUM;
52 else
53 dev->features &= ~NETIF_F_IP_CSUM;
54
55 return 0;
56}
57
69f6a0fa
JM		 58int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data)
59{
60 if (data)
61 dev->features |= NETIF_F_HW_CSUM;
62 else
63 dev->features &= ~NETIF_F_HW_CSUM;
64
65 return 0;
66}
97f8aefb 67EXPORT_SYMBOL(ethtool_op_set_tx_hw_csum);
6460d948
MC		 68
69int ethtool_op_set_tx_ipv6_csum(struct net_device *dev, u32 data)
70{
71 if (data)
72 dev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
73 else
74 dev->features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
75
76 return 0;
77}
97f8aefb 78EXPORT_SYMBOL(ethtool_op_set_tx_ipv6_csum);
6460d948 79
1da177e4
LT		 80u32 ethtool_op_get_sg(struct net_device *dev)
81{
82 return (dev->features & NETIF_F_SG) != 0;
83}
97f8aefb 84EXPORT_SYMBOL(ethtool_op_get_sg);
1da177e4
LT		 85
86int ethtool_op_set_sg(struct net_device *dev, u32 data)
87{
88 if (data)
89 dev->features |= NETIF_F_SG;
90 else
91 dev->features &= ~NETIF_F_SG;
92
93 return 0;
94}
97f8aefb 95EXPORT_SYMBOL(ethtool_op_set_sg);
1da177e4
LT		 96
97u32 ethtool_op_get_tso(struct net_device *dev)
98{
99 return (dev->features & NETIF_F_TSO) != 0;
100}
97f8aefb 101EXPORT_SYMBOL(ethtool_op_get_tso);
1da177e4
LT		 102
103int ethtool_op_set_tso(struct net_device *dev, u32 data)
104{
105 if (data)
106 dev->features |= NETIF_F_TSO;
107 else
108 dev->features &= ~NETIF_F_TSO;
109
110 return 0;
111}
97f8aefb 112EXPORT_SYMBOL(ethtool_op_set_tso);
1da177e4 113
e89e9cf5
AR		 114u32 ethtool_op_get_ufo(struct net_device *dev)
115{
116 return (dev->features & NETIF_F_UFO) != 0;
117}
97f8aefb 118EXPORT_SYMBOL(ethtool_op_get_ufo);
e89e9cf5
AR		 119
120int ethtool_op_set_ufo(struct net_device *dev, u32 data)
121{
122 if (data)
123 dev->features |= NETIF_F_UFO;
124 else
125 dev->features &= ~NETIF_F_UFO;
126 return 0;
127}
97f8aefb 128EXPORT_SYMBOL(ethtool_op_set_ufo);
e89e9cf5 129
3ae7c0b2
JG		 130/* the following list of flags are the same as their associated
131 * NETIF_F_xxx values in include/linux/netdevice.h
132 */
133static const u32 flags_dup_features =
b00fabb4 134 (ETH_FLAG_LRO | ETH_FLAG_NTUPLE | ETH_FLAG_RXHASH);
3ae7c0b2
JG		 135
136u32 ethtool_op_get_flags(struct net_device *dev)
137{
138 /* in the future, this function will probably contain additional
139 * handling for flags which are not so easily handled
140 * by a simple masking operation
141 */
142
143 return dev->features & flags_dup_features;
144}
97f8aefb 145EXPORT_SYMBOL(ethtool_op_get_flags);
3ae7c0b2
JG		 146
147int ethtool_op_set_flags(struct net_device *dev, u32 data)
148{
0d643e1f 149 const struct ethtool_ops *ops = dev->ethtool_ops;
9675478b 150 unsigned long features = dev->features;
0d643e1f 151
3ae7c0b2 152 if (data & ETH_FLAG_LRO)
9675478b 153 features |= NETIF_F_LRO;
3ae7c0b2 154 else
9675478b 155 features &= ~NETIF_F_LRO;
3ae7c0b2 156
0d643e1f
PW		 157 if (data & ETH_FLAG_NTUPLE) {
158 if (!ops->set_rx_ntuple)
159 return -EOPNOTSUPP;
9675478b 160 features |= NETIF_F_NTUPLE;
0d643e1f
PW		 161 } else {
162 /* safe to clear regardless */
9675478b 163 features &= ~NETIF_F_NTUPLE;
0d643e1f 164 }
15682bc4 165
b00fabb4 166 if (data & ETH_FLAG_RXHASH)
167 features |= NETIF_F_RXHASH;
168 else
169 features &= ~NETIF_F_RXHASH;
170
9675478b 171 dev->features = features;
3ae7c0b2
JG		 172 return 0;
173}
97f8aefb 174EXPORT_SYMBOL(ethtool_op_set_flags);
3ae7c0b2 175
15682bc4
PWJ		 176void ethtool_ntuple_flush(struct net_device *dev)
177{
178 struct ethtool_rx_ntuple_flow_spec_container *fsc, *f;
179
180 list_for_each_entry_safe(fsc, f, &dev->ethtool_ntuple_list.list, list) {
181 list_del(&fsc->list);
182 kfree(fsc);
183 }
184 dev->ethtool_ntuple_list.count = 0;
185}
186EXPORT_SYMBOL(ethtool_ntuple_flush);
187
1da177e4
LT		 188/* Handlers for each ethtool command */
189
190static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
191{
8e557421 192 struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET };
1da177e4
LT		 193 int err;
194
195 if (!dev->ethtool_ops->get_settings)
196 return -EOPNOTSUPP;
197
198 err = dev->ethtool_ops->get_settings(dev, &cmd);
199 if (err < 0)
200 return err;
201
202 if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
203 return -EFAULT;
204 return 0;
205}
206
207static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
208{
209 struct ethtool_cmd cmd;
210
211 if (!dev->ethtool_ops->set_settings)
212 return -EOPNOTSUPP;
213
214 if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
215 return -EFAULT;
216
217 return dev->ethtool_ops->set_settings(dev, &cmd);
218}
219
97f8aefb 220static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev,
221 void __user *useraddr)
1da177e4
LT		 222{
223 struct ethtool_drvinfo info;
76fd8593 224 const struct ethtool_ops *ops = dev->ethtool_ops;
1da177e4
LT		 225
226 if (!ops->get_drvinfo)
227 return -EOPNOTSUPP;
228
229 memset(&info, 0, sizeof(info));
230 info.cmd = ETHTOOL_GDRVINFO;
231 ops->get_drvinfo(dev, &info);
232
723b2f57
JG		 233 /*
234 * this method of obtaining string set info is deprecated;
d17792eb 235 * Use ETHTOOL_GSSET_INFO instead.
723b2f57 236 */
ff03d49f
JG		 237 if (ops->get_sset_count) {
238 int rc;
239
240 rc = ops->get_sset_count(dev, ETH_SS_TEST);
241 if (rc >= 0)
242 info.testinfo_len = rc;
243 rc = ops->get_sset_count(dev, ETH_SS_STATS);
244 if (rc >= 0)
245 info.n_stats = rc;
339bf024
JG		 246 rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);
247 if (rc >= 0)
248 info.n_priv_flags = rc;
ff03d49f 249 }
1da177e4
LT		 250 if (ops->get_regs_len)
251 info.regdump_len = ops->get_regs_len(dev);
252 if (ops->get_eeprom_len)
253 info.eedump_len = ops->get_eeprom_len(dev);
254
255 if (copy_to_user(useraddr, &info, sizeof(info)))
256 return -EFAULT;
257 return 0;
258}
259
f5c445ed 260static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,
97f8aefb 261 void __user *useraddr)
723b2f57
JG		 262{
263 struct ethtool_sset_info info;
264 const struct ethtool_ops *ops = dev->ethtool_ops;
265 u64 sset_mask;
266 int i, idx = 0, n_bits = 0, ret, rc;
267 u32 *info_buf = NULL;
268
269 if (!ops->get_sset_count)
270 return -EOPNOTSUPP;
271
272 if (copy_from_user(&info, useraddr, sizeof(info)))
273 return -EFAULT;
274
275 /* store copy of mask, because we zero struct later on */
276 sset_mask = info.sset_mask;
277 if (!sset_mask)
278 return 0;
279
280 /* calculate size of return buffer */
d17792eb 281 n_bits = hweight64(sset_mask);
723b2f57
JG		 282
283 memset(&info, 0, sizeof(info));
284 info.cmd = ETHTOOL_GSSET_INFO;
285
286 info_buf = kzalloc(n_bits * sizeof(u32), GFP_USER);
287 if (!info_buf)
288 return -ENOMEM;
289
290 /*
291 * fill return buffer based on input bitmask and successful
292 * get_sset_count return
293 */
294 for (i = 0; i < 64; i++) {
295 if (!(sset_mask & (1ULL << i)))
296 continue;
297
298 rc = ops->get_sset_count(dev, i);
299 if (rc >= 0) {
300 info.sset_mask |= (1ULL << i);
301 info_buf[idx++] = rc;
302 }
303 }
304
305 ret = -EFAULT;
306 if (copy_to_user(useraddr, &info, sizeof(info)))
307 goto out;
308
309 useraddr += offsetof(struct ethtool_sset_info, data);
310 if (copy_to_user(useraddr, info_buf, idx * sizeof(u32)))
311 goto out;
312
313 ret = 0;
314
315out:
316 kfree(info_buf);
317 return ret;
318}
319
97f8aefb 320static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev,
321 void __user *useraddr)
0853ad66
SB		 322{
323 struct ethtool_rxnfc cmd;
324
59089d8d 325 if (!dev->ethtool_ops->set_rxnfc)
0853ad66
SB		 326 return -EOPNOTSUPP;
327
328 if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
329 return -EFAULT;
330
59089d8d 331 return dev->ethtool_ops->set_rxnfc(dev, &cmd);
0853ad66
SB		 332}
333
97f8aefb 334static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev,
335 void __user *useraddr)
0853ad66
SB		 336{
337 struct ethtool_rxnfc info;
59089d8d
SB		 338 const struct ethtool_ops *ops = dev->ethtool_ops;
339 int ret;
340 void *rule_buf = NULL;
0853ad66 341
59089d8d 342 if (!ops->get_rxnfc)
0853ad66
SB		 343 return -EOPNOTSUPP;
344
345 if (copy_from_user(&info, useraddr, sizeof(info)))
346 return -EFAULT;
347
59089d8d
SB		 348 if (info.cmd == ETHTOOL_GRXCLSRLALL) {
349 if (info.rule_cnt > 0) {
db048b69
BH		 350 if (info.rule_cnt <= KMALLOC_MAX_SIZE / sizeof(u32))
351 rule_buf = kmalloc(info.rule_cnt * sizeof(u32),
352 GFP_USER);
59089d8d
SB		 353 if (!rule_buf)
354 return -ENOMEM;
355 }
356 }
0853ad66 357
59089d8d
SB		 358 ret = ops->get_rxnfc(dev, &info, rule_buf);
359 if (ret < 0)
360 goto err_out;
361
362 ret = -EFAULT;
0853ad66 363 if (copy_to_user(useraddr, &info, sizeof(info)))
59089d8d
SB		 364 goto err_out;
365
366 if (rule_buf) {
367 useraddr += offsetof(struct ethtool_rxnfc, rule_locs);
368 if (copy_to_user(useraddr, rule_buf,
369 info.rule_cnt * sizeof(u32)))
370 goto err_out;
371 }
372 ret = 0;
373
374err_out:
c9caceca 375 kfree(rule_buf);
59089d8d
SB		 376
377 return ret;
0853ad66
SB		 378}
379
e8589118 380static void __rx_ntuple_filter_add(struct ethtool_rx_ntuple_list *list,
97f8aefb 381 struct ethtool_rx_ntuple_flow_spec *spec,
382 struct ethtool_rx_ntuple_flow_spec_container *fsc)
15682bc4 383{
15682bc4
PWJ		 384
385 /* don't add filters forever */
e8589118
PW		 386 if (list->count >= ETHTOOL_MAX_NTUPLE_LIST_ENTRY) {
387 /* free the container */
388 kfree(fsc);
389 return;
390 }
15682bc4
PWJ		 391
392 /* Copy the whole filter over */
393 fsc->fs.flow_type = spec->flow_type;
394 memcpy(&fsc->fs.h_u, &spec->h_u, sizeof(spec->h_u));
395 memcpy(&fsc->fs.m_u, &spec->m_u, sizeof(spec->m_u));
396
397 fsc->fs.vlan_tag = spec->vlan_tag;
398 fsc->fs.vlan_tag_mask = spec->vlan_tag_mask;
399 fsc->fs.data = spec->data;
400 fsc->fs.data_mask = spec->data_mask;
401 fsc->fs.action = spec->action;
402
403 /* add to the list */
404 list_add_tail_rcu(&fsc->list, &list->list);
405 list->count++;
15682bc4
PWJ		 406}
407
97f8aefb 408static noinline_for_stack int ethtool_set_rx_ntuple(struct net_device *dev,
409 void __user *useraddr)
15682bc4
PWJ		 410{
411 struct ethtool_rx_ntuple cmd;
412 const struct ethtool_ops *ops = dev->ethtool_ops;
e8589118 413 struct ethtool_rx_ntuple_flow_spec_container *fsc = NULL;
15682bc4
PWJ		 414 int ret;
415
15682bc4
PWJ		 416 if (!(dev->features & NETIF_F_NTUPLE))
417 return -EINVAL;
418
419 if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
420 return -EFAULT;
421
15682bc4
PWJ		 422 /*
423 * Cache filter in dev struct for GET operation only if
424 * the underlying driver doesn't have its own GET operation, and
e8589118
PW		 425 * only if the filter was added successfully. First make sure we
426 * can allocate the filter, then continue if successful.
15682bc4 427 */
e8589118
PW		 428 if (!ops->get_rx_ntuple) {
429 fsc = kmalloc(sizeof(*fsc), GFP_ATOMIC);
430 if (!fsc)
15682bc4 431 return -ENOMEM;
e8589118
PW		 432 }
433
434 ret = ops->set_rx_ntuple(dev, &cmd);
435 if (ret) {
436 kfree(fsc);
437 return ret;
438 }
439
440 if (!ops->get_rx_ntuple)
441 __rx_ntuple_filter_add(&dev->ethtool_ntuple_list, &cmd.fs, fsc);
15682bc4
PWJ		 442
443 return ret;
444}
445
446static int ethtool_get_rx_ntuple(struct net_device *dev, void __user *useraddr)
447{
448 struct ethtool_gstrings gstrings;
449 const struct ethtool_ops *ops = dev->ethtool_ops;
450 struct ethtool_rx_ntuple_flow_spec_container *fsc;
451 u8 *data;
452 char *p;
453 int ret, i, num_strings = 0;
454
455 if (!ops->get_sset_count)
456 return -EOPNOTSUPP;
457
458 if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
459 return -EFAULT;
460
461 ret = ops->get_sset_count(dev, gstrings.string_set);
462 if (ret < 0)
463 return ret;
464
465 gstrings.len = ret;
466
467 data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
468 if (!data)
469 return -ENOMEM;
470
471 if (ops->get_rx_ntuple) {
472 /* driver-specific filter grab */
473 ret = ops->get_rx_ntuple(dev, gstrings.string_set, data);
474 goto copy;
475 }
476
477 /* default ethtool filter grab */
478 i = 0;
479 p = (char *)data;
480 list_for_each_entry(fsc, &dev->ethtool_ntuple_list.list, list) {
481 sprintf(p, "Filter %d:\n", i);
482 p += ETH_GSTRING_LEN;
483 num_strings++;
484
485 switch (fsc->fs.flow_type) {
486 case TCP_V4_FLOW:
487 sprintf(p, "\tFlow Type: TCP\n");
488 p += ETH_GSTRING_LEN;
489 num_strings++;
490 break;
491 case UDP_V4_FLOW:
492 sprintf(p, "\tFlow Type: UDP\n");
493 p += ETH_GSTRING_LEN;
494 num_strings++;
495 break;
496 case SCTP_V4_FLOW:
497 sprintf(p, "\tFlow Type: SCTP\n");
498 p += ETH_GSTRING_LEN;
499 num_strings++;
500 break;
501 case AH_ESP_V4_FLOW:
502 sprintf(p, "\tFlow Type: AH ESP\n");
503 p += ETH_GSTRING_LEN;
504 num_strings++;
505 break;
506 case ESP_V4_FLOW:
507 sprintf(p, "\tFlow Type: ESP\n");
508 p += ETH_GSTRING_LEN;
509 num_strings++;
510 break;
511 case IP_USER_FLOW:
512 sprintf(p, "\tFlow Type: Raw IP\n");
513 p += ETH_GSTRING_LEN;
514 num_strings++;
515 break;
516 case IPV4_FLOW:
517 sprintf(p, "\tFlow Type: IPv4\n");
518 p += ETH_GSTRING_LEN;
519 num_strings++;
520 break;
521 default:
522 sprintf(p, "\tFlow Type: Unknown\n");
523 p += ETH_GSTRING_LEN;
524 num_strings++;
525 goto unknown_filter;
ccbd6a5a 526 }
15682bc4
PWJ		 527
528 /* now the rest of the filters */
529 switch (fsc->fs.flow_type) {
530 case TCP_V4_FLOW:
531 case UDP_V4_FLOW:
532 case SCTP_V4_FLOW:
533 sprintf(p, "\tSrc IP addr: 0x%x\n",
97f8aefb 534 fsc->fs.h_u.tcp_ip4_spec.ip4src);
15682bc4
PWJ		 535 p += ETH_GSTRING_LEN;
536 num_strings++;
537 sprintf(p, "\tSrc IP mask: 0x%x\n",
97f8aefb 538 fsc->fs.m_u.tcp_ip4_spec.ip4src);
15682bc4
PWJ		 539 p += ETH_GSTRING_LEN;
540 num_strings++;
541 sprintf(p, "\tDest IP addr: 0x%x\n",
97f8aefb 542 fsc->fs.h_u.tcp_ip4_spec.ip4dst);
15682bc4
PWJ		 543 p += ETH_GSTRING_LEN;
544 num_strings++;
545 sprintf(p, "\tDest IP mask: 0x%x\n",
97f8aefb 546 fsc->fs.m_u.tcp_ip4_spec.ip4dst);
15682bc4
PWJ		 547 p += ETH_GSTRING_LEN;
548 num_strings++;
549 sprintf(p, "\tSrc Port: %d, mask: 0x%x\n",
97f8aefb 550 fsc->fs.h_u.tcp_ip4_spec.psrc,
551 fsc->fs.m_u.tcp_ip4_spec.psrc);
15682bc4
PWJ		 552 p += ETH_GSTRING_LEN;
553 num_strings++;
554 sprintf(p, "\tDest Port: %d, mask: 0x%x\n",
97f8aefb 555 fsc->fs.h_u.tcp_ip4_spec.pdst,
556 fsc->fs.m_u.tcp_ip4_spec.pdst);
15682bc4
PWJ		 557 p += ETH_GSTRING_LEN;
558 num_strings++;
559 sprintf(p, "\tTOS: %d, mask: 0x%x\n",
97f8aefb 560 fsc->fs.h_u.tcp_ip4_spec.tos,
561 fsc->fs.m_u.tcp_ip4_spec.tos);
15682bc4
PWJ		 562 p += ETH_GSTRING_LEN;
563 num_strings++;
564 break;
565 case AH_ESP_V4_FLOW:
566 case ESP_V4_FLOW:
567 sprintf(p, "\tSrc IP addr: 0x%x\n",
97f8aefb 568 fsc->fs.h_u.ah_ip4_spec.ip4src);
15682bc4
PWJ		 569 p += ETH_GSTRING_LEN;
570 num_strings++;
571 sprintf(p, "\tSrc IP mask: 0x%x\n",
97f8aefb 572 fsc->fs.m_u.ah_ip4_spec.ip4src);
15682bc4
PWJ		 573 p += ETH_GSTRING_LEN;
574 num_strings++;
575 sprintf(p, "\tDest IP addr: 0x%x\n",
97f8aefb 576 fsc->fs.h_u.ah_ip4_spec.ip4dst);
15682bc4
PWJ		 577 p += ETH_GSTRING_LEN;
578 num_strings++;
579 sprintf(p, "\tDest IP mask: 0x%x\n",
97f8aefb 580 fsc->fs.m_u.ah_ip4_spec.ip4dst);
15682bc4
PWJ		 581 p += ETH_GSTRING_LEN;
582 num_strings++;
583 sprintf(p, "\tSPI: %d, mask: 0x%x\n",
97f8aefb 584 fsc->fs.h_u.ah_ip4_spec.spi,
585 fsc->fs.m_u.ah_ip4_spec.spi);
15682bc4
PWJ		 586 p += ETH_GSTRING_LEN;
587 num_strings++;
588 sprintf(p, "\tTOS: %d, mask: 0x%x\n",
97f8aefb 589 fsc->fs.h_u.ah_ip4_spec.tos,
590 fsc->fs.m_u.ah_ip4_spec.tos);
15682bc4
PWJ		 591 p += ETH_GSTRING_LEN;
592 num_strings++;
593 break;
594 case IP_USER_FLOW:
595 sprintf(p, "\tSrc IP addr: 0x%x\n",
97f8aefb 596 fsc->fs.h_u.raw_ip4_spec.ip4src);
15682bc4
PWJ		 597 p += ETH_GSTRING_LEN;
598 num_strings++;
599 sprintf(p, "\tSrc IP mask: 0x%x\n",
97f8aefb 600 fsc->fs.m_u.raw_ip4_spec.ip4src);
15682bc4
PWJ		 601 p += ETH_GSTRING_LEN;
602 num_strings++;
603 sprintf(p, "\tDest IP addr: 0x%x\n",
97f8aefb 604 fsc->fs.h_u.raw_ip4_spec.ip4dst);
15682bc4
PWJ		 605 p += ETH_GSTRING_LEN;
606 num_strings++;
607 sprintf(p, "\tDest IP mask: 0x%x\n",
97f8aefb 608 fsc->fs.m_u.raw_ip4_spec.ip4dst);
15682bc4
PWJ		 609 p += ETH_GSTRING_LEN;
610 num_strings++;
611 break;
612 case IPV4_FLOW:
613 sprintf(p, "\tSrc IP addr: 0x%x\n",
97f8aefb 614 fsc->fs.h_u.usr_ip4_spec.ip4src);
15682bc4
PWJ		 615 p += ETH_GSTRING_LEN;
616 num_strings++;
617 sprintf(p, "\tSrc IP mask: 0x%x\n",
97f8aefb 618 fsc->fs.m_u.usr_ip4_spec.ip4src);
15682bc4
PWJ		 619 p += ETH_GSTRING_LEN;
620 num_strings++;
621 sprintf(p, "\tDest IP addr: 0x%x\n",
97f8aefb 622 fsc->fs.h_u.usr_ip4_spec.ip4dst);
15682bc4
PWJ		 623 p += ETH_GSTRING_LEN;
624 num_strings++;
625 sprintf(p, "\tDest IP mask: 0x%x\n",
97f8aefb 626 fsc->fs.m_u.usr_ip4_spec.ip4dst);
15682bc4
PWJ		 627 p += ETH_GSTRING_LEN;
628 num_strings++;
629 sprintf(p, "\tL4 bytes: 0x%x, mask: 0x%x\n",
97f8aefb 630 fsc->fs.h_u.usr_ip4_spec.l4_4_bytes,
631 fsc->fs.m_u.usr_ip4_spec.l4_4_bytes);
15682bc4
PWJ		 632 p += ETH_GSTRING_LEN;
633 num_strings++;
634 sprintf(p, "\tTOS: %d, mask: 0x%x\n",
97f8aefb 635 fsc->fs.h_u.usr_ip4_spec.tos,
636 fsc->fs.m_u.usr_ip4_spec.tos);
15682bc4
PWJ		 637 p += ETH_GSTRING_LEN;
638 num_strings++;
639 sprintf(p, "\tIP Version: %d, mask: 0x%x\n",
97f8aefb 640 fsc->fs.h_u.usr_ip4_spec.ip_ver,
641 fsc->fs.m_u.usr_ip4_spec.ip_ver);
15682bc4
PWJ		 642 p += ETH_GSTRING_LEN;
643 num_strings++;
644 sprintf(p, "\tProtocol: %d, mask: 0x%x\n",
97f8aefb 645 fsc->fs.h_u.usr_ip4_spec.proto,
646 fsc->fs.m_u.usr_ip4_spec.proto);
15682bc4
PWJ		 647 p += ETH_GSTRING_LEN;
648 num_strings++;
649 break;
ccbd6a5a 650 }
15682bc4 651 sprintf(p, "\tVLAN: %d, mask: 0x%x\n",
97f8aefb 652 fsc->fs.vlan_tag, fsc->fs.vlan_tag_mask);
15682bc4
PWJ		 653 p += ETH_GSTRING_LEN;
654 num_strings++;
655 sprintf(p, "\tUser-defined: 0x%Lx\n", fsc->fs.data);
656 p += ETH_GSTRING_LEN;
657 num_strings++;
658 sprintf(p, "\tUser-defined mask: 0x%Lx\n", fsc->fs.data_mask);
659 p += ETH_GSTRING_LEN;
660 num_strings++;
661 if (fsc->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP)
662 sprintf(p, "\tAction: Drop\n");
663 else
664 sprintf(p, "\tAction: Direct to queue %d\n",
97f8aefb 665 fsc->fs.action);
15682bc4
PWJ		 666 p += ETH_GSTRING_LEN;
667 num_strings++;
668unknown_filter:
669 i++;
670 }
671copy:
672 /* indicate to userspace how many strings we actually have */
673 gstrings.len = num_strings;
674 ret = -EFAULT;
675 if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
676 goto out;
677 useraddr += sizeof(gstrings);
678 if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
679 goto out;
680 ret = 0;
681
682out:
683 kfree(data);
684 return ret;
685}
686
1da177e4
LT		 687static int ethtool_get_regs(struct net_device *dev, char __user *useraddr)
688{
689 struct ethtool_regs regs;
76fd8593 690 const struct ethtool_ops *ops = dev->ethtool_ops;
1da177e4
LT		 691 void *regbuf;
692 int reglen, ret;
693
694 if (!ops->get_regs || !ops->get_regs_len)
695 return -EOPNOTSUPP;
696
697 if (copy_from_user(&regs, useraddr, sizeof(regs)))
698 return -EFAULT;
699
700 reglen = ops->get_regs_len(dev);
701 if (regs.len > reglen)
702 regs.len = reglen;
703
704 regbuf = kmalloc(reglen, GFP_USER);
705 if (!regbuf)
706 return -ENOMEM;
707
708 ops->get_regs(dev, &regs, regbuf);
709
710 ret = -EFAULT;
711 if (copy_to_user(useraddr, &regs, sizeof(regs)))
712 goto out;
713 useraddr += offsetof(struct ethtool_regs, data);
714 if (copy_to_user(useraddr, regbuf, regs.len))
715 goto out;
716 ret = 0;
717
718 out:
719 kfree(regbuf);
720 return ret;
721}
722
d73d3a8c
BH		 723static int ethtool_reset(struct net_device *dev, char __user *useraddr)
724{
725 struct ethtool_value reset;
726 int ret;
727
728 if (!dev->ethtool_ops->reset)
729 return -EOPNOTSUPP;
730
731 if (copy_from_user(&reset, useraddr, sizeof(reset)))
732 return -EFAULT;
733
734 ret = dev->ethtool_ops->reset(dev, &reset.data);
735 if (ret)
736 return ret;
737
738 if (copy_to_user(useraddr, &reset, sizeof(reset)))
739 return -EFAULT;
740 return 0;
741}
742
1da177e4
LT		 743static int ethtool_get_wol(struct net_device *dev, char __user *useraddr)
744{
8e557421 745 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
1da177e4
LT		 746
747 if (!dev->ethtool_ops->get_wol)
748 return -EOPNOTSUPP;
749
750 dev->ethtool_ops->get_wol(dev, &wol);
751
752 if (copy_to_user(useraddr, &wol, sizeof(wol)))
753 return -EFAULT;
754 return 0;
755}
756
757static int ethtool_set_wol(struct net_device *dev, char __user *useraddr)
758{
759 struct ethtool_wolinfo wol;
760
761 if (!dev->ethtool_ops->set_wol)
762 return -EOPNOTSUPP;
763
764 if (copy_from_user(&wol, useraddr, sizeof(wol)))
765 return -EFAULT;
766
767 return dev->ethtool_ops->set_wol(dev, &wol);
768}
769
1da177e4
LT		 770static int ethtool_nway_reset(struct net_device *dev)
771{
772 if (!dev->ethtool_ops->nway_reset)
773 return -EOPNOTSUPP;
774
775 return dev->ethtool_ops->nway_reset(dev);
776}
777
1da177e4
LT		 778static int ethtool_get_eeprom(struct net_device *dev, void __user *useraddr)
779{
780 struct ethtool_eeprom eeprom;
76fd8593 781 const struct ethtool_ops *ops = dev->ethtool_ops;
b131dd5d
MSB		 782 void __user *userbuf = useraddr + sizeof(eeprom);
783 u32 bytes_remaining;
1da177e4 784 u8 *data;
b131dd5d 785 int ret = 0;
1da177e4
LT		 786
787 if (!ops->get_eeprom || !ops->get_eeprom_len)
788 return -EOPNOTSUPP;
789
790 if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
791 return -EFAULT;
792
793 /* Check for wrap and zero */
794 if (eeprom.offset + eeprom.len <= eeprom.offset)
795 return -EINVAL;
796
797 /* Check for exceeding total eeprom len */
798 if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
799 return -EINVAL;
800
b131dd5d 801 data = kmalloc(PAGE_SIZE, GFP_USER);
1da177e4
LT		 802 if (!data)
803 return -ENOMEM;
804
b131dd5d
MSB		 805 bytes_remaining = eeprom.len;
806 while (bytes_remaining > 0) {
807 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
808
809 ret = ops->get_eeprom(dev, &eeprom, data);
810 if (ret)
811 break;
812 if (copy_to_user(userbuf, data, eeprom.len)) {
813 ret = -EFAULT;
814 break;
815 }
816 userbuf += eeprom.len;
817 eeprom.offset += eeprom.len;
818 bytes_remaining -= eeprom.len;
819 }
1da177e4 820
c5835df9
MSB		 821 eeprom.len = userbuf - (useraddr + sizeof(eeprom));
822 eeprom.offset -= eeprom.len;
823 if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
824 ret = -EFAULT;
825
1da177e4
LT		 826 kfree(data);
827 return ret;
828}
829
830static int ethtool_set_eeprom(struct net_device *dev, void __user *useraddr)
831{
832 struct ethtool_eeprom eeprom;
76fd8593 833 const struct ethtool_ops *ops = dev->ethtool_ops;
b131dd5d
MSB		 834 void __user *userbuf = useraddr + sizeof(eeprom);
835 u32 bytes_remaining;
1da177e4 836 u8 *data;
b131dd5d 837 int ret = 0;
1da177e4
LT		 838
839 if (!ops->set_eeprom || !ops->get_eeprom_len)
840 return -EOPNOTSUPP;
841
842 if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
843 return -EFAULT;
844
845 /* Check for wrap and zero */
846 if (eeprom.offset + eeprom.len <= eeprom.offset)
847 return -EINVAL;
848
849 /* Check for exceeding total eeprom len */
850 if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
851 return -EINVAL;
852
b131dd5d 853 data = kmalloc(PAGE_SIZE, GFP_USER);
1da177e4
LT		 854 if (!data)
855 return -ENOMEM;
856
b131dd5d
MSB		 857 bytes_remaining = eeprom.len;
858 while (bytes_remaining > 0) {
859 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
860
861 if (copy_from_user(data, userbuf, eeprom.len)) {
862 ret = -EFAULT;
863 break;
864 }
865 ret = ops->set_eeprom(dev, &eeprom, data);
866 if (ret)
867 break;
868 userbuf += eeprom.len;
869 eeprom.offset += eeprom.len;
870 bytes_remaining -= eeprom.len;
871 }
1da177e4 872
1da177e4
LT		 873 kfree(data);
874 return ret;
875}
876
97f8aefb 877static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev,
878 void __user *useraddr)
1da177e4 879{
8e557421 880 struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
1da177e4
LT		 881
882 if (!dev->ethtool_ops->get_coalesce)
883 return -EOPNOTSUPP;
884
885 dev->ethtool_ops->get_coalesce(dev, &coalesce);
886
887 if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
888 return -EFAULT;
889 return 0;
890}
891
97f8aefb 892static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev,
893 void __user *useraddr)
1da177e4
LT		 894{
895 struct ethtool_coalesce coalesce;
896
fa04ae5c 897 if (!dev->ethtool_ops->set_coalesce)
1da177e4
LT		 898 return -EOPNOTSUPP;
899
900 if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))
901 return -EFAULT;
902
903 return dev->ethtool_ops->set_coalesce(dev, &coalesce);
904}
905
906static int ethtool_get_ringparam(struct net_device *dev, void __user *useraddr)
907{
8e557421 908 struct ethtool_ringparam ringparam = { .cmd = ETHTOOL_GRINGPARAM };
1da177e4
LT		 909
910 if (!dev->ethtool_ops->get_ringparam)
911 return -EOPNOTSUPP;
912
913 dev->ethtool_ops->get_ringparam(dev, &ringparam);
914
915 if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))
916 return -EFAULT;
917 return 0;
918}
919
920static int ethtool_set_ringparam(struct net_device *dev, void __user *useraddr)
921{
922 struct ethtool_ringparam ringparam;
923
924 if (!dev->ethtool_ops->set_ringparam)
925 return -EOPNOTSUPP;
926
927 if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))
928 return -EFAULT;
929
930 return dev->ethtool_ops->set_ringparam(dev, &ringparam);
931}
932
933static int ethtool_get_pauseparam(struct net_device *dev, void __user *useraddr)
934{
935 struct ethtool_pauseparam pauseparam = { ETHTOOL_GPAUSEPARAM };
936
937 if (!dev->ethtool_ops->get_pauseparam)
938 return -EOPNOTSUPP;
939
940 dev->ethtool_ops->get_pauseparam(dev, &pauseparam);
941
942 if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))
943 return -EFAULT;
944 return 0;
945}
946
947static int ethtool_set_pauseparam(struct net_device *dev, void __user *useraddr)
948{
949 struct ethtool_pauseparam pauseparam;
950
e1b90c41 951 if (!dev->ethtool_ops->set_pauseparam)
1da177e4
LT		 952 return -EOPNOTSUPP;
953
954 if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))
955 return -EFAULT;
956
957 return dev->ethtool_ops->set_pauseparam(dev, &pauseparam);
958}
959
1da177e4
LT		 960static int __ethtool_set_sg(struct net_device *dev, u32 data)
961{
962 int err;
963
964 if (!data && dev->ethtool_ops->set_tso) {
965 err = dev->ethtool_ops->set_tso(dev, 0);
966 if (err)
967 return err;
968 }
969
e89e9cf5
AR		 970 if (!data && dev->ethtool_ops->set_ufo) {
971 err = dev->ethtool_ops->set_ufo(dev, 0);
972 if (err)
973 return err;
974 }
1da177e4
LT		 975 return dev->ethtool_ops->set_sg(dev, data);
976}
977
978static int ethtool_set_tx_csum(struct net_device *dev, char __user *useraddr)
979{
980 struct ethtool_value edata;
981 int err;
982
983 if (!dev->ethtool_ops->set_tx_csum)
984 return -EOPNOTSUPP;
985
986 if (copy_from_user(&edata, useraddr, sizeof(edata)))
987 return -EFAULT;
988
989 if (!edata.data && dev->ethtool_ops->set_sg) {
990 err = __ethtool_set_sg(dev, 0);
991 if (err)
992 return err;
993 }
994
995 return dev->ethtool_ops->set_tx_csum(dev, edata.data);
996}
97f8aefb 997EXPORT_SYMBOL(ethtool_op_set_tx_csum);
1da177e4 998
b240a0e5
HX		 999static int ethtool_set_rx_csum(struct net_device *dev, char __user *useraddr)
1000{
1001 struct ethtool_value edata;
1002
1003 if (!dev->ethtool_ops->set_rx_csum)
1004 return -EOPNOTSUPP;
1005
1006 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1007 return -EFAULT;
1008
1009 if (!edata.data && dev->ethtool_ops->set_sg)
1010 dev->features &= ~NETIF_F_GRO;
1011
1012 return dev->ethtool_ops->set_rx_csum(dev, edata.data);
1013}
1014
1da177e4
LT		 1015static int ethtool_set_sg(struct net_device *dev, char __user *useraddr)
1016{
1017 struct ethtool_value edata;
1018
1019 if (!dev->ethtool_ops->set_sg)
1020 return -EOPNOTSUPP;
1021
1022 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1023 return -EFAULT;
1024
4ec93edb 1025 if (edata.data &&
8648b305 1026 !(dev->features & NETIF_F_ALL_CSUM))
1da177e4
LT		 1027 return -EINVAL;
1028
1029 return __ethtool_set_sg(dev, edata.data);
1030}
1031
1da177e4
LT		 1032static int ethtool_set_tso(struct net_device *dev, char __user *useraddr)
1033{
1034 struct ethtool_value edata;
1035
1036 if (!dev->ethtool_ops->set_tso)
1037 return -EOPNOTSUPP;
1038
1039 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1040 return -EFAULT;
1041
1042 if (edata.data && !(dev->features & NETIF_F_SG))
1043 return -EINVAL;
1044
1045 return dev->ethtool_ops->set_tso(dev, edata.data);
1046}
1047
e89e9cf5
AR		 1048static int ethtool_set_ufo(struct net_device *dev, char __user *useraddr)
1049{
1050 struct ethtool_value edata;
1051
1052 if (!dev->ethtool_ops->set_ufo)
1053 return -EOPNOTSUPP;
1054 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1055 return -EFAULT;
1056 if (edata.data && !(dev->features & NETIF_F_SG))
1057 return -EINVAL;
1058 if (edata.data && !(dev->features & NETIF_F_HW_CSUM))
1059 return -EINVAL;
1060 return dev->ethtool_ops->set_ufo(dev, edata.data);
1061}
1062
37c3185a
HX		 1063static int ethtool_get_gso(struct net_device *dev, char __user *useraddr)
1064{
1065 struct ethtool_value edata = { ETHTOOL_GGSO };
1066
1067 edata.data = dev->features & NETIF_F_GSO;
1068 if (copy_to_user(useraddr, &edata, sizeof(edata)))
97f8aefb 1069 return -EFAULT;
37c3185a
HX		 1070 return 0;
1071}
1072
1073static int ethtool_set_gso(struct net_device *dev, char __user *useraddr)
1074{
1075 struct ethtool_value edata;
1076
1077 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1078 return -EFAULT;
1079 if (edata.data)
1080 dev->features |= NETIF_F_GSO;
1081 else
1082 dev->features &= ~NETIF_F_GSO;
1083 return 0;
1084}
1085
b240a0e5
HX		 1086static int ethtool_get_gro(struct net_device *dev, char __user *useraddr)
1087{
1088 struct ethtool_value edata = { ETHTOOL_GGRO };
1089
1090 edata.data = dev->features & NETIF_F_GRO;
1091 if (copy_to_user(useraddr, &edata, sizeof(edata)))
97f8aefb 1092 return -EFAULT;
b240a0e5
HX		 1093 return 0;
1094}
1095
1096static int ethtool_set_gro(struct net_device *dev, char __user *useraddr)
1097{
1098 struct ethtool_value edata;
1099
1100 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1101 return -EFAULT;
1102
1103 if (edata.data) {
1104 if (!dev->ethtool_ops->get_rx_csum ||
1105 !dev->ethtool_ops->get_rx_csum(dev))
1106 return -EINVAL;
1107 dev->features |= NETIF_F_GRO;
1108 } else
1109 dev->features &= ~NETIF_F_GRO;
1110
1111 return 0;
1112}
1113
1da177e4
LT		 1114static int ethtool_self_test(struct net_device *dev, char __user *useraddr)
1115{
1116 struct ethtool_test test;
76fd8593 1117 const struct ethtool_ops *ops = dev->ethtool_ops;
1da177e4 1118 u64 *data;
ff03d49f 1119 int ret, test_len;
1da177e4 1120
a9828ec6 1121 if (!ops->self_test || !ops->get_sset_count)
1da177e4
LT		 1122 return -EOPNOTSUPP;
1123
a9828ec6 1124 test_len = ops->get_sset_count(dev, ETH_SS_TEST);
ff03d49f
JG		 1125 if (test_len < 0)
1126 return test_len;
1127 WARN_ON(test_len == 0);
1128
1da177e4
LT		 1129 if (copy_from_user(&test, useraddr, sizeof(test)))
1130 return -EFAULT;
1131
ff03d49f
JG		 1132 test.len = test_len;
1133 data = kmalloc(test_len * sizeof(u64), GFP_USER);
1da177e4
LT		 1134 if (!data)
1135 return -ENOMEM;
1136
1137 ops->self_test(dev, &test, data);
1138
1139 ret = -EFAULT;
1140 if (copy_to_user(useraddr, &test, sizeof(test)))
1141 goto out;
1142 useraddr += sizeof(test);
1143 if (copy_to_user(useraddr, data, test.len * sizeof(u64)))
1144 goto out;
1145 ret = 0;
1146
1147 out:
1148 kfree(data);
1149 return ret;
1150}
1151
1152static int ethtool_get_strings(struct net_device *dev, void __user *useraddr)
1153{
1154 struct ethtool_gstrings gstrings;
76fd8593 1155 const struct ethtool_ops *ops = dev->ethtool_ops;
1da177e4
LT		 1156 u8 *data;
1157 int ret;
1158
a9828ec6 1159 if (!ops->get_strings || !ops->get_sset_count)
1da177e4
LT		 1160 return -EOPNOTSUPP;
1161
1162 if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
1163 return -EFAULT;
1164
a9828ec6
BH		 1165 ret = ops->get_sset_count(dev, gstrings.string_set);
1166 if (ret < 0)
1167 return ret;
1168
1169 gstrings.len = ret;
1da177e4
LT		 1170
1171 data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
1172 if (!data)
1173 return -ENOMEM;
1174
1175 ops->get_strings(dev, gstrings.string_set, data);
1176
1177 ret = -EFAULT;
1178 if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
1179 goto out;
1180 useraddr += sizeof(gstrings);
1181 if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
1182 goto out;
1183 ret = 0;
1184
1185 out:
1186 kfree(data);
1187 return ret;
1188}
1189
1190static int ethtool_phys_id(struct net_device *dev, void __user *useraddr)
1191{
1192 struct ethtool_value id;
1193
1194 if (!dev->ethtool_ops->phys_id)
1195 return -EOPNOTSUPP;
1196
1197 if (copy_from_user(&id, useraddr, sizeof(id)))
1198 return -EFAULT;
1199
1200 return dev->ethtool_ops->phys_id(dev, id.data);
1201}
1202
1203static int ethtool_get_stats(struct net_device *dev, void __user *useraddr)
1204{
1205 struct ethtool_stats stats;
76fd8593 1206 const struct ethtool_ops *ops = dev->ethtool_ops;
1da177e4 1207 u64 *data;
ff03d49f 1208 int ret, n_stats;
1da177e4 1209
a9828ec6 1210 if (!ops->get_ethtool_stats || !ops->get_sset_count)
1da177e4
LT		 1211 return -EOPNOTSUPP;
1212
a9828ec6 1213 n_stats = ops->get_sset_count(dev, ETH_SS_STATS);
ff03d49f
JG		 1214 if (n_stats < 0)
1215 return n_stats;
1216 WARN_ON(n_stats == 0);
1217
1da177e4
LT		 1218 if (copy_from_user(&stats, useraddr, sizeof(stats)))
1219 return -EFAULT;
1220
ff03d49f
JG		 1221 stats.n_stats = n_stats;
1222 data = kmalloc(n_stats * sizeof(u64), GFP_USER);
1da177e4
LT		 1223 if (!data)
1224 return -ENOMEM;
1225
1226 ops->get_ethtool_stats(dev, &stats, data);
1227
1228 ret = -EFAULT;
1229 if (copy_to_user(useraddr, &stats, sizeof(stats)))
1230 goto out;
1231 useraddr += sizeof(stats);
1232 if (copy_to_user(useraddr, data, stats.n_stats * sizeof(u64)))
1233 goto out;
1234 ret = 0;
1235
1236 out:
1237 kfree(data);
1238 return ret;
1239}
1240
0bf0519d 1241static int ethtool_get_perm_addr(struct net_device *dev, void __user *useraddr)
a6f9a705
JW		 1242{
1243 struct ethtool_perm_addr epaddr;
a6f9a705 1244
313674af 1245 if (copy_from_user(&epaddr, useraddr, sizeof(epaddr)))
a6f9a705
JW		 1246 return -EFAULT;
1247
313674af
MW		 1248 if (epaddr.size < dev->addr_len)
1249 return -ETOOSMALL;
1250 epaddr.size = dev->addr_len;
a6f9a705 1251
a6f9a705 1252 if (copy_to_user(useraddr, &epaddr, sizeof(epaddr)))
313674af 1253 return -EFAULT;
a6f9a705 1254 useraddr += sizeof(epaddr);
313674af
MW		 1255 if (copy_to_user(useraddr, dev->perm_addr, epaddr.size))
1256 return -EFAULT;
1257 return 0;
a6f9a705
JW		 1258}
1259
13c99b24
JG		 1260static int ethtool_get_value(struct net_device *dev, char __user *useraddr,
1261 u32 cmd, u32 (*actor)(struct net_device *))
3ae7c0b2 1262{
8e557421 1263 struct ethtool_value edata = { .cmd = cmd };
3ae7c0b2 1264
13c99b24 1265 if (!actor)
3ae7c0b2
JG		 1266 return -EOPNOTSUPP;
1267
13c99b24 1268 edata.data = actor(dev);
3ae7c0b2
JG		 1269
1270 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1271 return -EFAULT;
1272 return 0;
1273}
1274
13c99b24
JG		 1275static int ethtool_set_value_void(struct net_device *dev, char __user *useraddr,
1276 void (*actor)(struct net_device *, u32))
3ae7c0b2
JG		 1277{
1278 struct ethtool_value edata;
1279
13c99b24 1280 if (!actor)
3ae7c0b2
JG		 1281 return -EOPNOTSUPP;
1282
1283 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1284 return -EFAULT;
1285
13c99b24 1286 actor(dev, edata.data);
339bf024
JG		 1287 return 0;
1288}
1289
13c99b24
JG		 1290static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
1291 int (*actor)(struct net_device *, u32))
339bf024
JG		 1292{
1293 struct ethtool_value edata;
1294
13c99b24 1295 if (!actor)
339bf024
JG		 1296 return -EOPNOTSUPP;
1297
1298 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1299 return -EFAULT;
1300
13c99b24 1301 return actor(dev, edata.data);
339bf024
JG		 1302}
1303
97f8aefb 1304static noinline_for_stack int ethtool_flash_device(struct net_device *dev,
1305 char __user *useraddr)
05c6a8d7
AK		 1306{
1307 struct ethtool_flash efl;
1308
1309 if (copy_from_user(&efl, useraddr, sizeof(efl)))
1310 return -EFAULT;
1311
1312 if (!dev->ethtool_ops->flash_device)
1313 return -EOPNOTSUPP;
1314
1315 return dev->ethtool_ops->flash_device(dev, &efl);
1316}
1317
1da177e4
LT		 1318/* The main entry point in this file. Called from net/core/dev.c */
1319
881d966b 1320int dev_ethtool(struct net *net, struct ifreq *ifr)
1da177e4 1321{
881d966b 1322 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
1da177e4
LT		 1323 void __user *useraddr = ifr->ifr_data;
1324 u32 ethcmd;
1325 int rc;
81e81575 1326 unsigned long old_features;
1da177e4 1327
1da177e4
LT		 1328 if (!dev || !netif_device_present(dev))
1329 return -ENODEV;
1330
1331 if (!dev->ethtool_ops)
61a44b9c 1332 return -EOPNOTSUPP;
1da177e4 1333
97f8aefb 1334 if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
1da177e4
LT		 1335 return -EFAULT;
1336
75f3123c 1337 /* Allow some commands to be done by anyone */
97f8aefb 1338 switch (ethcmd) {
75f3123c 1339 case ETHTOOL_GDRVINFO:
75f3123c 1340 case ETHTOOL_GMSGLVL:
75f3123c
SH		 1341 case ETHTOOL_GCOALESCE:
1342 case ETHTOOL_GRINGPARAM:
1343 case ETHTOOL_GPAUSEPARAM:
1344 case ETHTOOL_GRXCSUM:
1345 case ETHTOOL_GTXCSUM:
1346 case ETHTOOL_GSG:
1347 case ETHTOOL_GSTRINGS:
75f3123c
SH		 1348 case ETHTOOL_GTSO:
1349 case ETHTOOL_GPERMADDR:
1350 case ETHTOOL_GUFO:
1351 case ETHTOOL_GGSO:
1cab819b 1352 case ETHTOOL_GGRO:
339bf024
JG		 1353 case ETHTOOL_GFLAGS:
1354 case ETHTOOL_GPFLAGS:
0853ad66 1355 case ETHTOOL_GRXFH:
59089d8d
SB		 1356 case ETHTOOL_GRXRINGS:
1357 case ETHTOOL_GRXCLSRLCNT:
1358 case ETHTOOL_GRXCLSRULE:
1359 case ETHTOOL_GRXCLSRLALL:
75f3123c
SH		 1360 break;
1361 default:
1362 if (!capable(CAP_NET_ADMIN))
1363 return -EPERM;
1364 }
1365
97f8aefb 1366 if (dev->ethtool_ops->begin) {
1367 rc = dev->ethtool_ops->begin(dev);
1368 if (rc < 0)
1da177e4 1369 return rc;
97f8aefb 1370 }
d8a33ac4
SH		 1371 old_features = dev->features;
1372
1da177e4
LT		 1373 switch (ethcmd) {
1374 case ETHTOOL_GSET:
1375 rc = ethtool_get_settings(dev, useraddr);
1376 break;
1377 case ETHTOOL_SSET:
1378 rc = ethtool_set_settings(dev, useraddr);
1379 break;
1380 case ETHTOOL_GDRVINFO:
1381 rc = ethtool_get_drvinfo(dev, useraddr);
1da177e4
LT		 1382 break;
1383 case ETHTOOL_GREGS:
1384 rc = ethtool_get_regs(dev, useraddr);
1385 break;
1386 case ETHTOOL_GWOL:
1387 rc = ethtool_get_wol(dev, useraddr);
1388 break;
1389 case ETHTOOL_SWOL:
1390 rc = ethtool_set_wol(dev, useraddr);
1391 break;
1392 case ETHTOOL_GMSGLVL:
13c99b24
JG		 1393 rc = ethtool_get_value(dev, useraddr, ethcmd,
1394 dev->ethtool_ops->get_msglevel);
1da177e4
LT		 1395 break;
1396 case ETHTOOL_SMSGLVL:
13c99b24
JG		 1397 rc = ethtool_set_value_void(dev, useraddr,
1398 dev->ethtool_ops->set_msglevel);
1da177e4
LT		 1399 break;
1400 case ETHTOOL_NWAY_RST:
1401 rc = ethtool_nway_reset(dev);
1402 break;
1403 case ETHTOOL_GLINK:
13c99b24
JG		 1404 rc = ethtool_get_value(dev, useraddr, ethcmd,
1405 dev->ethtool_ops->get_link);
1da177e4
LT		 1406 break;
1407 case ETHTOOL_GEEPROM:
1408 rc = ethtool_get_eeprom(dev, useraddr);
1409 break;
1410 case ETHTOOL_SEEPROM:
1411 rc = ethtool_set_eeprom(dev, useraddr);
1412 break;
1413 case ETHTOOL_GCOALESCE:
1414 rc = ethtool_get_coalesce(dev, useraddr);
1415 break;
1416 case ETHTOOL_SCOALESCE:
1417 rc = ethtool_set_coalesce(dev, useraddr);
1418 break;
1419 case ETHTOOL_GRINGPARAM:
1420 rc = ethtool_get_ringparam(dev, useraddr);
1421 break;
1422 case ETHTOOL_SRINGPARAM:
1423 rc = ethtool_set_ringparam(dev, useraddr);
1424 break;
1425 case ETHTOOL_GPAUSEPARAM:
1426 rc = ethtool_get_pauseparam(dev, useraddr);
1427 break;
1428 case ETHTOOL_SPAUSEPARAM:
1429 rc = ethtool_set_pauseparam(dev, useraddr);
1430 break;
1431 case ETHTOOL_GRXCSUM:
13c99b24 1432 rc = ethtool_get_value(dev, useraddr, ethcmd,
1896e61f
SS		 1433 (dev->ethtool_ops->get_rx_csum ?
1434 dev->ethtool_ops->get_rx_csum :
1435 ethtool_op_get_rx_csum));
1da177e4
LT		 1436 break;
1437 case ETHTOOL_SRXCSUM:
b240a0e5 1438 rc = ethtool_set_rx_csum(dev, useraddr);
1da177e4
LT		 1439 break;
1440 case ETHTOOL_GTXCSUM:
13c99b24 1441 rc = ethtool_get_value(dev, useraddr, ethcmd,
88d3aafd
JG		 1442 (dev->ethtool_ops->get_tx_csum ?
1443 dev->ethtool_ops->get_tx_csum :
1444 ethtool_op_get_tx_csum));
1da177e4
LT		 1445 break;
1446 case ETHTOOL_STXCSUM:
1447 rc = ethtool_set_tx_csum(dev, useraddr);
1448 break;
1449 case ETHTOOL_GSG:
13c99b24 1450 rc = ethtool_get_value(dev, useraddr, ethcmd,
88d3aafd
JG		 1451 (dev->ethtool_ops->get_sg ?
1452 dev->ethtool_ops->get_sg :
1453 ethtool_op_get_sg));
1da177e4
LT		 1454 break;
1455 case ETHTOOL_SSG:
1456 rc = ethtool_set_sg(dev, useraddr);
1457 break;
1458 case ETHTOOL_GTSO:
13c99b24 1459 rc = ethtool_get_value(dev, useraddr, ethcmd,
88d3aafd
JG		 1460 (dev->ethtool_ops->get_tso ?
1461 dev->ethtool_ops->get_tso :
1462 ethtool_op_get_tso));
1da177e4
LT		 1463 break;
1464 case ETHTOOL_STSO:
1465 rc = ethtool_set_tso(dev, useraddr);
1466 break;
1467 case ETHTOOL_TEST:
1468 rc = ethtool_self_test(dev, useraddr);
1469 break;
1470 case ETHTOOL_GSTRINGS:
1471 rc = ethtool_get_strings(dev, useraddr);
1472 break;
1473 case ETHTOOL_PHYS_ID:
1474 rc = ethtool_phys_id(dev, useraddr);
1475 break;
1476 case ETHTOOL_GSTATS:
1477 rc = ethtool_get_stats(dev, useraddr);
1478 break;
a6f9a705
JW		 1479 case ETHTOOL_GPERMADDR:
1480 rc = ethtool_get_perm_addr(dev, useraddr);
1481 break;
e89e9cf5 1482 case ETHTOOL_GUFO:
13c99b24 1483 rc = ethtool_get_value(dev, useraddr, ethcmd,
88d3aafd
JG		 1484 (dev->ethtool_ops->get_ufo ?
1485 dev->ethtool_ops->get_ufo :
1486 ethtool_op_get_ufo));
e89e9cf5
AR		 1487 break;
1488 case ETHTOOL_SUFO:
1489 rc = ethtool_set_ufo(dev, useraddr);
1490 break;
37c3185a
HX		 1491 case ETHTOOL_GGSO:
1492 rc = ethtool_get_gso(dev, useraddr);
1493 break;
1494 case ETHTOOL_SGSO:
1495 rc = ethtool_set_gso(dev, useraddr);
1496 break;
3ae7c0b2 1497 case ETHTOOL_GFLAGS:
13c99b24 1498 rc = ethtool_get_value(dev, useraddr, ethcmd,
1896e61f
SS		 1499 (dev->ethtool_ops->get_flags ?
1500 dev->ethtool_ops->get_flags :
1501 ethtool_op_get_flags));
3ae7c0b2
JG		 1502 break;
1503 case ETHTOOL_SFLAGS:
13c99b24
JG		 1504 rc = ethtool_set_value(dev, useraddr,
1505 dev->ethtool_ops->set_flags);
3ae7c0b2 1506 break;
339bf024 1507 case ETHTOOL_GPFLAGS:
13c99b24
JG		 1508 rc = ethtool_get_value(dev, useraddr, ethcmd,
1509 dev->ethtool_ops->get_priv_flags);
339bf024
JG		 1510 break;
1511 case ETHTOOL_SPFLAGS:
13c99b24
JG		 1512 rc = ethtool_set_value(dev, useraddr,
1513 dev->ethtool_ops->set_priv_flags);
339bf024 1514 break;
0853ad66 1515 case ETHTOOL_GRXFH:
59089d8d
SB		 1516 case ETHTOOL_GRXRINGS:
1517 case ETHTOOL_GRXCLSRLCNT:
1518 case ETHTOOL_GRXCLSRULE:
1519 case ETHTOOL_GRXCLSRLALL:
1520 rc = ethtool_get_rxnfc(dev, useraddr);
0853ad66
SB		 1521 break;
1522 case ETHTOOL_SRXFH:
59089d8d
SB		 1523 case ETHTOOL_SRXCLSRLDEL:
1524 case ETHTOOL_SRXCLSRLINS:
1525 rc = ethtool_set_rxnfc(dev, useraddr);
0853ad66 1526 break;
b240a0e5
HX		 1527 case ETHTOOL_GGRO:
1528 rc = ethtool_get_gro(dev, useraddr);
1529 break;
1530 case ETHTOOL_SGRO:
1531 rc = ethtool_set_gro(dev, useraddr);
1532 break;
05c6a8d7
AK		 1533 case ETHTOOL_FLASHDEV:
1534 rc = ethtool_flash_device(dev, useraddr);
1535 break;
d73d3a8c
BH		 1536 case ETHTOOL_RESET:
1537 rc = ethtool_reset(dev, useraddr);
1538 break;
15682bc4
PWJ		 1539 case ETHTOOL_SRXNTUPLE:
1540 rc = ethtool_set_rx_ntuple(dev, useraddr);
1541 break;
1542 case ETHTOOL_GRXNTUPLE:
1543 rc = ethtool_get_rx_ntuple(dev, useraddr);
1544 break;
723b2f57
JG		 1545 case ETHTOOL_GSSET_INFO:
1546 rc = ethtool_get_sset_info(dev, useraddr);
1547 break;
1da177e4 1548 default:
61a44b9c 1549 rc = -EOPNOTSUPP;
1da177e4 1550 }
4ec93edb 1551
e71a4783 1552 if (dev->ethtool_ops->complete)
1da177e4 1553 dev->ethtool_ops->complete(dev);
d8a33ac4
SH		 1554
1555 if (old_features != dev->features)
1556 netdev_features_change(dev);
1557
1da177e4 1558 return rc;
1da177e4 1559}
Linux kernel - Deliverables
This page took 0.836606 seconds and 5 git commands to generate.