Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 35b2a113cb0298d4f9a1263338b456094a414057

Authored by Johannes Berg 2012-05-17 05:40:18 +0800

Committed by John W. Linville 2012-06-06 03:32:15 +0800

Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches

wireless: remove wext sysfs

The only user of this was hal prior to its 0.5.12
release which happened over two years ago, so I'm
sure this can be removed without issues.

Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

Showing 3 changed files with 0 additions and 96 deletions Inline Diff

Documentation/feature-removal-schedule.txt
net/core/net-sysfs.c
net/wireless/Kconfig

Documentation/feature-removal-schedule.txt

Diff comments View file @ 35b2a11

 The following is a list of files and features that are going to be
 removed in the kernel source tree.  Every entry should contain what
 exactly is going away, why it is happening, and who is going to be doing
 the work.  When the feature is removed from the kernel, it should also
 be removed from this file.  The suggested deprecation period is 3 releases.
 ---------------------------
 What:	ddebug_query="query" boot cmdline param
 When:	v3.8
 Why:	obsoleted by dyndbg="query" and module.dyndbg="query"
 Who:	Jim Cromie <jim.cromie@gmail.com>, Jason Baron <jbaron@redhat.com>
 ---------------------------
 What:	CONFIG_APM_CPU_IDLE, and its ability to call APM BIOS in idle
 When:	2012
 Why:	This optional sub-feature of APM is of dubious reliability,
 	and ancient APM laptops are likely better served by calling HLT.
 	Deleting CONFIG_APM_CPU_IDLE allows x86 to stop exporting
 	the pm_idle function pointer to modules.
 Who:	Len Brown <len.brown@intel.com>
 ----------------------------
 What:	x86_32 "no-hlt" cmdline param
 When:	2012
 Why:	remove a branch from idle path, simplify code used by everybody.
 	This option disabled the use of HLT in idle and machine_halt()
 	for hardware that was flakey 15-years ago.  Today we have
 	"idle=poll" that removed HLT from idle, and so if such a machine
 	is still running the upstream kernel, "idle=poll" is likely sufficient.
 Who:	Len Brown <len.brown@intel.com>
 ----------------------------
 What:	x86 "idle=mwait" cmdline param
 When:	2012
 Why:	simplify x86 idle code
 Who:	Len Brown <len.brown@intel.com>
 ----------------------------
 What:	PRISM54
 When:	2.6.34
 Why:	prism54 FullMAC PCI / Cardbus devices used to be supported only by the
 	prism54 wireless driver. After Intersil stopped selling these
 	devices in preference for the newer more flexible SoftMAC devices
 	a SoftMAC device driver was required and prism54 did not support
 	them. The p54pci driver now exists and has been present in the kernel for
 	a while. This driver supports both SoftMAC devices and FullMAC devices.
 	The main difference between these devices was the amount of memory which
 	could be used for the firmware. The SoftMAC devices support a smaller
 	amount of memory. Because of this the SoftMAC firmware fits into FullMAC
 	devices's memory. p54pci supports not only PCI / Cardbus but also USB
 	and SPI. Since p54pci supports all devices prism54 supports
 	you will have a conflict. I'm not quite sure how distributions are
 	handling this conflict right now. prism54 was kept around due to
 	claims users may experience issues when using the SoftMAC driver.
 	Time has passed users have not reported issues. If you use prism54
 	and for whatever reason you cannot use p54pci please let us know!
 	E-mail us at: linux-wireless@vger.kernel.org
 	For more information see the p54 wiki page:
 	http://wireless.kernel.org/en/users/Drivers/p54
 Who:	Luis R. Rodriguez <lrodriguez@atheros.com>
 ---------------------------
 What:	IRQF_SAMPLE_RANDOM
 Check:	IRQF_SAMPLE_RANDOM
 When:	July 2009
 Why:	Many of IRQF_SAMPLE_RANDOM users are technically bogus as entropy
 	sources in the kernel's current entropy model. To resolve this, every
 	input point to the kernel's entropy pool needs to better document the
 	type of entropy source it actually is. This will be replaced with
 	additional add_*_randomness functions in drivers/char/random.c
 Who:	Robin Getz <rgetz@blackfin.uclinux.org> & Matt Mackall <mpm@selenic.com>
 ---------------------------
 What:	The ieee80211_regdom module parameter
 When:	March 2010 / desktop catchup
 Why:	This was inherited by the CONFIG_WIRELESS_OLD_REGULATORY code,
 	and currently serves as an option for users to define an
 	ISO / IEC 3166 alpha2 code for the country they are currently
 	present in. Although there are userspace API replacements for this
 	through nl80211 distributions haven't yet caught up with implementing
 	decent alternatives through standard GUIs. Although available as an
 	option through iw or wpa_supplicant its just a matter of time before
 	distributions pick up good GUI options for this. The ideal solution
 	would actually consist of intelligent designs which would do this for
 	the user automatically even when travelling through different countries.
 	Until then we leave this module parameter as a compromise.
 	When userspace improves with reasonable widely-available alternatives for
 	this we will no longer need this module parameter. This entry hopes that
 	by the super-futuristically looking date of "March 2010" we will have
 	such replacements widely available.
 Who:	Luis R. Rodriguez <lrodriguez@atheros.com>
 ---------------------------
 What:	dev->power.power_state
 When:	July 2007
 Why:	Broken design for runtime control over driver power states, confusing
 	driver-internal runtime power management with:  mechanisms to support
 	system-wide sleep state transitions; event codes that distinguish
 	different phases of swsusp "sleep" transitions; and userspace policy
 	inputs.  This framework was never widely used, and most attempts to
 	use it were broken.  Drivers should instead be exposing domain-specific
 	interfaces either to kernel or to userspace.
 Who:	Pavel Machek <pavel@ucw.cz>
 ---------------------------
 What:	/proc/<pid>/oom_adj
 When:	August 2012
 Why:	/proc/<pid>/oom_adj allows userspace to influence the oom killer's
 	badness heuristic used to determine which task to kill when the kernel
 	is out of memory.
 	The badness heuristic has since been rewritten since the introduction of
 	this tunable such that its meaning is deprecated.  The value was
 	implemented as a bitshift on a score generated by the badness()
 	function that did not have any precise units of measure.  With the
 	rewrite, the score is given as a proportion of available memory to the
 	task allocating pages, so using a bitshift which grows the score
 	exponentially is, thus, impossible to tune with fine granularity.
 	A much more powerful interface, /proc/<pid>/oom_score_adj, was
 	introduced with the oom killer rewrite that allows users to increase or
 	decrease the badness score linearly.  This interface will replace
 	/proc/<pid>/oom_adj.
 	A warning will be emitted to the kernel log if an application uses this
 	deprecated interface.  After it is printed once, future warnings will be
 	suppressed until the kernel is rebooted.
 ---------------------------
 What:	remove EXPORT_SYMBOL(kernel_thread)
 When:	August 2006
 Files:	arch/*/kernel/*_ksyms.c
 Check:	kernel_thread
 Why:	kernel_thread is a low-level implementation detail.  Drivers should
         use the <linux/kthread.h> API instead which shields them from
 	implementation details and provides a higherlevel interface that
 	prevents bugs and code duplication
 Who:	Christoph Hellwig <hch@lst.de>
 ---------------------------
 What:	Unused EXPORT_SYMBOL/EXPORT_SYMBOL_GPL exports
 	(temporary transition config option provided until then)
 	The transition config option will also be removed at the same time.
 When:	before 2.6.19
 Why:	Unused symbols are both increasing the size of the kernel binary
 	and are often a sign of "wrong API"
 Who:	Arjan van de Ven <arjan@linux.intel.com>
 ---------------------------
 What:	PHYSDEVPATH, PHYSDEVBUS, PHYSDEVDRIVER in the uevent environment
 When:	October 2008
 Why:	The stacking of class devices makes these values misleading and
 	inconsistent.
 	Class devices should not carry any of these properties, and bus
 	devices have SUBSYTEM and DRIVER as a replacement.
 Who:	Kay Sievers <kay.sievers@suse.de>
 ---------------------------
 What:	ACPI procfs interface
 When:	July 2008
 Why:	ACPI sysfs conversion should be finished by January 2008.
 	ACPI procfs interface will be removed in July 2008 so that
 	there is enough time for the user space to catch up.
 Who:	Zhang Rui <rui.zhang@intel.com>
 ---------------------------
 What:	CONFIG_ACPI_PROCFS_POWER
 When:	2.6.39
 Why:	sysfs I/F for ACPI power devices, including AC and Battery,
         has been working in upstream kernel since 2.6.24, Sep 2007.
 	In 2.6.37, we make the sysfs I/F always built in and this option
 	disabled by default.
 	Remove this option and the ACPI power procfs interface in 2.6.39.
 Who:	Zhang Rui <rui.zhang@intel.com>
 ---------------------------
 What:	/proc/acpi/event
 When:	February 2008
 Why:	/proc/acpi/event has been replaced by events via the input layer
 	and netlink since 2.6.23.
 Who:	Len Brown <len.brown@intel.com>
 ---------------------------
 What:	i386/x86_64 bzImage symlinks
 When:	April 2010
 Why:	The i386/x86_64 merge provides a symlink to the old bzImage
 	location so not yet updated user space tools, e.g. package
 	scripts, do not break.
 Who:	Thomas Gleixner <tglx@linutronix.de>
 ---------------------------
 What:	GPIO autorequest on gpio_direction_{input,output}() in gpiolib
 When:	February 2010
 Why:	All callers should use explicit gpio_request()/gpio_free().
 	The autorequest mechanism in gpiolib was provided mostly as a
 	migration aid for legacy GPIO interfaces (for SOC based GPIOs).
 	Those users have now largely migrated.  Platforms implementing
 	the GPIO interfaces without using gpiolib will see no changes.
 Who:	David Brownell <dbrownell@users.sourceforge.net>
 ---------------------------
 What:	b43 support for firmware revision < 410
 When:	The schedule was July 2008, but it was decided that we are going to keep the
         code as long as there are no major maintanance headaches.
 	So it _could_ be removed _any_ time now, if it conflicts with something new.
 Why:	The support code for the old firmware hurts code readability/maintainability
 	and slightly hurts runtime performance. Bugfixes for the old firmware
 	are not provided by Broadcom anymore.
 Who:	Michael Buesch <m@bues.ch>
 ---------------------------
 What:	Ability for non root users to shm_get hugetlb pages based on mlock
 	resource limits
 When:	2.6.31
 Why:	Non root users need to be part of /proc/sys/vm/hugetlb_shm_group or
 	have CAP_IPC_LOCK to be able to allocate shm segments backed by
 	huge pages.  The mlock based rlimit check to allow shm hugetlb is
 	inconsistent with mmap based allocations.  Hence it is being
 	deprecated.
 Who:	Ravikiran Thirumalai <kiran@scalex86.org>
 ---------------------------
-What:	Code that is now under CONFIG_WIRELESS_EXT_SYSFS
-	(in net/core/net-sysfs.c)
-When:	3.5
-Why:	Over 1K .text/.data size reduction, data is available in other
-	ways (ioctls)
-Who:	Johannes Berg <johannes@sipsolutions.net>
----------------------------
 What:	sysfs ui for changing p4-clockmod parameters
 When:	September 2009
 Why:	See commits 129f8ae9b1b5be94517da76009ea956e89104ce8 and
 	e088e4c9cdb618675874becb91b2fd581ee707e6.
 	Removal is subject to fixing any remaining bugs in ACPI which may
 	cause the thermal throttling not to happen at the right time.
 Who:	Dave Jones <davej@redhat.com>, Matthew Garrett <mjg@redhat.com>
 -----------------------------
 What:	fakephp and associated sysfs files in /sys/bus/pci/slots/
 When:	2011
 Why:	In 2.6.27, the semantics of /sys/bus/pci/slots was redefined to
 	represent a machine's physical PCI slots. The change in semantics
 	had userspace implications, as the hotplug core no longer allowed
 	drivers to create multiple sysfs files per physical slot (required
 	for multi-function devices, e.g.). fakephp was seen as a developer's
 	tool only, and its interface changed. Too late, we learned that
 	there were some users of the fakephp interface.
 	In 2.6.30, the original fakephp interface was restored. At the same
 	time, the PCI core gained the ability that fakephp provided, namely
 	function-level hot-remove and hot-add.
 	Since the PCI core now provides the same functionality, exposed in:
 		/sys/bus/pci/rescan
 		/sys/bus/pci/devices/.../remove
 		/sys/bus/pci/devices/.../rescan
 	there is no functional reason to maintain fakephp as well.
 	We will keep the existing module so that 'modprobe fakephp' will
 	present the old /sys/bus/pci/slots/... interface for compatibility,
 	but users are urged to migrate their applications to the API above.
 	After a reasonable transition period, we will remove the legacy
 	fakephp interface.
 Who:	Alex Chiang <achiang@hp.com>
 ---------------------------
 What:	CONFIG_RFKILL_INPUT
 When:	2.6.33
 Why:	Should be implemented in userspace, policy daemon.
 Who:	Johannes Berg <johannes@sipsolutions.net>
 ----------------------------
 What:	sound-slot/service-* module aliases and related clutters in
 	sound/sound_core.c
 When:	August 2010
 Why:	OSS sound_core grabs all legacy minors (0-255) of SOUND_MAJOR
 	(14) and requests modules using custom sound-slot/service-*
 	module aliases.  The only benefit of doing this is allowing
 	use of custom module aliases which might as well be considered
 	a bug at this point.  This preemptive claiming prevents
 	alternative OSS implementations.
 	Till the feature is removed, the kernel will be requesting
 	both sound-slot/service-* and the standard char-major-* module
 	aliases and allow turning off the pre-claiming selectively via
 	CONFIG_SOUND_OSS_CORE_PRECLAIM and soundcore.preclaim_oss
 	kernel parameter.
 	After the transition phase is complete, both the custom module
 	aliases and switches to disable it will go away.  This removal
 	will also allow making ALSA OSS emulation independent of
 	sound_core.  The dependency will be broken then too.
 Who:	Tejun Heo <tj@kernel.org>
 ----------------------------
 What:	sysfs-class-rfkill state file
 When:	Feb 2014
 Files:	net/rfkill/core.c
 Why: 	Documented as obsolete since Feb 2010. This file is limited to 3
 	states while the rfkill drivers can have 4 states.
 Who: 	anybody or Florian Mickler <florian@mickler.org>
 ----------------------------
 What: 	sysfs-class-rfkill claim file
 When:	Feb 2012
 Files:	net/rfkill/core.c
 Why:	It is not possible to claim an rfkill driver since 2007. This is
 	Documented as obsolete since Feb 2010.
 Who: 	anybody or Florian Mickler <florian@mickler.org>
 ----------------------------
 What:	iwlwifi 50XX module parameters
 When:	3.0
 Why:	The "..50" modules parameters were used to configure 5000 series and
 	up devices; different set of module parameters also available for 4965
 	with same functionalities. Consolidate both set into single place
 	in drivers/net/wireless/iwlwifi/iwl-agn.c
 Who:	Wey-Yi Guy <wey-yi.w.guy@intel.com>
 ----------------------------
 What:	iwl4965 alias support
 When:	3.0
 Why:	Internal alias support has been present in module-init-tools for some
 	time, the MODULE_ALIAS("iwl4965") boilerplate aliases can be removed
 	with no impact.
 Who:	Wey-Yi Guy <wey-yi.w.guy@intel.com>
 ---------------------------
 What:	xt_NOTRACK
 Files:	net/netfilter/xt_NOTRACK.c
 When:	April 2011
 Why:	Superseded by xt_CT
 Who:	Netfilter developer team <netfilter-devel@vger.kernel.org>
 ----------------------------
 What:	IRQF_DISABLED
 When:	2.6.36
 Why:	The flag is a NOOP as we run interrupt handlers with interrupts disabled
 Who:	Thomas Gleixner <tglx@linutronix.de>
 ----------------------------
 What: 	PCI DMA unmap state API
 When:	August 2012
 Why:	PCI DMA unmap state API (include/linux/pci-dma.h) was replaced
 	with DMA unmap state API (DMA unmap state API can be used for
 	any bus).
 Who:	FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
 ----------------------------
 What:	iwlwifi disable_hw_scan module parameters
 When:	3.0
 Why:	Hareware scan is the prefer method for iwlwifi devices for
 	scanning operation. Remove software scan support for all the
 	iwlwifi devices.
 Who:	Wey-Yi Guy <wey-yi.w.guy@intel.com>
 ----------------------------
 What:	Legacy, non-standard chassis intrusion detection interface.
 When:	June 2011
 Why:	The adm9240, w83792d and w83793 hardware monitoring drivers have
 	legacy interfaces for chassis intrusion detection. A standard
 	interface has been added to each driver, so the legacy interface
 	can be removed.
 Who:	Jean Delvare <khali@linux-fr.org>
 ----------------------------
 What:	xt_connlimit rev 0
 When:	2012
 Who:	Jan Engelhardt <jengelh@medozas.de>
 Files:	net/netfilter/xt_connlimit.c
 ----------------------------
 What:	ipt_addrtype match include file
 When:	2012
 Why:	superseded by xt_addrtype
 Who:	Florian Westphal <fw@strlen.de>
 Files:	include/linux/netfilter_ipv4/ipt_addrtype.h
 ----------------------------
 What:	i2c_driver.attach_adapter
 	i2c_driver.detach_adapter
 When:	September 2011
 Why:	These legacy callbacks should no longer be used as i2c-core offers
 	a variety of preferable alternative ways to instantiate I2C devices.
 Who:	Jean Delvare <khali@linux-fr.org>
 ----------------------------
 What:	Opening a radio device node will no longer automatically switch the
 	tuner mode from tv to radio.
 When:	3.3
 Why:	Just opening a V4L device should not change the state of the hardware
 	like that. It's very unexpected and against the V4L spec. Instead, you
 	switch to radio mode by calling VIDIOC_S_FREQUENCY. This is the second
 	and last step of the move to consistent handling of tv and radio tuners.
 Who:	Hans Verkuil <hans.verkuil@cisco.com>
 ----------------------------
 What:	g_file_storage driver
 When:	3.8
 Why:	This driver has been superseded by g_mass_storage.
 Who:	Alan Stern <stern@rowland.harvard.edu>
 ----------------------------
 What:   threeg and interface sysfs files in /sys/devices/platform/acer-wmi
 When:   2012
 Why:    In 3.0, we can now autodetect internal 3G device and already have
 	the threeg rfkill device. So, we plan to remove threeg sysfs support
 	for it's no longer necessary.
 	We also plan to remove interface sysfs file that exposed which ACPI-WMI
 	interface that was used by acer-wmi driver. It will replaced by
 	information log when acer-wmi initial.
 Who:    Lee, Chun-Yi <jlee@novell.com>
 ---------------------------
 What:	/sys/devices/platform/_UDC_/udc/_UDC_/is_dualspeed file and
 	is_dualspeed line in /sys/devices/platform/ci13xxx_*/udc/device file.
 When:	3.8
 Why:	The is_dualspeed file is superseded by maximum_speed in the same
 	directory and is_dualspeed line in device file is superseded by
 	max_speed line in the same file.
 	The maximum_speed/max_speed specifies maximum speed supported by UDC.
 	To check if dualspeeed is supported, check if the value is >= 3.
 	Various possible speeds are defined in <linux/usb/ch9.h>.
 Who:	Michal Nazarewicz <mina86@mina86.com>
 ----------------------------
 What:	The XFS nodelaylog mount option
 When:	3.3
 Why:	The delaylog mode that has been the default since 2.6.39 has proven
 	stable, and the old code is in the way of additional improvements in
 	the log code.
 Who:	Christoph Hellwig <hch@lst.de>
 ----------------------------
 What:	iwlagn alias support
 When:	3.5
 Why:	The iwlagn module has been renamed iwlwifi.  The alias will be around
 	for backward compatibility for several cycles and then dropped.
 Who:	Don Fry <donald.h.fry@intel.com>
 ----------------------------
 What:	pci_scan_bus_parented()
 When:	3.5
 Why:	The pci_scan_bus_parented() interface creates a new root bus.  The
 	bus is created with default resources (ioport_resource and
 	iomem_resource) that are always wrong, so we rely on arch code to
 	correct them later.  Callers of pci_scan_bus_parented() should
 	convert to using pci_scan_root_bus() so they can supply a list of
 	bus resources when the bus is created.
 Who:	Bjorn Helgaas <bhelgaas@google.com>
 ----------------------------
 What:	Low Performance USB Block driver ("CONFIG_BLK_DEV_UB")
 When:	3.6
 Why:	This driver provides support for USB storage devices like "USB
 	sticks". As of now, it is deactivated in Debian, Fedora and
         Ubuntu. All current users can switch over to usb-storage
         (CONFIG_USB_STORAGE) which only drawback is the additional SCSI
         stack.
 Who:	Sebastian Andrzej Siewior <sebastian@breakpoint.cc>
 ----------------------------
 What:	kmap_atomic(page, km_type)
 When:	3.5
 Why:	The old kmap_atomic() with two arguments is deprecated, we only
 	keep it for backward compatibility for few cycles and then drop it.
 Who:	Cong Wang <amwang@redhat.com>
 ----------------------------
 What:	get_robust_list syscall
 When:	2013
 Why:	There appear to be no production users of the get_robust_list syscall,
 	and it runs the risk of leaking address locations, allowing the bypass
 	of ASLR. It was only ever intended for debugging, so it should be
 	removed.
 Who:	Kees Cook <keescook@chromium.org>
 ----------------------------
 What:	Removing the pn544 raw driver.
 When:	3.6
 Why:	With the introduction of the NFC HCI and SHDL kernel layers, pn544.c
 	is being replaced by pn544_hci.c which is accessible through the netlink
 	and socket NFC APIs. Moreover, pn544.c is outdated and does not seem to
 	work properly with the latest Android stacks.
 	Having 2 drivers for the same hardware is confusing and as such we
 	should only keep the one following the kernel NFC APIs.
 Who:	Samuel Ortiz <sameo@linux.intel.com>
 ----------------------------
 What:	setitimer accepts user NULL pointer (value)
 When:	3.6
 Why:	setitimer is not returning -EFAULT if user pointer is NULL. This
 	violates the spec.
 Who:	Sasikantha Babu <sasikanth.v19@gmail.com>
 ----------------------------
 What:	remove bogus DV presets V4L2_DV_1080I29_97, V4L2_DV_1080I30 and
 	V4L2_DV_1080I25
 When:	3.6
 Why:	These HDTV formats do not exist and were added by a confused mind
 	(that was me, to be precise...)
 Who:	Hans Verkuil <hans.verkuil@cisco.com>
 ----------------------------
 What:	V4L2_CID_HCENTER, V4L2_CID_VCENTER V4L2 controls
 When:	3.7
 Why:	The V4L2_CID_VCENTER, V4L2_CID_HCENTER controls have been deprecated
 	for about 4 years and they are not used by any mainline driver.
 	There are newer controls (V4L2_CID_PAN*, V4L2_CID_TILT*) that provide
 	similar	functionality.
 Who:	Sylwester Nawrocki <sylvester.nawrocki@gmail.com>
 ----------------------------
 What:	cgroup option updates via remount
 When:	March 2013
 Why:	Remount currently allows changing bound subsystems and
 	release_agent.  Rebinding is hardly useful as it only works
 	when the hierarchy is empty and release_agent itself should be
 	replaced with conventional fsnotify.
 ----------------------------
 What:	KVM debugfs statistics
 When:	2013
 Why:	KVM tracepoints provide mostly equivalent information in a much more
         flexible fashion.
 ----------------------------
 What:	at91-mci driver ("CONFIG_MMC_AT91")
 When:	3.7
 Why:	There are two mci drivers: at91-mci and atmel-mci. The PDC support
 	was added to atmel-mci as a first step to support more chips.
 	Then at91-mci was kept only for old IP versions (on at91rm9200 and
 	at91sam9261). The support of these IP versions has just been added
 	to atmel-mci, so atmel-mci can be used for all chips.
 Who:	Ludovic Desroches <ludovic.desroches@atmel.com>
 ----------------------------
 What:	net/wanrouter/
 When:	June 2013
 Why:	Unsupported/unmaintained/unused since 2.6
 ----------------------------

