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