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