net/core/net-sysfs.c

Diff comments View file @ 35b2a11

 /*
  * net-sysfs.c - network device class and attributes
  *
  * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
  *
  *	This program is free software; you can redistribute it and/or
  *	modify it under the terms of the GNU General Public License
  *	as published by the Free Software Foundation; either version
  *	2 of the License, or (at your option) any later version.
  */
 #include <linux/capability.h>
 #include <linux/kernel.h>
 #include <linux/netdevice.h>
 #include <linux/if_arp.h>
 #include <linux/slab.h>
 #include <linux/nsproxy.h>
 #include <net/sock.h>
 #include <net/net_namespace.h>
 #include <linux/rtnetlink.h>
 #include <linux/wireless.h>
 #include <linux/vmalloc.h>
 #include <linux/export.h>
 #include <linux/jiffies.h>
 #include <net/wext.h>
 #include "net-sysfs.h"
 #ifdef CONFIG_SYSFS
 static const char fmt_hex[] = "%#x\n";
 static const char fmt_long_hex[] = "%#lx\n";
 static const char fmt_dec[] = "%d\n";
 static const char fmt_udec[] = "%u\n";
 static const char fmt_ulong[] = "%lu\n";
 static const char fmt_u64[] = "%llu\n";
 static inline int dev_isalive(const struct net_device *dev)
 {
 	return dev->reg_state <= NETREG_REGISTERED;
 }
 /* use same locking rules as GIF* ioctl's */
 static ssize_t netdev_show(const struct device *dev,
 			   struct device_attribute *attr, char *buf,
 			   ssize_t (*format)(const struct net_device *, char *))
 {
 	struct net_device *net = to_net_dev(dev);
 	ssize_t ret = -EINVAL;
 	read_lock(&dev_base_lock);
 	if (dev_isalive(net))
 		ret = (*format)(net, buf);
 	read_unlock(&dev_base_lock);
 	return ret;
 }
 /* generate a show function for simple field */
 #define NETDEVICE_SHOW(field, format_string)				\
 static ssize_t format_##field(const struct net_device *net, char *buf)	\
 {									\
 	return sprintf(buf, format_string, net->field);			\
 }									\
 static ssize_t show_##field(struct device *dev,				\
 			    struct device_attribute *attr, char *buf)	\
 {									\
 	return netdev_show(dev, attr, buf, format_##field);		\
 }
 /* use same locking and permission rules as SIF* ioctl's */
 static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
 			    const char *buf, size_t len,
 			    int (*set)(struct net_device *, unsigned long))
 {
 	struct net_device *net = to_net_dev(dev);
 	unsigned long new;
 	int ret = -EINVAL;
 	if (!capable(CAP_NET_ADMIN))
 		return -EPERM;
 	ret = kstrtoul(buf, 0, &new);
 	if (ret)
 		goto err;
 	if (!rtnl_trylock())
 		return restart_syscall();
 	if (dev_isalive(net)) {
 		if ((ret = (*set)(net, new)) == 0)
 			ret = len;
 	}
 	rtnl_unlock();
  err:
 	return ret;
 }
 NETDEVICE_SHOW(dev_id, fmt_hex);
 NETDEVICE_SHOW(addr_assign_type, fmt_dec);
 NETDEVICE_SHOW(addr_len, fmt_dec);
 NETDEVICE_SHOW(iflink, fmt_dec);
 NETDEVICE_SHOW(ifindex, fmt_dec);
 NETDEVICE_SHOW(type, fmt_dec);
 NETDEVICE_SHOW(link_mode, fmt_dec);
 /* use same locking rules as GIFHWADDR ioctl's */
 static ssize_t show_address(struct device *dev, struct device_attribute *attr,
 			    char *buf)
 {
 	struct net_device *net = to_net_dev(dev);
 	ssize_t ret = -EINVAL;
 	read_lock(&dev_base_lock);
 	if (dev_isalive(net))
 		ret = sysfs_format_mac(buf, net->dev_addr, net->addr_len);
 	read_unlock(&dev_base_lock);
 	return ret;
 }
 static ssize_t show_broadcast(struct device *dev,
 			    struct device_attribute *attr, char *buf)
 {
 	struct net_device *net = to_net_dev(dev);
 	if (dev_isalive(net))
 		return sysfs_format_mac(buf, net->broadcast, net->addr_len);
 	return -EINVAL;
 }
 static ssize_t show_carrier(struct device *dev,
 			    struct device_attribute *attr, char *buf)
 {
 	struct net_device *netdev = to_net_dev(dev);
 	if (netif_running(netdev)) {
 		return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev));
 	}
 	return -EINVAL;
 }
 static ssize_t show_speed(struct device *dev,
 			  struct device_attribute *attr, char *buf)
 {
 	struct net_device *netdev = to_net_dev(dev);
 	int ret = -EINVAL;
 	if (!rtnl_trylock())
 		return restart_syscall();
 	if (netif_running(netdev)) {
 		struct ethtool_cmd cmd;
 		if (!__ethtool_get_settings(netdev, &cmd))
 			ret = sprintf(buf, fmt_udec, ethtool_cmd_speed(&cmd));
 	}
 	rtnl_unlock();
 	return ret;
 }
 static ssize_t show_duplex(struct device *dev,
 			   struct device_attribute *attr, char *buf)
 {
 	struct net_device *netdev = to_net_dev(dev);
 	int ret = -EINVAL;
 	if (!rtnl_trylock())
 		return restart_syscall();
 	if (netif_running(netdev)) {
 		struct ethtool_cmd cmd;
 		if (!__ethtool_get_settings(netdev, &cmd))
 			ret = sprintf(buf, "%s\n",
 				      cmd.duplex ? "full" : "half");
 	}
 	rtnl_unlock();
 	return ret;
 }
 static ssize_t show_dormant(struct device *dev,
 			    struct device_attribute *attr, char *buf)
 {
 	struct net_device *netdev = to_net_dev(dev);
 	if (netif_running(netdev))
 		return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
 	return -EINVAL;
 }
 static const char *const operstates[] = {
 	"unknown",
 	"notpresent", /* currently unused */
 	"down",
 	"lowerlayerdown",
 	"testing", /* currently unused */
 	"dormant",
 	"up"
 };
 static ssize_t show_operstate(struct device *dev,
 			      struct device_attribute *attr, char *buf)
 {
 	const struct net_device *netdev = to_net_dev(dev);
 	unsigned char operstate;
 	read_lock(&dev_base_lock);
 	operstate = netdev->operstate;
 	if (!netif_running(netdev))
 		operstate = IF_OPER_DOWN;
 	read_unlock(&dev_base_lock);
 	if (operstate >= ARRAY_SIZE(operstates))
 		return -EINVAL; /* should not happen */
 	return sprintf(buf, "%s\n", operstates[operstate]);
 }
 /* read-write attributes */
 NETDEVICE_SHOW(mtu, fmt_dec);
 static int change_mtu(struct net_device *net, unsigned long new_mtu)
 {
 	return dev_set_mtu(net, (int) new_mtu);
 }
 static ssize_t store_mtu(struct device *dev, struct device_attribute *attr,
 			 const char *buf, size_t len)
 {
 	return netdev_store(dev, attr, buf, len, change_mtu);
 }
 NETDEVICE_SHOW(flags, fmt_hex);
 static int change_flags(struct net_device *net, unsigned long new_flags)
 {
 	return dev_change_flags(net, (unsigned int) new_flags);
 }
 static ssize_t store_flags(struct device *dev, struct device_attribute *attr,
 			   const char *buf, size_t len)
 {
 	return netdev_store(dev, attr, buf, len, change_flags);
 }
 NETDEVICE_SHOW(tx_queue_len, fmt_ulong);
 static int change_tx_queue_len(struct net_device *net, unsigned long new_len)
 {
 	net->tx_queue_len = new_len;
 	return 0;
 }
 static ssize_t store_tx_queue_len(struct device *dev,
 				  struct device_attribute *attr,
 				  const char *buf, size_t len)
 {
 	return netdev_store(dev, attr, buf, len, change_tx_queue_len);
 }
 static ssize_t store_ifalias(struct device *dev, struct device_attribute *attr,
 			     const char *buf, size_t len)
 {
 	struct net_device *netdev = to_net_dev(dev);
 	size_t count = len;
 	ssize_t ret;
 	if (!capable(CAP_NET_ADMIN))
 		return -EPERM;
 	/* ignore trailing newline */
 	if (len >  0 && buf[len - 1] == '\n')
 		--count;
 	if (!rtnl_trylock())
 		return restart_syscall();
 	ret = dev_set_alias(netdev, buf, count);
 	rtnl_unlock();
 	return ret < 0 ? ret : len;
 }
 static ssize_t show_ifalias(struct device *dev,
 			    struct device_attribute *attr, char *buf)
 {
 	const struct net_device *netdev = to_net_dev(dev);
 	ssize_t ret = 0;
 	if (!rtnl_trylock())
 		return restart_syscall();
 	if (netdev->ifalias)
 		ret = sprintf(buf, "%s\n", netdev->ifalias);
 	rtnl_unlock();
 	return ret;
 }
 NETDEVICE_SHOW(group, fmt_dec);
 static int change_group(struct net_device *net, unsigned long new_group)
 {
 	dev_set_group(net, (int) new_group);
 	return 0;
 }
 static ssize_t store_group(struct device *dev, struct device_attribute *attr,
 			 const char *buf, size_t len)
 {
 	return netdev_store(dev, attr, buf, len, change_group);
 }
 static struct device_attribute net_class_attributes[] = {
 	__ATTR(addr_assign_type, S_IRUGO, show_addr_assign_type, NULL),
 	__ATTR(addr_len, S_IRUGO, show_addr_len, NULL),
 	__ATTR(dev_id, S_IRUGO, show_dev_id, NULL),
 	__ATTR(ifalias, S_IRUGO | S_IWUSR, show_ifalias, store_ifalias),
 	__ATTR(iflink, S_IRUGO, show_iflink, NULL),
 	__ATTR(ifindex, S_IRUGO, show_ifindex, NULL),
 	__ATTR(type, S_IRUGO, show_type, NULL),
 	__ATTR(link_mode, S_IRUGO, show_link_mode, NULL),
 	__ATTR(address, S_IRUGO, show_address, NULL),
 	__ATTR(broadcast, S_IRUGO, show_broadcast, NULL),
 	__ATTR(carrier, S_IRUGO, show_carrier, NULL),
 	__ATTR(speed, S_IRUGO, show_speed, NULL),
 	__ATTR(duplex, S_IRUGO, show_duplex, NULL),
 	__ATTR(dormant, S_IRUGO, show_dormant, NULL),
 	__ATTR(operstate, S_IRUGO, show_operstate, NULL),
 	__ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu),
 	__ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags),
 	__ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len,
 	       store_tx_queue_len),
 	__ATTR(netdev_group, S_IRUGO | S_IWUSR, show_group, store_group),
 	{}
 };
 /* Show a given an attribute in the statistics group */
 static ssize_t netstat_show(const struct device *d,
 			    struct device_attribute *attr, char *buf,
 			    unsigned long offset)
 {
 	struct net_device *dev = to_net_dev(d);
 	ssize_t ret = -EINVAL;
 	WARN_ON(offset > sizeof(struct rtnl_link_stats64) ||
 			offset % sizeof(u64) != 0);
 	read_lock(&dev_base_lock);
 	if (dev_isalive(dev)) {
 		struct rtnl_link_stats64 temp;
 		const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
 		ret = sprintf(buf, fmt_u64, *(u64 *)(((u8 *) stats) + offset));
 	}
 	read_unlock(&dev_base_lock);
 	return ret;
 }
 /* generate a read-only statistics attribute */
 #define NETSTAT_ENTRY(name)						\
 static ssize_t show_##name(struct device *d,				\
 			   struct device_attribute *attr, char *buf) 	\
 {									\
 	return netstat_show(d, attr, buf,				\
 			    offsetof(struct rtnl_link_stats64, name));	\
 }									\
 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
 NETSTAT_ENTRY(rx_packets);
 NETSTAT_ENTRY(tx_packets);
 NETSTAT_ENTRY(rx_bytes);
 NETSTAT_ENTRY(tx_bytes);
 NETSTAT_ENTRY(rx_errors);
 NETSTAT_ENTRY(tx_errors);
 NETSTAT_ENTRY(rx_dropped);
 NETSTAT_ENTRY(tx_dropped);
 NETSTAT_ENTRY(multicast);
 NETSTAT_ENTRY(collisions);
 NETSTAT_ENTRY(rx_length_errors);
 NETSTAT_ENTRY(rx_over_errors);
 NETSTAT_ENTRY(rx_crc_errors);
 NETSTAT_ENTRY(rx_frame_errors);
 NETSTAT_ENTRY(rx_fifo_errors);
 NETSTAT_ENTRY(rx_missed_errors);
 NETSTAT_ENTRY(tx_aborted_errors);
 NETSTAT_ENTRY(tx_carrier_errors);
 NETSTAT_ENTRY(tx_fifo_errors);
 NETSTAT_ENTRY(tx_heartbeat_errors);
 NETSTAT_ENTRY(tx_window_errors);
 NETSTAT_ENTRY(rx_compressed);
 NETSTAT_ENTRY(tx_compressed);
 static struct attribute *netstat_attrs[] = {
 	&dev_attr_rx_packets.attr,
 	&dev_attr_tx_packets.attr,
 	&dev_attr_rx_bytes.attr,
 	&dev_attr_tx_bytes.attr,
 	&dev_attr_rx_errors.attr,
 	&dev_attr_tx_errors.attr,
 	&dev_attr_rx_dropped.attr,
 	&dev_attr_tx_dropped.attr,
 	&dev_attr_multicast.attr,
 	&dev_attr_collisions.attr,
 	&dev_attr_rx_length_errors.attr,
 	&dev_attr_rx_over_errors.attr,
 	&dev_attr_rx_crc_errors.attr,
 	&dev_attr_rx_frame_errors.attr,
 	&dev_attr_rx_fifo_errors.attr,
 	&dev_attr_rx_missed_errors.attr,
 	&dev_attr_tx_aborted_errors.attr,
 	&dev_attr_tx_carrier_errors.attr,
 	&dev_attr_tx_fifo_errors.attr,
 	&dev_attr_tx_heartbeat_errors.attr,
 	&dev_attr_tx_window_errors.attr,
 	&dev_attr_rx_compressed.attr,
 	&dev_attr_tx_compressed.attr,
 	NULL
 };
 static struct attribute_group netstat_group = {
 	.name  = "statistics",
 	.attrs  = netstat_attrs,
 };
