blob: c1a71bb738da4db6c8cd62b75d36b5d091316fd8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Matthew Wilcox61a44b92007-07-31 14:00:02 -07006 * the information ethtool needs.
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
Matthew Wilcox61a44b92007-07-31 14:00:02 -07008 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 */
13
14#include <linux/module.h>
15#include <linux/types.h>
Randy Dunlap4fc268d2006-01-11 12:17:47 -080016#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/errno.h>
18#include <linux/ethtool.h>
19#include <linux/netdevice.h>
Jeff Garzikd17792e2010-03-04 08:21:53 +000020#include <linux/bitops.h>
chavey97f8aef2010-04-07 21:54:42 -070021#include <linux/uaccess.h>
David S. Miller73da16c2010-09-21 16:12:11 -070022#include <linux/vmalloc.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090023#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +090025/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070026 * 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
31u32 ethtool_op_get_link(struct net_device *dev)
32{
33 return netif_carrier_ok(dev) ? 1 : 0;
34}
chavey97f8aef2010-04-07 21:54:42 -070035EXPORT_SYMBOL(ethtool_op_get_link);
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37u32 ethtool_op_get_tx_csum(struct net_device *dev)
38{
Herbert Xu8648b302006-06-17 22:06:05 -070039 return (dev->features & NETIF_F_ALL_CSUM) != 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040}
Eric Dumazet8a729fc2009-07-26 23:18:11 +000041EXPORT_SYMBOL(ethtool_op_get_tx_csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
43int ethtool_op_set_tx_csum(struct net_device *dev, u32 data)
44{
45 if (data)
46 dev->features |= NETIF_F_IP_CSUM;
47 else
48 dev->features &= ~NETIF_F_IP_CSUM;
49
50 return 0;
51}
Michał Mirosław9a279ea2011-02-15 16:59:16 +000052EXPORT_SYMBOL(ethtool_op_set_tx_csum);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Jon Mason69f6a0f2005-05-29 20:27:24 -070054int ethtool_op_set_tx_hw_csum(struct net_device *dev, u32 data)
55{
56 if (data)
57 dev->features |= NETIF_F_HW_CSUM;
58 else
59 dev->features &= ~NETIF_F_HW_CSUM;
60
61 return 0;
62}
chavey97f8aef2010-04-07 21:54:42 -070063EXPORT_SYMBOL(ethtool_op_set_tx_hw_csum);
Michael Chan6460d942007-07-14 19:07:52 -070064
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}
chavey97f8aef2010-04-07 21:54:42 -070074EXPORT_SYMBOL(ethtool_op_set_tx_ipv6_csum);
Michael Chan6460d942007-07-14 19:07:52 -070075
Linus Torvalds1da177e2005-04-16 15:20:36 -070076u32 ethtool_op_get_sg(struct net_device *dev)
77{
78 return (dev->features & NETIF_F_SG) != 0;
79}
chavey97f8aef2010-04-07 21:54:42 -070080EXPORT_SYMBOL(ethtool_op_get_sg);
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
82int ethtool_op_set_sg(struct net_device *dev, u32 data)
83{
84 if (data)
85 dev->features |= NETIF_F_SG;
86 else
87 dev->features &= ~NETIF_F_SG;
88
89 return 0;
90}
chavey97f8aef2010-04-07 21:54:42 -070091EXPORT_SYMBOL(ethtool_op_set_sg);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
93u32 ethtool_op_get_tso(struct net_device *dev)
94{
95 return (dev->features & NETIF_F_TSO) != 0;
96}
chavey97f8aef2010-04-07 21:54:42 -070097EXPORT_SYMBOL(ethtool_op_get_tso);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
99int ethtool_op_set_tso(struct net_device *dev, u32 data)
100{
101 if (data)
102 dev->features |= NETIF_F_TSO;
103 else
104 dev->features &= ~NETIF_F_TSO;
105
106 return 0;
107}
chavey97f8aef2010-04-07 21:54:42 -0700108EXPORT_SYMBOL(ethtool_op_set_tso);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Ananda Rajue89e9cf2005-10-18 15:46:41 -0700110u32 ethtool_op_get_ufo(struct net_device *dev)
111{
112 return (dev->features & NETIF_F_UFO) != 0;
113}
chavey97f8aef2010-04-07 21:54:42 -0700114EXPORT_SYMBOL(ethtool_op_get_ufo);
Ananda Rajue89e9cf2005-10-18 15:46:41 -0700115
116int ethtool_op_set_ufo(struct net_device *dev, u32 data)
117{
118 if (data)
119 dev->features |= NETIF_F_UFO;
120 else
121 dev->features &= ~NETIF_F_UFO;
122 return 0;
123}
chavey97f8aef2010-04-07 21:54:42 -0700124EXPORT_SYMBOL(ethtool_op_set_ufo);
Ananda Rajue89e9cf2005-10-18 15:46:41 -0700125
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -0700126/* the following list of flags are the same as their associated
127 * NETIF_F_xxx values in include/linux/netdevice.h
128 */
129static const u32 flags_dup_features =
Jesse Grossd5dbda22010-10-20 13:56:07 +0000130 (ETH_FLAG_LRO | ETH_FLAG_RXVLAN | ETH_FLAG_TXVLAN | ETH_FLAG_NTUPLE |
131 ETH_FLAG_RXHASH);
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -0700132
133u32 ethtool_op_get_flags(struct net_device *dev)
134{
135 /* in the future, this function will probably contain additional
136 * handling for flags which are not so easily handled
137 * by a simple masking operation
138 */
139
140 return dev->features & flags_dup_features;
141}
chavey97f8aef2010-04-07 21:54:42 -0700142EXPORT_SYMBOL(ethtool_op_get_flags);
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -0700143
Ben Hutchings1437ce32010-06-30 02:44:32 +0000144int ethtool_op_set_flags(struct net_device *dev, u32 data, u32 supported)
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -0700145{
Ben Hutchings1437ce32010-06-30 02:44:32 +0000146 if (data & ~supported)
147 return -EINVAL;
Peter Waskiewicz0d643e12010-02-12 13:48:25 +0000148
Ben Hutchings1437ce32010-06-30 02:44:32 +0000149 dev->features = ((dev->features & ~flags_dup_features) |
150 (data & flags_dup_features));
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -0700151 return 0;
152}
chavey97f8aef2010-04-07 21:54:42 -0700153EXPORT_SYMBOL(ethtool_op_set_flags);
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -0700154
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800155void ethtool_ntuple_flush(struct net_device *dev)
156{
157 struct ethtool_rx_ntuple_flow_spec_container *fsc, *f;
158
159 list_for_each_entry_safe(fsc, f, &dev->ethtool_ntuple_list.list, list) {
160 list_del(&fsc->list);
161 kfree(fsc);
162 }
163 dev->ethtool_ntuple_list.count = 0;
164}
165EXPORT_SYMBOL(ethtool_ntuple_flush);
166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167/* Handlers for each ethtool command */
168
Michał Mirosław5455c692011-02-15 16:59:17 +0000169#define ETHTOOL_DEV_FEATURE_WORDS 1
170
Michał Mirosław4e4db202011-02-22 16:52:28 +0000171static void ethtool_get_features_compat(struct net_device *dev,
172 struct ethtool_get_features_block *features)
173{
174 if (!dev->ethtool_ops)
175 return;
176
177 /* getting RX checksum */
178 if (dev->ethtool_ops->get_rx_csum)
179 if (dev->ethtool_ops->get_rx_csum(dev))
180 features[0].active |= NETIF_F_RXCSUM;
Michał Mirosław39fc0ce2011-02-22 16:52:29 +0000181
182 /* mark legacy-changeable features */
183 if (dev->ethtool_ops->set_sg)
184 features[0].available |= NETIF_F_SG;
185 if (dev->ethtool_ops->set_tx_csum)
186 features[0].available |= NETIF_F_ALL_CSUM;
187 if (dev->ethtool_ops->set_tso)
188 features[0].available |= NETIF_F_ALL_TSO;
189 if (dev->ethtool_ops->set_rx_csum)
190 features[0].available |= NETIF_F_RXCSUM;
191 if (dev->ethtool_ops->set_flags)
192 features[0].available |= flags_dup_features;
193}
194
195static int ethtool_set_feature_compat(struct net_device *dev,
196 int (*legacy_set)(struct net_device *, u32),
197 struct ethtool_set_features_block *features, u32 mask)
198{
199 u32 do_set;
200
201 if (!legacy_set)
202 return 0;
203
204 if (!(features[0].valid & mask))
205 return 0;
206
207 features[0].valid &= ~mask;
208
209 do_set = !!(features[0].requested & mask);
210
211 if (legacy_set(dev, do_set) < 0)
212 netdev_info(dev,
213 "Legacy feature change (%s) failed for 0x%08x\n",
214 do_set ? "set" : "clear", mask);
215
216 return 1;
217}
218
219static int ethtool_set_features_compat(struct net_device *dev,
220 struct ethtool_set_features_block *features)
221{
222 int compat;
223
224 if (!dev->ethtool_ops)
225 return 0;
226
227 compat = ethtool_set_feature_compat(dev, dev->ethtool_ops->set_sg,
228 features, NETIF_F_SG);
229 compat |= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_tx_csum,
230 features, NETIF_F_ALL_CSUM);
231 compat |= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_tso,
232 features, NETIF_F_ALL_TSO);
233 compat |= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_rx_csum,
234 features, NETIF_F_RXCSUM);
235 compat |= ethtool_set_feature_compat(dev, dev->ethtool_ops->set_flags,
236 features, flags_dup_features);
237
238 return compat;
Michał Mirosław4e4db202011-02-22 16:52:28 +0000239}
240
Michał Mirosław5455c692011-02-15 16:59:17 +0000241static int ethtool_get_features(struct net_device *dev, void __user *useraddr)
242{
243 struct ethtool_gfeatures cmd = {
244 .cmd = ETHTOOL_GFEATURES,
245 .size = ETHTOOL_DEV_FEATURE_WORDS,
246 };
247 struct ethtool_get_features_block features[ETHTOOL_DEV_FEATURE_WORDS] = {
248 {
249 .available = dev->hw_features,
250 .requested = dev->wanted_features,
251 .active = dev->features,
252 .never_changed = NETIF_F_NEVER_CHANGE,
253 },
254 };
255 u32 __user *sizeaddr;
256 u32 copy_size;
257
Michał Mirosław4e4db202011-02-22 16:52:28 +0000258 ethtool_get_features_compat(dev, features);
259
Michał Mirosław5455c692011-02-15 16:59:17 +0000260 sizeaddr = useraddr + offsetof(struct ethtool_gfeatures, size);
261 if (get_user(copy_size, sizeaddr))
262 return -EFAULT;
263
264 if (copy_size > ETHTOOL_DEV_FEATURE_WORDS)
265 copy_size = ETHTOOL_DEV_FEATURE_WORDS;
266
267 if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
268 return -EFAULT;
269 useraddr += sizeof(cmd);
270 if (copy_to_user(useraddr, features, copy_size * sizeof(*features)))
271 return -EFAULT;
272
273 return 0;
274}
275
276static int ethtool_set_features(struct net_device *dev, void __user *useraddr)
277{
278 struct ethtool_sfeatures cmd;
279 struct ethtool_set_features_block features[ETHTOOL_DEV_FEATURE_WORDS];
280 int ret = 0;
281
282 if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
283 return -EFAULT;
284 useraddr += sizeof(cmd);
285
286 if (cmd.size != ETHTOOL_DEV_FEATURE_WORDS)
287 return -EINVAL;
288
289 if (copy_from_user(features, useraddr, sizeof(features)))
290 return -EFAULT;
291
292 if (features[0].valid & ~NETIF_F_ETHTOOL_BITS)
293 return -EINVAL;
294
Michał Mirosław39fc0ce2011-02-22 16:52:29 +0000295 if (ethtool_set_features_compat(dev, features))
296 ret |= ETHTOOL_F_COMPAT;
297
Michał Mirosław5455c692011-02-15 16:59:17 +0000298 if (features[0].valid & ~dev->hw_features) {
299 features[0].valid &= dev->hw_features;
300 ret |= ETHTOOL_F_UNSUPPORTED;
301 }
302
303 dev->wanted_features &= ~features[0].valid;
304 dev->wanted_features |= features[0].valid & features[0].requested;
305 netdev_update_features(dev);
306
307 if ((dev->wanted_features ^ dev->features) & features[0].valid)
308 ret |= ETHTOOL_F_WISH;
309
310 return ret;
311}
312
313static const char netdev_features_strings[ETHTOOL_DEV_FEATURE_WORDS * 32][ETH_GSTRING_LEN] = {
314 /* NETIF_F_SG */ "tx-scatter-gather",
315 /* NETIF_F_IP_CSUM */ "tx-checksum-ipv4",
316 /* NETIF_F_NO_CSUM */ "tx-checksum-unneeded",
317 /* NETIF_F_HW_CSUM */ "tx-checksum-ip-generic",
318 /* NETIF_F_IPV6_CSUM */ "tx_checksum-ipv6",
319 /* NETIF_F_HIGHDMA */ "highdma",
320 /* NETIF_F_FRAGLIST */ "tx-scatter-gather-fraglist",
321 /* NETIF_F_HW_VLAN_TX */ "tx-vlan-hw-insert",
322
323 /* NETIF_F_HW_VLAN_RX */ "rx-vlan-hw-parse",
324 /* NETIF_F_HW_VLAN_FILTER */ "rx-vlan-filter",
325 /* NETIF_F_VLAN_CHALLENGED */ "vlan-challenged",
326 /* NETIF_F_GSO */ "tx-generic-segmentation",
327 /* NETIF_F_LLTX */ "tx-lockless",
328 /* NETIF_F_NETNS_LOCAL */ "netns-local",
329 /* NETIF_F_GRO */ "rx-gro",
330 /* NETIF_F_LRO */ "rx-lro",
331
332 /* NETIF_F_TSO */ "tx-tcp-segmentation",
333 /* NETIF_F_UFO */ "tx-udp-fragmentation",
334 /* NETIF_F_GSO_ROBUST */ "tx-gso-robust",
335 /* NETIF_F_TSO_ECN */ "tx-tcp-ecn-segmentation",
336 /* NETIF_F_TSO6 */ "tx-tcp6-segmentation",
337 /* NETIF_F_FSO */ "tx-fcoe-segmentation",
338 "",
339 "",
340
341 /* NETIF_F_FCOE_CRC */ "tx-checksum-fcoe-crc",
342 /* NETIF_F_SCTP_CSUM */ "tx-checksum-sctp",
343 /* NETIF_F_FCOE_MTU */ "fcoe-mtu",
344 /* NETIF_F_NTUPLE */ "rx-ntuple-filter",
345 /* NETIF_F_RXHASH */ "rx-hashing",
Michał Mirosławe83d3602011-02-15 16:59:18 +0000346 /* NETIF_F_RXCSUM */ "rx-checksum",
Michał Mirosław5455c692011-02-15 16:59:17 +0000347 "",
348 "",
349};
350
Michał Mirosław340ae162011-02-15 16:59:16 +0000351static int __ethtool_get_sset_count(struct net_device *dev, int sset)
352{
353 const struct ethtool_ops *ops = dev->ethtool_ops;
354
Michał Mirosław5455c692011-02-15 16:59:17 +0000355 if (sset == ETH_SS_FEATURES)
356 return ARRAY_SIZE(netdev_features_strings);
357
Michał Mirosław340ae162011-02-15 16:59:16 +0000358 if (ops && ops->get_sset_count && ops->get_strings)
359 return ops->get_sset_count(dev, sset);
360 else
361 return -EOPNOTSUPP;
362}
363
364static void __ethtool_get_strings(struct net_device *dev,
365 u32 stringset, u8 *data)
366{
367 const struct ethtool_ops *ops = dev->ethtool_ops;
368
Michał Mirosław5455c692011-02-15 16:59:17 +0000369 if (stringset == ETH_SS_FEATURES)
370 memcpy(data, netdev_features_strings,
371 sizeof(netdev_features_strings));
372 else
373 /* ops->get_strings is valid because checked earlier */
374 ops->get_strings(dev, stringset, data);
Michał Mirosław340ae162011-02-15 16:59:16 +0000375}
376
Michał Mirosław0a417702011-02-15 16:59:17 +0000377static u32 ethtool_get_feature_mask(u32 eth_cmd)
378{
379 /* feature masks of legacy discrete ethtool ops */
380
381 switch (eth_cmd) {
382 case ETHTOOL_GTXCSUM:
383 case ETHTOOL_STXCSUM:
384 return NETIF_F_ALL_CSUM | NETIF_F_SCTP_CSUM;
Michał Mirosławe83d3602011-02-15 16:59:18 +0000385 case ETHTOOL_GRXCSUM:
386 case ETHTOOL_SRXCSUM:
387 return NETIF_F_RXCSUM;
Michał Mirosław0a417702011-02-15 16:59:17 +0000388 case ETHTOOL_GSG:
389 case ETHTOOL_SSG:
390 return NETIF_F_SG;
391 case ETHTOOL_GTSO:
392 case ETHTOOL_STSO:
393 return NETIF_F_ALL_TSO;
394 case ETHTOOL_GUFO:
395 case ETHTOOL_SUFO:
396 return NETIF_F_UFO;
397 case ETHTOOL_GGSO:
398 case ETHTOOL_SGSO:
399 return NETIF_F_GSO;
400 case ETHTOOL_GGRO:
401 case ETHTOOL_SGRO:
402 return NETIF_F_GRO;
403 default:
404 BUG();
405 }
406}
407
408static void *__ethtool_get_one_feature_actor(struct net_device *dev, u32 ethcmd)
409{
410 const struct ethtool_ops *ops = dev->ethtool_ops;
411
412 if (!ops)
413 return NULL;
414
415 switch (ethcmd) {
416 case ETHTOOL_GTXCSUM:
417 return ops->get_tx_csum;
Michał Mirosławe83d3602011-02-15 16:59:18 +0000418 case ETHTOOL_GRXCSUM:
419 return ops->get_rx_csum;
Michał Mirosław0a417702011-02-15 16:59:17 +0000420 case ETHTOOL_SSG:
421 return ops->get_sg;
422 case ETHTOOL_STSO:
423 return ops->get_tso;
424 case ETHTOOL_SUFO:
425 return ops->get_ufo;
426 default:
427 return NULL;
428 }
429}
430
Michał Mirosławe83d3602011-02-15 16:59:18 +0000431static u32 __ethtool_get_rx_csum_oldbug(struct net_device *dev)
432{
433 return !!(dev->features & NETIF_F_ALL_CSUM);
434}
435
Michał Mirosław0a417702011-02-15 16:59:17 +0000436static int ethtool_get_one_feature(struct net_device *dev,
437 char __user *useraddr, u32 ethcmd)
438{
Michał Mirosław86794882011-02-15 16:59:17 +0000439 u32 mask = ethtool_get_feature_mask(ethcmd);
Michał Mirosław0a417702011-02-15 16:59:17 +0000440 struct ethtool_value edata = {
441 .cmd = ethcmd,
Michał Mirosław86794882011-02-15 16:59:17 +0000442 .data = !!(dev->features & mask),
Michał Mirosław0a417702011-02-15 16:59:17 +0000443 };
Michał Mirosław0a417702011-02-15 16:59:17 +0000444
Michał Mirosław86794882011-02-15 16:59:17 +0000445 /* compatibility with discrete get_ ops */
446 if (!(dev->hw_features & mask)) {
447 u32 (*actor)(struct net_device *);
448
449 actor = __ethtool_get_one_feature_actor(dev, ethcmd);
450
Michał Mirosławe83d3602011-02-15 16:59:18 +0000451 /* bug compatibility with old get_rx_csum */
452 if (ethcmd == ETHTOOL_GRXCSUM && !actor)
453 actor = __ethtool_get_rx_csum_oldbug;
454
Michał Mirosław86794882011-02-15 16:59:17 +0000455 if (actor)
456 edata.data = actor(dev);
457 }
Michał Mirosław0a417702011-02-15 16:59:17 +0000458
459 if (copy_to_user(useraddr, &edata, sizeof(edata)))
460 return -EFAULT;
461 return 0;
462}
463
464static int __ethtool_set_tx_csum(struct net_device *dev, u32 data);
Michał Mirosławe83d3602011-02-15 16:59:18 +0000465static int __ethtool_set_rx_csum(struct net_device *dev, u32 data);
Michał Mirosław0a417702011-02-15 16:59:17 +0000466static int __ethtool_set_sg(struct net_device *dev, u32 data);
467static int __ethtool_set_tso(struct net_device *dev, u32 data);
468static int __ethtool_set_ufo(struct net_device *dev, u32 data);
469
470static int ethtool_set_one_feature(struct net_device *dev,
471 void __user *useraddr, u32 ethcmd)
472{
473 struct ethtool_value edata;
474 u32 mask;
475
476 if (copy_from_user(&edata, useraddr, sizeof(edata)))
477 return -EFAULT;
478
Michał Mirosław86794882011-02-15 16:59:17 +0000479 mask = ethtool_get_feature_mask(ethcmd);
480 mask &= dev->hw_features;
481 if (mask) {
482 if (edata.data)
483 dev->wanted_features |= mask;
484 else
485 dev->wanted_features &= ~mask;
486
487 netdev_update_features(dev);
488 return 0;
489 }
490
491 /* Driver is not converted to ndo_fix_features or does not
492 * support changing this offload. In the latter case it won't
493 * have corresponding ethtool_ops field set.
494 *
495 * Following part is to be removed after all drivers advertise
496 * their changeable features in netdev->hw_features and stop
497 * using discrete offload setting ops.
498 */
499
Michał Mirosław0a417702011-02-15 16:59:17 +0000500 switch (ethcmd) {
501 case ETHTOOL_STXCSUM:
502 return __ethtool_set_tx_csum(dev, edata.data);
Michał Mirosławe83d3602011-02-15 16:59:18 +0000503 case ETHTOOL_SRXCSUM:
504 return __ethtool_set_rx_csum(dev, edata.data);
Michał Mirosław0a417702011-02-15 16:59:17 +0000505 case ETHTOOL_SSG:
506 return __ethtool_set_sg(dev, edata.data);
507 case ETHTOOL_STSO:
508 return __ethtool_set_tso(dev, edata.data);
509 case ETHTOOL_SUFO:
510 return __ethtool_set_ufo(dev, edata.data);
Michał Mirosław0a417702011-02-15 16:59:17 +0000511 default:
512 return -EOPNOTSUPP;
513 }
514}
515
Michał Mirosławda8ac86c2011-02-15 16:59:18 +0000516static int __ethtool_set_flags(struct net_device *dev, u32 data)
517{
518 u32 changed;
519
520 if (data & ~flags_dup_features)
521 return -EINVAL;
522
523 /* legacy set_flags() op */
524 if (dev->ethtool_ops->set_flags) {
525 if (unlikely(dev->hw_features & flags_dup_features))
526 netdev_warn(dev,
527 "driver BUG: mixed hw_features and set_flags()\n");
528 return dev->ethtool_ops->set_flags(dev, data);
529 }
530
531 /* allow changing only bits set in hw_features */
532 changed = (data ^ dev->wanted_features) & flags_dup_features;
533 if (changed & ~dev->hw_features)
534 return (changed & dev->hw_features) ? -EINVAL : -EOPNOTSUPP;
535
536 dev->wanted_features =
537 (dev->wanted_features & ~changed) | data;
538
539 netdev_update_features(dev);
540
541 return 0;
542}
543
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
545{
Roland Dreier8e557422010-02-11 12:14:23 -0800546 struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 int err;
548
549 if (!dev->ethtool_ops->get_settings)
550 return -EOPNOTSUPP;
551
552 err = dev->ethtool_ops->get_settings(dev, &cmd);
553 if (err < 0)
554 return err;
555
556 if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
557 return -EFAULT;
558 return 0;
559}
560
561static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
562{
563 struct ethtool_cmd cmd;
564
565 if (!dev->ethtool_ops->set_settings)
566 return -EOPNOTSUPP;
567
568 if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
569 return -EFAULT;
570
571 return dev->ethtool_ops->set_settings(dev, &cmd);
572}
573
chavey97f8aef2010-04-07 21:54:42 -0700574static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev,
575 void __user *useraddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576{
577 struct ethtool_drvinfo info;
Stephen Hemminger76fd8592006-09-08 11:16:13 -0700578 const struct ethtool_ops *ops = dev->ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 memset(&info, 0, sizeof(info));
581 info.cmd = ETHTOOL_GDRVINFO;
Ben Hutchings01414802010-08-17 02:31:15 -0700582 if (ops && ops->get_drvinfo) {
583 ops->get_drvinfo(dev, &info);
584 } else if (dev->dev.parent && dev->dev.parent->driver) {
585 strlcpy(info.bus_info, dev_name(dev->dev.parent),
586 sizeof(info.bus_info));
587 strlcpy(info.driver, dev->dev.parent->driver->name,
588 sizeof(info.driver));
589 } else {
590 return -EOPNOTSUPP;
591 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
Jeff Garzik723b2f52010-03-03 22:51:50 +0000593 /*
594 * this method of obtaining string set info is deprecated;
Jeff Garzikd17792e2010-03-04 08:21:53 +0000595 * Use ETHTOOL_GSSET_INFO instead.
Jeff Garzik723b2f52010-03-03 22:51:50 +0000596 */
Ben Hutchings01414802010-08-17 02:31:15 -0700597 if (ops && ops->get_sset_count) {
Jeff Garzikff03d492007-08-15 16:01:08 -0700598 int rc;
599
600 rc = ops->get_sset_count(dev, ETH_SS_TEST);
601 if (rc >= 0)
602 info.testinfo_len = rc;
603 rc = ops->get_sset_count(dev, ETH_SS_STATS);
604 if (rc >= 0)
605 info.n_stats = rc;
Jeff Garzik339bf022007-08-15 16:01:32 -0700606 rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);
607 if (rc >= 0)
608 info.n_priv_flags = rc;
Jeff Garzikff03d492007-08-15 16:01:08 -0700609 }
Ben Hutchings01414802010-08-17 02:31:15 -0700610 if (ops && ops->get_regs_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 info.regdump_len = ops->get_regs_len(dev);
Ben Hutchings01414802010-08-17 02:31:15 -0700612 if (ops && ops->get_eeprom_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 info.eedump_len = ops->get_eeprom_len(dev);
614
615 if (copy_to_user(useraddr, &info, sizeof(info)))
616 return -EFAULT;
617 return 0;
618}
619
Eric Dumazetf5c445e2010-03-08 12:17:04 -0800620static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,
chavey97f8aef2010-04-07 21:54:42 -0700621 void __user *useraddr)
Jeff Garzik723b2f52010-03-03 22:51:50 +0000622{
623 struct ethtool_sset_info info;
Jeff Garzik723b2f52010-03-03 22:51:50 +0000624 u64 sset_mask;
625 int i, idx = 0, n_bits = 0, ret, rc;
626 u32 *info_buf = NULL;
627
Jeff Garzik723b2f52010-03-03 22:51:50 +0000628 if (copy_from_user(&info, useraddr, sizeof(info)))
629 return -EFAULT;
630
631 /* store copy of mask, because we zero struct later on */
632 sset_mask = info.sset_mask;
633 if (!sset_mask)
634 return 0;
635
636 /* calculate size of return buffer */
Jeff Garzikd17792e2010-03-04 08:21:53 +0000637 n_bits = hweight64(sset_mask);
Jeff Garzik723b2f52010-03-03 22:51:50 +0000638
639 memset(&info, 0, sizeof(info));
640 info.cmd = ETHTOOL_GSSET_INFO;
641
642 info_buf = kzalloc(n_bits * sizeof(u32), GFP_USER);
643 if (!info_buf)
644 return -ENOMEM;
645
646 /*
647 * fill return buffer based on input bitmask and successful
648 * get_sset_count return
649 */
650 for (i = 0; i < 64; i++) {
651 if (!(sset_mask & (1ULL << i)))
652 continue;
653
Michał Mirosław340ae162011-02-15 16:59:16 +0000654 rc = __ethtool_get_sset_count(dev, i);
Jeff Garzik723b2f52010-03-03 22:51:50 +0000655 if (rc >= 0) {
656 info.sset_mask |= (1ULL << i);
657 info_buf[idx++] = rc;
658 }
659 }
660
661 ret = -EFAULT;
662 if (copy_to_user(useraddr, &info, sizeof(info)))
663 goto out;
664
665 useraddr += offsetof(struct ethtool_sset_info, data);
666 if (copy_to_user(useraddr, info_buf, idx * sizeof(u32)))
667 goto out;
668
669 ret = 0;
670
671out:
672 kfree(info_buf);
673 return ret;
674}
675
chavey97f8aef2010-04-07 21:54:42 -0700676static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev,
Ben Hutchingsbf988432010-06-28 08:45:58 +0000677 u32 cmd, void __user *useraddr)
Santwona Behera0853ad62008-07-02 03:47:41 -0700678{
Ben Hutchingsbf988432010-06-28 08:45:58 +0000679 struct ethtool_rxnfc info;
680 size_t info_size = sizeof(info);
Santwona Behera0853ad62008-07-02 03:47:41 -0700681
Santwona Behera59089d82009-02-20 00:58:13 -0800682 if (!dev->ethtool_ops->set_rxnfc)
Santwona Behera0853ad62008-07-02 03:47:41 -0700683 return -EOPNOTSUPP;
684
Ben Hutchingsbf988432010-06-28 08:45:58 +0000685 /* struct ethtool_rxnfc was originally defined for
686 * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
687 * members. User-space might still be using that
688 * definition. */
689 if (cmd == ETHTOOL_SRXFH)
690 info_size = (offsetof(struct ethtool_rxnfc, data) +
691 sizeof(info.data));
692
693 if (copy_from_user(&info, useraddr, info_size))
Santwona Behera0853ad62008-07-02 03:47:41 -0700694 return -EFAULT;
695
Ben Hutchingsbf988432010-06-28 08:45:58 +0000696 return dev->ethtool_ops->set_rxnfc(dev, &info);
Santwona Behera0853ad62008-07-02 03:47:41 -0700697}
698
chavey97f8aef2010-04-07 21:54:42 -0700699static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev,
Ben Hutchingsbf988432010-06-28 08:45:58 +0000700 u32 cmd, void __user *useraddr)
Santwona Behera0853ad62008-07-02 03:47:41 -0700701{
702 struct ethtool_rxnfc info;
Ben Hutchingsbf988432010-06-28 08:45:58 +0000703 size_t info_size = sizeof(info);
Santwona Behera59089d82009-02-20 00:58:13 -0800704 const struct ethtool_ops *ops = dev->ethtool_ops;
705 int ret;
706 void *rule_buf = NULL;
Santwona Behera0853ad62008-07-02 03:47:41 -0700707
Santwona Behera59089d82009-02-20 00:58:13 -0800708 if (!ops->get_rxnfc)
Santwona Behera0853ad62008-07-02 03:47:41 -0700709 return -EOPNOTSUPP;
710
Ben Hutchingsbf988432010-06-28 08:45:58 +0000711 /* struct ethtool_rxnfc was originally defined for
712 * ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data
713 * members. User-space might still be using that
714 * definition. */
715 if (cmd == ETHTOOL_GRXFH)
716 info_size = (offsetof(struct ethtool_rxnfc, data) +
717 sizeof(info.data));
718
719 if (copy_from_user(&info, useraddr, info_size))
Santwona Behera0853ad62008-07-02 03:47:41 -0700720 return -EFAULT;
721
Santwona Behera59089d82009-02-20 00:58:13 -0800722 if (info.cmd == ETHTOOL_GRXCLSRLALL) {
723 if (info.rule_cnt > 0) {
Ben Hutchingsdb048b62010-06-28 08:44:07 +0000724 if (info.rule_cnt <= KMALLOC_MAX_SIZE / sizeof(u32))
Kees Cookae6df5f2010-10-07 10:03:48 +0000725 rule_buf = kzalloc(info.rule_cnt * sizeof(u32),
Ben Hutchingsdb048b62010-06-28 08:44:07 +0000726 GFP_USER);
Santwona Behera59089d82009-02-20 00:58:13 -0800727 if (!rule_buf)
728 return -ENOMEM;
729 }
730 }
Santwona Behera0853ad62008-07-02 03:47:41 -0700731
Santwona Behera59089d82009-02-20 00:58:13 -0800732 ret = ops->get_rxnfc(dev, &info, rule_buf);
733 if (ret < 0)
734 goto err_out;
735
736 ret = -EFAULT;
Ben Hutchingsbf988432010-06-28 08:45:58 +0000737 if (copy_to_user(useraddr, &info, info_size))
Santwona Behera59089d82009-02-20 00:58:13 -0800738 goto err_out;
739
740 if (rule_buf) {
741 useraddr += offsetof(struct ethtool_rxnfc, rule_locs);
742 if (copy_to_user(useraddr, rule_buf,
743 info.rule_cnt * sizeof(u32)))
744 goto err_out;
745 }
746 ret = 0;
747
748err_out:
Wei Yongjunc9cacec2009-03-31 15:06:26 -0700749 kfree(rule_buf);
Santwona Behera59089d82009-02-20 00:58:13 -0800750
751 return ret;
Santwona Behera0853ad62008-07-02 03:47:41 -0700752}
753
Ben Hutchingsa5b6ee22010-06-30 05:05:23 +0000754static noinline_for_stack int ethtool_get_rxfh_indir(struct net_device *dev,
755 void __user *useraddr)
756{
757 struct ethtool_rxfh_indir *indir;
758 u32 table_size;
759 size_t full_size;
760 int ret;
761
762 if (!dev->ethtool_ops->get_rxfh_indir)
763 return -EOPNOTSUPP;
764
765 if (copy_from_user(&table_size,
766 useraddr + offsetof(struct ethtool_rxfh_indir, size),
767 sizeof(table_size)))
768 return -EFAULT;
769
770 if (table_size >
771 (KMALLOC_MAX_SIZE - sizeof(*indir)) / sizeof(*indir->ring_index))
772 return -ENOMEM;
773 full_size = sizeof(*indir) + sizeof(*indir->ring_index) * table_size;
Kees Cookb00916b2010-10-11 12:23:25 -0700774 indir = kzalloc(full_size, GFP_USER);
Ben Hutchingsa5b6ee22010-06-30 05:05:23 +0000775 if (!indir)
776 return -ENOMEM;
777
778 indir->cmd = ETHTOOL_GRXFHINDIR;
779 indir->size = table_size;
780 ret = dev->ethtool_ops->get_rxfh_indir(dev, indir);
781 if (ret)
782 goto out;
783
784 if (copy_to_user(useraddr, indir, full_size))
785 ret = -EFAULT;
786
787out:
788 kfree(indir);
789 return ret;
790}
791
792static noinline_for_stack int ethtool_set_rxfh_indir(struct net_device *dev,
793 void __user *useraddr)
794{
795 struct ethtool_rxfh_indir *indir;
796 u32 table_size;
797 size_t full_size;
798 int ret;
799
800 if (!dev->ethtool_ops->set_rxfh_indir)
801 return -EOPNOTSUPP;
802
803 if (copy_from_user(&table_size,
804 useraddr + offsetof(struct ethtool_rxfh_indir, size),
805 sizeof(table_size)))
806 return -EFAULT;
807
808 if (table_size >
809 (KMALLOC_MAX_SIZE - sizeof(*indir)) / sizeof(*indir->ring_index))
810 return -ENOMEM;
811 full_size = sizeof(*indir) + sizeof(*indir->ring_index) * table_size;
812 indir = kmalloc(full_size, GFP_USER);
813 if (!indir)
814 return -ENOMEM;
815
816 if (copy_from_user(indir, useraddr, full_size)) {
817 ret = -EFAULT;
818 goto out;
819 }
820
821 ret = dev->ethtool_ops->set_rxfh_indir(dev, indir);
822
823out:
824 kfree(indir);
825 return ret;
826}
827
Peter Waskiewicze8589112010-02-12 13:48:05 +0000828static void __rx_ntuple_filter_add(struct ethtool_rx_ntuple_list *list,
chavey97f8aef2010-04-07 21:54:42 -0700829 struct ethtool_rx_ntuple_flow_spec *spec,
830 struct ethtool_rx_ntuple_flow_spec_container *fsc)
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800831{
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800832
833 /* don't add filters forever */
Peter Waskiewicze8589112010-02-12 13:48:05 +0000834 if (list->count >= ETHTOOL_MAX_NTUPLE_LIST_ENTRY) {
835 /* free the container */
836 kfree(fsc);
837 return;
838 }
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800839
840 /* Copy the whole filter over */
841 fsc->fs.flow_type = spec->flow_type;
842 memcpy(&fsc->fs.h_u, &spec->h_u, sizeof(spec->h_u));
843 memcpy(&fsc->fs.m_u, &spec->m_u, sizeof(spec->m_u));
844
845 fsc->fs.vlan_tag = spec->vlan_tag;
846 fsc->fs.vlan_tag_mask = spec->vlan_tag_mask;
847 fsc->fs.data = spec->data;
848 fsc->fs.data_mask = spec->data_mask;
849 fsc->fs.action = spec->action;
850
851 /* add to the list */
852 list_add_tail_rcu(&fsc->list, &list->list);
853 list->count++;
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800854}
855
Ben Hutchingsbe2902d2010-09-16 11:28:07 +0000856/*
857 * ethtool does not (or did not) set masks for flow parameters that are
858 * not specified, so if both value and mask are 0 then this must be
859 * treated as equivalent to a mask with all bits set. Implement that
860 * here rather than in drivers.
861 */
862static void rx_ntuple_fix_masks(struct ethtool_rx_ntuple_flow_spec *fs)
863{
864 struct ethtool_tcpip4_spec *entry = &fs->h_u.tcp_ip4_spec;
865 struct ethtool_tcpip4_spec *mask = &fs->m_u.tcp_ip4_spec;
866
867 if (fs->flow_type != TCP_V4_FLOW &&
868 fs->flow_type != UDP_V4_FLOW &&
869 fs->flow_type != SCTP_V4_FLOW)
870 return;
871
872 if (!(entry->ip4src | mask->ip4src))
873 mask->ip4src = htonl(0xffffffff);
874 if (!(entry->ip4dst | mask->ip4dst))
875 mask->ip4dst = htonl(0xffffffff);
876 if (!(entry->psrc | mask->psrc))
877 mask->psrc = htons(0xffff);
878 if (!(entry->pdst | mask->pdst))
879 mask->pdst = htons(0xffff);
880 if (!(entry->tos | mask->tos))
881 mask->tos = 0xff;
882 if (!(fs->vlan_tag | fs->vlan_tag_mask))
883 fs->vlan_tag_mask = 0xffff;
884 if (!(fs->data | fs->data_mask))
885 fs->data_mask = 0xffffffffffffffffULL;
886}
887
chavey97f8aef2010-04-07 21:54:42 -0700888static noinline_for_stack int ethtool_set_rx_ntuple(struct net_device *dev,
889 void __user *useraddr)
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800890{
891 struct ethtool_rx_ntuple cmd;
892 const struct ethtool_ops *ops = dev->ethtool_ops;
Peter Waskiewicze8589112010-02-12 13:48:05 +0000893 struct ethtool_rx_ntuple_flow_spec_container *fsc = NULL;
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800894 int ret;
895
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800896 if (!(dev->features & NETIF_F_NTUPLE))
897 return -EINVAL;
898
899 if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
900 return -EFAULT;
901
Ben Hutchingsbe2902d2010-09-16 11:28:07 +0000902 rx_ntuple_fix_masks(&cmd.fs);
903
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800904 /*
905 * Cache filter in dev struct for GET operation only if
906 * the underlying driver doesn't have its own GET operation, and
Peter Waskiewicze8589112010-02-12 13:48:05 +0000907 * only if the filter was added successfully. First make sure we
908 * can allocate the filter, then continue if successful.
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800909 */
Peter Waskiewicze8589112010-02-12 13:48:05 +0000910 if (!ops->get_rx_ntuple) {
911 fsc = kmalloc(sizeof(*fsc), GFP_ATOMIC);
912 if (!fsc)
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800913 return -ENOMEM;
Peter Waskiewicze8589112010-02-12 13:48:05 +0000914 }
915
916 ret = ops->set_rx_ntuple(dev, &cmd);
917 if (ret) {
918 kfree(fsc);
919 return ret;
920 }
921
922 if (!ops->get_rx_ntuple)
923 __rx_ntuple_filter_add(&dev->ethtool_ntuple_list, &cmd.fs, fsc);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800924
925 return ret;
926}
927
928static int ethtool_get_rx_ntuple(struct net_device *dev, void __user *useraddr)
929{
930 struct ethtool_gstrings gstrings;
931 const struct ethtool_ops *ops = dev->ethtool_ops;
932 struct ethtool_rx_ntuple_flow_spec_container *fsc;
933 u8 *data;
934 char *p;
935 int ret, i, num_strings = 0;
936
937 if (!ops->get_sset_count)
938 return -EOPNOTSUPP;
939
940 if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
941 return -EFAULT;
942
943 ret = ops->get_sset_count(dev, gstrings.string_set);
944 if (ret < 0)
945 return ret;
946
947 gstrings.len = ret;
948
Kees Cookb00916b2010-10-11 12:23:25 -0700949 data = kzalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -0800950 if (!data)
951 return -ENOMEM;
952
953 if (ops->get_rx_ntuple) {
954 /* driver-specific filter grab */
955 ret = ops->get_rx_ntuple(dev, gstrings.string_set, data);
956 goto copy;
957 }
958
959 /* default ethtool filter grab */
960 i = 0;
961 p = (char *)data;
962 list_for_each_entry(fsc, &dev->ethtool_ntuple_list.list, list) {
963 sprintf(p, "Filter %d:\n", i);
964 p += ETH_GSTRING_LEN;
965 num_strings++;
966
967 switch (fsc->fs.flow_type) {
968 case TCP_V4_FLOW:
969 sprintf(p, "\tFlow Type: TCP\n");
970 p += ETH_GSTRING_LEN;
971 num_strings++;
972 break;
973 case UDP_V4_FLOW:
974 sprintf(p, "\tFlow Type: UDP\n");
975 p += ETH_GSTRING_LEN;
976 num_strings++;
977 break;
978 case SCTP_V4_FLOW:
979 sprintf(p, "\tFlow Type: SCTP\n");
980 p += ETH_GSTRING_LEN;
981 num_strings++;
982 break;
983 case AH_ESP_V4_FLOW:
984 sprintf(p, "\tFlow Type: AH ESP\n");
985 p += ETH_GSTRING_LEN;
986 num_strings++;
987 break;
988 case ESP_V4_FLOW:
989 sprintf(p, "\tFlow Type: ESP\n");
990 p += ETH_GSTRING_LEN;
991 num_strings++;
992 break;
993 case IP_USER_FLOW:
994 sprintf(p, "\tFlow Type: Raw IP\n");
995 p += ETH_GSTRING_LEN;
996 num_strings++;
997 break;
998 case IPV4_FLOW:
999 sprintf(p, "\tFlow Type: IPv4\n");
1000 p += ETH_GSTRING_LEN;
1001 num_strings++;
1002 break;
1003 default:
1004 sprintf(p, "\tFlow Type: Unknown\n");
1005 p += ETH_GSTRING_LEN;
1006 num_strings++;
1007 goto unknown_filter;
Joe Perchesccbd6a52010-05-14 10:58:26 +00001008 }
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001009
1010 /* now the rest of the filters */
1011 switch (fsc->fs.flow_type) {
1012 case TCP_V4_FLOW:
1013 case UDP_V4_FLOW:
1014 case SCTP_V4_FLOW:
1015 sprintf(p, "\tSrc IP addr: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001016 fsc->fs.h_u.tcp_ip4_spec.ip4src);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001017 p += ETH_GSTRING_LEN;
1018 num_strings++;
1019 sprintf(p, "\tSrc IP mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001020 fsc->fs.m_u.tcp_ip4_spec.ip4src);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001021 p += ETH_GSTRING_LEN;
1022 num_strings++;
1023 sprintf(p, "\tDest IP addr: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001024 fsc->fs.h_u.tcp_ip4_spec.ip4dst);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001025 p += ETH_GSTRING_LEN;
1026 num_strings++;
1027 sprintf(p, "\tDest IP mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001028 fsc->fs.m_u.tcp_ip4_spec.ip4dst);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001029 p += ETH_GSTRING_LEN;
1030 num_strings++;
1031 sprintf(p, "\tSrc Port: %d, mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001032 fsc->fs.h_u.tcp_ip4_spec.psrc,
1033 fsc->fs.m_u.tcp_ip4_spec.psrc);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001034 p += ETH_GSTRING_LEN;
1035 num_strings++;
1036 sprintf(p, "\tDest Port: %d, mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001037 fsc->fs.h_u.tcp_ip4_spec.pdst,
1038 fsc->fs.m_u.tcp_ip4_spec.pdst);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001039 p += ETH_GSTRING_LEN;
1040 num_strings++;
1041 sprintf(p, "\tTOS: %d, mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001042 fsc->fs.h_u.tcp_ip4_spec.tos,
1043 fsc->fs.m_u.tcp_ip4_spec.tos);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001044 p += ETH_GSTRING_LEN;
1045 num_strings++;
1046 break;
1047 case AH_ESP_V4_FLOW:
1048 case ESP_V4_FLOW:
1049 sprintf(p, "\tSrc IP addr: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001050 fsc->fs.h_u.ah_ip4_spec.ip4src);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001051 p += ETH_GSTRING_LEN;
1052 num_strings++;
1053 sprintf(p, "\tSrc IP mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001054 fsc->fs.m_u.ah_ip4_spec.ip4src);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001055 p += ETH_GSTRING_LEN;
1056 num_strings++;
1057 sprintf(p, "\tDest IP addr: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001058 fsc->fs.h_u.ah_ip4_spec.ip4dst);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001059 p += ETH_GSTRING_LEN;
1060 num_strings++;
1061 sprintf(p, "\tDest IP mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001062 fsc->fs.m_u.ah_ip4_spec.ip4dst);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001063 p += ETH_GSTRING_LEN;
1064 num_strings++;
1065 sprintf(p, "\tSPI: %d, mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001066 fsc->fs.h_u.ah_ip4_spec.spi,
1067 fsc->fs.m_u.ah_ip4_spec.spi);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001068 p += ETH_GSTRING_LEN;
1069 num_strings++;
1070 sprintf(p, "\tTOS: %d, mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001071 fsc->fs.h_u.ah_ip4_spec.tos,
1072 fsc->fs.m_u.ah_ip4_spec.tos);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001073 p += ETH_GSTRING_LEN;
1074 num_strings++;
1075 break;
1076 case IP_USER_FLOW:
1077 sprintf(p, "\tSrc IP addr: 0x%x\n",
Ben Hutchingse0de7c92010-09-14 09:13:08 +00001078 fsc->fs.h_u.usr_ip4_spec.ip4src);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001079 p += ETH_GSTRING_LEN;
1080 num_strings++;
1081 sprintf(p, "\tSrc IP mask: 0x%x\n",
Ben Hutchingse0de7c92010-09-14 09:13:08 +00001082 fsc->fs.m_u.usr_ip4_spec.ip4src);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001083 p += ETH_GSTRING_LEN;
1084 num_strings++;
1085 sprintf(p, "\tDest IP addr: 0x%x\n",
Ben Hutchingse0de7c92010-09-14 09:13:08 +00001086 fsc->fs.h_u.usr_ip4_spec.ip4dst);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001087 p += ETH_GSTRING_LEN;
1088 num_strings++;
1089 sprintf(p, "\tDest IP mask: 0x%x\n",
Ben Hutchingse0de7c92010-09-14 09:13:08 +00001090 fsc->fs.m_u.usr_ip4_spec.ip4dst);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001091 p += ETH_GSTRING_LEN;
1092 num_strings++;
1093 break;
1094 case IPV4_FLOW:
1095 sprintf(p, "\tSrc IP addr: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001096 fsc->fs.h_u.usr_ip4_spec.ip4src);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001097 p += ETH_GSTRING_LEN;
1098 num_strings++;
1099 sprintf(p, "\tSrc IP mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001100 fsc->fs.m_u.usr_ip4_spec.ip4src);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001101 p += ETH_GSTRING_LEN;
1102 num_strings++;
1103 sprintf(p, "\tDest IP addr: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001104 fsc->fs.h_u.usr_ip4_spec.ip4dst);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001105 p += ETH_GSTRING_LEN;
1106 num_strings++;
1107 sprintf(p, "\tDest IP mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001108 fsc->fs.m_u.usr_ip4_spec.ip4dst);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001109 p += ETH_GSTRING_LEN;
1110 num_strings++;
1111 sprintf(p, "\tL4 bytes: 0x%x, mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001112 fsc->fs.h_u.usr_ip4_spec.l4_4_bytes,
1113 fsc->fs.m_u.usr_ip4_spec.l4_4_bytes);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001114 p += ETH_GSTRING_LEN;
1115 num_strings++;
1116 sprintf(p, "\tTOS: %d, mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001117 fsc->fs.h_u.usr_ip4_spec.tos,
1118 fsc->fs.m_u.usr_ip4_spec.tos);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001119 p += ETH_GSTRING_LEN;
1120 num_strings++;
1121 sprintf(p, "\tIP Version: %d, mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001122 fsc->fs.h_u.usr_ip4_spec.ip_ver,
1123 fsc->fs.m_u.usr_ip4_spec.ip_ver);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001124 p += ETH_GSTRING_LEN;
1125 num_strings++;
1126 sprintf(p, "\tProtocol: %d, mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001127 fsc->fs.h_u.usr_ip4_spec.proto,
1128 fsc->fs.m_u.usr_ip4_spec.proto);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001129 p += ETH_GSTRING_LEN;
1130 num_strings++;
1131 break;
Joe Perchesccbd6a52010-05-14 10:58:26 +00001132 }
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001133 sprintf(p, "\tVLAN: %d, mask: 0x%x\n",
chavey97f8aef2010-04-07 21:54:42 -07001134 fsc->fs.vlan_tag, fsc->fs.vlan_tag_mask);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001135 p += ETH_GSTRING_LEN;
1136 num_strings++;
1137 sprintf(p, "\tUser-defined: 0x%Lx\n", fsc->fs.data);
1138 p += ETH_GSTRING_LEN;
1139 num_strings++;
1140 sprintf(p, "\tUser-defined mask: 0x%Lx\n", fsc->fs.data_mask);
1141 p += ETH_GSTRING_LEN;
1142 num_strings++;
1143 if (fsc->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP)
1144 sprintf(p, "\tAction: Drop\n");
1145 else
1146 sprintf(p, "\tAction: Direct to queue %d\n",
chavey97f8aef2010-04-07 21:54:42 -07001147 fsc->fs.action);
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001148 p += ETH_GSTRING_LEN;
1149 num_strings++;
1150unknown_filter:
1151 i++;
1152 }
1153copy:
1154 /* indicate to userspace how many strings we actually have */
1155 gstrings.len = num_strings;
1156 ret = -EFAULT;
1157 if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
1158 goto out;
1159 useraddr += sizeof(gstrings);
1160 if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
1161 goto out;
1162 ret = 0;
1163
1164out:
1165 kfree(data);
1166 return ret;
1167}
1168
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169static int ethtool_get_regs(struct net_device *dev, char __user *useraddr)
1170{
1171 struct ethtool_regs regs;
Stephen Hemminger76fd8592006-09-08 11:16:13 -07001172 const struct ethtool_ops *ops = dev->ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 void *regbuf;
1174 int reglen, ret;
1175
1176 if (!ops->get_regs || !ops->get_regs_len)
1177 return -EOPNOTSUPP;
1178
1179 if (copy_from_user(&regs, useraddr, sizeof(regs)))
1180 return -EFAULT;
1181
1182 reglen = ops->get_regs_len(dev);
1183 if (regs.len > reglen)
1184 regs.len = reglen;
1185
Eugene Teob7c7d012011-01-24 21:05:17 -08001186 regbuf = vzalloc(reglen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187 if (!regbuf)
1188 return -ENOMEM;
1189
1190 ops->get_regs(dev, &regs, regbuf);
1191
1192 ret = -EFAULT;
1193 if (copy_to_user(useraddr, &regs, sizeof(regs)))
1194 goto out;
1195 useraddr += offsetof(struct ethtool_regs, data);
1196 if (copy_to_user(useraddr, regbuf, regs.len))
1197 goto out;
1198 ret = 0;
1199
1200 out:
Ben Hutchingsa77f5db2010-09-20 08:42:17 +00001201 vfree(regbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 return ret;
1203}
1204
Ben Hutchingsd73d3a82009-10-05 10:59:58 +00001205static int ethtool_reset(struct net_device *dev, char __user *useraddr)
1206{
1207 struct ethtool_value reset;
1208 int ret;
1209
1210 if (!dev->ethtool_ops->reset)
1211 return -EOPNOTSUPP;
1212
1213 if (copy_from_user(&reset, useraddr, sizeof(reset)))
1214 return -EFAULT;
1215
1216 ret = dev->ethtool_ops->reset(dev, &reset.data);
1217 if (ret)
1218 return ret;
1219
1220 if (copy_to_user(useraddr, &reset, sizeof(reset)))
1221 return -EFAULT;
1222 return 0;
1223}
1224
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225static int ethtool_get_wol(struct net_device *dev, char __user *useraddr)
1226{
Roland Dreier8e557422010-02-11 12:14:23 -08001227 struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228
1229 if (!dev->ethtool_ops->get_wol)
1230 return -EOPNOTSUPP;
1231
1232 dev->ethtool_ops->get_wol(dev, &wol);
1233
1234 if (copy_to_user(useraddr, &wol, sizeof(wol)))
1235 return -EFAULT;
1236 return 0;
1237}
1238
1239static int ethtool_set_wol(struct net_device *dev, char __user *useraddr)
1240{
1241 struct ethtool_wolinfo wol;
1242
1243 if (!dev->ethtool_ops->set_wol)
1244 return -EOPNOTSUPP;
1245
1246 if (copy_from_user(&wol, useraddr, sizeof(wol)))
1247 return -EFAULT;
1248
1249 return dev->ethtool_ops->set_wol(dev, &wol);
1250}
1251
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252static int ethtool_nway_reset(struct net_device *dev)
1253{
1254 if (!dev->ethtool_ops->nway_reset)
1255 return -EOPNOTSUPP;
1256
1257 return dev->ethtool_ops->nway_reset(dev);
1258}
1259
Ben Hutchingse596e6e2010-12-09 12:08:35 +00001260static int ethtool_get_link(struct net_device *dev, char __user *useraddr)
1261{
1262 struct ethtool_value edata = { .cmd = ETHTOOL_GLINK };
1263
1264 if (!dev->ethtool_ops->get_link)
1265 return -EOPNOTSUPP;
1266
1267 edata.data = netif_running(dev) && dev->ethtool_ops->get_link(dev);
1268
1269 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1270 return -EFAULT;
1271 return 0;
1272}
1273
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274static int ethtool_get_eeprom(struct net_device *dev, void __user *useraddr)
1275{
1276 struct ethtool_eeprom eeprom;
Stephen Hemminger76fd8592006-09-08 11:16:13 -07001277 const struct ethtool_ops *ops = dev->ethtool_ops;
Mandeep Singh Bainesb131dd52008-04-15 19:24:17 -07001278 void __user *userbuf = useraddr + sizeof(eeprom);
1279 u32 bytes_remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 u8 *data;
Mandeep Singh Bainesb131dd52008-04-15 19:24:17 -07001281 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282
1283 if (!ops->get_eeprom || !ops->get_eeprom_len)
1284 return -EOPNOTSUPP;
1285
1286 if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
1287 return -EFAULT;
1288
1289 /* Check for wrap and zero */
1290 if (eeprom.offset + eeprom.len <= eeprom.offset)
1291 return -EINVAL;
1292
1293 /* Check for exceeding total eeprom len */
1294 if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
1295 return -EINVAL;
1296
Mandeep Singh Bainesb131dd52008-04-15 19:24:17 -07001297 data = kmalloc(PAGE_SIZE, GFP_USER);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 if (!data)
1299 return -ENOMEM;
1300
Mandeep Singh Bainesb131dd52008-04-15 19:24:17 -07001301 bytes_remaining = eeprom.len;
1302 while (bytes_remaining > 0) {
1303 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304
Mandeep Singh Bainesb131dd52008-04-15 19:24:17 -07001305 ret = ops->get_eeprom(dev, &eeprom, data);
1306 if (ret)
1307 break;
1308 if (copy_to_user(userbuf, data, eeprom.len)) {
1309 ret = -EFAULT;
1310 break;
1311 }
1312 userbuf += eeprom.len;
1313 eeprom.offset += eeprom.len;
1314 bytes_remaining -= eeprom.len;
1315 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
Mandeep Singh Bainesc5835df2008-04-24 20:55:56 -07001317 eeprom.len = userbuf - (useraddr + sizeof(eeprom));
1318 eeprom.offset -= eeprom.len;
1319 if (copy_to_user(useraddr, &eeprom, sizeof(eeprom)))
1320 ret = -EFAULT;
1321
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 kfree(data);
1323 return ret;
1324}
1325
1326static int ethtool_set_eeprom(struct net_device *dev, void __user *useraddr)
1327{
1328 struct ethtool_eeprom eeprom;
Stephen Hemminger76fd8592006-09-08 11:16:13 -07001329 const struct ethtool_ops *ops = dev->ethtool_ops;
Mandeep Singh Bainesb131dd52008-04-15 19:24:17 -07001330 void __user *userbuf = useraddr + sizeof(eeprom);
1331 u32 bytes_remaining;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 u8 *data;
Mandeep Singh Bainesb131dd52008-04-15 19:24:17 -07001333 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334
1335 if (!ops->set_eeprom || !ops->get_eeprom_len)
1336 return -EOPNOTSUPP;
1337
1338 if (copy_from_user(&eeprom, useraddr, sizeof(eeprom)))
1339 return -EFAULT;
1340
1341 /* Check for wrap and zero */
1342 if (eeprom.offset + eeprom.len <= eeprom.offset)
1343 return -EINVAL;
1344
1345 /* Check for exceeding total eeprom len */
1346 if (eeprom.offset + eeprom.len > ops->get_eeprom_len(dev))
1347 return -EINVAL;
1348
Mandeep Singh Bainesb131dd52008-04-15 19:24:17 -07001349 data = kmalloc(PAGE_SIZE, GFP_USER);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 if (!data)
1351 return -ENOMEM;
1352
Mandeep Singh Bainesb131dd52008-04-15 19:24:17 -07001353 bytes_remaining = eeprom.len;
1354 while (bytes_remaining > 0) {
1355 eeprom.len = min(bytes_remaining, (u32)PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
Mandeep Singh Bainesb131dd52008-04-15 19:24:17 -07001357 if (copy_from_user(data, userbuf, eeprom.len)) {
1358 ret = -EFAULT;
1359 break;
1360 }
1361 ret = ops->set_eeprom(dev, &eeprom, data);
1362 if (ret)
1363 break;
1364 userbuf += eeprom.len;
1365 eeprom.offset += eeprom.len;
1366 bytes_remaining -= eeprom.len;
1367 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 kfree(data);
1370 return ret;
1371}
1372
chavey97f8aef2010-04-07 21:54:42 -07001373static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev,
1374 void __user *useraddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375{
Roland Dreier8e557422010-02-11 12:14:23 -08001376 struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377
1378 if (!dev->ethtool_ops->get_coalesce)
1379 return -EOPNOTSUPP;
1380
1381 dev->ethtool_ops->get_coalesce(dev, &coalesce);
1382
1383 if (copy_to_user(useraddr, &coalesce, sizeof(coalesce)))
1384 return -EFAULT;
1385 return 0;
1386}
1387
chavey97f8aef2010-04-07 21:54:42 -07001388static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev,
1389 void __user *useraddr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390{
1391 struct ethtool_coalesce coalesce;
1392
David S. Millerfa04ae52005-06-06 15:07:19 -07001393 if (!dev->ethtool_ops->set_coalesce)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 return -EOPNOTSUPP;
1395
1396 if (copy_from_user(&coalesce, useraddr, sizeof(coalesce)))
1397 return -EFAULT;
1398
1399 return dev->ethtool_ops->set_coalesce(dev, &coalesce);
1400}
1401
1402static int ethtool_get_ringparam(struct net_device *dev, void __user *useraddr)
1403{
Roland Dreier8e557422010-02-11 12:14:23 -08001404 struct ethtool_ringparam ringparam = { .cmd = ETHTOOL_GRINGPARAM };
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405
1406 if (!dev->ethtool_ops->get_ringparam)
1407 return -EOPNOTSUPP;
1408
1409 dev->ethtool_ops->get_ringparam(dev, &ringparam);
1410
1411 if (copy_to_user(useraddr, &ringparam, sizeof(ringparam)))
1412 return -EFAULT;
1413 return 0;
1414}
1415
1416static int ethtool_set_ringparam(struct net_device *dev, void __user *useraddr)
1417{
1418 struct ethtool_ringparam ringparam;
1419
1420 if (!dev->ethtool_ops->set_ringparam)
1421 return -EOPNOTSUPP;
1422
1423 if (copy_from_user(&ringparam, useraddr, sizeof(ringparam)))
1424 return -EFAULT;
1425
1426 return dev->ethtool_ops->set_ringparam(dev, &ringparam);
1427}
1428
1429static int ethtool_get_pauseparam(struct net_device *dev, void __user *useraddr)
1430{
1431 struct ethtool_pauseparam pauseparam = { ETHTOOL_GPAUSEPARAM };
1432
1433 if (!dev->ethtool_ops->get_pauseparam)
1434 return -EOPNOTSUPP;
1435
1436 dev->ethtool_ops->get_pauseparam(dev, &pauseparam);
1437
1438 if (copy_to_user(useraddr, &pauseparam, sizeof(pauseparam)))
1439 return -EFAULT;
1440 return 0;
1441}
1442
1443static int ethtool_set_pauseparam(struct net_device *dev, void __user *useraddr)
1444{
1445 struct ethtool_pauseparam pauseparam;
1446
Jeff Garzike1b90c42006-07-17 12:54:40 -04001447 if (!dev->ethtool_ops->set_pauseparam)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 return -EOPNOTSUPP;
1449
1450 if (copy_from_user(&pauseparam, useraddr, sizeof(pauseparam)))
1451 return -EFAULT;
1452
1453 return dev->ethtool_ops->set_pauseparam(dev, &pauseparam);
1454}
1455
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456static int __ethtool_set_sg(struct net_device *dev, u32 data)
1457{
1458 int err;
1459
Michał Mirosław0a417702011-02-15 16:59:17 +00001460 if (data && !(dev->features & NETIF_F_ALL_CSUM))
1461 return -EINVAL;
1462
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 if (!data && dev->ethtool_ops->set_tso) {
1464 err = dev->ethtool_ops->set_tso(dev, 0);
1465 if (err)
1466 return err;
1467 }
1468
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001469 if (!data && dev->ethtool_ops->set_ufo) {
1470 err = dev->ethtool_ops->set_ufo(dev, 0);
1471 if (err)
1472 return err;
1473 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 return dev->ethtool_ops->set_sg(dev, data);
1475}
1476
Michał Mirosław0a417702011-02-15 16:59:17 +00001477static int __ethtool_set_tx_csum(struct net_device *dev, u32 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 int err;
1480
1481 if (!dev->ethtool_ops->set_tx_csum)
1482 return -EOPNOTSUPP;
1483
Michał Mirosław0a417702011-02-15 16:59:17 +00001484 if (!data && dev->ethtool_ops->set_sg) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 err = __ethtool_set_sg(dev, 0);
1486 if (err)
1487 return err;
1488 }
1489
Michał Mirosław0a417702011-02-15 16:59:17 +00001490 return dev->ethtool_ops->set_tx_csum(dev, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491}
1492
Michał Mirosławe83d3602011-02-15 16:59:18 +00001493static int __ethtool_set_rx_csum(struct net_device *dev, u32 data)
Herbert Xub240a0e2008-12-15 23:44:31 -08001494{
Herbert Xub240a0e2008-12-15 23:44:31 -08001495 if (!dev->ethtool_ops->set_rx_csum)
1496 return -EOPNOTSUPP;
1497
Michał Mirosławe83d3602011-02-15 16:59:18 +00001498 if (!data)
Herbert Xub240a0e2008-12-15 23:44:31 -08001499 dev->features &= ~NETIF_F_GRO;
1500
Michał Mirosławe83d3602011-02-15 16:59:18 +00001501 return dev->ethtool_ops->set_rx_csum(dev, data);
Herbert Xub240a0e2008-12-15 23:44:31 -08001502}
1503
Michał Mirosław0a417702011-02-15 16:59:17 +00001504static int __ethtool_set_tso(struct net_device *dev, u32 data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 if (!dev->ethtool_ops->set_tso)
1507 return -EOPNOTSUPP;
1508
Michał Mirosław0a417702011-02-15 16:59:17 +00001509 if (data && !(dev->features & NETIF_F_SG))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 return -EINVAL;
1511
Michał Mirosław0a417702011-02-15 16:59:17 +00001512 return dev->ethtool_ops->set_tso(dev, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513}
1514
Michał Mirosław0a417702011-02-15 16:59:17 +00001515static int __ethtool_set_ufo(struct net_device *dev, u32 data)
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001516{
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001517 if (!dev->ethtool_ops->set_ufo)
1518 return -EOPNOTSUPP;
Michał Mirosław0a417702011-02-15 16:59:17 +00001519 if (data && !(dev->features & NETIF_F_SG))
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001520 return -EINVAL;
Michał Mirosław0a417702011-02-15 16:59:17 +00001521 if (data && !((dev->features & NETIF_F_GEN_CSUM) ||
Michał Mirosław79032642010-11-30 06:38:00 +00001522 (dev->features & (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM))
1523 == (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM)))
Ananda Rajue89e9cf2005-10-18 15:46:41 -07001524 return -EINVAL;
Michał Mirosław0a417702011-02-15 16:59:17 +00001525 return dev->ethtool_ops->set_ufo(dev, data);
Herbert Xub240a0e2008-12-15 23:44:31 -08001526}
1527
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528static int ethtool_self_test(struct net_device *dev, char __user *useraddr)
1529{
1530 struct ethtool_test test;
Stephen Hemminger76fd8592006-09-08 11:16:13 -07001531 const struct ethtool_ops *ops = dev->ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 u64 *data;
Jeff Garzikff03d492007-08-15 16:01:08 -07001533 int ret, test_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534
Ben Hutchingsa9828ec2009-10-01 11:33:03 +00001535 if (!ops->self_test || !ops->get_sset_count)
Jeff Garzikff03d492007-08-15 16:01:08 -07001536 return -EOPNOTSUPP;
1537
Ben Hutchingsa9828ec2009-10-01 11:33:03 +00001538 test_len = ops->get_sset_count(dev, ETH_SS_TEST);
Jeff Garzikff03d492007-08-15 16:01:08 -07001539 if (test_len < 0)
1540 return test_len;
1541 WARN_ON(test_len == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542
1543 if (copy_from_user(&test, useraddr, sizeof(test)))
1544 return -EFAULT;
1545
Jeff Garzikff03d492007-08-15 16:01:08 -07001546 test.len = test_len;
1547 data = kmalloc(test_len * sizeof(u64), GFP_USER);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 if (!data)
1549 return -ENOMEM;
1550
1551 ops->self_test(dev, &test, data);
1552
1553 ret = -EFAULT;
1554 if (copy_to_user(useraddr, &test, sizeof(test)))
1555 goto out;
1556 useraddr += sizeof(test);
1557 if (copy_to_user(useraddr, data, test.len * sizeof(u64)))
1558 goto out;
1559 ret = 0;
1560
1561 out:
1562 kfree(data);
1563 return ret;
1564}
1565
1566static int ethtool_get_strings(struct net_device *dev, void __user *useraddr)
1567{
1568 struct ethtool_gstrings gstrings;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001569 u8 *data;
1570 int ret;
1571
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
1573 return -EFAULT;
1574
Michał Mirosław340ae162011-02-15 16:59:16 +00001575 ret = __ethtool_get_sset_count(dev, gstrings.string_set);
Ben Hutchingsa9828ec2009-10-01 11:33:03 +00001576 if (ret < 0)
1577 return ret;
Jeff Garzikff03d492007-08-15 16:01:08 -07001578
Ben Hutchingsa9828ec2009-10-01 11:33:03 +00001579 gstrings.len = ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580
1581 data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
1582 if (!data)
1583 return -ENOMEM;
1584
Michał Mirosław340ae162011-02-15 16:59:16 +00001585 __ethtool_get_strings(dev, gstrings.string_set, data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586
1587 ret = -EFAULT;
1588 if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
1589 goto out;
1590 useraddr += sizeof(gstrings);
1591 if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
1592 goto out;
1593 ret = 0;
1594
Michał Mirosław340ae162011-02-15 16:59:16 +00001595out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 kfree(data);
1597 return ret;
1598}
1599
1600static int ethtool_phys_id(struct net_device *dev, void __user *useraddr)
1601{
1602 struct ethtool_value id;
1603
1604 if (!dev->ethtool_ops->phys_id)
1605 return -EOPNOTSUPP;
1606
1607 if (copy_from_user(&id, useraddr, sizeof(id)))
1608 return -EFAULT;
1609
1610 return dev->ethtool_ops->phys_id(dev, id.data);
1611}
1612
1613static int ethtool_get_stats(struct net_device *dev, void __user *useraddr)
1614{
1615 struct ethtool_stats stats;
Stephen Hemminger76fd8592006-09-08 11:16:13 -07001616 const struct ethtool_ops *ops = dev->ethtool_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 u64 *data;
Jeff Garzikff03d492007-08-15 16:01:08 -07001618 int ret, n_stats;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619
Ben Hutchingsa9828ec2009-10-01 11:33:03 +00001620 if (!ops->get_ethtool_stats || !ops->get_sset_count)
Jeff Garzikff03d492007-08-15 16:01:08 -07001621 return -EOPNOTSUPP;
1622
Ben Hutchingsa9828ec2009-10-01 11:33:03 +00001623 n_stats = ops->get_sset_count(dev, ETH_SS_STATS);
Jeff Garzikff03d492007-08-15 16:01:08 -07001624 if (n_stats < 0)
1625 return n_stats;
1626 WARN_ON(n_stats == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627
1628 if (copy_from_user(&stats, useraddr, sizeof(stats)))
1629 return -EFAULT;
1630
Jeff Garzikff03d492007-08-15 16:01:08 -07001631 stats.n_stats = n_stats;
1632 data = kmalloc(n_stats * sizeof(u64), GFP_USER);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 if (!data)
1634 return -ENOMEM;
1635
1636 ops->get_ethtool_stats(dev, &stats, data);
1637
1638 ret = -EFAULT;
1639 if (copy_to_user(useraddr, &stats, sizeof(stats)))
1640 goto out;
1641 useraddr += sizeof(stats);
1642 if (copy_to_user(useraddr, data, stats.n_stats * sizeof(u64)))
1643 goto out;
1644 ret = 0;
1645
1646 out:
1647 kfree(data);
1648 return ret;
1649}
1650
viro@ftp.linux.org.uk0bf0519d2005-09-05 03:26:18 +01001651static int ethtool_get_perm_addr(struct net_device *dev, void __user *useraddr)
Jon Wetzela6f9a702005-08-20 17:15:54 -07001652{
1653 struct ethtool_perm_addr epaddr;
Jon Wetzela6f9a702005-08-20 17:15:54 -07001654
Matthew Wilcox313674a2007-07-31 14:00:29 -07001655 if (copy_from_user(&epaddr, useraddr, sizeof(epaddr)))
Jon Wetzela6f9a702005-08-20 17:15:54 -07001656 return -EFAULT;
1657
Matthew Wilcox313674a2007-07-31 14:00:29 -07001658 if (epaddr.size < dev->addr_len)
1659 return -ETOOSMALL;
1660 epaddr.size = dev->addr_len;
Jon Wetzela6f9a702005-08-20 17:15:54 -07001661
Jon Wetzela6f9a702005-08-20 17:15:54 -07001662 if (copy_to_user(useraddr, &epaddr, sizeof(epaddr)))
Matthew Wilcox313674a2007-07-31 14:00:29 -07001663 return -EFAULT;
Jon Wetzela6f9a702005-08-20 17:15:54 -07001664 useraddr += sizeof(epaddr);
Matthew Wilcox313674a2007-07-31 14:00:29 -07001665 if (copy_to_user(useraddr, dev->perm_addr, epaddr.size))
1666 return -EFAULT;
1667 return 0;
Jon Wetzela6f9a702005-08-20 17:15:54 -07001668}
1669
Jeff Garzik13c99b22007-08-15 16:01:56 -07001670static int ethtool_get_value(struct net_device *dev, char __user *useraddr,
1671 u32 cmd, u32 (*actor)(struct net_device *))
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -07001672{
Roland Dreier8e557422010-02-11 12:14:23 -08001673 struct ethtool_value edata = { .cmd = cmd };
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -07001674
Jeff Garzik13c99b22007-08-15 16:01:56 -07001675 if (!actor)
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -07001676 return -EOPNOTSUPP;
1677
Jeff Garzik13c99b22007-08-15 16:01:56 -07001678 edata.data = actor(dev);
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -07001679
1680 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1681 return -EFAULT;
1682 return 0;
1683}
1684
Jeff Garzik13c99b22007-08-15 16:01:56 -07001685static int ethtool_set_value_void(struct net_device *dev, char __user *useraddr,
1686 void (*actor)(struct net_device *, u32))
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -07001687{
1688 struct ethtool_value edata;
1689
Jeff Garzik13c99b22007-08-15 16:01:56 -07001690 if (!actor)
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -07001691 return -EOPNOTSUPP;
1692
1693 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1694 return -EFAULT;
1695
Jeff Garzik13c99b22007-08-15 16:01:56 -07001696 actor(dev, edata.data);
Jeff Garzik339bf022007-08-15 16:01:32 -07001697 return 0;
1698}
1699
Jeff Garzik13c99b22007-08-15 16:01:56 -07001700static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
1701 int (*actor)(struct net_device *, u32))
Jeff Garzik339bf022007-08-15 16:01:32 -07001702{
1703 struct ethtool_value edata;
1704
Jeff Garzik13c99b22007-08-15 16:01:56 -07001705 if (!actor)
Jeff Garzik339bf022007-08-15 16:01:32 -07001706 return -EOPNOTSUPP;
1707
1708 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1709 return -EFAULT;
1710
Jeff Garzik13c99b22007-08-15 16:01:56 -07001711 return actor(dev, edata.data);
Jeff Garzik339bf022007-08-15 16:01:32 -07001712}
1713
chavey97f8aef2010-04-07 21:54:42 -07001714static noinline_for_stack int ethtool_flash_device(struct net_device *dev,
1715 char __user *useraddr)
Ajit Khaparde05c6a8d2009-09-02 17:02:55 +00001716{
1717 struct ethtool_flash efl;
1718
1719 if (copy_from_user(&efl, useraddr, sizeof(efl)))
1720 return -EFAULT;
1721
1722 if (!dev->ethtool_ops->flash_device)
1723 return -EOPNOTSUPP;
1724
1725 return dev->ethtool_ops->flash_device(dev, &efl);
1726}
1727
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728/* The main entry point in this file. Called from net/core/dev.c */
1729
Eric W. Biederman881d9662007-09-17 11:56:21 -07001730int dev_ethtool(struct net *net, struct ifreq *ifr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731{
Eric W. Biederman881d9662007-09-17 11:56:21 -07001732 struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 void __user *useraddr = ifr->ifr_data;
1734 u32 ethcmd;
1735 int rc;
Michał Mirosław04ed3e72011-01-24 15:32:47 -08001736 u32 old_features;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 if (!dev || !netif_device_present(dev))
1739 return -ENODEV;
1740
chavey97f8aef2010-04-07 21:54:42 -07001741 if (copy_from_user(&ethcmd, useraddr, sizeof(ethcmd)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 return -EFAULT;
1743
Ben Hutchings01414802010-08-17 02:31:15 -07001744 if (!dev->ethtool_ops) {
1745 /* ETHTOOL_GDRVINFO does not require any driver support.
1746 * It is also unprivileged and does not change anything,
1747 * so we can take a shortcut to it. */
1748 if (ethcmd == ETHTOOL_GDRVINFO)
1749 return ethtool_get_drvinfo(dev, useraddr);
1750 else
1751 return -EOPNOTSUPP;
1752 }
1753
Stephen Hemminger75f31232006-09-28 15:13:37 -07001754 /* Allow some commands to be done by anyone */
chavey97f8aef2010-04-07 21:54:42 -07001755 switch (ethcmd) {
stephen hemminger0fdc1002010-08-23 10:24:18 +00001756 case ETHTOOL_GSET:
Stephen Hemminger75f31232006-09-28 15:13:37 -07001757 case ETHTOOL_GDRVINFO:
Stephen Hemminger75f31232006-09-28 15:13:37 -07001758 case ETHTOOL_GMSGLVL:
Stephen Hemminger75f31232006-09-28 15:13:37 -07001759 case ETHTOOL_GCOALESCE:
1760 case ETHTOOL_GRINGPARAM:
1761 case ETHTOOL_GPAUSEPARAM:
1762 case ETHTOOL_GRXCSUM:
1763 case ETHTOOL_GTXCSUM:
1764 case ETHTOOL_GSG:
1765 case ETHTOOL_GSTRINGS:
Stephen Hemminger75f31232006-09-28 15:13:37 -07001766 case ETHTOOL_GTSO:
1767 case ETHTOOL_GPERMADDR:
1768 case ETHTOOL_GUFO:
1769 case ETHTOOL_GGSO:
stephen hemminger1cab8192010-02-11 13:48:29 +00001770 case ETHTOOL_GGRO:
Jeff Garzik339bf022007-08-15 16:01:32 -07001771 case ETHTOOL_GFLAGS:
1772 case ETHTOOL_GPFLAGS:
Santwona Behera0853ad62008-07-02 03:47:41 -07001773 case ETHTOOL_GRXFH:
Santwona Behera59089d82009-02-20 00:58:13 -08001774 case ETHTOOL_GRXRINGS:
1775 case ETHTOOL_GRXCLSRLCNT:
1776 case ETHTOOL_GRXCLSRULE:
1777 case ETHTOOL_GRXCLSRLALL:
Michał Mirosław5455c692011-02-15 16:59:17 +00001778 case ETHTOOL_GFEATURES:
Stephen Hemminger75f31232006-09-28 15:13:37 -07001779 break;
1780 default:
1781 if (!capable(CAP_NET_ADMIN))
1782 return -EPERM;
1783 }
1784
chavey97f8aef2010-04-07 21:54:42 -07001785 if (dev->ethtool_ops->begin) {
1786 rc = dev->ethtool_ops->begin(dev);
1787 if (rc < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 return rc;
chavey97f8aef2010-04-07 21:54:42 -07001789 }
Stephen Hemmingerd8a33ac2005-05-29 14:13:47 -07001790 old_features = dev->features;
1791
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 switch (ethcmd) {
1793 case ETHTOOL_GSET:
1794 rc = ethtool_get_settings(dev, useraddr);
1795 break;
1796 case ETHTOOL_SSET:
1797 rc = ethtool_set_settings(dev, useraddr);
1798 break;
1799 case ETHTOOL_GDRVINFO:
1800 rc = ethtool_get_drvinfo(dev, useraddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 break;
1802 case ETHTOOL_GREGS:
1803 rc = ethtool_get_regs(dev, useraddr);
1804 break;
1805 case ETHTOOL_GWOL:
1806 rc = ethtool_get_wol(dev, useraddr);
1807 break;
1808 case ETHTOOL_SWOL:
1809 rc = ethtool_set_wol(dev, useraddr);
1810 break;
1811 case ETHTOOL_GMSGLVL:
Jeff Garzik13c99b22007-08-15 16:01:56 -07001812 rc = ethtool_get_value(dev, useraddr, ethcmd,
1813 dev->ethtool_ops->get_msglevel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 break;
1815 case ETHTOOL_SMSGLVL:
Jeff Garzik13c99b22007-08-15 16:01:56 -07001816 rc = ethtool_set_value_void(dev, useraddr,
1817 dev->ethtool_ops->set_msglevel);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 break;
1819 case ETHTOOL_NWAY_RST:
1820 rc = ethtool_nway_reset(dev);
1821 break;
1822 case ETHTOOL_GLINK:
Ben Hutchingse596e6e2010-12-09 12:08:35 +00001823 rc = ethtool_get_link(dev, useraddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 break;
1825 case ETHTOOL_GEEPROM:
1826 rc = ethtool_get_eeprom(dev, useraddr);
1827 break;
1828 case ETHTOOL_SEEPROM:
1829 rc = ethtool_set_eeprom(dev, useraddr);
1830 break;
1831 case ETHTOOL_GCOALESCE:
1832 rc = ethtool_get_coalesce(dev, useraddr);
1833 break;
1834 case ETHTOOL_SCOALESCE:
1835 rc = ethtool_set_coalesce(dev, useraddr);
1836 break;
1837 case ETHTOOL_GRINGPARAM:
1838 rc = ethtool_get_ringparam(dev, useraddr);
1839 break;
1840 case ETHTOOL_SRINGPARAM:
1841 rc = ethtool_set_ringparam(dev, useraddr);
1842 break;
1843 case ETHTOOL_GPAUSEPARAM:
1844 rc = ethtool_get_pauseparam(dev, useraddr);
1845 break;
1846 case ETHTOOL_SPAUSEPARAM:
1847 rc = ethtool_set_pauseparam(dev, useraddr);
1848 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 case ETHTOOL_TEST:
1850 rc = ethtool_self_test(dev, useraddr);
1851 break;
1852 case ETHTOOL_GSTRINGS:
1853 rc = ethtool_get_strings(dev, useraddr);
1854 break;
1855 case ETHTOOL_PHYS_ID:
1856 rc = ethtool_phys_id(dev, useraddr);
1857 break;
1858 case ETHTOOL_GSTATS:
1859 rc = ethtool_get_stats(dev, useraddr);
1860 break;
Jon Wetzela6f9a702005-08-20 17:15:54 -07001861 case ETHTOOL_GPERMADDR:
1862 rc = ethtool_get_perm_addr(dev, useraddr);
1863 break;
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -07001864 case ETHTOOL_GFLAGS:
Jeff Garzik13c99b22007-08-15 16:01:56 -07001865 rc = ethtool_get_value(dev, useraddr, ethcmd,
Sridhar Samudrala1896e612009-07-22 13:38:22 +00001866 (dev->ethtool_ops->get_flags ?
1867 dev->ethtool_ops->get_flags :
1868 ethtool_op_get_flags));
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -07001869 break;
1870 case ETHTOOL_SFLAGS:
Michał Mirosławda8ac86c2011-02-15 16:59:18 +00001871 rc = ethtool_set_value(dev, useraddr, __ethtool_set_flags);
Jeff Garzik3ae7c0b2007-08-15 16:00:51 -07001872 break;
Jeff Garzik339bf022007-08-15 16:01:32 -07001873 case ETHTOOL_GPFLAGS:
Jeff Garzik13c99b22007-08-15 16:01:56 -07001874 rc = ethtool_get_value(dev, useraddr, ethcmd,
1875 dev->ethtool_ops->get_priv_flags);
Jeff Garzik339bf022007-08-15 16:01:32 -07001876 break;
1877 case ETHTOOL_SPFLAGS:
Jeff Garzik13c99b22007-08-15 16:01:56 -07001878 rc = ethtool_set_value(dev, useraddr,
1879 dev->ethtool_ops->set_priv_flags);
Jeff Garzik339bf022007-08-15 16:01:32 -07001880 break;
Santwona Behera0853ad62008-07-02 03:47:41 -07001881 case ETHTOOL_GRXFH:
Santwona Behera59089d82009-02-20 00:58:13 -08001882 case ETHTOOL_GRXRINGS:
1883 case ETHTOOL_GRXCLSRLCNT:
1884 case ETHTOOL_GRXCLSRULE:
1885 case ETHTOOL_GRXCLSRLALL:
Ben Hutchingsbf988432010-06-28 08:45:58 +00001886 rc = ethtool_get_rxnfc(dev, ethcmd, useraddr);
Santwona Behera0853ad62008-07-02 03:47:41 -07001887 break;
1888 case ETHTOOL_SRXFH:
Santwona Behera59089d82009-02-20 00:58:13 -08001889 case ETHTOOL_SRXCLSRLDEL:
1890 case ETHTOOL_SRXCLSRLINS:
Ben Hutchingsbf988432010-06-28 08:45:58 +00001891 rc = ethtool_set_rxnfc(dev, ethcmd, useraddr);
Santwona Behera0853ad62008-07-02 03:47:41 -07001892 break;
Ajit Khaparde05c6a8d2009-09-02 17:02:55 +00001893 case ETHTOOL_FLASHDEV:
1894 rc = ethtool_flash_device(dev, useraddr);
1895 break;
Ben Hutchingsd73d3a82009-10-05 10:59:58 +00001896 case ETHTOOL_RESET:
1897 rc = ethtool_reset(dev, useraddr);
1898 break;
Peter P Waskiewicz Jr15682bc2010-02-10 20:03:05 -08001899 case ETHTOOL_SRXNTUPLE:
1900 rc = ethtool_set_rx_ntuple(dev, useraddr);
1901 break;
1902 case ETHTOOL_GRXNTUPLE:
1903 rc = ethtool_get_rx_ntuple(dev, useraddr);
1904 break;
Jeff Garzik723b2f52010-03-03 22:51:50 +00001905 case ETHTOOL_GSSET_INFO:
1906 rc = ethtool_get_sset_info(dev, useraddr);
1907 break;
Ben Hutchingsa5b6ee22010-06-30 05:05:23 +00001908 case ETHTOOL_GRXFHINDIR:
1909 rc = ethtool_get_rxfh_indir(dev, useraddr);
1910 break;
1911 case ETHTOOL_SRXFHINDIR:
1912 rc = ethtool_set_rxfh_indir(dev, useraddr);
1913 break;
Michał Mirosław5455c692011-02-15 16:59:17 +00001914 case ETHTOOL_GFEATURES:
1915 rc = ethtool_get_features(dev, useraddr);
1916 break;
1917 case ETHTOOL_SFEATURES:
1918 rc = ethtool_set_features(dev, useraddr);
1919 break;
Michał Mirosław0a417702011-02-15 16:59:17 +00001920 case ETHTOOL_GTXCSUM:
Michał Mirosławe83d3602011-02-15 16:59:18 +00001921 case ETHTOOL_GRXCSUM:
Michał Mirosław0a417702011-02-15 16:59:17 +00001922 case ETHTOOL_GSG:
1923 case ETHTOOL_GTSO:
1924 case ETHTOOL_GUFO:
1925 case ETHTOOL_GGSO:
1926 case ETHTOOL_GGRO:
1927 rc = ethtool_get_one_feature(dev, useraddr, ethcmd);
1928 break;
1929 case ETHTOOL_STXCSUM:
Michał Mirosławe83d3602011-02-15 16:59:18 +00001930 case ETHTOOL_SRXCSUM:
Michał Mirosław0a417702011-02-15 16:59:17 +00001931 case ETHTOOL_SSG:
1932 case ETHTOOL_STSO:
1933 case ETHTOOL_SUFO:
1934 case ETHTOOL_SGSO:
1935 case ETHTOOL_SGRO:
1936 rc = ethtool_set_one_feature(dev, useraddr, ethcmd);
1937 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 default:
Matthew Wilcox61a44b92007-07-31 14:00:02 -07001939 rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 }
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001941
Stephen Hemmingere71a4782007-04-10 20:10:33 -07001942 if (dev->ethtool_ops->complete)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 dev->ethtool_ops->complete(dev);
Stephen Hemmingerd8a33ac2005-05-29 14:13:47 -07001944
1945 if (old_features != dev->features)
1946 netdev_features_change(dev);
1947
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949}