]> bbs.cooldavid.org Git - net-next-2.6.git/blame - net/core/ethtool.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
drivers: Kill now superfluous ->last_rx stores
[net-next-2.6.git] / net / core / ethtool.c
CommitLineData
1da177e4
LT		 1/*
2 * net/core/ethtool.c - Ethtool ioctl handler
3 * Copyright (c) 2003 Matthew Wilcox <matthew@wil.cx>
4 *
5 * This file is where we call all the ethtool_ops commands to get
61a44b9c 6 * the information ethtool needs.
1da177e4 7 *
61a44b9c
MW		 8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
1da177e4
LT		 12 */
13
14#include <linux/module.h>
15#include <linux/types.h>
4fc268d2 16#include <linux/capability.h>
1da177e4
LT		 17#include <linux/errno.h>
18#include <linux/ethtool.h>
19#include <linux/netdevice.h>
20#include <asm/uaccess.h>
21
4ec93edb 22/*
1da177e4
LT		 23 * Some useful ethtool_ops methods that're device independent.
24 * If we find that all drivers want to do the same thing here,
25 * we can turn these into dev_() function calls.
26 */
27
28u32 ethtool_op_get_link(struct net_device *dev)
29{
30 return netif_carrier_ok(dev) ? 1 : 0;
31}
32
1896e61f
SS		 33u32 ethtool_op_get_rx_csum(struct net_device *dev)
34{
35 return (dev->features & NETIF_F_ALL_CSUM) != 0;
36}
8a729fce 37EXPORT_SYMBOL(ethtool_op_get_rx_csum);
1896e61f 38
1da177e4
LT		 39u32 ethtool_op_get_tx_csum(struct net_device *dev)
40{
8648b305 41 return (dev->features & NETIF_F_ALL_CSUM) != 0;
1da177e4 42}
8a729fce 43EXPORT_SYMBOL(ethtool_op_get_tx_csum);
1da177e4
LT		 44
45int 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
69f6a0fa
JM		 55int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data)
56{
57 if (data)
58 dev->features |= NETIF_F_HW_CSUM;
59 else
60 dev->features &= ~NETIF_F_HW_CSUM;
61
62 return 0;
63}
6460d948
MC		 64
65int ethtool_op_set_tx_ipv6_csum(struct net_device *dev, u32 data)
66{
67 if (data)
68 dev->features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM;
69 else
70 dev->features &= ~(NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM);
71
72 return 0;
73}
74
1da177e4
LT		 75u32 ethtool_op_get_sg(struct net_device *dev)
76{
77 return (dev->features & NETIF_F_SG) != 0;
78}
79
80int ethtool_op_set_sg(struct net_device *dev, u32 data)
81{
82 if (data)
83 dev->features |= NETIF_F_SG;
84 else
85 dev->features &= ~NETIF_F_SG;
86
87 return 0;
88}
89
90u32 ethtool_op_get_tso(struct net_device *dev)
91{
92 return (dev->features & NETIF_F_TSO) != 0;
93}
94
95int ethtool_op_set_tso(struct net_device *dev, u32 data)
96{
97 if (data)
98 dev->features |= NETIF_F_TSO;
99 else
100 dev->features &= ~NETIF_F_TSO;
101
102 return 0;
103}
104
e89e9cf5
AR		 105u32 ethtool_op_get_ufo(struct net_device *dev)
106{
107 return (dev->features & NETIF_F_UFO) != 0;
108}
109
110int ethtool_op_set_ufo(struct net_device *dev, u32 data)
111{
112 if (data)
113 dev->features |= NETIF_F_UFO;
114 else
115 dev->features &= ~NETIF_F_UFO;
116 return 0;
117}
118
3ae7c0b2
JG		 119/* the following list of flags are the same as their associated
120 * NETIF_F_xxx values in include/linux/netdevice.h
121 */
122static const u32 flags_dup_features =
123 ETH_FLAG_LRO;
124
125u32 ethtool_op_get_flags(struct net_device *dev)
126{
127 /* in the future, this function will probably contain additional
128 * handling for flags which are not so easily handled
129 * by a simple masking operation
130 */
131
132 return dev->features & flags_dup_features;
133}
134
135int ethtool_op_set_flags(struct net_device *dev, u32 data)
136{
137 if (data & ETH_FLAG_LRO)
138 dev->features |= NETIF_F_LRO;
139 else
140 dev->features &= ~NETIF_F_LRO;
141
142 return 0;
143}
144
1da177e4
LT		 145/* Handlers for each ethtool command */
146
147static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
148{
149 struct ethtool_cmd cmd = { ETHTOOL_GSET };
150 int err;
151
152 if (!dev->ethtool_ops->get_settings)
153 return -EOPNOTSUPP;
154
155 err = dev->ethtool_ops->get_settings(dev, &cmd);
156 if (err < 0)
157 return err;
158
159 if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
160 return -EFAULT;
161 return 0;
162}
163
164static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
165{
166 struct ethtool_cmd cmd;
167
168 if (!dev->ethtool_ops->set_settings)
169 return -EOPNOTSUPP;
170
171 if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
172 return -EFAULT;
173
174 return dev->ethtool_ops->set_settings(dev, &cmd);
175}
176
177static int ethtool_get_drvinfo(struct net_device *dev, void __user *useraddr)
178{
179 struct ethtool_drvinfo info;
76fd8593 180 const struct ethtool_ops *ops = dev->ethtool_ops;
1da177e4
LT		 181
182 if (!ops->get_drvinfo)
183 return -EOPNOTSUPP;
184
185 memset(&info, 0, sizeof(info));
186 info.cmd = ETHTOOL_GDRVINFO;
187 ops->get_drvinfo(dev, &info);
188
ff03d49f
JG		 189 if (ops->get_sset_count) {
190 int rc;
191
192 rc = ops->get_sset_count(dev, ETH_SS_TEST);
193 if (rc >= 0)
194 info.testinfo_len = rc;
195 rc = ops->get_sset_count(dev, ETH_SS_STATS);
196 if (rc >= 0)
197 info.n_stats = rc;
339bf024
JG		 198 rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);
199 if (rc >= 0)
200 info.n_priv_flags = rc;
ff03d49f
JG		 201 } else {
202 /* code path for obsolete hooks */
203
204 if (ops->self_test_count)
205 info.testinfo_len = ops->self_test_count(dev);
206 if (ops->get_stats_count)
207 info.n_stats = ops->get_stats_count(dev);
208 }
1da177e4
LT		 209 if (ops->get_regs_len)
210 info.regdump_len = ops->get_regs_len(dev);
211 if (ops->get_eeprom_len)
212 info.eedump_len = ops->get_eeprom_len(dev);
213
214 if (copy_to_user(useraddr, &info, sizeof(info)))
215 return -EFAULT;
216 return 0;
217}
218
59089d8d 219static int ethtool_set_rxnfc(struct net_device *dev, void __user *useraddr)
0853ad66
SB		 220{
221 struct ethtool_rxnfc cmd;
222
59089d8d 223 if (!dev->ethtool_ops->set_rxnfc)
0853ad66
SB		 224 return -EOPNOTSUPP;
225
226 if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
227 return -EFAULT;
228
59089d8d 229 return dev->ethtool_ops->set_rxnfc(dev, &cmd);
0853ad66
SB		 230}
231
59089d8d 232static int ethtool_get_rxnfc(struct net_device *dev, void __user *useraddr)
0853ad66
SB		 233{
234 struct ethtool_rxnfc info;
59089d8d
SB		 235 const struct ethtool_ops *ops = dev->ethtool_ops;
236 int ret;
237 void *rule_buf = NULL;
0853ad66 238
59089d8d 239 if (!ops->get_rxnfc)
0853ad66
SB		 240 return -EOPNOTSUPP;
241
242 if (copy_from_user(&info, useraddr, sizeof(info)))
243 return -EFAULT;
244
59089d8d
SB		 245 if (info.cmd == ETHTOOL_GRXCLSRLALL) {
246 if (info.rule_cnt > 0) {
247 rule_buf = kmalloc(info.rule_cnt * sizeof(u32),
248 GFP_USER);
249 if (!rule_buf)
250 return -ENOMEM;
251 }
252 }
0853ad66 253
59089d8d
SB		 254 ret = ops->get_rxnfc(dev, &info, rule_buf);
255 if (ret < 0)
256 goto err_out;
257
258 ret = -EFAULT;
0853ad66 259 if (copy_to_user(useraddr, &info, sizeof(info)))
59089d8d
SB		 260 goto err_out;
261
262 if (rule_buf) {
263 useraddr += offsetof(struct ethtool_rxnfc, rule_locs);
264 if (copy_to_user(useraddr, rule_buf,
265 info.rule_cnt * sizeof(u32)))
266 goto err_out;
267 }
268 ret = 0;
269
270err_out:
c9caceca 271 kfree(rule_buf);
59089d8d
SB		 272
273 return ret;
0853ad66
SB		 274}
275
1da177e4
LT		 276static int ethtool_get_regs(struct net_device *dev, char __user *useraddr)
277{
278 struct ethtool_regs regs;
76fd8593 279 const struct ethtool_ops *ops = dev->ethtool_ops;
1da177e4
LT		 280 void *regbuf;
281 int reglen, ret;
282
283 if (!ops->get_regs || !ops->get_regs_len)
284 return -EOPNOTSUPP;
285
286 if (copy_from_user(&regs, useraddr, sizeof(regs)))
287 return -EFAULT;
288
289 reglen = ops->get_regs_len(dev);
290 if (regs.len > reglen)
291 regs.len = reglen;
292
293 regbuf = kmalloc(reglen, GFP_USER);
294 if (!regbuf)
295 return -ENOMEM;
296
297 ops->get_regs(dev, &regs, regbuf);
298
299 ret = -EFAULT;
300 if (copy_to_user(useraddr, &regs, sizeof(regs)))
301 goto out;
302 useraddr += offsetof(struct ethtool_regs, data);
303 if (copy_to_user(useraddr, regbuf, regs.len))
304 goto out;
305 ret = 0;
306
307 out:
308 kfree(regbuf);
309 return ret;
310}
311
312static int ethtool_get_wol(struct net_device *dev, char __user *useraddr)
313{
314 struct ethtool_wolinfo wol = { ETHTOOL_GWOL };
315
316 if (!dev->ethtool_ops->get_wol)
317 return -EOPNOTSUPP;
318
319 dev->ethtool_ops->get_wol(dev, &wol);
320
321 if (copy_to_user(useraddr, &wol, sizeof(wol)))
322 return -EFAULT;
323 return 0;
324}
325
326static int ethtool_set_wol(struct net_device *dev, char __user *useraddr)
327{
328 struct ethtool_wolinfo wol;
329
330 if (!dev->ethtool_ops->set_wol)
331 return -EOPNOTSUPP;
332
333 if (copy_from_user(&wol, useraddr, sizeof(wol)))
334 return -EFAULT;
335
336 return dev->ethtool_ops->set_wol(dev, &wol);
337}
338
1da177e4
LT		 339static int ethtool_nway_reset(struct net_device *dev)
340{
341 if (!dev->ethtool_ops->nway_reset)
342 return -EOPNOTSUPP;
343
344 return dev->ethtool_ops->nway_reset(dev);
345}
346
1da177e4
LT		 347static int ethtool_get_eeprom(struct net_device *dev, void __user *useraddr)
348{
349 struct ethtool_eeprom eeprom;
76fd8593 350 const struct ethtool_ops *ops = dev->ethtool_ops;
b131dd5d
MSB		 351 void __user *userbuf = useraddr + sizeof(eeprom);
352 u32 bytes_remaining;
1da177e4 353 u8 *data;
b131dd5d 354 int ret = 0;
1da177e4
LT		 355
356 if (!ops->get_eeprom || !ops->get_eeprom_len)
357 return -EOPNOTSUPP;
358
359 if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
360 return -EFAULT;
361
362 /* Check for wrap and zero */
363 if (eeprom.offset + eeprom.len <= eeprom.offset)
364 return -EINVAL;
365
366 /* Check for exceeding total eeprom len */
367 if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
368 return -EINVAL;
369
b131dd5d 370 data = kmalloc(PAGE_SIZE, GFP_USER);
1da177e4
LT		 371 if (!data)
372 return -ENOMEM;
373
b131dd5d
MSB		 374 bytes_remaining = eeprom.len;
375 while (bytes_remaining > 0) {
376 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
377
378 ret = ops->get_eeprom(dev, &eeprom, data);
379 if (ret)
380 break;
381 if (copy_to_user(userbuf, data, eeprom.len)) {
382 ret = -EFAULT;
383 break;
384 }
385 userbuf += eeprom.len;
386 eeprom.offset += eeprom.len;
387 bytes_remaining -= eeprom.len;
388 }
1da177e4 389
c5835df9
MSB		 390 eeprom.len = userbuf - (useraddr + sizeof(eeprom));
391 eeprom.offset -= eeprom.len;
392 if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
393 ret = -EFAULT;
394
1da177e4
LT		 395 kfree(data);
396 return ret;
397}
398
399static int ethtool_set_eeprom(struct net_device *dev, void __user *useraddr)
400{
401 struct ethtool_eeprom eeprom;
76fd8593 402 const struct ethtool_ops *ops = dev->ethtool_ops;
b131dd5d
MSB		 403 void __user *userbuf = useraddr + sizeof(eeprom);
404 u32 bytes_remaining;
1da177e4 405 u8 *data;
b131dd5d 406 int ret = 0;
1da177e4
LT		 407
408 if (!ops->set_eeprom || !ops->get_eeprom_len)
409 return -EOPNOTSUPP;
410
411 if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
412 return -EFAULT;
413
414 /* Check for wrap and zero */
415 if (eeprom.offset + eeprom.len <= eeprom.offset)
416 return -EINVAL;
417
418 /* Check for exceeding total eeprom len */
419 if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
420 return -EINVAL;
421
b131dd5d 422 data = kmalloc(PAGE_SIZE, GFP_USER);
1da177e4
LT		 423 if (!data)
424 return -ENOMEM;
425
b131dd5d
MSB		 426 bytes_remaining = eeprom.len;
427 while (bytes_remaining > 0) {
428 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
429
430 if (copy_from_user(data, userbuf, eeprom.len)) {
431 ret = -EFAULT;
432 break;
433 }
434 ret = ops->set_eeprom(dev, &eeprom, data);
435 if (ret)
436 break;
437 userbuf += eeprom.len;
438 eeprom.offset += eeprom.len;
439 bytes_remaining -= eeprom.len;
440 }
1da177e4 441
1da177e4
LT		 442 kfree(data);
443 return ret;
444}
445
446static int ethtool_get_coalesce(struct net_device *dev, void __user *useraddr)
447{
448 struct ethtool_coalesce coalesce = { ETHTOOL_GCOALESCE };
449
450 if (!dev->ethtool_ops->get_coalesce)
451 return -EOPNOTSUPP;
452
453 dev->ethtool_ops->get_coalesce(dev, &coalesce);
454
455 if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
456 return -EFAULT;
457 return 0;
458}
459
460static int ethtool_set_coalesce(struct net_device *dev, void __user *useraddr)
461{
462 struct ethtool_coalesce coalesce;
463
fa04ae5c 464 if (!dev->ethtool_ops->set_coalesce)
1da177e4
LT		 465 return -EOPNOTSUPP;
466
467 if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))
468 return -EFAULT;
469
470 return dev->ethtool_ops->set_coalesce(dev, &coalesce);
471}
472
473static int ethtool_get_ringparam(struct net_device *dev, void __user *useraddr)
474{
475 struct ethtool_ringparam ringparam = { ETHTOOL_GRINGPARAM };
476
477 if (!dev->ethtool_ops->get_ringparam)
478 return -EOPNOTSUPP;
479
480 dev->ethtool_ops->get_ringparam(dev, &ringparam);
481
482 if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))
483 return -EFAULT;
484 return 0;
485}
486
487static int ethtool_set_ringparam(struct net_device *dev, void __user *useraddr)
488{
489 struct ethtool_ringparam ringparam;
490
491 if (!dev->ethtool_ops->set_ringparam)
492 return -EOPNOTSUPP;
493
494 if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))
495 return -EFAULT;
496
497 return dev->ethtool_ops->set_ringparam(dev, &ringparam);
498}
499
500static int ethtool_get_pauseparam(struct net_device *dev, void __user *useraddr)
501{
502 struct ethtool_pauseparam pauseparam = { ETHTOOL_GPAUSEPARAM };
503
504 if (!dev->ethtool_ops->get_pauseparam)
505 return -EOPNOTSUPP;
506
507 dev->ethtool_ops->get_pauseparam(dev, &pauseparam);
508
509 if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))
510 return -EFAULT;
511 return 0;
512}
513
514static int ethtool_set_pauseparam(struct net_device *dev, void __user *useraddr)
515{
516 struct ethtool_pauseparam pauseparam;
517
e1b90c41 518 if (!dev->ethtool_ops->set_pauseparam)
1da177e4
LT		 519 return -EOPNOTSUPP;
520
521 if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))
522 return -EFAULT;
523
524 return dev->ethtool_ops->set_pauseparam(dev, &pauseparam);
525}
526
1da177e4
LT		 527static int __ethtool_set_sg(struct net_device *dev, u32 data)
528{
529 int err;
530
531 if (!data && dev->ethtool_ops->set_tso) {
532 err = dev->ethtool_ops->set_tso(dev, 0);
533 if (err)
534 return err;
535 }
536
e89e9cf5
AR		 537 if (!data && dev->ethtool_ops->set_ufo) {
538 err = dev->ethtool_ops->set_ufo(dev, 0);
539 if (err)
540 return err;
541 }
1da177e4
LT		 542 return dev->ethtool_ops->set_sg(dev, data);
543}
544
545static int ethtool_set_tx_csum(struct net_device *dev, char __user *useraddr)
546{
547 struct ethtool_value edata;
548 int err;
549
550 if (!dev->ethtool_ops->set_tx_csum)
551 return -EOPNOTSUPP;
552
553 if (copy_from_user(&edata, useraddr, sizeof(edata)))
554 return -EFAULT;
555
556 if (!edata.data && dev->ethtool_ops->set_sg) {
557 err = __ethtool_set_sg(dev, 0);
558 if (err)
559 return err;
560 }
561
562 return dev->ethtool_ops->set_tx_csum(dev, edata.data);
563}
564
b240a0e5
HX		 565static int ethtool_set_rx_csum(struct net_device *dev, char __user *useraddr)
566{
567 struct ethtool_value edata;
568
569 if (!dev->ethtool_ops->set_rx_csum)
570 return -EOPNOTSUPP;
571
572 if (copy_from_user(&edata, useraddr, sizeof(edata)))
573 return -EFAULT;
574
575 if (!edata.data && dev->ethtool_ops->set_sg)
576 dev->features &= ~NETIF_F_GRO;
577
578 return dev->ethtool_ops->set_rx_csum(dev, edata.data);
579}
580
1da177e4
LT		 581static int ethtool_set_sg(struct net_device *dev, char __user *useraddr)
582{
583 struct ethtool_value edata;
584
585 if (!dev->ethtool_ops->set_sg)
586 return -EOPNOTSUPP;
587
588 if (copy_from_user(&edata, useraddr, sizeof(edata)))
589 return -EFAULT;
590
4ec93edb 591 if (edata.data &&
8648b305 592 !(dev->features & NETIF_F_ALL_CSUM))
1da177e4
LT		 593 return -EINVAL;
594
595 return __ethtool_set_sg(dev, edata.data);
596}
597
1da177e4
LT		 598static int ethtool_set_tso(struct net_device *dev, char __user *useraddr)
599{
600 struct ethtool_value edata;
601
602 if (!dev->ethtool_ops->set_tso)
603 return -EOPNOTSUPP;
604
605 if (copy_from_user(&edata, useraddr, sizeof(edata)))
606 return -EFAULT;
607
608 if (edata.data && !(dev->features & NETIF_F_SG))
609 return -EINVAL;
610
611 return dev->ethtool_ops->set_tso(dev, edata.data);
612}
613
e89e9cf5
AR		 614static int ethtool_set_ufo(struct net_device *dev, char __user *useraddr)
615{
616 struct ethtool_value edata;
617
618 if (!dev->ethtool_ops->set_ufo)
619 return -EOPNOTSUPP;
620 if (copy_from_user(&edata, useraddr, sizeof(edata)))
621 return -EFAULT;
622 if (edata.data && !(dev->features & NETIF_F_SG))
623 return -EINVAL;
624 if (edata.data && !(dev->features & NETIF_F_HW_CSUM))
625 return -EINVAL;
626 return dev->ethtool_ops->set_ufo(dev, edata.data);
627}
628
37c3185a
HX		 629static int ethtool_get_gso(struct net_device *dev, char __user *useraddr)
630{
631 struct ethtool_value edata = { ETHTOOL_GGSO };
632
633 edata.data = dev->features & NETIF_F_GSO;
634 if (copy_to_user(useraddr, &edata, sizeof(edata)))
635 return -EFAULT;
636 return 0;
637}
638
639static int ethtool_set_gso(struct net_device *dev, char __user *useraddr)
640{
641 struct ethtool_value edata;
642
643 if (copy_from_user(&edata, useraddr, sizeof(edata)))
644 return -EFAULT;
645 if (edata.data)
646 dev->features |= NETIF_F_GSO;
647 else
648 dev->features &= ~NETIF_F_GSO;
649 return 0;
650}
651
b240a0e5
HX		 652static int ethtool_get_gro(struct net_device *dev, char __user *useraddr)
653{
654 struct ethtool_value edata = { ETHTOOL_GGRO };
655
656 edata.data = dev->features & NETIF_F_GRO;
657 if (copy_to_user(useraddr, &edata, sizeof(edata)))
658 return -EFAULT;
659 return 0;
660}
661
662static int ethtool_set_gro(struct net_device *dev, char __user *useraddr)
663{
664 struct ethtool_value edata;
665
666 if (copy_from_user(&edata, useraddr, sizeof(edata)))
667 return -EFAULT;
668
669 if (edata.data) {
670 if (!dev->ethtool_ops->get_rx_csum ||
671 !dev->ethtool_ops->get_rx_csum(dev))
672 return -EINVAL;
673 dev->features |= NETIF_F_GRO;
674 } else
675 dev->features &= ~NETIF_F_GRO;
676
677 return 0;
678}
679
1da177e4
LT		 680static int ethtool_self_test(struct net_device *dev, char __user *useraddr)
681{
682 struct ethtool_test test;
76fd8593 683 const struct ethtool_ops *ops = dev->ethtool_ops;
1da177e4 684 u64 *data;
ff03d49f 685 int ret, test_len;
1da177e4 686
ff03d49f
JG		 687 if (!ops->self_test)
688 return -EOPNOTSUPP;
689 if (!ops->get_sset_count && !ops->self_test_count)
1da177e4
LT		 690 return -EOPNOTSUPP;
691
ff03d49f
JG		 692 if (ops->get_sset_count)
693 test_len = ops->get_sset_count(dev, ETH_SS_TEST);
694 else
695 /* code path for obsolete hook */
696 test_len = ops->self_test_count(dev);
697 if (test_len < 0)
698 return test_len;
699 WARN_ON(test_len == 0);
700
1da177e4
LT		 701 if (copy_from_user(&test, useraddr, sizeof(test)))
702 return -EFAULT;
703
ff03d49f
JG		 704 test.len = test_len;
705 data = kmalloc(test_len * sizeof(u64), GFP_USER);
1da177e4
LT		 706 if (!data)
707 return -ENOMEM;
708
709 ops->self_test(dev, &test, data);
710
711 ret = -EFAULT;
712 if (copy_to_user(useraddr, &test, sizeof(test)))
713 goto out;
714 useraddr += sizeof(test);
715 if (copy_to_user(useraddr, data, test.len * sizeof(u64)))
716 goto out;
717 ret = 0;
718
719 out:
720 kfree(data);
721 return ret;
722}
723
724static int ethtool_get_strings(struct net_device *dev, void __user *useraddr)
725{
726 struct ethtool_gstrings gstrings;
76fd8593 727 const struct ethtool_ops *ops = dev->ethtool_ops;
1da177e4
LT		 728 u8 *data;
729 int ret;
730
731 if (!ops->get_strings)
732 return -EOPNOTSUPP;
733
734 if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
735 return -EFAULT;
736
ff03d49f
JG		 737 if (ops->get_sset_count) {
738 ret = ops->get_sset_count(dev, gstrings.string_set);
739 if (ret < 0)
740 return ret;
741
742 gstrings.len = ret;
743 } else {
744 /* code path for obsolete hooks */
745
746 switch (gstrings.string_set) {
747 case ETH_SS_TEST:
748 if (!ops->self_test_count)
749 return -EOPNOTSUPP;
750 gstrings.len = ops->self_test_count(dev);
751 break;
752 case ETH_SS_STATS:
753 if (!ops->get_stats_count)
754 return -EOPNOTSUPP;
755 gstrings.len = ops->get_stats_count(dev);
756 break;
757 default:
758 return -EINVAL;
759 }
1da177e4
LT		 760 }
761
762 data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
763 if (!data)
764 return -ENOMEM;
765
766 ops->get_strings(dev, gstrings.string_set, data);
767
768 ret = -EFAULT;
769 if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
770 goto out;
771 useraddr += sizeof(gstrings);
772 if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
773 goto out;
774 ret = 0;
775
776 out:
777 kfree(data);
778 return ret;
779}
780
781static int ethtool_phys_id(struct net_device *dev, void __user *useraddr)
782{
783 struct ethtool_value id;
784
785 if (!dev->ethtool_ops->phys_id)
786 return -EOPNOTSUPP;
787
788 if (copy_from_user(&id, useraddr, sizeof(id)))
789 return -EFAULT;
790
791 return dev->ethtool_ops->phys_id(dev, id.data);
792}
793
794static int ethtool_get_stats(struct net_device *dev, void __user *useraddr)
795{
796 struct ethtool_stats stats;
76fd8593 797 const struct ethtool_ops *ops = dev->ethtool_ops;
1da177e4 798 u64 *data;
ff03d49f 799 int ret, n_stats;
1da177e4 800
ff03d49f
JG		 801 if (!ops->get_ethtool_stats)
802 return -EOPNOTSUPP;
803 if (!ops->get_sset_count && !ops->get_stats_count)
1da177e4
LT		 804 return -EOPNOTSUPP;
805
ff03d49f
JG		 806 if (ops->get_sset_count)
807 n_stats = ops->get_sset_count(dev, ETH_SS_STATS);
808 else
809 /* code path for obsolete hook */
810 n_stats = ops->get_stats_count(dev);
811 if (n_stats < 0)
812 return n_stats;
813 WARN_ON(n_stats == 0);
814
1da177e4
LT		 815 if (copy_from_user(&stats, useraddr, sizeof(stats)))
816 return -EFAULT;
817
ff03d49f
JG		 818 stats.n_stats = n_stats;
819 data = kmalloc(n_stats * sizeof(u64), GFP_USER);
1da177e4
LT		 820 if (!data)
821 return -ENOMEM;
822
823 ops->get_ethtool_stats(dev, &stats, data);
824
825 ret = -EFAULT;
826 if (copy_to_user(useraddr, &stats, sizeof(stats)))
827 goto out;
828 useraddr += sizeof(stats);
829 if (copy_to_user(useraddr, data, stats.n_stats * sizeof(u64)))
830 goto out;
831 ret = 0;
832
833 out:
834 kfree(data);
835 return ret;
836}
837
0bf0519d 838static int ethtool_get_perm_addr(struct net_device *dev, void __user *useraddr)
a6f9a705
JW		 839{
840 struct ethtool_perm_addr epaddr;
a6f9a705 841
313674af 842 if (copy_from_user(&epaddr, useraddr, sizeof(epaddr)))
a6f9a705
JW		 843 return -EFAULT;
844
313674af
MW		 845 if (epaddr.size < dev->addr_len)
846 return -ETOOSMALL;
847 epaddr.size = dev->addr_len;
a6f9a705 848
a6f9a705 849 if (copy_to_user(useraddr, &epaddr, sizeof(epaddr)))
313674af 850 return -EFAULT;
a6f9a705 851 useraddr += sizeof(epaddr);
313674af
MW		 852 if (copy_to_user(useraddr, dev->perm_addr, epaddr.size))
853 return -EFAULT;
854 return 0;
a6f9a705
JW		 855}
856
13c99b24
JG		 857static int ethtool_get_value(struct net_device *dev, char __user *useraddr,
858 u32 cmd, u32 (*actor)(struct net_device *))
3ae7c0b2 859{
13c99b24 860 struct ethtool_value edata = { cmd };
3ae7c0b2 861
13c99b24 862 if (!actor)
3ae7c0b2
JG		 863 return -EOPNOTSUPP;
864
13c99b24 865 edata.data = actor(dev);
3ae7c0b2
JG		 866
867 if (copy_to_user(useraddr, &edata, sizeof(edata)))
868 return -EFAULT;
869 return 0;
870}
871
13c99b24
JG		 872static int ethtool_set_value_void(struct net_device *dev, char __user *useraddr,
873 void (*actor)(struct net_device *, u32))
3ae7c0b2
JG		 874{
875 struct ethtool_value edata;
876
13c99b24 877 if (!actor)
3ae7c0b2
JG		 878 return -EOPNOTSUPP;
879
880 if (copy_from_user(&edata, useraddr, sizeof(edata)))
881 return -EFAULT;
882
13c99b24 883 actor(dev, edata.data);
339bf024
JG		 884 return 0;
885}
886
13c99b24
JG		 887static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
888 int (*actor)(struct net_device *, u32))
339bf024
JG		 889{
890 struct ethtool_value edata;
891
13c99b24 892 if (!actor)
339bf024
JG		 893 return -EOPNOTSUPP;
894
895 if (copy_from_user(&edata, useraddr, sizeof(edata)))
896 return -EFAULT;
897
13c99b24 898 return actor(dev, edata.data);
339bf024
JG		 899}
900
1da177e4
LT		 901/* The main entry point in this file. Called from net/core/dev.c */
902
881d966b 903int dev_ethtool(struct net *net, struct ifreq *ifr)
1da177e4 904{
881d966b 905 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
1da177e4
LT		 906 void __user *useraddr = ifr->ifr_data;
907 u32 ethcmd;
908 int rc;
81e81575 909 unsigned long old_features;
1da177e4 910
1da177e4
LT		 911 if (!dev || !netif_device_present(dev))
912 return -ENODEV;
913
914 if (!dev->ethtool_ops)
61a44b9c 915 return -EOPNOTSUPP;
1da177e4
LT		 916
917 if (copy_from_user(&ethcmd, useraddr, sizeof (ethcmd)))
918 return -EFAULT;
919
75f3123c
SH		 920 /* Allow some commands to be done by anyone */
921 switch(ethcmd) {
75f3123c 922 case ETHTOOL_GDRVINFO:
75f3123c 923 case ETHTOOL_GMSGLVL:
75f3123c
SH		 924 case ETHTOOL_GCOALESCE:
925 case ETHTOOL_GRINGPARAM:
926 case ETHTOOL_GPAUSEPARAM:
927 case ETHTOOL_GRXCSUM:
928 case ETHTOOL_GTXCSUM:
929 case ETHTOOL_GSG:
930 case ETHTOOL_GSTRINGS:
75f3123c
SH		 931 case ETHTOOL_GTSO:
932 case ETHTOOL_GPERMADDR:
933 case ETHTOOL_GUFO:
934 case ETHTOOL_GGSO:
339bf024
JG		 935 case ETHTOOL_GFLAGS:
936 case ETHTOOL_GPFLAGS:
0853ad66 937 case ETHTOOL_GRXFH:
59089d8d
SB		 938 case ETHTOOL_GRXRINGS:
939 case ETHTOOL_GRXCLSRLCNT:
940 case ETHTOOL_GRXCLSRULE:
941 case ETHTOOL_GRXCLSRLALL:
75f3123c
SH		 942 break;
943 default:
944 if (!capable(CAP_NET_ADMIN))
945 return -EPERM;
946 }
947
e71a4783 948 if (dev->ethtool_ops->begin)
1da177e4
LT		 949 if ((rc = dev->ethtool_ops->begin(dev)) < 0)
950 return rc;
951
d8a33ac4
SH		 952 old_features = dev->features;
953
1da177e4
LT		 954 switch (ethcmd) {
955 case ETHTOOL_GSET:
956 rc = ethtool_get_settings(dev, useraddr);
957 break;
958 case ETHTOOL_SSET:
959 rc = ethtool_set_settings(dev, useraddr);
960 break;
961 case ETHTOOL_GDRVINFO:
962 rc = ethtool_get_drvinfo(dev, useraddr);
1da177e4
LT		 963 break;
964 case ETHTOOL_GREGS:
965 rc = ethtool_get_regs(dev, useraddr);
966 break;
967 case ETHTOOL_GWOL:
968 rc = ethtool_get_wol(dev, useraddr);
969 break;
970 case ETHTOOL_SWOL:
971 rc = ethtool_set_wol(dev, useraddr);
972 break;
973 case ETHTOOL_GMSGLVL:
13c99b24
JG		 974 rc = ethtool_get_value(dev, useraddr, ethcmd,
975 dev->ethtool_ops->get_msglevel);
1da177e4
LT		 976 break;
977 case ETHTOOL_SMSGLVL:
13c99b24
JG		 978 rc = ethtool_set_value_void(dev, useraddr,
979 dev->ethtool_ops->set_msglevel);
1da177e4
LT		 980 break;
981 case ETHTOOL_NWAY_RST:
982 rc = ethtool_nway_reset(dev);
983 break;
984 case ETHTOOL_GLINK:
13c99b24
JG		 985 rc = ethtool_get_value(dev, useraddr, ethcmd,
986 dev->ethtool_ops->get_link);
1da177e4
LT		 987 break;
988 case ETHTOOL_GEEPROM:
989 rc = ethtool_get_eeprom(dev, useraddr);
990 break;
991 case ETHTOOL_SEEPROM:
992 rc = ethtool_set_eeprom(dev, useraddr);
993 break;
994 case ETHTOOL_GCOALESCE:
995 rc = ethtool_get_coalesce(dev, useraddr);
996 break;
997 case ETHTOOL_SCOALESCE:
998 rc = ethtool_set_coalesce(dev, useraddr);
999 break;
1000 case ETHTOOL_GRINGPARAM:
1001 rc = ethtool_get_ringparam(dev, useraddr);
1002 break;
1003 case ETHTOOL_SRINGPARAM:
1004 rc = ethtool_set_ringparam(dev, useraddr);
1005 break;
1006 case ETHTOOL_GPAUSEPARAM:
1007 rc = ethtool_get_pauseparam(dev, useraddr);
1008 break;
1009 case ETHTOOL_SPAUSEPARAM:
1010 rc = ethtool_set_pauseparam(dev, useraddr);
1011 break;
1012 case ETHTOOL_GRXCSUM:
13c99b24 1013 rc = ethtool_get_value(dev, useraddr, ethcmd,
1896e61f
SS		 1014 (dev->ethtool_ops->get_rx_csum ?
1015 dev->ethtool_ops->get_rx_csum :
1016 ethtool_op_get_rx_csum));
1da177e4
LT		 1017 break;
1018 case ETHTOOL_SRXCSUM:
b240a0e5 1019 rc = ethtool_set_rx_csum(dev, useraddr);
1da177e4
LT		 1020 break;
1021 case ETHTOOL_GTXCSUM:
13c99b24 1022 rc = ethtool_get_value(dev, useraddr, ethcmd,
88d3aafd
JG		 1023 (dev->ethtool_ops->get_tx_csum ?
1024 dev->ethtool_ops->get_tx_csum :
1025 ethtool_op_get_tx_csum));
1da177e4
LT		 1026 break;
1027 case ETHTOOL_STXCSUM:
1028 rc = ethtool_set_tx_csum(dev, useraddr);
1029 break;
1030 case ETHTOOL_GSG:
13c99b24 1031 rc = ethtool_get_value(dev, useraddr, ethcmd,
88d3aafd
JG		 1032 (dev->ethtool_ops->get_sg ?
1033 dev->ethtool_ops->get_sg :
1034 ethtool_op_get_sg));
1da177e4
LT		 1035 break;
1036 case ETHTOOL_SSG:
1037 rc = ethtool_set_sg(dev, useraddr);
1038 break;
1039 case ETHTOOL_GTSO:
13c99b24 1040 rc = ethtool_get_value(dev, useraddr, ethcmd,
88d3aafd
JG		 1041 (dev->ethtool_ops->get_tso ?
1042 dev->ethtool_ops->get_tso :
1043 ethtool_op_get_tso));
1da177e4
LT		 1044 break;
1045 case ETHTOOL_STSO:
1046 rc = ethtool_set_tso(dev, useraddr);
1047 break;
1048 case ETHTOOL_TEST:
1049 rc = ethtool_self_test(dev, useraddr);
1050 break;
1051 case ETHTOOL_GSTRINGS:
1052 rc = ethtool_get_strings(dev, useraddr);
1053 break;
1054 case ETHTOOL_PHYS_ID:
1055 rc = ethtool_phys_id(dev, useraddr);
1056 break;
1057 case ETHTOOL_GSTATS:
1058 rc = ethtool_get_stats(dev, useraddr);
1059 break;
a6f9a705
JW		 1060 case ETHTOOL_GPERMADDR:
1061 rc = ethtool_get_perm_addr(dev, useraddr);
1062 break;
e89e9cf5 1063 case ETHTOOL_GUFO:
13c99b24 1064 rc = ethtool_get_value(dev, useraddr, ethcmd,
88d3aafd
JG		 1065 (dev->ethtool_ops->get_ufo ?
1066 dev->ethtool_ops->get_ufo :
1067 ethtool_op_get_ufo));
e89e9cf5
AR		 1068 break;
1069 case ETHTOOL_SUFO:
1070 rc = ethtool_set_ufo(dev, useraddr);
1071 break;
37c3185a
HX		 1072 case ETHTOOL_GGSO:
1073 rc = ethtool_get_gso(dev, useraddr);
1074 break;
1075 case ETHTOOL_SGSO:
1076 rc = ethtool_set_gso(dev, useraddr);
1077 break;
3ae7c0b2 1078 case ETHTOOL_GFLAGS:
13c99b24 1079 rc = ethtool_get_value(dev, useraddr, ethcmd,
1896e61f
SS		 1080 (dev->ethtool_ops->get_flags ?
1081 dev->ethtool_ops->get_flags :
1082 ethtool_op_get_flags));
3ae7c0b2
JG		 1083 break;
1084 case ETHTOOL_SFLAGS:
13c99b24
JG		 1085 rc = ethtool_set_value(dev, useraddr,
1086 dev->ethtool_ops->set_flags);
3ae7c0b2 1087 break;
339bf024 1088 case ETHTOOL_GPFLAGS:
13c99b24
JG		 1089 rc = ethtool_get_value(dev, useraddr, ethcmd,
1090 dev->ethtool_ops->get_priv_flags);
339bf024
JG		 1091 break;
1092 case ETHTOOL_SPFLAGS:
13c99b24
JG		 1093 rc = ethtool_set_value(dev, useraddr,
1094 dev->ethtool_ops->set_priv_flags);
339bf024 1095 break;
0853ad66 1096 case ETHTOOL_GRXFH:
59089d8d
SB		 1097 case ETHTOOL_GRXRINGS:
1098 case ETHTOOL_GRXCLSRLCNT:
1099 case ETHTOOL_GRXCLSRULE:
1100 case ETHTOOL_GRXCLSRLALL:
1101 rc = ethtool_get_rxnfc(dev, useraddr);
0853ad66
SB		 1102 break;
1103 case ETHTOOL_SRXFH:
59089d8d
SB		 1104 case ETHTOOL_SRXCLSRLDEL:
1105 case ETHTOOL_SRXCLSRLINS:
1106 rc = ethtool_set_rxnfc(dev, useraddr);
0853ad66 1107 break;
b240a0e5
HX		 1108 case ETHTOOL_GGRO:
1109 rc = ethtool_get_gro(dev, useraddr);
1110 break;
1111 case ETHTOOL_SGRO:
1112 rc = ethtool_set_gro(dev, useraddr);
1113 break;
1da177e4 1114 default:
61a44b9c 1115 rc = -EOPNOTSUPP;
1da177e4 1116 }
4ec93edb 1117
e71a4783 1118 if (dev->ethtool_ops->complete)
1da177e4 1119 dev->ethtool_ops->complete(dev);
d8a33ac4
SH		 1120
1121 if (old_features != dev->features)
1122 netdev_features_change(dev);
1123
1da177e4 1124 return rc;
1da177e4
LT		 1125}
1126
1da177e4
LT		 1127EXPORT_SYMBOL(ethtool_op_get_link);
1128EXPORT_SYMBOL(ethtool_op_get_sg);
1129EXPORT_SYMBOL(ethtool_op_get_tso);
1da177e4
LT		 1130EXPORT_SYMBOL(ethtool_op_set_sg);
1131EXPORT_SYMBOL(ethtool_op_set_tso);
1132EXPORT_SYMBOL(ethtool_op_set_tx_csum);
69f6a0fa 1133EXPORT_SYMBOL(ethtool_op_set_tx_hw_csum);
6460d948 1134EXPORT_SYMBOL(ethtool_op_set_tx_ipv6_csum);
e89e9cf5
AR		 1135EXPORT_SYMBOL(ethtool_op_set_ufo);
1136EXPORT_SYMBOL(ethtool_op_get_ufo);
3ae7c0b2
JG		 1137EXPORT_SYMBOL(ethtool_op_set_flags);
1138EXPORT_SYMBOL(ethtool_op_get_flags);
Clone of davem's net-next-2.6 tree