-#ifdef CONFIG_WIRELESS_EXT_SYSFS
-/* helper function that does all the locking etc for wireless stats */
-static ssize_t wireless_show(struct device *d, char *buf,
-			     ssize_t (*format)(const struct iw_statistics *,
-					       char *))
-{
-	struct net_device *dev = to_net_dev(d);
-	const struct iw_statistics *iw;
-	ssize_t ret = -EINVAL;
-	if (!rtnl_trylock())
-		return restart_syscall();
-	if (dev_isalive(dev)) {
-		iw = get_wireless_stats(dev);
-		if (iw)
-			ret = (*format)(iw, buf);
-	}
-	rtnl_unlock();
-	return ret;
-}
-/* show function template for wireless fields */
-#define WIRELESS_SHOW(name, field, format_string)			\
-static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \
-{									\
-	return sprintf(buf, format_string, iw->field);			\
-}									\
-static ssize_t show_iw_##name(struct device *d,				\
-			      struct device_attribute *attr, char *buf)	\
-{									\
-	return wireless_show(d, buf, format_iw_##name);			\
-}									\
-static DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
-WIRELESS_SHOW(status, status, fmt_hex);
-WIRELESS_SHOW(link, qual.qual, fmt_dec);
-WIRELESS_SHOW(level, qual.level, fmt_dec);
-WIRELESS_SHOW(noise, qual.noise, fmt_dec);
-WIRELESS_SHOW(nwid, discard.nwid, fmt_dec);
-WIRELESS_SHOW(crypt, discard.code, fmt_dec);
-WIRELESS_SHOW(fragment, discard.fragment, fmt_dec);
-WIRELESS_SHOW(misc, discard.misc, fmt_dec);
-WIRELESS_SHOW(retries, discard.retries, fmt_dec);
-WIRELESS_SHOW(beacon, miss.beacon, fmt_dec);
-static struct attribute *wireless_attrs[] = {
-	&dev_attr_status.attr,
-	&dev_attr_link.attr,
-	&dev_attr_level.attr,
-	&dev_attr_noise.attr,
-	&dev_attr_nwid.attr,
-	&dev_attr_crypt.attr,
-	&dev_attr_fragment.attr,
-	&dev_attr_retries.attr,
-	&dev_attr_misc.attr,
-	&dev_attr_beacon.attr,
-	NULL
-};
-static struct attribute_group wireless_group = {
-	.name = "wireless",
-	.attrs = wireless_attrs,
-};
-#endif
 #endif /* CONFIG_SYSFS */
 #ifdef CONFIG_RPS
 /*
  * RX queue sysfs structures and functions.
  */
 struct rx_queue_attribute {
 	struct attribute attr;
 	ssize_t (*show)(struct netdev_rx_queue *queue,
 	    struct rx_queue_attribute *attr, char *buf);
 	ssize_t (*store)(struct netdev_rx_queue *queue,
 	    struct rx_queue_attribute *attr, const char *buf, size_t len);
 };
 #define to_rx_queue_attr(_attr) container_of(_attr,		\
     struct rx_queue_attribute, attr)
 #define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj)
 static ssize_t rx_queue_attr_show(struct kobject *kobj, struct attribute *attr,
 				  char *buf)
 {
 	struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
 	struct netdev_rx_queue *queue = to_rx_queue(kobj);
 	if (!attribute->show)
 		return -EIO;
 	return attribute->show(queue, attribute, buf);
 }
 static ssize_t rx_queue_attr_store(struct kobject *kobj, struct attribute *attr,
 				   const char *buf, size_t count)
 {
 	struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
 	struct netdev_rx_queue *queue = to_rx_queue(kobj);
 	if (!attribute->store)
 		return -EIO;
 	return attribute->store(queue, attribute, buf, count);
 }
 static const struct sysfs_ops rx_queue_sysfs_ops = {
 	.show = rx_queue_attr_show,
 	.store = rx_queue_attr_store,
 };
 static ssize_t show_rps_map(struct netdev_rx_queue *queue,
 			    struct rx_queue_attribute *attribute, char *buf)
 {
 	struct rps_map *map;
 	cpumask_var_t mask;
 	size_t len = 0;
 	int i;
 	if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
 		return -ENOMEM;
 	rcu_read_lock();
 	map = rcu_dereference(queue->rps_map);
 	if (map)
 		for (i = 0; i < map->len; i++)
 			cpumask_set_cpu(map->cpus[i], mask);
 	len += cpumask_scnprintf(buf + len, PAGE_SIZE, mask);
 	if (PAGE_SIZE - len < 3) {
 		rcu_read_unlock();
 		free_cpumask_var(mask);
 		return -EINVAL;
 	}
 	rcu_read_unlock();
 	free_cpumask_var(mask);
 	len += sprintf(buf + len, "\n");
 	return len;
 }
 static ssize_t store_rps_map(struct netdev_rx_queue *queue,
 		      struct rx_queue_attribute *attribute,
 		      const char *buf, size_t len)
 {
 	struct rps_map *old_map, *map;
 	cpumask_var_t mask;
 	int err, cpu, i;
 	static DEFINE_SPINLOCK(rps_map_lock);
 	if (!capable(CAP_NET_ADMIN))
 		return -EPERM;
 	if (!alloc_cpumask_var(&mask, GFP_KERNEL))
 		return -ENOMEM;
 	err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
 	if (err) {
 		free_cpumask_var(mask);
 		return err;
 	}
 	map = kzalloc(max_t(unsigned int,
 	    RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
 	    GFP_KERNEL);
 	if (!map) {
 		free_cpumask_var(mask);
 		return -ENOMEM;
 	}
 	i = 0;
 	for_each_cpu_and(cpu, mask, cpu_online_mask)
 		map->cpus[i++] = cpu;
 	if (i)
 		map->len = i;
 	else {
 		kfree(map);
 		map = NULL;
 	}
 	spin_lock(&rps_map_lock);
 	old_map = rcu_dereference_protected(queue->rps_map,
 					    lockdep_is_held(&rps_map_lock));
 	rcu_assign_pointer(queue->rps_map, map);
 	spin_unlock(&rps_map_lock);
 	if (map)
 		static_key_slow_inc(&rps_needed);
 	if (old_map) {
 		kfree_rcu(old_map, rcu);
 		static_key_slow_dec(&rps_needed);
 	}
 	free_cpumask_var(mask);
 	return len;
 }
 static ssize_t show_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
 					   struct rx_queue_attribute *attr,
 					   char *buf)
 {
 	struct rps_dev_flow_table *flow_table;
 	unsigned long val = 0;
 	rcu_read_lock();
 	flow_table = rcu_dereference(queue->rps_flow_table);
 	if (flow_table)
 		val = (unsigned long)flow_table->mask + 1;
 	rcu_read_unlock();
 	return sprintf(buf, "%lu\n", val);
 }
 static void rps_dev_flow_table_release_work(struct work_struct *work)
 {
 	struct rps_dev_flow_table *table = container_of(work,
 	    struct rps_dev_flow_table, free_work);
 	vfree(table);
 }
 static void rps_dev_flow_table_release(struct rcu_head *rcu)
 {
 	struct rps_dev_flow_table *table = container_of(rcu,
 	    struct rps_dev_flow_table, rcu);
 	INIT_WORK(&table->free_work, rps_dev_flow_table_release_work);
 	schedule_work(&table->free_work);
 }
 static ssize_t store_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
 				     struct rx_queue_attribute *attr,
 				     const char *buf, size_t len)
 {
 	unsigned long mask, count;
 	struct rps_dev_flow_table *table, *old_table;
 	static DEFINE_SPINLOCK(rps_dev_flow_lock);
 	int rc;
 	if (!capable(CAP_NET_ADMIN))
 		return -EPERM;
 	rc = kstrtoul(buf, 0, &count);
 	if (rc < 0)
 		return rc;
 	if (count) {
 		mask = count - 1;
 		/* mask = roundup_pow_of_two(count) - 1;
 		 * without overflows...
 		 */
 		while ((mask | (mask >> 1)) != mask)
 			mask |= (mask >> 1);
 		/* On 64 bit arches, must check mask fits in table->mask (u32),
 		 * and on 32bit arches, must check RPS_DEV_FLOW_TABLE_SIZE(mask + 1)
 		 * doesnt overflow.
 		 */
 #if BITS_PER_LONG > 32
 		if (mask > (unsigned long)(u32)mask)
 			return -EINVAL;
 #else
 		if (mask > (ULONG_MAX - RPS_DEV_FLOW_TABLE_SIZE(1))
 				/ sizeof(struct rps_dev_flow)) {
 			/* Enforce a limit to prevent overflow */
 			return -EINVAL;
 		}
 #endif
 		table = vmalloc(RPS_DEV_FLOW_TABLE_SIZE(mask + 1));
 		if (!table)
 			return -ENOMEM;
 		table->mask = mask;
 		for (count = 0; count <= mask; count++)
 			table->flows[count].cpu = RPS_NO_CPU;
 	} else
 		table = NULL;
 	spin_lock(&rps_dev_flow_lock);
 	old_table = rcu_dereference_protected(queue->rps_flow_table,
 					      lockdep_is_held(&rps_dev_flow_lock));
 	rcu_assign_pointer(queue->rps_flow_table, table);
 	spin_unlock(&rps_dev_flow_lock);
 	if (old_table)
 		call_rcu(&old_table->rcu, rps_dev_flow_table_release);
 	return len;
 }
 static struct rx_queue_attribute rps_cpus_attribute =
 	__ATTR(rps_cpus, S_IRUGO | S_IWUSR, show_rps_map, store_rps_map);
 static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute =
 	__ATTR(rps_flow_cnt, S_IRUGO | S_IWUSR,
 	    show_rps_dev_flow_table_cnt, store_rps_dev_flow_table_cnt);
 static struct attribute *rx_queue_default_attrs[] = {
 	&rps_cpus_attribute.attr,
 	&rps_dev_flow_table_cnt_attribute.attr,
 	NULL
 };
 static void rx_queue_release(struct kobject *kobj)
 {
 	struct netdev_rx_queue *queue = to_rx_queue(kobj);
 	struct rps_map *map;
 	struct rps_dev_flow_table *flow_table;
 	map = rcu_dereference_protected(queue->rps_map, 1);
 	if (map) {
 		RCU_INIT_POINTER(queue->rps_map, NULL);
 		kfree_rcu(map, rcu);
 	}
 	flow_table = rcu_dereference_protected(queue->rps_flow_table, 1);
 	if (flow_table) {
 		RCU_INIT_POINTER(queue->rps_flow_table, NULL);
 		call_rcu(&flow_table->rcu, rps_dev_flow_table_release);
 	}
 	memset(kobj, 0, sizeof(*kobj));
 	dev_put(queue->dev);
 }
 static struct kobj_type rx_queue_ktype = {
 	.sysfs_ops = &rx_queue_sysfs_ops,
 	.release = rx_queue_release,
 	.default_attrs = rx_queue_default_attrs,
 };
 static int rx_queue_add_kobject(struct net_device *net, int index)
 {
 	struct netdev_rx_queue *queue = net->_rx + index;
 	struct kobject *kobj = &queue->kobj;
 	int error = 0;
 	kobj->kset = net->queues_kset;
 	error = kobject_init_and_add(kobj, &rx_queue_ktype, NULL,
 	    "rx-%u", index);
 	if (error) {
 		kobject_put(kobj);
 		return error;
 	}
 	kobject_uevent(kobj, KOBJ_ADD);
 	dev_hold(queue->dev);
 	return error;
 }
 #endif /* CONFIG_RPS */
 int
 net_rx_queue_update_kobjects(struct net_device *net, int old_num, int new_num)
 {
 #ifdef CONFIG_RPS
 	int i;
 	int error = 0;
 	for (i = old_num; i < new_num; i++) {
 		error = rx_queue_add_kobject(net, i);
 		if (error) {
 			new_num = old_num;
 			break;
 		}
 	}
 	while (--i >= new_num)
 		kobject_put(&net->_rx[i].kobj);
 	return error;
 #else
 	return 0;
 #endif
 }
 #ifdef CONFIG_SYSFS
 /*
  * netdev_queue sysfs structures and functions.
  */
 struct netdev_queue_attribute {
 	struct attribute attr;
 	ssize_t (*show)(struct netdev_queue *queue,
 	    struct netdev_queue_attribute *attr, char *buf);
 	ssize_t (*store)(struct netdev_queue *queue,
 	    struct netdev_queue_attribute *attr, const char *buf, size_t len);
 };
 #define to_netdev_queue_attr(_attr) container_of(_attr,		\
     struct netdev_queue_attribute, attr)
 #define to_netdev_queue(obj) container_of(obj, struct netdev_queue, kobj)
 static ssize_t netdev_queue_attr_show(struct kobject *kobj,
 				      struct attribute *attr, char *buf)
 {
 	struct netdev_queue_attribute *attribute = to_netdev_queue_attr(attr);
 	struct netdev_queue *queue = to_netdev_queue(kobj);
 	if (!attribute->show)
 		return -EIO;
 	return attribute->show(queue, attribute, buf);
 }
 static ssize_t netdev_queue_attr_store(struct kobject *kobj,
 				       struct attribute *attr,
 				       const char *buf, size_t count)
 {
 	struct netdev_queue_attribute *attribute = to_netdev_queue_attr(attr);
 	struct netdev_queue *queue = to_netdev_queue(kobj);
 	if (!attribute->store)
 		return -EIO;
 	return attribute->store(queue, attribute, buf, count);
 }
 static const struct sysfs_ops netdev_queue_sysfs_ops = {
 	.show = netdev_queue_attr_show,
 	.store = netdev_queue_attr_store,
 };
 static ssize_t show_trans_timeout(struct netdev_queue *queue,
 				  struct netdev_queue_attribute *attribute,
 				  char *buf)
 {
 	unsigned long trans_timeout;
 	spin_lock_irq(&queue->_xmit_lock);
 	trans_timeout = queue->trans_timeout;
 	spin_unlock_irq(&queue->_xmit_lock);
 	return sprintf(buf, "%lu", trans_timeout);
 }
 static struct netdev_queue_attribute queue_trans_timeout =
 	__ATTR(tx_timeout, S_IRUGO, show_trans_timeout, NULL);
 #ifdef CONFIG_BQL
 /*
  * Byte queue limits sysfs structures and functions.
  */
 static ssize_t bql_show(char *buf, unsigned int value)
 {
 	return sprintf(buf, "%u\n", value);
 }
 static ssize_t bql_set(const char *buf, const size_t count,
 		       unsigned int *pvalue)
 {
 	unsigned int value;
 	int err;
 	if (!strcmp(buf, "max") || !strcmp(buf, "max\n"))
 		value = DQL_MAX_LIMIT;
 	else {
 		err = kstrtouint(buf, 10, &value);
 		if (err < 0)
 			return err;
 		if (value > DQL_MAX_LIMIT)
 			return -EINVAL;
 	}
 	*pvalue = value;
 	return count;
 }
 static ssize_t bql_show_hold_time(struct netdev_queue *queue,
 				  struct netdev_queue_attribute *attr,
 				  char *buf)
 {
 	struct dql *dql = &queue->dql;
 	return sprintf(buf, "%u\n", jiffies_to_msecs(dql->slack_hold_time));
 }
 static ssize_t bql_set_hold_time(struct netdev_queue *queue,
 				 struct netdev_queue_attribute *attribute,
 				 const char *buf, size_t len)
 {
 	struct dql *dql = &queue->dql;
 	unsigned int value;
 	int err;
 	err = kstrtouint(buf, 10, &value);
 	if (err < 0)
 		return err;
 	dql->slack_hold_time = msecs_to_jiffies(value);
 	return len;
 }
 static struct netdev_queue_attribute bql_hold_time_attribute =
 	__ATTR(hold_time, S_IRUGO | S_IWUSR, bql_show_hold_time,
 	    bql_set_hold_time);
 static ssize_t bql_show_inflight(struct netdev_queue *queue,
 				 struct netdev_queue_attribute *attr,
 				 char *buf)
 {
 	struct dql *dql = &queue->dql;
 	return sprintf(buf, "%u\n", dql->num_queued - dql->num_completed);
 }
 static struct netdev_queue_attribute bql_inflight_attribute =
 	__ATTR(inflight, S_IRUGO, bql_show_inflight, NULL);
 #define BQL_ATTR(NAME, FIELD)						\
 static ssize_t bql_show_ ## NAME(struct netdev_queue *queue,		\
 				 struct netdev_queue_attribute *attr,	\
 				 char *buf)				\
 {									\
 	return bql_show(buf, queue->dql.FIELD);				\
 }									\
 									\
 static ssize_t bql_set_ ## NAME(struct netdev_queue *queue,		\
 				struct netdev_queue_attribute *attr,	\
 				const char *buf, size_t len)		\
 {									\
 	return bql_set(buf, len, &queue->dql.FIELD);			\
 }									\
 									\
 static struct netdev_queue_attribute bql_ ## NAME ## _attribute =	\
 	__ATTR(NAME, S_IRUGO | S_IWUSR, bql_show_ ## NAME,		\
 	    bql_set_ ## NAME);
 BQL_ATTR(limit, limit)
 BQL_ATTR(limit_max, max_limit)
 BQL_ATTR(limit_min, min_limit)
 static struct attribute *dql_attrs[] = {
 	&bql_limit_attribute.attr,
 	&bql_limit_max_attribute.attr,
 	&bql_limit_min_attribute.attr,
 	&bql_hold_time_attribute.attr,
 	&bql_inflight_attribute.attr,
 	NULL
 };
 static struct attribute_group dql_group = {
 	.name  = "byte_queue_limits",
 	.attrs  = dql_attrs,
 };
 #endif /* CONFIG_BQL */
 #ifdef CONFIG_XPS
 static inline unsigned int get_netdev_queue_index(struct netdev_queue *queue)
 {
 	struct net_device *dev = queue->dev;
 	int i;
 	for (i = 0; i < dev->num_tx_queues; i++)
 		if (queue == &dev->_tx[i])
 			break;
 	BUG_ON(i >= dev->num_tx_queues);
 	return i;
 }
 static ssize_t show_xps_map(struct netdev_queue *queue,
 			    struct netdev_queue_attribute *attribute, char *buf)
 {
 	struct net_device *dev = queue->dev;
 	struct xps_dev_maps *dev_maps;
 	cpumask_var_t mask;
 	unsigned long index;
 	size_t len = 0;
 	int i;
 	if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
 		return -ENOMEM;
 	index = get_netdev_queue_index(queue);
 	rcu_read_lock();
 	dev_maps = rcu_dereference(dev->xps_maps);
 	if (dev_maps) {
 		for_each_possible_cpu(i) {
 			struct xps_map *map =
 			    rcu_dereference(dev_maps->cpu_map[i]);
 			if (map) {
 				int j;
 				for (j = 0; j < map->len; j++) {
 					if (map->queues[j] == index) {
 						cpumask_set_cpu(i, mask);
 						break;
 					}
 				}
 			}
 		}
 	}
 	rcu_read_unlock();
 	len += cpumask_scnprintf(buf + len, PAGE_SIZE, mask);
 	if (PAGE_SIZE - len < 3) {
 		free_cpumask_var(mask);
 		return -EINVAL;
 	}
 	free_cpumask_var(mask);
 	len += sprintf(buf + len, "\n");
 	return len;
 }
 static DEFINE_MUTEX(xps_map_mutex);
 #define xmap_dereference(P)		\
 	rcu_dereference_protected((P), lockdep_is_held(&xps_map_mutex))
 static void xps_queue_release(struct netdev_queue *queue)
 {
 	struct net_device *dev = queue->dev;
 	struct xps_dev_maps *dev_maps;
 	struct xps_map *map;
 	unsigned long index;
 	int i, pos, nonempty = 0;
 	index = get_netdev_queue_index(queue);
 	mutex_lock(&xps_map_mutex);
 	dev_maps = xmap_dereference(dev->xps_maps);
 	if (dev_maps) {
 		for_each_possible_cpu(i) {
 			map = xmap_dereference(dev_maps->cpu_map[i]);
 			if (!map)
 				continue;
 			for (pos = 0; pos < map->len; pos++)
 				if (map->queues[pos] == index)
 					break;
 			if (pos < map->len) {
 				if (map->len > 1)
 					map->queues[pos] =
 					    map->queues[--map->len];
 				else {
 					RCU_INIT_POINTER(dev_maps->cpu_map[i],
 					    NULL);
 					kfree_rcu(map, rcu);
 					map = NULL;
 				}
 			}
 			if (map)
 				nonempty = 1;
 		}
 		if (!nonempty) {
 			RCU_INIT_POINTER(dev->xps_maps, NULL);
 			kfree_rcu(dev_maps, rcu);
 		}
 	}
 	mutex_unlock(&xps_map_mutex);
 }
 static ssize_t store_xps_map(struct netdev_queue *queue,
 		      struct netdev_queue_attribute *attribute,
 		      const char *buf, size_t len)
 {
 	struct net_device *dev = queue->dev;
 	cpumask_var_t mask;
 	int err, i, cpu, pos, map_len, alloc_len, need_set;
 	unsigned long index;
 	struct xps_map *map, *new_map;
 	struct xps_dev_maps *dev_maps, *new_dev_maps;
 	int nonempty = 0;
 	int numa_node_id = -2;
 	if (!capable(CAP_NET_ADMIN))
 		return -EPERM;
 	if (!alloc_cpumask_var(&mask, GFP_KERNEL))
 		return -ENOMEM;
 	index = get_netdev_queue_index(queue);
 	err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
 	if (err) {
 		free_cpumask_var(mask);
 		return err;
 	}
 	new_dev_maps = kzalloc(max_t(unsigned int,
 	    XPS_DEV_MAPS_SIZE, L1_CACHE_BYTES), GFP_KERNEL);
 	if (!new_dev_maps) {
 		free_cpumask_var(mask);
 		return -ENOMEM;
 	}
 	mutex_lock(&xps_map_mutex);
 	dev_maps = xmap_dereference(dev->xps_maps);
 	for_each_possible_cpu(cpu) {
 		map = dev_maps ?
 			xmap_dereference(dev_maps->cpu_map[cpu]) : NULL;
 		new_map = map;
 		if (map) {
 			for (pos = 0; pos < map->len; pos++)
 				if (map->queues[pos] == index)
 					break;
 			map_len = map->len;
 			alloc_len = map->alloc_len;
 		} else
 			pos = map_len = alloc_len = 0;
 		need_set = cpumask_test_cpu(cpu, mask) && cpu_online(cpu);
 #ifdef CONFIG_NUMA
 		if (need_set) {
 			if (numa_node_id == -2)
 				numa_node_id = cpu_to_node(cpu);
 			else if (numa_node_id != cpu_to_node(cpu))
 				numa_node_id = -1;
 		}
 #endif
 		if (need_set && pos >= map_len) {
 			/* Need to add queue to this CPU's map */
 			if (map_len >= alloc_len) {
 				alloc_len = alloc_len ?
 				    2 * alloc_len : XPS_MIN_MAP_ALLOC;
 				new_map = kzalloc_node(XPS_MAP_SIZE(alloc_len),
 						       GFP_KERNEL,
 						       cpu_to_node(cpu));
 				if (!new_map)
 					goto error;
 				new_map->alloc_len = alloc_len;
 				for (i = 0; i < map_len; i++)
 					new_map->queues[i] = map->queues[i];
 				new_map->len = map_len;
 			}
 			new_map->queues[new_map->len++] = index;
 		} else if (!need_set && pos < map_len) {
 			/* Need to remove queue from this CPU's map */
 			if (map_len > 1)
 				new_map->queues[pos] =
 				    new_map->queues[--new_map->len];
 			else
 				new_map = NULL;
 		}
 		RCU_INIT_POINTER(new_dev_maps->cpu_map[cpu], new_map);
 	}
 	/* Cleanup old maps */
 	for_each_possible_cpu(cpu) {
 		map = dev_maps ?
 			xmap_dereference(dev_maps->cpu_map[cpu]) : NULL;
 		if (map && xmap_dereference(new_dev_maps->cpu_map[cpu]) != map)
 			kfree_rcu(map, rcu);
 		if (new_dev_maps->cpu_map[cpu])
 			nonempty = 1;
 	}
 	if (nonempty) {
 		rcu_assign_pointer(dev->xps_maps, new_dev_maps);
 	} else {
 		kfree(new_dev_maps);
 		RCU_INIT_POINTER(dev->xps_maps, NULL);
 	}
 	if (dev_maps)
 		kfree_rcu(dev_maps, rcu);
 	netdev_queue_numa_node_write(queue, (numa_node_id >= 0) ? numa_node_id :
 					    NUMA_NO_NODE);
 	mutex_unlock(&xps_map_mutex);
 	free_cpumask_var(mask);
 	return len;
 error:
 	mutex_unlock(&xps_map_mutex);
 	if (new_dev_maps)
 		for_each_possible_cpu(i)
 			kfree(rcu_dereference_protected(
 				new_dev_maps->cpu_map[i],
 				1));
 	kfree(new_dev_maps);
 	free_cpumask_var(mask);
 	return -ENOMEM;
 }
 static struct netdev_queue_attribute xps_cpus_attribute =
     __ATTR(xps_cpus, S_IRUGO | S_IWUSR, show_xps_map, store_xps_map);
 #endif /* CONFIG_XPS */
 static struct attribute *netdev_queue_default_attrs[] = {
 	&queue_trans_timeout.attr,
 #ifdef CONFIG_XPS
 	&xps_cpus_attribute.attr,
 #endif
 	NULL
 };
 static void netdev_queue_release(struct kobject *kobj)
 {
 	struct netdev_queue *queue = to_netdev_queue(kobj);
 #ifdef CONFIG_XPS
 	xps_queue_release(queue);
 #endif
 	memset(kobj, 0, sizeof(*kobj));
 	dev_put(queue->dev);
 }
 static struct kobj_type netdev_queue_ktype = {
 	.sysfs_ops = &netdev_queue_sysfs_ops,
 	.release = netdev_queue_release,
 	.default_attrs = netdev_queue_default_attrs,
 };
 static int netdev_queue_add_kobject(struct net_device *net, int index)
 {
 	struct netdev_queue *queue = net->_tx + index;
 	struct kobject *kobj = &queue->kobj;
 	int error = 0;
 	kobj->kset = net->queues_kset;
 	error = kobject_init_and_add(kobj, &netdev_queue_ktype, NULL,
 	    "tx-%u", index);
 	if (error)
 		goto exit;
 #ifdef CONFIG_BQL
 	error = sysfs_create_group(kobj, &dql_group);
 	if (error)
 		goto exit;
 #endif
 	kobject_uevent(kobj, KOBJ_ADD);
 	dev_hold(queue->dev);
 	return 0;
 exit:
 	kobject_put(kobj);
 	return error;
 }
 #endif /* CONFIG_SYSFS */
 int
 netdev_queue_update_kobjects(struct net_device *net, int old_num, int new_num)
 {
 #ifdef CONFIG_SYSFS
 	int i;
 	int error = 0;
 	for (i = old_num; i < new_num; i++) {
 		error = netdev_queue_add_kobject(net, i);
 		if (error) {
 			new_num = old_num;
 			break;
 		}
 	}
 	while (--i >= new_num) {
 		struct netdev_queue *queue = net->_tx + i;
 #ifdef CONFIG_BQL
 		sysfs_remove_group(&queue->kobj, &dql_group);
 #endif
 		kobject_put(&queue->kobj);
 	}
 	return error;
 #else
 	return 0;
 #endif /* CONFIG_SYSFS */
 }
 static int register_queue_kobjects(struct net_device *net)
 {
 	int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0;
 #ifdef CONFIG_SYSFS
 	net->queues_kset = kset_create_and_add("queues",
 	    NULL, &net->dev.kobj);
 	if (!net->queues_kset)
 		return -ENOMEM;
 #endif
 #ifdef CONFIG_RPS
 	real_rx = net->real_num_rx_queues;
 #endif
 	real_tx = net->real_num_tx_queues;
 	error = net_rx_queue_update_kobjects(net, 0, real_rx);
 	if (error)
 		goto error;
 	rxq = real_rx;
 	error = netdev_queue_update_kobjects(net, 0, real_tx);
 	if (error)
 		goto error;
 	txq = real_tx;
 	return 0;
 error:
 	netdev_queue_update_kobjects(net, txq, 0);
 	net_rx_queue_update_kobjects(net, rxq, 0);
 	return error;
 }
 static void remove_queue_kobjects(struct net_device *net)
 {
 	int real_rx = 0, real_tx = 0;
 #ifdef CONFIG_RPS
 	real_rx = net->real_num_rx_queues;
 #endif
 	real_tx = net->real_num_tx_queues;
 	net_rx_queue_update_kobjects(net, real_rx, 0);
 	netdev_queue_update_kobjects(net, real_tx, 0);
 #ifdef CONFIG_SYSFS
 	kset_unregister(net->queues_kset);
 #endif
 }
 static void *net_grab_current_ns(void)
 {
 	struct net *ns = current->nsproxy->net_ns;
 #ifdef CONFIG_NET_NS
 	if (ns)
 		atomic_inc(&ns->passive);
 #endif
 	return ns;
 }
 static const void *net_initial_ns(void)
 {
 	return &init_net;
 }
 static const void *net_netlink_ns(struct sock *sk)
 {
 	return sock_net(sk);
 }
 struct kobj_ns_type_operations net_ns_type_operations = {
 	.type = KOBJ_NS_TYPE_NET,
 	.grab_current_ns = net_grab_current_ns,
 	.netlink_ns = net_netlink_ns,
 	.initial_ns = net_initial_ns,
 	.drop_ns = net_drop_ns,
 };
 EXPORT_SYMBOL_GPL(net_ns_type_operations);
 #ifdef CONFIG_HOTPLUG
 static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
 {
 	struct net_device *dev = to_net_dev(d);
 	int retval;
 	/* pass interface to uevent. */
 	retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
 	if (retval)
 		goto exit;
 	/* pass ifindex to uevent.
 	 * ifindex is useful as it won't change (interface name may change)
 	 * and is what RtNetlink uses natively. */
 	retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
 exit:
 	return retval;
 }
 #endif
 /*
  *	netdev_release -- destroy and free a dead device.
  *	Called when last reference to device kobject is gone.
  */
 static void netdev_release(struct device *d)
 {
 	struct net_device *dev = to_net_dev(d);
 	BUG_ON(dev->reg_state != NETREG_RELEASED);
 	kfree(dev->ifalias);
 	kfree((char *)dev - dev->padded);
 }
 static const void *net_namespace(struct device *d)
 {
 	struct net_device *dev;
 	dev = container_of(d, struct net_device, dev);
 	return dev_net(dev);
 }
 static struct class net_class = {
 	.name = "net",
 	.dev_release = netdev_release,
 #ifdef CONFIG_SYSFS
 	.dev_attrs = net_class_attributes,
 #endif /* CONFIG_SYSFS */
 #ifdef CONFIG_HOTPLUG
 	.dev_uevent = netdev_uevent,
 #endif
 	.ns_type = &net_ns_type_operations,
 	.namespace = net_namespace,
 };
 /* Delete sysfs entries but hold kobject reference until after all
  * netdev references are gone.
  */
 void netdev_unregister_kobject(struct net_device * net)
 {
 	struct device *dev = &(net->dev);
 	kobject_get(&dev->kobj);
 	remove_queue_kobjects(net);
 	device_del(dev);
 }
 /* Create sysfs entries for network device. */
 int netdev_register_kobject(struct net_device *net)
 {
 	struct device *dev = &(net->dev);
 	const struct attribute_group **groups = net->sysfs_groups;
 	int error = 0;
 	device_initialize(dev);
 	dev->class = &net_class;
 	dev->platform_data = net;
 	dev->groups = groups;
 	dev_set_name(dev, "%s", net->name);
 #ifdef CONFIG_SYSFS
 	/* Allow for a device specific group */
 	if (*groups)
 		groups++;
 	*groups++ = &netstat_group;
-#ifdef CONFIG_WIRELESS_EXT_SYSFS
-	if (net->ieee80211_ptr)
-		*groups++ = &wireless_group;
-#ifdef CONFIG_WIRELESS_EXT
-	else if (net->wireless_handlers)
-		*groups++ = &wireless_group;
-#endif
-#endif
 #endif /* CONFIG_SYSFS */
 	error = device_add(dev);
 	if (error)
 		return error;
 	error = register_queue_kobjects(net);
 	if (error) {
 		device_del(dev);
 		return error;
 	}
 	return error;
 }
 int netdev_class_create_file(struct class_attribute *class_attr)
 {
 	return class_create_file(&net_class, class_attr);
 }
 EXPORT_SYMBOL(netdev_class_create_file);
 void netdev_class_remove_file(struct class_attribute *class_attr)
 {
 	class_remove_file(&net_class, class_attr);
 }
 EXPORT_SYMBOL(netdev_class_remove_file);
 int netdev_kobject_init(void)
 {
 	kobj_ns_type_register(&net_ns_type_operations);
 	return class_register(&net_class);
 }

net/wireless/Kconfig

Diff comments View file @ 35b2a11

 config WIRELESS_EXT
 	bool
 config WEXT_CORE
 	def_bool y
 	depends on CFG80211_WEXT || WIRELESS_EXT
 config WEXT_PROC
 	def_bool y
 	depends on PROC_FS
 	depends on WEXT_CORE
 config WEXT_SPY
 	bool
 config WEXT_PRIV
 	bool
 config CFG80211
 	tristate "cfg80211 - wireless configuration API"
 	depends on RFKILL || !RFKILL
 	---help---
 	  cfg80211 is the Linux wireless LAN (802.11) configuration API.
 	  Enable this if you have a wireless device.
 	  For more information refer to documentation on the wireless wiki:
 	  http://wireless.kernel.org/en/developers/Documentation/cfg80211
 	  When built as a module it will be called cfg80211.
 config NL80211_TESTMODE
 	bool "nl80211 testmode command"
 	depends on CFG80211
 	help
 	  The nl80211 testmode command helps implementing things like
 	  factory calibration or validation tools for wireless chips.
 	  Select this option ONLY for kernels that are specifically
 	  built for such purposes.
 	  Debugging tools that are supposed to end up in the hands of
 	  users should better be implemented with debugfs.
 	  Say N.
 config CFG80211_DEVELOPER_WARNINGS
 	bool "enable developer warnings"
 	depends on CFG80211
 	default n
 	help
 	  This option enables some additional warnings that help
 	  cfg80211 developers and driver developers, but that can
 	  trigger due to races with userspace.
 	  For example, when a driver reports that it was disconnected
 	  from the AP, but the user disconnects manually at the same
 	  time, the warning might trigger spuriously due to races.
 	  Say Y only if you are developing cfg80211 or a driver based
 	  on it (or mac80211).
 config CFG80211_REG_DEBUG
 	bool "cfg80211 regulatory debugging"
 	depends on CFG80211
 	default n
 	---help---
 	  You can enable this if you want to debug regulatory changes.
 	  For more information on cfg80211 regulatory refer to the wireless
 	  wiki:
 	  http://wireless.kernel.org/en/developers/Regulatory
 	  If unsure, say N.
 config CFG80211_DEFAULT_PS
 	bool "enable powersave by default"
 	depends on CFG80211
 	default y
 	help
 	  This option enables powersave mode by default.
 	  If this causes your applications to misbehave you should fix your
 	  applications instead -- they need to register their network
 	  latency requirement, see Documentation/power/pm_qos_interface.txt.
 config CFG80211_DEBUGFS
 	bool "cfg80211 DebugFS entries"
 	depends on CFG80211
 	depends on DEBUG_FS
 	---help---
 	  You can enable this if you want to debugfs entries for cfg80211.
 	  If unsure, say N.
 config CFG80211_INTERNAL_REGDB
 	bool "use statically compiled regulatory rules database" if EXPERT
 	default n
 	depends on CFG80211
 	---help---
 	  This option generates an internal data structure representing
 	  the wireless regulatory rules described in net/wireless/db.txt
 	  and includes code to query that database.  This is an alternative
 	  to using CRDA for defining regulatory rules for the kernel.
 	  For details see:
 	  http://wireless.kernel.org/en/developers/Regulatory
 	  Most distributions have a CRDA package.  So if unsure, say N.
 config CFG80211_WEXT
 	bool "cfg80211 wireless extensions compatibility"
 	depends on CFG80211
 	select WEXT_CORE
 	default y
 	help
 	  Enable this option if you need old userspace for wireless
 	  extensions with cfg80211-based drivers.
-config WIRELESS_EXT_SYSFS
-	bool "Wireless extensions sysfs files"
-	depends on WEXT_CORE && SYSFS
-	help
-	  This option enables the deprecated wireless statistics
-	  files in /sys/class/net/*/wireless/. The same information
-	  is available via the ioctls as well.
-	  Say N. If you know you have ancient tools requiring it,
-	  like very old versions of hal (prior to 0.5.12 release),
-	  say Y and update the tools as soon as possible as this
-	  option will be removed soon.
 config LIB80211
 	tristate "Common routines for IEEE802.11 drivers"
 	default n
 	help
 	  This options enables a library of common routines used
 	  by IEEE802.11 wireless LAN drivers.
 	  Drivers should select this themselves if needed.  Say Y if
 	  you want this built into your kernel.
 config LIB80211_CRYPT_WEP
 	tristate
 config LIB80211_CRYPT_CCMP
 	tristate
 config LIB80211_CRYPT_TKIP
 	tristate
 config LIB80211_DEBUG
 	bool "lib80211 debugging messages"
 	depends on LIB80211
 	default n
 	---help---
 	  You can enable this if you want verbose debugging messages
 	  from lib80211.
 	  If unsure, say N.