?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
net: implement dev_disable_lro() hw_features compatibility
[linux-2.6/libata-dev.git] / net / core / ethtool.c
blob24bd57493c0d602d38259b6111a6780611ca46fd
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
6 * the information ethtool needs.
7 *
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.
12 */
13
14 #include <linux/module.h>
15 #include <linux/types.h>
16 #include <linux/capability.h>
17 #include <linux/errno.h>
18 #include <linux/ethtool.h>
19 #include <linux/netdevice.h>
20 #include <linux/bitops.h>
21 #include <linux/uaccess.h>
22 #include <linux/vmalloc.h>
23 #include <linux/slab.h>
24
25 /*
26 * Some useful ethtool_ops methods that're device independent.
27 * If we find that all drivers want to do the same thing here,
28 * we can turn these into dev_() function calls.
29 */
30
31 u32 ethtool_op_get_link(struct net_device *dev)
32 {
33 return netif_carrier_ok(dev) ? 1 : 0;
34 }
35 EXPORT_SYMBOL(ethtool_op_get_link);
36
37 u32 ethtool_op_get_tx_csum(struct net_device *dev)
38 {
39 return (dev->features & NETIF_F_ALL_CSUM) != 0;
40 }
41 EXPORT_SYMBOL(ethtool_op_get_tx_csum);
42
43 int ethtool_op_set_tx_csum(struct net_device *dev, u32 data)
44 {
45 if (data)
46 dev->features |= NETIF_F_IP_CSUM;
47 else
48 dev->features &= ~NETIF_F_IP_CSUM;
49
50 return 0;
51 }
52 EXPORT_SYMBOL(ethtool_op_set_tx_csum);
53
54 int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data)
55 {
56 if (data)
57 dev->features |= NETIF_F_HW_CSUM;
58 else
59 dev->features &= ~NETIF_F_HW_CSUM;
60
61 return 0;
62 }
63 EXPORT_SYMBOL(ethtool_op_set_tx_hw_csum);
64
65 int ethtool_op_set_tx_ipv6_csum(struct net_device *dev, u32 data)
66 {
67 if (data)
68 dev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
69 else
70 dev->features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
71
72 return 0;
73 }
74 EXPORT_SYMBOL(ethtool_op_set_tx_ipv6_csum);
75
76 u32 ethtool_op_get_sg(struct net_device *dev)
77 {
78 return (dev->features & NETIF_F_SG) != 0;
79 }
80 EXPORT_SYMBOL(ethtool_op_get_sg);
81
82 int ethtool_op_set_sg(struct net_device *dev, u32 data)
83 {
84 if (data)
85 dev->features |= NETIF_F_SG;
86 else
87 dev->features &= ~NETIF_F_SG;
88
89 return 0;
90 }
91 EXPORT_SYMBOL(ethtool_op_set_sg);
92
93 u32 ethtool_op_get_tso(struct net_device *dev)
94 {
95 return (dev->features & NETIF_F_TSO) != 0;
96 }
97 EXPORT_SYMBOL(ethtool_op_get_tso);
98
99 int ethtool_op_set_tso(struct net_device *dev, u32 data)
100 {
101 if (data)
102 dev->features |= NETIF_F_TSO;
103 else
104 dev->features &= ~NETIF_F_TSO;
105
106 return 0;
107 }
108 EXPORT_SYMBOL(ethtool_op_set_tso);
109
110 u32 ethtool_op_get_ufo(struct net_device *dev)
111 {
112 return (dev->features & NETIF_F_UFO) != 0;
113 }
114 EXPORT_SYMBOL(ethtool_op_get_ufo);
115
116 int ethtool_op_set_ufo(struct net_device *dev, u32 data)
117 {
118 if (data)
119 dev->features |= NETIF_F_UFO;
120 else
121 dev->features &= ~NETIF_F_UFO;
122 return 0;
123 }
124 EXPORT_SYMBOL(ethtool_op_set_ufo);
125
126 /* the following list of flags are the same as their associated
127 * NETIF_F_xxx values in include/linux/netdevice.h
128 */
129 static const u32 flags_dup_features =
130 (ETH_FLAG_LRO | ETH_FLAG_RXVLAN | ETH_FLAG_TXVLAN | ETH_FLAG_NTUPLE |
131 ETH_FLAG_RXHASH);
132
133 u32 ethtool_op_get_flags(struct net_device *dev)
134 {
135 /* in the future, this function will probably contain additional
136 * handling for flags which are not so easily handled
137 * by a simple masking operation
138 */
139
140 return dev->features & flags_dup_features;
141 }
142 EXPORT_SYMBOL(ethtool_op_get_flags);
143
144 int ethtool_op_set_flags(struct net_device *dev, u32 data, u32 supported)
145 {
146 if (data & ~supported)
147 return -EINVAL;
148
149 dev->features = ((dev->features & ~flags_dup_features) |
150 (data & flags_dup_features));
151 return 0;
152 }
153 EXPORT_SYMBOL(ethtool_op_set_flags);
154
155 void ethtool_ntuple_flush(struct net_device *dev)
156 {
157 struct ethtool_rx_ntuple_flow_spec_container *fsc, *f;
158
159 list_for_each_entry_safe(fsc, f, &dev->ethtool_ntuple_list.list, list) {
160 list_del(&fsc->list);
161 kfree(fsc);
162 }
163 dev->ethtool_ntuple_list.count = 0;
164 }
165 EXPORT_SYMBOL(ethtool_ntuple_flush);
166
167 /* Handlers for each ethtool command */
168
169 #define ETHTOOL_DEV_FEATURE_WORDS 1
170
171 static void ethtool_get_features_compat(struct net_device *dev,
172 struct ethtool_get_features_block *features)
173 {
174 if (!dev->ethtool_ops)
175 return;
176
177 /* getting RX checksum */
178 if (dev->ethtool_ops->get_rx_csum)
179 if (dev->ethtool_ops->get_rx_csum(dev))
180 features[0].active |= NETIF_F_RXCSUM;
181
182 /* mark legacy-changeable features */
183 if (dev->ethtool_ops->set_sg)
184 features[0].available |= NETIF_F_SG;
185 if (dev->ethtool_ops->set_tx_csum)
186 features[0].available |= NETIF_F_ALL_CSUM;
187 if (dev->ethtool_ops->set_tso)
188 features[0].available |= NETIF_F_ALL_TSO;
189 if (dev->ethtool_ops->set_rx_csum)
190 features[0].available |= NETIF_F_RXCSUM;
191 if (dev->ethtool_ops->set_flags)
192 features[0].available |= flags_dup_features;
193 }
194
195 static int ethtool_set_feature_compat(struct net_device *dev,
196 int (*legacy_set)(struct net_device *, u32),
197 struct ethtool_set_features_block *features, u32 mask)
198 {
199 u32 do_set;
200
201 if (!legacy_set)
202 return 0;
203
204 if (!(features[0].valid & mask))
205 return 0;
206
207 features[0].valid &= ~mask;
208
209 do_set = !!(features[0].requested & mask);
210
211 if (legacy_set(dev, do_set) < 0)
212 netdev_info(dev,
213 "Legacy feature change (%s) failed for 0x%08x\n",
214 do_set ? "set" : "clear", mask);
215
216 return 1;
217 }
218
219 static int ethtool_set_features_compat(struct net_device *dev,
220 struct ethtool_set_features_block *features)
221 {
222 int compat;
223
224 if (!dev->ethtool_ops)
225 return 0;
226
227 compat = ethtool_set_feature_compat(dev, dev->ethtool_ops->set_sg,
228 features, NETIF_F_SG);
229 compat |= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_tx_csum,
230 features, NETIF_F_ALL_CSUM);
231 compat |= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_tso,
232 features, NETIF_F_ALL_TSO);
233 compat |= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_rx_csum,
234 features, NETIF_F_RXCSUM);
235 compat |= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_flags,
236 features, flags_dup_features);
237
238 return compat;
239 }
240
241 static int ethtool_get_features(struct net_device *dev, void __user *useraddr)
242 {
243 struct ethtool_gfeatures cmd = {
244 .cmd = ETHTOOL_GFEATURES,
245 .size = ETHTOOL_DEV_FEATURE_WORDS,
246 };
247 struct ethtool_get_features_block features[ETHTOOL_DEV_FEATURE_WORDS] = {
248 {
249 .available = dev->hw_features,
250 .requested = dev->wanted_features,
251 .active = dev->features,
252 .never_changed = NETIF_F_NEVER_CHANGE,
253 },
254 };
255 u32 __user *sizeaddr;
256 u32 copy_size;
257
258 ethtool_get_features_compat(dev, features);
259
260 sizeaddr = useraddr + offsetof(struct ethtool_gfeatures, size);
261 if (get_user(copy_size, sizeaddr))
262 return -EFAULT;
263
264 if (copy_size > ETHTOOL_DEV_FEATURE_WORDS)
265 copy_size = ETHTOOL_DEV_FEATURE_WORDS;
266
267 if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
268 return -EFAULT;
269 useraddr += sizeof(cmd);
270 if (copy_to_user(useraddr, features, copy_size * sizeof(*features)))
271 return -EFAULT;
272
273 return 0;
274 }
275
276 static int ethtool_set_features(struct net_device *dev, void __user *useraddr)
277 {
278 struct ethtool_sfeatures cmd;
279 struct ethtool_set_features_block features[ETHTOOL_DEV_FEATURE_WORDS];
280 int ret = 0;
281
282 if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
283 return -EFAULT;
284 useraddr += sizeof(cmd);
285
286 if (cmd.size != ETHTOOL_DEV_FEATURE_WORDS)
287 return -EINVAL;
288
289 if (copy_from_user(features, useraddr, sizeof(features)))
290 return -EFAULT;
291
292 if (features[0].valid & ~NETIF_F_ETHTOOL_BITS)
293 return -EINVAL;
294
295 if (ethtool_set_features_compat(dev, features))
296 ret |= ETHTOOL_F_COMPAT;
297
298 if (features[0].valid & ~dev->hw_features) {
299 features[0].valid &= dev->hw_features;
300 ret |= ETHTOOL_F_UNSUPPORTED;
301 }
302
303 dev->wanted_features &= ~features[0].valid;
304 dev->wanted_features |= features[0].valid & features[0].requested;
305 netdev_update_features(dev);
306
307 if ((dev->wanted_features ^ dev->features) & features[0].valid)
308 ret |= ETHTOOL_F_WISH;
309
310 return ret;
311 }
312
313 static const char netdev_features_strings[ETHTOOL_DEV_FEATURE_WORDS * 32][ETH_GSTRING_LEN] = {
314 /* NETIF_F_SG */ "tx-scatter-gather",
315 /* NETIF_F_IP_CSUM */ "tx-checksum-ipv4",
316 /* NETIF_F_NO_CSUM */ "tx-checksum-unneeded",
317 /* NETIF_F_HW_CSUM */ "tx-checksum-ip-generic",
318 /* NETIF_F_IPV6_CSUM */ "tx_checksum-ipv6",
319 /* NETIF_F_HIGHDMA */ "highdma",
320 /* NETIF_F_FRAGLIST */ "tx-scatter-gather-fraglist",
321 /* NETIF_F_HW_VLAN_TX */ "tx-vlan-hw-insert",
322
323 /* NETIF_F_HW_VLAN_RX */ "rx-vlan-hw-parse",
324 /* NETIF_F_HW_VLAN_FILTER */ "rx-vlan-filter",
325 /* NETIF_F_VLAN_CHALLENGED */ "vlan-challenged",
326 /* NETIF_F_GSO */ "tx-generic-segmentation",
327 /* NETIF_F_LLTX */ "tx-lockless",
328 /* NETIF_F_NETNS_LOCAL */ "netns-local",
329 /* NETIF_F_GRO */ "rx-gro",
330 /* NETIF_F_LRO */ "rx-lro",
331
332 /* NETIF_F_TSO */ "tx-tcp-segmentation",
333 /* NETIF_F_UFO */ "tx-udp-fragmentation",
334 /* NETIF_F_GSO_ROBUST */ "tx-gso-robust",
335 /* NETIF_F_TSO_ECN */ "tx-tcp-ecn-segmentation",
336 /* NETIF_F_TSO6 */ "tx-tcp6-segmentation",
337 /* NETIF_F_FSO */ "tx-fcoe-segmentation",
338 "",
339 "",
340
341 /* NETIF_F_FCOE_CRC */ "tx-checksum-fcoe-crc",
342 /* NETIF_F_SCTP_CSUM */ "tx-checksum-sctp",
343 /* NETIF_F_FCOE_MTU */ "fcoe-mtu",
344 /* NETIF_F_NTUPLE */ "rx-ntuple-filter",
345 /* NETIF_F_RXHASH */ "rx-hashing",
346 /* NETIF_F_RXCSUM */ "rx-checksum",
347 "",
348 "",
349 };
350
351 static int __ethtool_get_sset_count(struct net_device *dev, int sset)
352 {
353 const struct ethtool_ops *ops = dev->ethtool_ops;
354
355 if (sset == ETH_SS_FEATURES)
356 return ARRAY_SIZE(netdev_features_strings);
357
358 if (ops && ops->get_sset_count && ops->get_strings)
359 return ops->get_sset_count(dev, sset);
360 else
361 return -EOPNOTSUPP;
362 }
363
364 static void __ethtool_get_strings(struct net_device *dev,
365 u32 stringset, u8 *data)
366 {
367 const struct ethtool_ops *ops = dev->ethtool_ops;
368
369 if (stringset == ETH_SS_FEATURES)
370 memcpy(data, netdev_features_strings,
371 sizeof(netdev_features_strings));
372 else
373 /* ops->get_strings is valid because checked earlier */
374 ops->get_strings(dev, stringset, data);
375 }
376
377 static u32 ethtool_get_feature_mask(u32 eth_cmd)
378 {
379 /* feature masks of legacy discrete ethtool ops */
380
381 switch (eth_cmd) {
382 case ETHTOOL_GTXCSUM:
383 case ETHTOOL_STXCSUM:
384 return NETIF_F_ALL_CSUM | NETIF_F_SCTP_CSUM;
385 case ETHTOOL_GRXCSUM:
386 case ETHTOOL_SRXCSUM:
387 return NETIF_F_RXCSUM;
388 case ETHTOOL_GSG:
389 case ETHTOOL_SSG:
390 return NETIF_F_SG;
391 case ETHTOOL_GTSO:
392 case ETHTOOL_STSO:
393 return NETIF_F_ALL_TSO;
394 case ETHTOOL_GUFO:
395 case ETHTOOL_SUFO:
396 return NETIF_F_UFO;
397 case ETHTOOL_GGSO:
398 case ETHTOOL_SGSO:
399 return NETIF_F_GSO;
400 case ETHTOOL_GGRO:
401 case ETHTOOL_SGRO:
402 return NETIF_F_GRO;
403 default:
404 BUG();
405 }
406 }
407
408 static void *__ethtool_get_one_feature_actor(struct net_device *dev, u32 ethcmd)
409 {
410 const struct ethtool_ops *ops = dev->ethtool_ops;
411
412 if (!ops)
413 return NULL;
414
415 switch (ethcmd) {
416 case ETHTOOL_GTXCSUM:
417 return ops->get_tx_csum;
418 case ETHTOOL_GRXCSUM:
419 return ops->get_rx_csum;
420 case ETHTOOL_SSG:
421 return ops->get_sg;
422 case ETHTOOL_STSO:
423 return ops->get_tso;
424 case ETHTOOL_SUFO:
425 return ops->get_ufo;
426 default:
427 return NULL;
428 }
429 }
430
431 static u32 __ethtool_get_rx_csum_oldbug(struct net_device *dev)
432 {
433 return !!(dev->features & NETIF_F_ALL_CSUM);
434 }
435
436 static int ethtool_get_one_feature(struct net_device *dev,
437 char __user *useraddr, u32 ethcmd)
438 {
439 u32 mask = ethtool_get_feature_mask(ethcmd);
440 struct ethtool_value edata = {
441 .cmd = ethcmd,
442 .data = !!(dev->features & mask),
443 };
444
445 /* compatibility with discrete get_ ops */
446 if (!(dev->hw_features & mask)) {
447 u32 (*actor)(struct net_device *);
448
449 actor = __ethtool_get_one_feature_actor(dev, ethcmd);
450
451 /* bug compatibility with old get_rx_csum */
452 if (ethcmd == ETHTOOL_GRXCSUM && !actor)
453 actor = __ethtool_get_rx_csum_oldbug;
454
455 if (actor)
456 edata.data = actor(dev);
457 }
458
459 if (copy_to_user(useraddr, &edata, sizeof(edata)))
460 return -EFAULT;
461 return 0;
462 }
463
464 static int __ethtool_set_tx_csum(struct net_device *dev, u32 data);
465 static int __ethtool_set_rx_csum(struct net_device *dev, u32 data);
466 static int __ethtool_set_sg(struct net_device *dev, u32 data);
467 static int __ethtool_set_tso(struct net_device *dev, u32 data);
468 static int __ethtool_set_ufo(struct net_device *dev, u32 data);
469
470 static int ethtool_set_one_feature(struct net_device *dev,
471 void __user *useraddr, u32 ethcmd)
472 {
473 struct ethtool_value edata;
474 u32 mask;
475
476 if (copy_from_user(&edata, useraddr, sizeof(edata)))
477 return -EFAULT;
478
479 mask = ethtool_get_feature_mask(ethcmd);
480 mask &= dev->hw_features;
481 if (mask) {
482 if (edata.data)
483 dev->wanted_features |= mask;
484 else
485 dev->wanted_features &= ~mask;
486
487 netdev_update_features(dev);
488 return 0;
489 }
490
491 /* Driver is not converted to ndo_fix_features or does not
492 * support changing this offload. In the latter case it won't
493 * have corresponding ethtool_ops field set.
494 *
495 * Following part is to be removed after all drivers advertise
496 * their changeable features in netdev->hw_features and stop
497 * using discrete offload setting ops.
498 */
499
500 switch (ethcmd) {
501 case ETHTOOL_STXCSUM:
502 return __ethtool_set_tx_csum(dev, edata.data);
503 case ETHTOOL_SRXCSUM:
504 return __ethtool_set_rx_csum(dev, edata.data);
505 case ETHTOOL_SSG:
506 return __ethtool_set_sg(dev, edata.data);
507 case ETHTOOL_STSO:
508 return __ethtool_set_tso(dev, edata.data);
509 case ETHTOOL_SUFO:
510 return __ethtool_set_ufo(dev, edata.data);
511 default:
512 return -EOPNOTSUPP;
513 }
514 }
515
516 int __ethtool_set_flags(struct net_device *dev, u32 data)
517 {
518 u32 changed;
519
520 if (data & ~flags_dup_features)
521 return -EINVAL;
522
523 /* legacy set_flags() op */
524 if (dev->ethtool_ops->set_flags) {
525 if (unlikely(dev->hw_features & flags_dup_features))
526 netdev_warn(dev,
527 "driver BUG: mixed hw_features and set_flags()\n");
528 return dev->ethtool_ops->set_flags(dev, data);
529 }
530
531 /* allow changing only bits set in hw_features */
532 changed = (data ^ dev->wanted_features) & flags_dup_features;
533 if (changed & ~dev->hw_features)
534 return (changed & dev->hw_features) ? -EINVAL : -EOPNOTSUPP;
535
536 dev->wanted_features =
537 (dev->wanted_features & ~changed) | data;
538
539 netdev_update_features(dev);
540
541 return 0;
542 }
543
544 static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
545 {
546 struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET };
547 int err;
548
549 if (!dev->ethtool_ops->get_settings)
550 return -EOPNOTSUPP;
551
552 err = dev->ethtool_ops->get_settings(dev, &cmd);
553 if (err < 0)
554 return err;
555
556 if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
557 return -EFAULT;
558 return 0;
559 }
560
561 static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
562 {
563 struct ethtool_cmd cmd;
564
565 if (!dev->ethtool_ops->set_settings)
566 return -EOPNOTSUPP;
567
568 if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
569 return -EFAULT;
570
571 return dev->ethtool_ops->set_settings(dev, &cmd);
572 }
573
574 static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev,
575 void __user *useraddr)
576 {
577 struct ethtool_drvinfo info;
578 const struct ethtool_ops *ops = dev->ethtool_ops;
579
580 memset(&info, 0, sizeof(info));
581 info.cmd = ETHTOOL_GDRVINFO;
582 if (ops && ops->get_drvinfo) {
583 ops->get_drvinfo(dev, &info);
584 } else if (dev->dev.parent && dev->dev.parent->driver) {
585 strlcpy(info.bus_info, dev_name(dev->dev.parent),
586 sizeof(info.bus_info));
587 strlcpy(info.driver, dev->dev.parent->driver->name,
588 sizeof(info.driver));
589 } else {
590 return -EOPNOTSUPP;
591 }
592
593 /*
594 * this method of obtaining string set info is deprecated;
595 * Use ETHTOOL_GSSET_INFO instead.
596 */
597 if (ops && ops->get_sset_count) {
598 int rc;
599
600 rc = ops->get_sset_count(dev, ETH_SS_TEST);
601 if (rc >= 0)
602 info.testinfo_len = rc;
603 rc = ops->get_sset_count(dev, ETH_SS_STATS);
604 if (rc >= 0)
605 info.n_stats = rc;
606 rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);
607 if (rc >= 0)
608 info.n_priv_flags = rc;
609 }
610 if (ops && ops->get_regs_len)
611 info.regdump_len = ops->get_regs_len(dev);
612 if (ops && ops->get_eeprom_len)
613 info.eedump_len = ops->get_eeprom_len(dev);
614
615 if (copy_to_user(useraddr, &info, sizeof(info)))
616 return -EFAULT;
617 return 0;
618 }
619
620 static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,
621 void __user *useraddr)
622 {
623 struct ethtool_sset_info info;
624 u64 sset_mask;
625 int i, idx = 0, n_bits = 0, ret, rc;
626 u32 *info_buf = NULL;
627
628 if (copy_from_user(&info, useraddr, sizeof(info)))
629 return -EFAULT;
630
631 /* store copy of mask, because we zero struct later on */
632 sset_mask = info.sset_mask;
633 if (!sset_mask)
634 return 0;
635
636 /* calculate size of return buffer */
637 n_bits = hweight64(sset_mask);
638
639 memset(&info, 0, sizeof(info));
640 info.cmd = ETHTOOL_GSSET_INFO;
641
642 info_buf = kzalloc(n_bits * sizeof(u32), GFP_USER);
643 if (!info_buf)
644 return -ENOMEM;
645
646 /*
647 * fill return buffer based on input bitmask and successful
648 * get_sset_count return
649 */
650 for (i = 0; i < 64; i++) {
651 if (!(sset_mask & (1ULL << i)))
652 continue;
653
654 rc = __ethtool_get_sset_count(dev, i);
655 if (rc >= 0) {
656 info.sset_mask |= (1ULL << i);
657 info_buf[idx++] = rc;
658 }
659 }
660
661 ret = -EFAULT;
662 if (copy_to_user(useraddr, &info, sizeof(info)))
663 goto out;
664
665 useraddr += offsetof(struct ethtool_sset_info, data);
666 if (copy_to_user(useraddr, info_buf, idx * sizeof(u32)))
667 goto out;
668
669 ret = 0;
670
671 out:
672 kfree(info_buf);
673 return ret;
674 }
675
676 static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev,
677 u32 cmd, void __user *useraddr)
678 {
679 struct ethtool_rxnfc info;
680 size_t info_size = sizeof(info);
681
682 if (!dev->ethtool_ops->set_rxnfc)
683 return -EOPNOTSUPP;
684
685 /* struct ethtool_rxnfc was originally defined for
686 * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
687 * members. User-space might still be using that
688 * definition. */
689 if (cmd == ETHTOOL_SRXFH)
690 info_size = (offsetof(struct ethtool_rxnfc, data) +
691 sizeof(info.data));
692
693 if (copy_from_user(&info, useraddr, info_size))
694 return -EFAULT;
695
696 return dev->ethtool_ops->set_rxnfc(dev, &info);
697 }
698
699 static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev,
700 u32 cmd, void __user *useraddr)
701 {
702 struct ethtool_rxnfc info;
703 size_t info_size = sizeof(info);
704 const struct ethtool_ops *ops = dev->ethtool_ops;
705 int ret;
706 void *rule_buf = NULL;
707
708 if (!ops->get_rxnfc)
709 return -EOPNOTSUPP;
710
711 /* struct ethtool_rxnfc was originally defined for
712 * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
713 * members. User-space might still be using that
714 * definition. */
715 if (cmd == ETHTOOL_GRXFH)
716 info_size = (offsetof(struct ethtool_rxnfc, data) +
717 sizeof(info.data));
718
719 if (copy_from_user(&info, useraddr, info_size))
720 return -EFAULT;
721
722 if (info.cmd == ETHTOOL_GRXCLSRLALL) {
723 if (info.rule_cnt > 0) {
724 if (info.rule_cnt <= KMALLOC_MAX_SIZE / sizeof(u32))
725 rule_buf = kzalloc(info.rule_cnt * sizeof(u32),
726 GFP_USER);
727 if (!rule_buf)
728 return -ENOMEM;
729 }
730 }
731
732 ret = ops->get_rxnfc(dev, &info, rule_buf);
733 if (ret < 0)
734 goto err_out;
735
736 ret = -EFAULT;
737 if (copy_to_user(useraddr, &info, info_size))
738 goto err_out;
739
740 if (rule_buf) {
741 useraddr += offsetof(struct ethtool_rxnfc, rule_locs);
742 if (copy_to_user(useraddr, rule_buf,
743 info.rule_cnt * sizeof(u32)))
744 goto err_out;
745 }
746 ret = 0;
747
748 err_out:
749 kfree(rule_buf);
750
751 return ret;
752 }
753
754 static noinline_for_stack int ethtool_get_rxfh_indir(struct net_device *dev,
755 void __user *useraddr)
756 {
757 struct ethtool_rxfh_indir *indir;
758 u32 table_size;
759 size_t full_size;
760 int ret;
761
762 if (!dev->ethtool_ops->get_rxfh_indir)
763 return -EOPNOTSUPP;
764
765 if (copy_from_user(&table_size,
766 useraddr + offsetof(struct ethtool_rxfh_indir, size),
767 sizeof(table_size)))
768 return -EFAULT;
769
770 if (table_size >
771 (KMALLOC_MAX_SIZE - sizeof(*indir)) / sizeof(*indir->ring_index))
772 return -ENOMEM;
773 full_size = sizeof(*indir) + sizeof(*indir->ring_index) * table_size;
774 indir = kzalloc(full_size, GFP_USER);
775 if (!indir)
776 return -ENOMEM;
777
778 indir->cmd = ETHTOOL_GRXFHINDIR;
779 indir->size = table_size;
780 ret = dev->ethtool_ops->get_rxfh_indir(dev, indir);
781 if (ret)
782 goto out;
783
784 if (copy_to_user(useraddr, indir, full_size))
785 ret = -EFAULT;
786
787 out:
788 kfree(indir);
789 return ret;
790 }
791
792 static noinline_for_stack int ethtool_set_rxfh_indir(struct net_device *dev,
793 void __user *useraddr)
794 {
795 struct ethtool_rxfh_indir *indir;
796 u32 table_size;
797 size_t full_size;
798 int ret;
799
800 if (!dev->ethtool_ops->set_rxfh_indir)
801 return -EOPNOTSUPP;
802
803 if (copy_from_user(&table_size,
804 useraddr + offsetof(struct ethtool_rxfh_indir, size),
805 sizeof(table_size)))
806 return -EFAULT;
807
808 if (table_size >
809 (KMALLOC_MAX_SIZE - sizeof(*indir)) / sizeof(*indir->ring_index))
810 return -ENOMEM;
811 full_size = sizeof(*indir) + sizeof(*indir->ring_index) * table_size;
812 indir = kmalloc(full_size, GFP_USER);
813 if (!indir)
814 return -ENOMEM;
815
816 if (copy_from_user(indir, useraddr, full_size)) {
817 ret = -EFAULT;
818 goto out;
819 }
820
821 ret = dev->ethtool_ops->set_rxfh_indir(dev, indir);
822
823 out:
824 kfree(indir);
825 return ret;
826 }
827
828 static void __rx_ntuple_filter_add(struct ethtool_rx_ntuple_list *list,
829 struct ethtool_rx_ntuple_flow_spec *spec,
830 struct ethtool_rx_ntuple_flow_spec_container *fsc)
831 {
832
833 /* don't add filters forever */
834 if (list->count >= ETHTOOL_MAX_NTUPLE_LIST_ENTRY) {
835 /* free the container */
836 kfree(fsc);
837 return;
838 }
839
840 /* Copy the whole filter over */
841 fsc->fs.flow_type = spec->flow_type;
842 memcpy(&fsc->fs.h_u, &spec->h_u, sizeof(spec->h_u));
843 memcpy(&fsc->fs.m_u, &spec->m_u, sizeof(spec->m_u));
844
845 fsc->fs.vlan_tag = spec->vlan_tag;
846 fsc->fs.vlan_tag_mask = spec->vlan_tag_mask;
847 fsc->fs.data = spec->data;
848 fsc->fs.data_mask = spec->data_mask;
849 fsc->fs.action = spec->action;
850
851 /* add to the list */
852 list_add_tail_rcu(&fsc->list, &list->list);
853 list->count++;
854 }
855
856 /*
857 * ethtool does not (or did not) set masks for flow parameters that are
858 * not specified, so if both value and mask are 0 then this must be
859 * treated as equivalent to a mask with all bits set. Implement that
860 * here rather than in drivers.
861 */
862 static void rx_ntuple_fix_masks(struct ethtool_rx_ntuple_flow_spec *fs)
863 {
864 struct ethtool_tcpip4_spec *entry = &fs->h_u.tcp_ip4_spec;
865 struct ethtool_tcpip4_spec *mask = &fs->m_u.tcp_ip4_spec;
866
867 if (fs->flow_type != TCP_V4_FLOW &&
868 fs->flow_type != UDP_V4_FLOW &&
869 fs->flow_type != SCTP_V4_FLOW)
870 return;
871
872 if (!(entry->ip4src | mask->ip4src))
873 mask->ip4src = htonl(0xffffffff);
874 if (!(entry->ip4dst | mask->ip4dst))
875 mask->ip4dst = htonl(0xffffffff);
876 if (!(entry->psrc | mask->psrc))
877 mask->psrc = htons(0xffff);
878 if (!(entry->pdst | mask->pdst))
879 mask->pdst = htons(0xffff);
880 if (!(entry->tos | mask->tos))
881 mask->tos = 0xff;
882 if (!(fs->vlan_tag | fs->vlan_tag_mask))
883 fs->vlan_tag_mask = 0xffff;
884 if (!(fs->data | fs->data_mask))
885 fs->data_mask = 0xffffffffffffffffULL;
886 }
887
888 static noinline_for_stack int ethtool_set_rx_ntuple(struct net_device *dev,
889 void __user *useraddr)
890 {
891 struct ethtool_rx_ntuple cmd;
892 const struct ethtool_ops *ops = dev->ethtool_ops;
893 struct ethtool_rx_ntuple_flow_spec_container *fsc = NULL;
894 int ret;
895
896 if (!(dev->features & NETIF_F_NTUPLE))
897 return -EINVAL;
898
899 if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
900 return -EFAULT;
901
902 rx_ntuple_fix_masks(&cmd.fs);
903
904 /*
905 * Cache filter in dev struct for GET operation only if
906 * the underlying driver doesn't have its own GET operation, and
907 * only if the filter was added successfully. First make sure we
908 * can allocate the filter, then continue if successful.
909 */
910 if (!ops->get_rx_ntuple) {
911 fsc = kmalloc(sizeof(*fsc), GFP_ATOMIC);
912 if (!fsc)
913 return -ENOMEM;
914 }
915
916 ret = ops->set_rx_ntuple(dev, &cmd);
917 if (ret) {
918 kfree(fsc);
919 return ret;
920 }
921
922 if (!ops->get_rx_ntuple)
923 __rx_ntuple_filter_add(&dev->ethtool_ntuple_list, &cmd.fs, fsc);
924
925 return ret;
926 }
927
928 static int ethtool_get_rx_ntuple(struct net_device *dev, void __user *useraddr)
929 {
930 struct ethtool_gstrings gstrings;
931 const struct ethtool_ops *ops = dev->ethtool_ops;
932 struct ethtool_rx_ntuple_flow_spec_container *fsc;
933 u8 *data;
934 char *p;
935 int ret, i, num_strings = 0;
936
937 if (!ops->get_sset_count)
938 return -EOPNOTSUPP;
939
940 if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
941 return -EFAULT;
942
943 ret = ops->get_sset_count(dev, gstrings.string_set);
944 if (ret < 0)
945 return ret;
946
947 gstrings.len = ret;
948
949 data = kzalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
950 if (!data)
951 return -ENOMEM;
952
953 if (ops->get_rx_ntuple) {
954 /* driver-specific filter grab */
955 ret = ops->get_rx_ntuple(dev, gstrings.string_set, data);
956 goto copy;
957 }
958
959 /* default ethtool filter grab */
960 i = 0;
961 p = (char *)data;
962 list_for_each_entry(fsc, &dev->ethtool_ntuple_list.list, list) {
963 sprintf(p, "Filter %d:\n", i);
964 p += ETH_GSTRING_LEN;
965 num_strings++;
966
967 switch (fsc->fs.flow_type) {
968 case TCP_V4_FLOW:
969 sprintf(p, "\tFlow Type: TCP\n");
970 p += ETH_GSTRING_LEN;
971 num_strings++;
972 break;
973 case UDP_V4_FLOW:
974 sprintf(p, "\tFlow Type: UDP\n");
975 p += ETH_GSTRING_LEN;
976 num_strings++;
977 break;
978 case SCTP_V4_FLOW:
979 sprintf(p, "\tFlow Type: SCTP\n");
980 p += ETH_GSTRING_LEN;
981 num_strings++;
982 break;
983 case AH_ESP_V4_FLOW:
984 sprintf(p, "\tFlow Type: AH ESP\n");
985 p += ETH_GSTRING_LEN;
986 num_strings++;
987 break;
988 case ESP_V4_FLOW:
989 sprintf(p, "\tFlow Type: ESP\n");
990 p += ETH_GSTRING_LEN;
991 num_strings++;
992 break;
993 case IP_USER_FLOW:
994 sprintf(p, "\tFlow Type: Raw IP\n");
995 p += ETH_GSTRING_LEN;
996 num_strings++;
997 break;
998 case IPV4_FLOW:
999 sprintf(p, "\tFlow Type: IPv4\n");
1000 p += ETH_GSTRING_LEN;
1001 num_strings++;
1002 break;
1003 default:
1004 sprintf(p, "\tFlow Type: Unknown\n");
1005 p += ETH_GSTRING_LEN;
1006 num_strings++;
1007 goto unknown_filter;
1008 }
1009
1010 /* now the rest of the filters */
1011 switch (fsc->fs.flow_type) {
1012 case TCP_V4_FLOW:
1013 case UDP_V4_FLOW:
1014 case SCTP_V4_FLOW:
1015 sprintf(p, "\tSrc IP addr: 0x%x\n",
1016 fsc->fs.h_u.tcp_ip4_spec.ip4src);
1017 p += ETH_GSTRING_LEN;
1018 num_strings++;
1019 sprintf(p, "\tSrc IP mask: 0x%x\n",
1020 fsc->fs.m_u.tcp_ip4_spec.ip4src);
1021 p += ETH_GSTRING_LEN;
1022 num_strings++;
1023 sprintf(p, "\tDest IP addr: 0x%x\n",
1024 fsc->fs.h_u.tcp_ip4_spec.ip4dst);
1025 p += ETH_GSTRING_LEN;
1026 num_strings++;
1027 sprintf(p, "\tDest IP mask: 0x%x\n",
1028 fsc->fs.m_u.tcp_ip4_spec.ip4dst);
1029 p += ETH_GSTRING_LEN;
1030 num_strings++;
1031 sprintf(p, "\tSrc Port: %d, mask: 0x%x\n",
1032 fsc->fs.h_u.tcp_ip4_spec.psrc,
1033 fsc->fs.m_u.tcp_ip4_spec.psrc);
1034 p += ETH_GSTRING_LEN;
1035 num_strings++;
1036 sprintf(p, "\tDest Port: %d, mask: 0x%x\n",
1037 fsc->fs.h_u.tcp_ip4_spec.pdst,
1038 fsc->fs.m_u.tcp_ip4_spec.pdst);
1039 p += ETH_GSTRING_LEN;
1040 num_strings++;
1041 sprintf(p, "\tTOS: %d, mask: 0x%x\n",
1042 fsc->fs.h_u.tcp_ip4_spec.tos,
1043 fsc->fs.m_u.tcp_ip4_spec.tos);
1044 p += ETH_GSTRING_LEN;
1045 num_strings++;
1046 break;
1047 case AH_ESP_V4_FLOW:
1048 case ESP_V4_FLOW:
1049 sprintf(p, "\tSrc IP addr: 0x%x\n",
1050 fsc->fs.h_u.ah_ip4_spec.ip4src);
1051 p += ETH_GSTRING_LEN;
1052 num_strings++;
1053 sprintf(p, "\tSrc IP mask: 0x%x\n",
1054 fsc->fs.m_u.ah_ip4_spec.ip4src);
1055 p += ETH_GSTRING_LEN;
1056 num_strings++;
1057 sprintf(p, "\tDest IP addr: 0x%x\n",
1058 fsc->fs.h_u.ah_ip4_spec.ip4dst);
1059 p += ETH_GSTRING_LEN;
1060 num_strings++;
1061 sprintf(p, "\tDest IP mask: 0x%x\n",
1062 fsc->fs.m_u.ah_ip4_spec.ip4dst);
1063 p += ETH_GSTRING_LEN;
1064 num_strings++;
1065 sprintf(p, "\tSPI: %d, mask: 0x%x\n",
1066 fsc->fs.h_u.ah_ip4_spec.spi,
1067 fsc->fs.m_u.ah_ip4_spec.spi);
1068 p += ETH_GSTRING_LEN;
1069 num_strings++;
1070 sprintf(p, "\tTOS: %d, mask: 0x%x\n",
1071 fsc->fs.h_u.ah_ip4_spec.tos,
1072 fsc->fs.m_u.ah_ip4_spec.tos);
1073 p += ETH_GSTRING_LEN;
1074 num_strings++;
1075 break;
1076 case IP_USER_FLOW:
1077 sprintf(p, "\tSrc IP addr: 0x%x\n",
1078 fsc->fs.h_u.usr_ip4_spec.ip4src);
1079 p += ETH_GSTRING_LEN;
1080 num_strings++;
1081 sprintf(p, "\tSrc IP mask: 0x%x\n",
1082 fsc->fs.m_u.usr_ip4_spec.ip4src);
1083 p += ETH_GSTRING_LEN;
1084 num_strings++;
1085 sprintf(p, "\tDest IP addr: 0x%x\n",
1086 fsc->fs.h_u.usr_ip4_spec.ip4dst);
1087 p += ETH_GSTRING_LEN;
1088 num_strings++;
1089 sprintf(p, "\tDest IP mask: 0x%x\n",
1090 fsc->fs.m_u.usr_ip4_spec.ip4dst);
1091 p += ETH_GSTRING_LEN;
1092 num_strings++;
1093 break;
1094 case IPV4_FLOW:
1095 sprintf(p, "\tSrc IP addr: 0x%x\n",
1096 fsc->fs.h_u.usr_ip4_spec.ip4src);
1097 p += ETH_GSTRING_LEN;
1098 num_strings++;
1099 sprintf(p, "\tSrc IP mask: 0x%x\n",
1100 fsc->fs.m_u.usr_ip4_spec.ip4src);
1101 p += ETH_GSTRING_LEN;
1102 num_strings++;
1103 sprintf(p, "\tDest IP addr: 0x%x\n",
1104 fsc->fs.h_u.usr_ip4_spec.ip4dst);
1105 p += ETH_GSTRING_LEN;
1106 num_strings++;
1107 sprintf(p, "\tDest IP mask: 0x%x\n",
1108 fsc->fs.m_u.usr_ip4_spec.ip4dst);
1109 p += ETH_GSTRING_LEN;
1110 num_strings++;
1111 sprintf(p, "\tL4 bytes: 0x%x, mask: 0x%x\n",
1112 fsc->fs.h_u.usr_ip4_spec.l4_4_bytes,
1113 fsc->fs.m_u.usr_ip4_spec.l4_4_bytes);
1114 p += ETH_GSTRING_LEN;
1115 num_strings++;
1116 sprintf(p, "\tTOS: %d, mask: 0x%x\n",
1117 fsc->fs.h_u.usr_ip4_spec.tos,
1118 fsc->fs.m_u.usr_ip4_spec.tos);
1119 p += ETH_GSTRING_LEN;
1120 num_strings++;
1121 sprintf(p, "\tIP Version: %d, mask: 0x%x\n",
1122 fsc->fs.h_u.usr_ip4_spec.ip_ver,
1123 fsc->fs.m_u.usr_ip4_spec.ip_ver);
1124 p += ETH_GSTRING_LEN;
1125 num_strings++;
1126 sprintf(p, "\tProtocol: %d, mask: 0x%x\n",
1127 fsc->fs.h_u.usr_ip4_spec.proto,
1128 fsc->fs.m_u.usr_ip4_spec.proto);
1129 p += ETH_GSTRING_LEN;
1130 num_strings++;
1131 break;
1132 }
1133 sprintf(p, "\tVLAN: %d, mask: 0x%x\n",
1134 fsc->fs.vlan_tag, fsc->fs.vlan_tag_mask);
1135 p += ETH_GSTRING_LEN;
1136 num_strings++;
1137 sprintf(p, "\tUser-defined: 0x%Lx\n", fsc->fs.data);
1138 p += ETH_GSTRING_LEN;
1139 num_strings++;
1140 sprintf(p, "\tUser-defined mask: 0x%Lx\n", fsc->fs.data_mask);
1141 p += ETH_GSTRING_LEN;
1142 num_strings++;
1143 if (fsc->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP)
1144 sprintf(p, "\tAction: Drop\n");
1145 else
1146 sprintf(p, "\tAction: Direct to queue %d\n",
1147 fsc->fs.action);
1148 p += ETH_GSTRING_LEN;
1149 num_strings++;
1150 unknown_filter:
1151 i++;
1152 }
1153 copy:
1154 /* indicate to userspace how many strings we actually have */
1155 gstrings.len = num_strings;
1156 ret = -EFAULT;
1157 if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
1158 goto out;
1159 useraddr += sizeof(gstrings);
1160 if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
1161 goto out;
1162 ret = 0;
1163
1164 out:
1165 kfree(data);
1166 return ret;
1167 }
1168
1169 static int ethtool_get_regs(struct net_device *dev, char __user *useraddr)
1170 {
1171 struct ethtool_regs regs;
1172 const struct ethtool_ops *ops = dev->ethtool_ops;
1173 void *regbuf;
1174 int reglen, ret;
1175
1176 if (!ops->get_regs || !ops->get_regs_len)
1177 return -EOPNOTSUPP;
1178
1179 if (copy_from_user(&regs, useraddr, sizeof(regs)))
1180 return -EFAULT;
1181
1182 reglen = ops->get_regs_len(dev);
1183 if (regs.len > reglen)
1184 regs.len = reglen;
1185
1186 regbuf = vzalloc(reglen);
1187 if (!regbuf)
1188 return -ENOMEM;
1189
1190 ops->get_regs(dev, &regs, regbuf);
1191
1192 ret = -EFAULT;
1193 if (copy_to_user(useraddr, &regs, sizeof(regs)))
1194 goto out;
1195 useraddr += offsetof(struct ethtool_regs, data);
1196 if (copy_to_user(useraddr, regbuf, regs.len))
1197 goto out;
1198 ret = 0;
1199
1200 out:
1201 vfree(regbuf);
1202 return ret;
1203 }
1204
1205 static int ethtool_reset(struct net_device *dev, char __user *useraddr)
1206 {
1207 struct ethtool_value reset;
1208 int ret;
1209
1210 if (!dev->ethtool_ops->reset)
1211 return -EOPNOTSUPP;
1212
1213 if (copy_from_user(&reset, useraddr, sizeof(reset)))
1214 return -EFAULT;
1215
1216 ret = dev->ethtool_ops->reset(dev, &reset.data);
1217 if (ret)
1218 return ret;
1219
1220 if (copy_to_user(useraddr, &reset, sizeof(reset)))
1221 return -EFAULT;
1222 return 0;
1223 }
1224
1225 static int ethtool_get_wol(struct net_device *dev, char __user *useraddr)
1226 {
1227 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
1228
1229 if (!dev->ethtool_ops->get_wol)
1230 return -EOPNOTSUPP;
1231
1232 dev->ethtool_ops->get_wol(dev, &wol);
1233
1234 if (copy_to_user(useraddr, &wol, sizeof(wol)))
1235 return -EFAULT;
1236 return 0;
1237 }
1238
1239 static int ethtool_set_wol(struct net_device *dev, char __user *useraddr)
1240 {
1241 struct ethtool_wolinfo wol;
1242
1243 if (!dev->ethtool_ops->set_wol)
1244 return -EOPNOTSUPP;
1245
1246 if (copy_from_user(&wol, useraddr, sizeof(wol)))
1247 return -EFAULT;
1248
1249 return dev->ethtool_ops->set_wol(dev, &wol);
1250 }
1251
1252 static int ethtool_nway_reset(struct net_device *dev)
1253 {
1254 if (!dev->ethtool_ops->nway_reset)
1255 return -EOPNOTSUPP;
1256
1257 return dev->ethtool_ops->nway_reset(dev);
1258 }
1259
1260 static int ethtool_get_link(struct net_device *dev, char __user *useraddr)
1261 {
1262 struct ethtool_value edata = { .cmd = ETHTOOL_GLINK };
1263
1264 if (!dev->ethtool_ops->get_link)
1265 return -EOPNOTSUPP;
1266
1267 edata.data = netif_running(dev) && dev->ethtool_ops->get_link(dev);
1268
1269 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1270 return -EFAULT;
1271 return 0;
1272 }
1273
1274 static int ethtool_get_eeprom(struct net_device *dev, void __user *useraddr)
1275 {
1276 struct ethtool_eeprom eeprom;
1277 const struct ethtool_ops *ops = dev->ethtool_ops;
1278 void __user *userbuf = useraddr + sizeof(eeprom);
1279 u32 bytes_remaining;
1280 u8 *data;
1281 int ret = 0;
1282
1283 if (!ops->get_eeprom || !ops->get_eeprom_len)
1284 return -EOPNOTSUPP;
1285
1286 if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
1287 return -EFAULT;
1288
1289 /* Check for wrap and zero */
1290 if (eeprom.offset + eeprom.len <= eeprom.offset)
1291 return -EINVAL;
1292
1293 /* Check for exceeding total eeprom len */
1294 if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
1295 return -EINVAL;
1296
1297 data = kmalloc(PAGE_SIZE, GFP_USER);
1298 if (!data)
1299 return -ENOMEM;
1300
1301 bytes_remaining = eeprom.len;
1302 while (bytes_remaining > 0) {
1303 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
1304
1305 ret = ops->get_eeprom(dev, &eeprom, data);
1306 if (ret)
1307 break;
1308 if (copy_to_user(userbuf, data, eeprom.len)) {
1309 ret = -EFAULT;
1310 break;
1311 }
1312 userbuf += eeprom.len;
1313 eeprom.offset += eeprom.len;
1314 bytes_remaining -= eeprom.len;
1315 }
1316
1317 eeprom.len = userbuf - (useraddr + sizeof(eeprom));
1318 eeprom.offset -= eeprom.len;
1319 if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
1320 ret = -EFAULT;
1321
1322 kfree(data);
1323 return ret;
1324 }
1325
1326 static int ethtool_set_eeprom(struct net_device *dev, void __user *useraddr)
1327 {
1328 struct ethtool_eeprom eeprom;
1329 const struct ethtool_ops *ops = dev->ethtool_ops;
1330 void __user *userbuf = useraddr + sizeof(eeprom);
1331 u32 bytes_remaining;
1332 u8 *data;
1333 int ret = 0;
1334
1335 if (!ops->set_eeprom || !ops->get_eeprom_len)
1336 return -EOPNOTSUPP;
1337
1338 if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
1339 return -EFAULT;
1340
1341 /* Check for wrap and zero */
1342 if (eeprom.offset + eeprom.len <= eeprom.offset)
1343 return -EINVAL;
1344
1345 /* Check for exceeding total eeprom len */
1346 if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
1347 return -EINVAL;
1348
1349 data = kmalloc(PAGE_SIZE, GFP_USER);
1350 if (!data)
1351 return -ENOMEM;
1352
1353 bytes_remaining = eeprom.len;
1354 while (bytes_remaining > 0) {
1355 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
1356
1357 if (copy_from_user(data, userbuf, eeprom.len)) {
1358 ret = -EFAULT;
1359 break;
1360 }
1361 ret = ops->set_eeprom(dev, &eeprom, data);
1362 if (ret)
1363 break;
1364 userbuf += eeprom.len;
1365 eeprom.offset += eeprom.len;
1366 bytes_remaining -= eeprom.len;
1367 }
1368
1369 kfree(data);
1370 return ret;
1371 }
1372
1373 static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev,
1374 void __user *useraddr)
1375 {
1376 struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
1377
1378 if (!dev->ethtool_ops->get_coalesce)
1379 return -EOPNOTSUPP;
1380
1381 dev->ethtool_ops->get_coalesce(dev, &coalesce);
1382
1383 if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
1384 return -EFAULT;
1385 return 0;
1386 }
1387
1388 static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev,
1389 void __user *useraddr)
1390 {
1391 struct ethtool_coalesce coalesce;
1392
1393 if (!dev->ethtool_ops->set_coalesce)
1394 return -EOPNOTSUPP;
1395
1396 if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))
1397 return -EFAULT;
1398
1399 return dev->ethtool_ops->set_coalesce(dev, &coalesce);
1400 }
1401
1402 static int ethtool_get_ringparam(struct net_device *dev, void __user *useraddr)
1403 {
1404 struct ethtool_ringparam ringparam = { .cmd = ETHTOOL_GRINGPARAM };
1405
1406 if (!dev->ethtool_ops->get_ringparam)
1407 return -EOPNOTSUPP;
1408
1409 dev->ethtool_ops->get_ringparam(dev, &ringparam);
1410
1411 if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))
1412 return -EFAULT;
1413 return 0;
1414 }
1415
1416 static int ethtool_set_ringparam(struct net_device *dev, void __user *useraddr)
1417 {
1418 struct ethtool_ringparam ringparam;
1419
1420 if (!dev->ethtool_ops->set_ringparam)
1421 return -EOPNOTSUPP;
1422
1423 if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))
1424 return -EFAULT;
1425
1426 return dev->ethtool_ops->set_ringparam(dev, &ringparam);
1427 }
1428
1429 static int ethtool_get_pauseparam(struct net_device *dev, void __user *useraddr)
1430 {
1431 struct ethtool_pauseparam pauseparam = { ETHTOOL_GPAUSEPARAM };
1432
1433 if (!dev->ethtool_ops->get_pauseparam)
1434 return -EOPNOTSUPP;
1435
1436 dev->ethtool_ops->get_pauseparam(dev, &pauseparam);
1437
1438 if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))
1439 return -EFAULT;
1440 return 0;
1441 }
1442
1443 static int ethtool_set_pauseparam(struct net_device *dev, void __user *useraddr)
1444 {
1445 struct ethtool_pauseparam pauseparam;
1446
1447 if (!dev->ethtool_ops->set_pauseparam)
1448 return -EOPNOTSUPP;
1449
1450 if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))
1451 return -EFAULT;
1452
1453 return dev->ethtool_ops->set_pauseparam(dev, &pauseparam);
1454 }
1455
1456 static int __ethtool_set_sg(struct net_device *dev, u32 data)
1457 {
1458 int err;
1459
1460 if (!dev->ethtool_ops->set_sg)
1461 return -EOPNOTSUPP;
1462
1463 if (data && !(dev->features & NETIF_F_ALL_CSUM))
1464 return -EINVAL;
1465
1466 if (!data && dev->ethtool_ops->set_tso) {
1467 err = dev->ethtool_ops->set_tso(dev, 0);
1468 if (err)
1469 return err;
1470 }
1471
1472 if (!data && dev->ethtool_ops->set_ufo) {
1473 err = dev->ethtool_ops->set_ufo(dev, 0);
1474 if (err)
1475 return err;
1476 }
1477 return dev->ethtool_ops->set_sg(dev, data);
1478 }
1479
1480 static int __ethtool_set_tx_csum(struct net_device *dev, u32 data)
1481 {
1482 int err;
1483
1484 if (!dev->ethtool_ops->set_tx_csum)
1485 return -EOPNOTSUPP;
1486
1487 if (!data && dev->ethtool_ops->set_sg) {
1488 err = __ethtool_set_sg(dev, 0);
1489 if (err)
1490 return err;
1491 }
1492
1493 return dev->ethtool_ops->set_tx_csum(dev, data);
1494 }
1495
1496 static int __ethtool_set_rx_csum(struct net_device *dev, u32 data)
1497 {
1498 if (!dev->ethtool_ops->set_rx_csum)
1499 return -EOPNOTSUPP;
1500
1501 if (!data)
1502 dev->features &= ~NETIF_F_GRO;
1503
1504 return dev->ethtool_ops->set_rx_csum(dev, data);
1505 }
1506
1507 static int __ethtool_set_tso(struct net_device *dev, u32 data)
1508 {
1509 if (!dev->ethtool_ops->set_tso)
1510 return -EOPNOTSUPP;
1511
1512 if (data && !(dev->features & NETIF_F_SG))
1513 return -EINVAL;
1514
1515 return dev->ethtool_ops->set_tso(dev, data);
1516 }
1517
1518 static int __ethtool_set_ufo(struct net_device *dev, u32 data)
1519 {
1520 if (!dev->ethtool_ops->set_ufo)
1521 return -EOPNOTSUPP;
1522 if (data && !(dev->features & NETIF_F_SG))
1523 return -EINVAL;
1524 if (data && !((dev->features & NETIF_F_GEN_CSUM) ||
1525 (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))
1526 == (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM)))
1527 return -EINVAL;
1528 return dev->ethtool_ops->set_ufo(dev, data);
1529 }
1530
1531 static int ethtool_self_test(struct net_device *dev, char __user *useraddr)
1532 {
1533 struct ethtool_test test;
1534 const struct ethtool_ops *ops = dev->ethtool_ops;
1535 u64 *data;
1536 int ret, test_len;
1537
1538 if (!ops->self_test || !ops->get_sset_count)
1539 return -EOPNOTSUPP;
1540
1541 test_len = ops->get_sset_count(dev, ETH_SS_TEST);
1542 if (test_len < 0)
1543 return test_len;
1544 WARN_ON(test_len == 0);
1545
1546 if (copy_from_user(&test, useraddr, sizeof(test)))
1547 return -EFAULT;
1548
1549 test.len = test_len;
1550 data = kmalloc(test_len * sizeof(u64), GFP_USER);
1551 if (!data)
1552 return -ENOMEM;
1553
1554 ops->self_test(dev, &test, data);
1555
1556 ret = -EFAULT;
1557 if (copy_to_user(useraddr, &test, sizeof(test)))
1558 goto out;
1559 useraddr += sizeof(test);
1560 if (copy_to_user(useraddr, data, test.len * sizeof(u64)))
1561 goto out;
1562 ret = 0;
1563
1564 out:
1565 kfree(data);
1566 return ret;
1567 }
1568
1569 static int ethtool_get_strings(struct net_device *dev, void __user *useraddr)
1570 {
1571 struct ethtool_gstrings gstrings;
1572 u8 *data;
1573 int ret;
1574
1575 if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
1576 return -EFAULT;
1577
1578 ret = __ethtool_get_sset_count(dev, gstrings.string_set);
1579 if (ret < 0)
1580 return ret;
1581
1582 gstrings.len = ret;
1583
1584 data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
1585 if (!data)
1586 return -ENOMEM;
1587
1588 __ethtool_get_strings(dev, gstrings.string_set, data);
1589
1590 ret = -EFAULT;
1591 if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
1592 goto out;
1593 useraddr += sizeof(gstrings);
1594 if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
1595 goto out;
1596 ret = 0;
1597
1598 out:
1599 kfree(data);
1600 return ret;
1601 }
1602
1603 static int ethtool_phys_id(struct net_device *dev, void __user *useraddr)
1604 {
1605 struct ethtool_value id;
1606
1607 if (!dev->ethtool_ops->phys_id)
1608 return -EOPNOTSUPP;
1609
1610 if (copy_from_user(&id, useraddr, sizeof(id)))
1611 return -EFAULT;
1612
1613 return dev->ethtool_ops->phys_id(dev, id.data);
1614 }
1615
1616 static int ethtool_get_stats(struct net_device *dev, void __user *useraddr)
1617 {
1618 struct ethtool_stats stats;
1619 const struct ethtool_ops *ops = dev->ethtool_ops;
1620 u64 *data;
1621 int ret, n_stats;
1622
1623 if (!ops->get_ethtool_stats || !ops->get_sset_count)
1624 return -EOPNOTSUPP;
1625
1626 n_stats = ops->get_sset_count(dev, ETH_SS_STATS);
1627 if (n_stats < 0)
1628 return n_stats;
1629 WARN_ON(n_stats == 0);
1630
1631 if (copy_from_user(&stats, useraddr, sizeof(stats)))
1632 return -EFAULT;
1633
1634 stats.n_stats = n_stats;
1635 data = kmalloc(n_stats * sizeof(u64), GFP_USER);
1636 if (!data)
1637 return -ENOMEM;
1638
1639 ops->get_ethtool_stats(dev, &stats, data);
1640
1641 ret = -EFAULT;
1642 if (copy_to_user(useraddr, &stats, sizeof(stats)))
1643 goto out;
1644 useraddr += sizeof(stats);
1645 if (copy_to_user(useraddr, data, stats.n_stats * sizeof(u64)))
1646 goto out;
1647 ret = 0;
1648
1649 out:
1650 kfree(data);
1651 return ret;
1652 }
1653
1654 static int ethtool_get_perm_addr(struct net_device *dev, void __user *useraddr)
1655 {
1656 struct ethtool_perm_addr epaddr;
1657
1658 if (copy_from_user(&epaddr, useraddr, sizeof(epaddr)))
1659 return -EFAULT;
1660
1661 if (epaddr.size < dev->addr_len)
1662 return -ETOOSMALL;
1663 epaddr.size = dev->addr_len;
1664
1665 if (copy_to_user(useraddr, &epaddr, sizeof(epaddr)))
1666 return -EFAULT;
1667 useraddr += sizeof(epaddr);
1668 if (copy_to_user(useraddr, dev->perm_addr, epaddr.size))
1669 return -EFAULT;
1670 return 0;
1671 }
1672
1673 static int ethtool_get_value(struct net_device *dev, char __user *useraddr,
1674 u32 cmd, u32 (*actor)(struct net_device *))
1675 {
1676 struct ethtool_value edata = { .cmd = cmd };
1677
1678 if (!actor)
1679 return -EOPNOTSUPP;
1680
1681 edata.data = actor(dev);
1682
1683 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1684 return -EFAULT;
1685 return 0;
1686 }
1687
1688 static int ethtool_set_value_void(struct net_device *dev, char __user *useraddr,
1689 void (*actor)(struct net_device *, u32))
1690 {
1691 struct ethtool_value edata;
1692
1693 if (!actor)
1694 return -EOPNOTSUPP;
1695
1696 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1697 return -EFAULT;
1698
1699 actor(dev, edata.data);
1700 return 0;
1701 }
1702
1703 static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
1704 int (*actor)(struct net_device *, u32))
1705 {
1706 struct ethtool_value edata;
1707
1708 if (!actor)
1709 return -EOPNOTSUPP;
1710
1711 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1712 return -EFAULT;
1713
1714 return actor(dev, edata.data);
1715 }
1716
1717 static noinline_for_stack int ethtool_flash_device(struct net_device *dev,
1718 char __user *useraddr)
1719 {
1720 struct ethtool_flash efl;
1721
1722 if (copy_from_user(&efl, useraddr, sizeof(efl)))
1723 return -EFAULT;
1724
1725 if (!dev->ethtool_ops->flash_device)
1726 return -EOPNOTSUPP;
1727
1728 return dev->ethtool_ops->flash_device(dev, &efl);
1729 }
1730
1731 /* The main entry point in this file. Called from net/core/dev.c */
1732
1733 int dev_ethtool(struct net *net, struct ifreq *ifr)
1734 {
1735 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
1736 void __user *useraddr = ifr->ifr_data;
1737 u32 ethcmd;
1738 int rc;
1739 u32 old_features;
1740
1741 if (!dev || !netif_device_present(dev))
1742 return -ENODEV;
1743
1744 if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
1745 return -EFAULT;
1746
1747 if (!dev->ethtool_ops) {
1748 /* ETHTOOL_GDRVINFO does not require any driver support.
1749 * It is also unprivileged and does not change anything,
1750 * so we can take a shortcut to it. */
1751 if (ethcmd == ETHTOOL_GDRVINFO)
1752 return ethtool_get_drvinfo(dev, useraddr);
1753 else
1754 return -EOPNOTSUPP;
1755 }
1756
1757 /* Allow some commands to be done by anyone */
1758 switch (ethcmd) {
1759 case ETHTOOL_GSET:
1760 case ETHTOOL_GDRVINFO:
1761 case ETHTOOL_GMSGLVL:
1762 case ETHTOOL_GCOALESCE:
1763 case ETHTOOL_GRINGPARAM:
1764 case ETHTOOL_GPAUSEPARAM:
1765 case ETHTOOL_GRXCSUM:
1766 case ETHTOOL_GTXCSUM:
1767 case ETHTOOL_GSG:
1768 case ETHTOOL_GSTRINGS:
1769 case ETHTOOL_GTSO:
1770 case ETHTOOL_GPERMADDR:
1771 case ETHTOOL_GUFO:
1772 case ETHTOOL_GGSO:
1773 case ETHTOOL_GGRO:
1774 case ETHTOOL_GFLAGS:
1775 case ETHTOOL_GPFLAGS:
1776 case ETHTOOL_GRXFH:
1777 case ETHTOOL_GRXRINGS:
1778 case ETHTOOL_GRXCLSRLCNT:
1779 case ETHTOOL_GRXCLSRULE:
1780 case ETHTOOL_GRXCLSRLALL:
1781 case ETHTOOL_GFEATURES:
1782 break;
1783 default:
1784 if (!capable(CAP_NET_ADMIN))
1785 return -EPERM;
1786 }
1787
1788 if (dev->ethtool_ops->begin) {
1789 rc = dev->ethtool_ops->begin(dev);
1790 if (rc < 0)
1791 return rc;
1792 }
1793 old_features = dev->features;
1794
1795 switch (ethcmd) {
1796 case ETHTOOL_GSET:
1797 rc = ethtool_get_settings(dev, useraddr);
1798 break;
1799 case ETHTOOL_SSET:
1800 rc = ethtool_set_settings(dev, useraddr);
1801 break;
1802 case ETHTOOL_GDRVINFO:
1803 rc = ethtool_get_drvinfo(dev, useraddr);
1804 break;
1805 case ETHTOOL_GREGS:
1806 rc = ethtool_get_regs(dev, useraddr);
1807 break;
1808 case ETHTOOL_GWOL:
1809 rc = ethtool_get_wol(dev, useraddr);
1810 break;
1811 case ETHTOOL_SWOL:
1812 rc = ethtool_set_wol(dev, useraddr);
1813 break;
1814 case ETHTOOL_GMSGLVL:
1815 rc = ethtool_get_value(dev, useraddr, ethcmd,
1816 dev->ethtool_ops->get_msglevel);
1817 break;
1818 case ETHTOOL_SMSGLVL:
1819 rc = ethtool_set_value_void(dev, useraddr,
1820 dev->ethtool_ops->set_msglevel);
1821 break;
1822 case ETHTOOL_NWAY_RST:
1823 rc = ethtool_nway_reset(dev);
1824 break;
1825 case ETHTOOL_GLINK:
1826 rc = ethtool_get_link(dev, useraddr);
1827 break;
1828 case ETHTOOL_GEEPROM:
1829 rc = ethtool_get_eeprom(dev, useraddr);
1830 break;
1831 case ETHTOOL_SEEPROM:
1832 rc = ethtool_set_eeprom(dev, useraddr);
1833 break;
1834 case ETHTOOL_GCOALESCE:
1835 rc = ethtool_get_coalesce(dev, useraddr);
1836 break;
1837 case ETHTOOL_SCOALESCE:
1838 rc = ethtool_set_coalesce(dev, useraddr);
1839 break;
1840 case ETHTOOL_GRINGPARAM:
1841 rc = ethtool_get_ringparam(dev, useraddr);
1842 break;
1843 case ETHTOOL_SRINGPARAM:
1844 rc = ethtool_set_ringparam(dev, useraddr);
1845 break;
1846 case ETHTOOL_GPAUSEPARAM:
1847 rc = ethtool_get_pauseparam(dev, useraddr);
1848 break;
1849 case ETHTOOL_SPAUSEPARAM:
1850 rc = ethtool_set_pauseparam(dev, useraddr);
1851 break;
1852 case ETHTOOL_TEST:
1853 rc = ethtool_self_test(dev, useraddr);
1854 break;
1855 case ETHTOOL_GSTRINGS:
1856 rc = ethtool_get_strings(dev, useraddr);
1857 break;
1858 case ETHTOOL_PHYS_ID:
1859 rc = ethtool_phys_id(dev, useraddr);
1860 break;
1861 case ETHTOOL_GSTATS:
1862 rc = ethtool_get_stats(dev, useraddr);
1863 break;
1864 case ETHTOOL_GPERMADDR:
1865 rc = ethtool_get_perm_addr(dev, useraddr);
1866 break;
1867 case ETHTOOL_GFLAGS:
1868 rc = ethtool_get_value(dev, useraddr, ethcmd,
1869 (dev->ethtool_ops->get_flags ?
1870 dev->ethtool_ops->get_flags :
1871 ethtool_op_get_flags));
1872 break;
1873 case ETHTOOL_SFLAGS:
1874 rc = ethtool_set_value(dev, useraddr, __ethtool_set_flags);
1875 break;
1876 case ETHTOOL_GPFLAGS:
1877 rc = ethtool_get_value(dev, useraddr, ethcmd,
1878 dev->ethtool_ops->get_priv_flags);
1879 break;
1880 case ETHTOOL_SPFLAGS:
1881 rc = ethtool_set_value(dev, useraddr,
1882 dev->ethtool_ops->set_priv_flags);
1883 break;
1884 case ETHTOOL_GRXFH:
1885 case ETHTOOL_GRXRINGS:
1886 case ETHTOOL_GRXCLSRLCNT:
1887 case ETHTOOL_GRXCLSRULE:
1888 case ETHTOOL_GRXCLSRLALL:
1889 rc = ethtool_get_rxnfc(dev, ethcmd, useraddr);
1890 break;
1891 case ETHTOOL_SRXFH:
1892 case ETHTOOL_SRXCLSRLDEL:
1893 case ETHTOOL_SRXCLSRLINS:
1894 rc = ethtool_set_rxnfc(dev, ethcmd, useraddr);
1895 break;
1896 case ETHTOOL_FLASHDEV:
1897 rc = ethtool_flash_device(dev, useraddr);
1898 break;
1899 case ETHTOOL_RESET:
1900 rc = ethtool_reset(dev, useraddr);
1901 break;
1902 case ETHTOOL_SRXNTUPLE:
1903 rc = ethtool_set_rx_ntuple(dev, useraddr);
1904 break;
1905 case ETHTOOL_GRXNTUPLE:
1906 rc = ethtool_get_rx_ntuple(dev, useraddr);
1907 break;
1908 case ETHTOOL_GSSET_INFO:
1909 rc = ethtool_get_sset_info(dev, useraddr);
1910 break;
1911 case ETHTOOL_GRXFHINDIR:
1912 rc = ethtool_get_rxfh_indir(dev, useraddr);
1913 break;
1914 case ETHTOOL_SRXFHINDIR:
1915 rc = ethtool_set_rxfh_indir(dev, useraddr);
1916 break;
1917 case ETHTOOL_GFEATURES:
1918 rc = ethtool_get_features(dev, useraddr);
1919 break;
1920 case ETHTOOL_SFEATURES:
1921 rc = ethtool_set_features(dev, useraddr);
1922 break;
1923 case ETHTOOL_GTXCSUM:
1924 case ETHTOOL_GRXCSUM:
1925 case ETHTOOL_GSG:
1926 case ETHTOOL_GTSO:
1927 case ETHTOOL_GUFO:
1928 case ETHTOOL_GGSO:
1929 case ETHTOOL_GGRO:
1930 rc = ethtool_get_one_feature(dev, useraddr, ethcmd);
1931 break;
1932 case ETHTOOL_STXCSUM:
1933 case ETHTOOL_SRXCSUM:
1934 case ETHTOOL_SSG:
1935 case ETHTOOL_STSO:
1936 case ETHTOOL_SUFO:
1937 case ETHTOOL_SGSO:
1938 case ETHTOOL_SGRO:
1939 rc = ethtool_set_one_feature(dev, useraddr, ethcmd);
1940 break;
1941 default:
1942 rc = -EOPNOTSUPP;
1943 }
1944
1945 if (dev->ethtool_ops->complete)
1946 dev->ethtool_ops->complete(dev);
1947
1948 if (old_features != dev->features)
1949 netdev_features_change(dev);
1950
1951 return rc;
1952 }
Linux 2.6 libata-dev (mirror)