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

Commit 14897e35fdc045fff9baabf0354570da22386706

Authored by Linus Torvalds 2008-04-12 04:24:16 +0800

Exists in master and in 7 other branches

Merge branch 'docs' of git://git.lwn.net/linux-2.6

* 'docs' of git://git.lwn.net/linux-2.6:
  Add additional examples in Documentation/spinlocks.txt
  Move sched-rt-group.txt to scheduler/
  Documentation: move rpc-cache.txt to filesystems/
  Documentation: move nfsroot.txt to filesystems/
  Spell out behavior of atomic_dec_and_lock() in kerneldoc
  Fix a typo in highres.txt
  Fixes to the seq_file document
  Fill out information on patch tags in SubmittingPatches
  Add the seq_file documentation

Showing 18 changed files Inline Diff

Documentation/00-INDEX
Documentation/SubmittingPatches
Documentation/filesystems/00-INDEX
Documentation/filesystems/nfsroot.txt
Documentation/filesystems/rpc-cache.txt
Documentation/filesystems/seq_file.txt
Documentation/hrtimers/highres.txt
Documentation/kernel-parameters.txt
Documentation/nfsroot.txt
Documentation/rpc-cache.txt
Documentation/sched-rt-group.txt
Documentation/scheduler/00-INDEX
Documentation/scheduler/sched-rt-group.txt
Documentation/spinlocks.txt
fs/Kconfig
include/linux/spinlock.h
net/ipv4/Kconfig
net/ipv4/ipconfig.c

Documentation/00-INDEX

Diff comments View file @ 14897e3

 This is a brief list of all the files in ./linux/Documentation and what
 they contain. If you add a documentation file, please list it here in
 alphabetical order as well, or risk being hunted down like a rabid dog.
 Please try and keep the descriptions small enough to fit on one line.
 							 Thanks -- Paul G.
 Following translations are available on the WWW:
    - Japanese, maintained by the JF Project (JF@linux.or.jp), at
      http://www.linux.or.jp/JF/
 00-INDEX
 	- this file.
 ABI/
 	- info on kernel <-> userspace ABI and relative interface stability.
 BUG-HUNTING
 	- brute force method of doing binary search of patches to find bug.
 Changes
 	- list of changes that break older software packages.
 CodingStyle
 	- how the boss likes the C code in the kernel to look.
 DMA-API.txt
 	- DMA API, pci_ API & extensions for non-consistent memory machines.
 DMA-ISA-LPC.txt
 	- How to do DMA with ISA (and LPC) devices.
 DMA-mapping.txt
 	- info for PCI drivers using DMA portably across all platforms.
 DocBook/
 	- directory with DocBook templates etc. for kernel documentation.
 HOWTO
 	- the process and procedures of how to do Linux kernel development.
 IO-mapping.txt
 	- how to access I/O mapped memory from within device drivers.
 IPMI.txt
 	- info on Linux Intelligent Platform Management Interface (IPMI) Driver.
 IRQ-affinity.txt
 	- how to select which CPU(s) handle which interrupt events on SMP.
 IRQ.txt
 	- description of what an IRQ is.
 ManagementStyle
 	- how to (attempt to) manage kernel hackers.
 MSI-HOWTO.txt
 	- the Message Signaled Interrupts (MSI) Driver Guide HOWTO and FAQ.
 PCIEBUS-HOWTO.txt
 	- a guide describing the PCI Express Port Bus driver.
 RCU/
 	- directory with info on RCU (read-copy update).
 README.DAC960
 	- info on Mylex DAC960/DAC1100 PCI RAID Controller Driver for Linux.
 README.cycladesZ
 	- info on Cyclades-Z firmware loading.
 SAK.txt
 	- info on Secure Attention Keys.
 SM501.txt
 	- Silicon Motion SM501 multimedia companion chip
 SecurityBugs
 	- procedure for reporting security bugs found in the kernel.
 SubmitChecklist
 	- Linux kernel patch submission checklist.
 SubmittingDrivers
 	- procedure to get a new driver source included into the kernel tree.
 SubmittingPatches
 	- procedure to get a source patch included into the kernel tree.
 VGA-softcursor.txt
 	- how to change your VGA cursor from a blinking underscore.
 accounting/
 	- documentation on accounting and taskstats.
 acpi/
 	- info on ACPI-specific hooks in the kernel.
 aoe/
 	- description of AoE (ATA over Ethernet) along with config examples.
 applying-patches.txt
 	- description of various trees and how to apply their patches.
 arm/
 	- directory with info about Linux on the ARM architecture.
 atomic_ops.txt
 	- semantics and behavior of atomic and bitmask operations.
 auxdisplay/
 	- misc. LCD driver documentation (cfag12864b, ks0108).
 basic_profiling.txt
 	- basic instructions for those who wants to profile Linux kernel.
 binfmt_misc.txt
 	- info on the kernel support for extra binary formats.
 blackfin/
 	- directory with documentation for the Blackfin arch.
 block/
 	- info on the Block I/O (BIO) layer.
 cachetlb.txt
 	- describes the cache/TLB flushing interfaces Linux uses.
 cciss.txt
 	- info, major/minor #'s for Compaq's SMART Array Controllers.
 cdrom/
 	- directory with information on the CD-ROM drivers that Linux has.
 cli-sti-removal.txt
 	- cli()/sti() removal guide.
 computone.txt
 	- info on Computone Intelliport II/Plus Multiport Serial Driver.
 connector/
 	- docs on the netlink based userspace<->kernel space communication mod.
 console/
 	- documentation on Linux console drivers.
 cpqarray.txt
 	- info on using Compaq's SMART2 Intelligent Disk Array Controllers.
 cpu-freq/
 	- info on CPU frequency and voltage scaling.
 cpu-hotplug.txt
 	- document describing CPU hotplug support in the Linux kernel.
 cpu-load.txt
 	- document describing how CPU load statistics are collected.
 cpuidle/
 	- info on CPU_IDLE, CPU idle state management subsystem.
 cpusets.txt
 	- documents the cpusets feature; assign CPUs and Mem to a set of tasks.
 cputopology.txt
 	- documentation on how CPU topology info is exported via sysfs.
 cris/
 	- directory with info about Linux on CRIS architecture.
 crypto/
 	- directory with info on the Crypto API.
 dcdbas.txt
 	- information on the Dell Systems Management Base Driver.
 debugging-modules.txt
 	- some notes on debugging modules after Linux 2.6.3.
 dell_rbu.txt
 	- document demonstrating the use of the Dell Remote BIOS Update driver.
 device-mapper/
 	- directory with info on Device Mapper.
 devices.txt
 	- plain ASCII listing of all the nodes in /dev/ with major minor #'s.
 digiepca.txt
 	- info on Digi Intl. {PC,PCI,EISA}Xx and Xem series cards.
 dontdiff
 	- file containing a list of files that should never be diff'ed.
 driver-model/
 	- directory with info about Linux driver model.
 dvb/
 	- info on Linux Digital Video Broadcast (DVB) subsystem.
 early-userspace/
 	- info about initramfs, klibc, and userspace early during boot.
 edac.txt
 	- information on EDAC - Error Detection And Correction
 eisa.txt
 	- info on EISA bus support.
 exception.txt
 	- how Linux v2.2 handles exceptions without verify_area etc.
 fault-injection/
 	- dir with docs about the fault injection capabilities infrastructure.
 fb/
 	- directory with info on the frame buffer graphics abstraction layer.
 feature-removal-schedule.txt
 	- list of files and features that are going to be removed.
 filesystems/
 	- info on the vfs and the various filesystems that Linux supports.
 firmware_class/
 	- request_firmware() hotplug interface info.
 floppy.txt
 	- notes and driver options for the floppy disk driver.
 frv/
 	- Fujitsu FR-V Linux documentation.
 gpio.txt
 	- overview of GPIO (General Purpose Input/Output) access conventions.
 hayes-esp.txt
 	- info on using the Hayes ESP serial driver.
 highuid.txt
 	- notes on the change from 16 bit to 32 bit user/group IDs.
 hpet.txt
 	- High Precision Event Timer Driver for Linux.
 hrtimer/
 	- info on the timer_stats debugging facility for timer (ab)use.
 hrtimers/
 	- info on the hrtimers subsystem for high-resolution kernel timers.
 hw_random.txt
 	- info on Linux support for random number generator in i8xx chipsets.
 hwmon/
 	- directory with docs on various hardware monitoring drivers.
 i2c/
 	- directory with info about the I2C bus/protocol (2 wire, kHz speed).
 i2o/
 	- directory with info about the Linux I2O subsystem.
 i386/
 	- directory with info about Linux on Intel 32 bit architecture.
 ia64/
 	- directory with info about Linux on Intel 64 bit architecture.
 infiniband/
 	- directory with documents concerning Linux InfiniBand support.
 initrd.txt
 	- how to use the RAM disk as an initial/temporary root filesystem.
 input/
 	- info on Linux input device support.
 io_ordering.txt
 	- info on ordering I/O writes to memory-mapped addresses.
 ioctl/
 	- directory with documents describing various IOCTL calls.
 ioctl-number.txt
 	- how to implement and register device/driver ioctl calls.
 iostats.txt
 	- info on I/O statistics Linux kernel provides.
 irqflags-tracing.txt
 	- how to use the irq-flags tracing feature.
 isapnp.txt
 	- info on Linux ISA Plug & Play support.
 isdn/
 	- directory with info on the Linux ISDN support, and supported cards.
 java.txt
 	- info on the in-kernel binary support for Java(tm).
 kbuild/
 	- directory with info about the kernel build process.
 kdump/
 	- directory with mini HowTo on getting the crash dump code to work.
 kernel-doc-nano-HOWTO.txt
 	- mini HowTo on generation and location of kernel documentation files.
 kernel-docs.txt
 	- listing of various WWW + books that document kernel internals.
 kernel-parameters.txt
 	- summary listing of command line / boot prompt args for the kernel.
 keys-request-key.txt
 	- description of the kernel key request service.
 keys.txt
 	- description of the kernel key retention service.
 kobject.txt
 	- info of the kobject infrastructure of the Linux kernel.
 kprobes.txt
 	- documents the kernel probes debugging feature.
 kref.txt
 	- docs on adding reference counters (krefs) to kernel objects.
 laptops/
 	- directory with laptop related info and laptop driver documentation.
 ldm.txt
 	- a brief description of LDM (Windows Dynamic Disks).
 leds-class.txt
 	- documents LED handling under Linux.
 local_ops.txt
 	- semantics and behavior of local atomic operations.
 lockdep-design.txt
 	- documentation on the runtime locking correctness validator.
 logo.gif
 	- full colour GIF image of Linux logo (penguin - Tux).
 logo.txt
 	- info on creator of above logo & site to get additional images from.
 m68k/
 	- directory with info about Linux on Motorola 68k architecture.
 magic-number.txt
 	- list of magic numbers used to mark/protect kernel data structures.
 mca.txt
 	- info on supporting Micro Channel Architecture (e.g. PS/2) systems.
 md.txt
 	- info on boot arguments for the multiple devices driver.
 memory-barriers.txt
 	- info on Linux kernel memory barriers.
 memory-hotplug.txt
 	- Hotpluggable memory support, how to use and current status.
 memory.txt
 	- info on typical Linux memory problems.
 mips/
 	- directory with info about Linux on MIPS architecture.
 mono.txt
 	- how to execute Mono-based .NET binaries with the help of BINFMT_MISC.
 moxa-smartio
 	- file with info on installing/using Moxa multiport serial driver.
 mtrr.txt
 	- how to use PPro Memory Type Range Registers to increase performance.
 mutex-design.txt
 	- info on the generic mutex subsystem.
 namespaces/
 	- directory with various information about namespaces
 nbd.txt
 	- info on a TCP implementation of a network block device.
 netlabel/
 	- directory with information on the NetLabel subsystem.
 networking/
 	- directory with info on various aspects of networking with Linux.
-nfsroot.txt
-	- short guide on setting up a diskless box with NFS root filesystem.
 nmi_watchdog.txt
 	- info on NMI watchdog for SMP systems.
 nommu-mmap.txt
 	- documentation about no-mmu memory mapping support.
 numastat.txt
 	- info on how to read Numa policy hit/miss statistics in sysfs.
 oops-tracing.txt
 	- how to decode those nasty internal kernel error dump messages.
 paride.txt
 	- information about the parallel port IDE subsystem.
 parisc/
 	- directory with info on using Linux on PA-RISC architecture.
 parport.txt
 	- how to use the parallel-port driver.
 parport-lowlevel.txt
 	- description and usage of the low level parallel port functions.
 pci-error-recovery.txt
 	- info on PCI error recovery.
 pci.txt
 	- info on the PCI subsystem for device driver authors.
 pcieaer-howto.txt
 	- the PCI Express Advanced Error Reporting Driver Guide HOWTO.
 pcmcia/
 	- info on the Linux PCMCIA driver.
 pi-futex.txt
 	- documentation on lightweight PI-futexes.
 pnp.txt
 	- Linux Plug and Play documentation.
 power/
 	- directory with info on Linux PCI power management.
 powerpc/
 	- directory with info on using Linux with the PowerPC.
 preempt-locking.txt
 	- info on locking under a preemptive kernel.
 prio_tree.txt
 	- info on radix-priority-search-tree use for indexing vmas.
 ramdisk.txt
 	- short guide on how to set up and use the RAM disk.
 rbtree.txt
 	- info on what red-black trees are and what they are for.
 riscom8.txt
 	- notes on using the RISCom/8 multi-port serial driver.
 robust-futex-ABI.txt
 	- documentation of the robust futex ABI.
 robust-futexes.txt
 	- a description of what robust futexes are.
 rocket.txt
 	- info on the Comtrol RocketPort multiport serial driver.
-rpc-cache.txt
-	- introduction to the caching mechanisms in the sunrpc layer.
 rt-mutex-design.txt
 	- description of the RealTime mutex implementation design.
 rt-mutex.txt
 	- desc. of RT-mutex subsystem with PI (Priority Inheritance) support.
 rtc.txt
 	- notes on how to use the Real Time Clock (aka CMOS clock) driver.
 s390/
 	- directory with info on using Linux on the IBM S390.
 scheduler/
 	- directory with info on the scheduler.
 scsi/
 	- directory with info on Linux scsi support.
 serial/
 	- directory with info on the low level serial API.
 serial-console.txt
 	- how to set up Linux with a serial line console as the default.
 sgi-ioc4.txt
 	- description of the SGI IOC4 PCI (multi function) device.
 sgi-visws.txt
 	- short blurb on the SGI Visual Workstations.
 sh/
 	- directory with info on porting Linux to a new architecture.
 smart-config.txt
 	- description of the Smart Config makefile feature.
 sound/
 	- directory with info on sound card support.
 sparc/
 	- directory with info on using Linux on Sparc architecture.
 sparse.txt
 	- info on how to obtain and use the sparse tool for typechecking.
 specialix.txt
 	- info on hardware/driver for specialix IO8+ multiport serial card.
 spi/
 	- overview of Linux kernel Serial Peripheral Interface (SPI) support.
 spinlocks.txt
 	- info on using spinlocks to provide exclusive access in kernel.
 stable_api_nonsense.txt
 	- info on why the kernel does not have a stable in-kernel api or abi.
 stable_kernel_rules.txt
 	- rules and procedures for the -stable kernel releases.
 stallion.txt
 	- info on using the Stallion multiport serial driver.
 svga.txt
 	- short guide on selecting video modes at boot via VGA BIOS.
 sysfs-rules.txt
 	- How not to use sysfs.
 sx.txt
 	- info on the Specialix SX/SI multiport serial driver.
 sysctl/
 	- directory with info on the /proc/sys/* files.
 sysrq.txt
 	- info on the magic SysRq key.
 telephony/
 	- directory with info on telephony (e.g. voice over IP) support.
 time_interpolators.txt
 	- info on time interpolators.
 tipar.txt
 	- information about Parallel link cable for Texas Instruments handhelds.
 tty.txt
 	- guide to the locking policies of the tty layer.
 uml/
 	- directory with information about User Mode Linux.
 unicode.txt
 	- info on the Unicode character/font mapping used in Linux.
 unshare.txt
 	- description of the Linux unshare system call.
 usb/
 	- directory with info regarding the Universal Serial Bus.
 video-output.txt
 	- sysfs class driver interface to enable/disable a video output device.
 video4linux/
 	- directory with info regarding video/TV/radio cards and linux.
 vm/
 	- directory with info on the Linux vm code.
 volatile-considered-harmful.txt
 	- Why the "volatile" type class should not be used
 voyager.txt
 	- guide to running Linux on the Voyager architecture.
 w1/
 	- directory with documents regarding the 1-wire (w1) subsystem.
 watchdog/
 	- how to auto-reboot Linux if it has "fallen and can't get up". ;-)
 x86_64/
 	- directory with info on Linux support for AMD x86-64 (Hammer) machines.
 zorro.txt
 	- info on writing drivers for Zorro bus devices found on Amigas.

Documentation/SubmittingPatches

Diff comments View file @ 14897e3

Documentation/filesystems/00-INDEX

Diff comments View file @ 14897e3

 00-INDEX
 	- this file (info on some of the filesystems supported by linux).
 Exporting
 	- explanation of how to make filesystems exportable.
 Locking
 	- info on locking rules as they pertain to Linux VFS.
 9p.txt
 	- 9p (v9fs) is an implementation of the Plan 9 remote fs protocol.
 adfs.txt
 	- info and mount options for the Acorn Advanced Disc Filing System.
 afs.txt
 	- info and examples for the distributed AFS (Andrew File System) fs.
 affs.txt
 	- info and mount options for the Amiga Fast File System.
 automount-support.txt
 	- information about filesystem automount support.
 befs.txt
 	- information about the BeOS filesystem for Linux.
 bfs.txt
 	- info for the SCO UnixWare Boot Filesystem (BFS).
 cifs.txt
 	- description of the CIFS filesystem.
 coda.txt
 	- description of the CODA filesystem.
 configfs/
 	- directory containing configfs documentation and example code.
 cramfs.txt
 	- info on the cram filesystem for small storage (ROMs etc).
 dentry-locking.txt
 	- info on the RCU-based dcache locking model.
 directory-locking
 	- info about the locking scheme used for directory operations.
 dlmfs.txt
 	- info on the userspace interface to the OCFS2 DLM.
 dnotify.txt
 	- info about directory notification in Linux.
 ecryptfs.txt
 	- docs on eCryptfs: stacked cryptographic filesystem for Linux.
 ext2.txt
 	- info, mount options and specifications for the Ext2 filesystem.
 ext3.txt
 	- info, mount options and specifications for the Ext3 filesystem.
 ext4.txt
 	- info, mount options and specifications for the Ext4 filesystem.
 files.txt
 	- info on file management in the Linux kernel.
 fuse.txt
 	- info on the Filesystem in User SpacE including mount options.
 gfs2.txt
 	- info on the Global File System 2.
 hfs.txt
 	- info on the Macintosh HFS Filesystem for Linux.
 hfsplus.txt
 	- info on the Macintosh HFSPlus Filesystem for Linux.
 hpfs.txt
 	- info and mount options for the OS/2 HPFS.
 inotify.txt
 	- info on the powerful yet simple file change notification system.
 isofs.txt
 	- info and mount options for the ISO 9660 (CDROM) filesystem.
 jfs.txt
 	- info and mount options for the JFS filesystem.
 locks.txt
 	- info on file locking implementations, flock() vs. fcntl(), etc.
 mandatory-locking.txt
 	- info on the Linux implementation of Sys V mandatory file locking.
 ncpfs.txt
 	- info on Novell Netware(tm) filesystem using NCP protocol.
+nfsroot.txt
+	- short guide on setting up a diskless box with NFS root filesystem.
 ntfs.txt
 	- info and mount options for the NTFS filesystem (Windows NT).
 ocfs2.txt
 	- info and mount options for the OCFS2 clustered filesystem.
 porting
 	- various information on filesystem porting.
 proc.txt
 	- info on Linux's /proc filesystem.
 ramfs-rootfs-initramfs.txt
 	- info on the 'in memory' filesystems ramfs, rootfs and initramfs.
 reiser4.txt
 	- info on the Reiser4 filesystem based on dancing tree algorithms.
 relay.txt
 	- info on relay, for efficient streaming from kernel to user space.
 romfs.txt
 	- description of the ROMFS filesystem.
+rpc-cache.txt
+	- introduction to the caching mechanisms in the sunrpc layer.
+seq_file.txt
+	- how to use the seq_file API
 sharedsubtree.txt
 	- a description of shared subtrees for namespaces.
 smbfs.txt
 	- info on using filesystems with the SMB protocol (Win 3.11 and NT).
 spufs.txt
 	- info and mount options for the SPU filesystem used on Cell.
 sysfs-pci.txt
 	- info on accessing PCI device resources through sysfs.
 sysfs.txt
 	- info on sysfs, a ram-based filesystem for exporting kernel objects.
 sysv-fs.txt
 	- info on the SystemV/V7/Xenix/Coherent filesystem.
 tmpfs.txt
 	- info on tmpfs, a filesystem that holds all files in virtual memory.
 udf.txt
 	- info and mount options for the UDF filesystem.
 ufs.txt
 	- info on the ufs filesystem.
 vfat.txt
 	- info on using the VFAT filesystem used in Windows NT and Windows 95
 vfs.txt
 	- overview of the Virtual File System
 xfs.txt
 	- info and mount options for the XFS filesystem.
 xip.txt
 	- info on execute-in-place for file mappings.

Documentation/filesystems/nfsroot.txt

Diff comments View file @ 14897e3

File was created	1	Mounting the root filesystem via NFS (nfsroot)
	2	===============================================
	3
	4	Written 1996 by Gero Kuhlmann <gero@gkminix.han.de>
	5	Updated 1997 by Martin Mares <mj@atrey.karlin.mff.cuni.cz>
	6	Updated 2006 by Nico Schottelius <nico-kernel-nfsroot@schottelius.org>
	7	Updated 2006 by Horms <horms@verge.net.au>
	8
	9
	10
	11	In order to use a diskless system, such as an X-terminal or printer server
	12	for example, it is necessary for the root filesystem to be present on a
	13	non-disk device. This may be an initramfs (see Documentation/filesystems/
	14	ramfs-rootfs-initramfs.txt), a ramdisk (see Documentation/initrd.txt) or a
	15	filesystem mounted via NFS. The following text describes on how to use NFS
	16	for the root filesystem. For the rest of this text 'client' means the
	17	diskless system, and 'server' means the NFS server.
	18
	19
	20
	21
	22	1.) Enabling nfsroot capabilities
	23	-----------------------------
	24
	25	In order to use nfsroot, NFS client support needs to be selected as
	26	built-in during configuration. Once this has been selected, the nfsroot
	27	option will become available, which should also be selected.
	28
	29	In the networking options, kernel level autoconfiguration can be selected,
	30	along with the types of autoconfiguration to support. Selecting all of
	31	DHCP, BOOTP and RARP is safe.
	32
	33
	34
	35
	36	2.) Kernel command line
	37	-------------------
	38
	39	When the kernel has been loaded by a boot loader (see below) it needs to be
	40	told what root fs device to use. And in the case of nfsroot, where to find
	41	both the server and the name of the directory on the server to mount as root.
	42	This can be established using the following kernel command line parameters:
	43
	44
	45	root=/dev/nfs
	46
	47	This is necessary to enable the pseudo-NFS-device. Note that it's not a
	48	real device but just a synonym to tell the kernel to use NFS instead of
	49	a real device.
	50
	51
	52	nfsroot=[<server-ip>:]<root-dir>[,<nfs-options>]
	53
	54	If the `nfsroot' parameter is NOT given on the command line,
	55	the default "/tftpboot/%s" will be used.
	56
	57	<server-ip> Specifies the IP address of the NFS server.
	58	The default address is determined by the `ip' parameter
	59	(see below). This parameter allows the use of different
	60	servers for IP autoconfiguration and NFS.
	61
	62	<root-dir> Name of the directory on the server to mount as root.
	63	If there is a "%s" token in the string, it will be
	64	replaced by the ASCII-representation of the client's
	65	IP address.
	66
	67	<nfs-options> Standard NFS options. All options are separated by commas.
	68	The following defaults are used:
	69	port = as given by server portmap daemon
	70	rsize = 4096
	71	wsize = 4096
	72	timeo = 7
	73	retrans = 3
	74	acregmin = 3
	75	acregmax = 60
	76	acdirmin = 30
	77	acdirmax = 60
	78	flags = hard, nointr, noposix, cto, ac
	79
	80
	81	ip=<client-ip>:<server-ip>:<gw-ip>:<netmask>:<hostname>:<device>:<autoconf>
	82
	83	This parameter tells the kernel how to configure IP addresses of devices
	84	and also how to set up the IP routing table. It was originally called
	85	`nfsaddrs', but now the boot-time IP configuration works independently of
	86	NFS, so it was renamed to `ip' and the old name remained as an alias for
	87	compatibility reasons.
	88
	89	If this parameter is missing from the kernel command line, all fields are
	90	assumed to be empty, and the defaults mentioned below apply. In general
	91	this means that the kernel tries to configure everything using
	92	autoconfiguration.
	93
	94	The <autoconf> parameter can appear alone as the value to the `ip'
	95	parameter (without all the ':' characters before). If the value is
	96	"ip=off" or "ip=none", no autoconfiguration will take place, otherwise
	97	autoconfiguration will take place. The most common way to use this
	98	is "ip=dhcp".
	99
	100	<client-ip> IP address of the client.
	101
	102	Default: Determined using autoconfiguration.
	103
	104	<server-ip> IP address of the NFS server. If RARP is used to determine
	105	the client address and this parameter is NOT empty only
	106	replies from the specified server are accepted.
	107
	108	Only required for for NFS root. That is autoconfiguration
	109	will not be triggered if it is missing and NFS root is not
	110	in operation.
	111
	112	Default: Determined using autoconfiguration.
	113	The address of the autoconfiguration server is used.
	114
	115	<gw-ip> IP address of a gateway if the server is on a different subnet.
	116
	117	Default: Determined using autoconfiguration.
	118
	119	<netmask> Netmask for local network interface. If unspecified
	120	the netmask is derived from the client IP address assuming
	121	classful addressing.
	122
	123	Default: Determined using autoconfiguration.
	124
	125	<hostname> Name of the client. May be supplied by autoconfiguration,
	126	but its absence will not trigger autoconfiguration.
	127
	128	Default: Client IP address is used in ASCII notation.
	129
	130	<device> Name of network device to use.
	131
	132	Default: If the host only has one device, it is used.
	133	Otherwise the device is determined using
	134	autoconfiguration. This is done by sending
	135	autoconfiguration requests out of all devices,
	136	and using the device that received the first reply.
	137
	138	<autoconf> Method to use for autoconfiguration. In the case of options
	139	which specify multiple autoconfiguration protocols,
	140	requests are sent using all protocols, and the first one
	141	to reply is used.
	142
	143	Only autoconfiguration protocols that have been compiled
	144	into the kernel will be used, regardless of the value of
	145	this option.
	146
	147	off or none: don't use autoconfiguration
	148	(do static IP assignment instead)
	149	on or any: use any protocol available in the kernel
	150	(default)
	151	dhcp: use DHCP
	152	bootp: use BOOTP
	153	rarp: use RARP
	154	both: use both BOOTP and RARP but not DHCP
	155	(old option kept for backwards compatibility)
	156
	157	Default: any
	158
	159
	160
	161
	162	3.) Boot Loader
	163	----------
	164
	165	To get the kernel into memory different approaches can be used.
	166	They depend on various facilities being available:
	167
	168
	169	3.1) Booting from a floppy using syslinux
	170
	171	When building kernels, an easy way to create a boot floppy that uses
	172	syslinux is to use the zdisk or bzdisk make targets which use
	173	and bzimage images respectively. Both targets accept the
	174	FDARGS parameter which can be used to set the kernel command line.
	175
	176	e.g.
	177	make bzdisk FDARGS="root=/dev/nfs"
	178
	179	Note that the user running this command will need to have
	180	access to the floppy drive device, /dev/fd0
	181
	182	For more information on syslinux, including how to create bootdisks
	183	for prebuilt kernels, see http://syslinux.zytor.com/
	184
	185	N.B: Previously it was possible to write a kernel directly to
	186	a floppy using dd, configure the boot device using rdev, and
	187	boot using the resulting floppy. Linux no longer supports this
	188	method of booting.
	189
	190	3.2) Booting from a cdrom using isolinux
	191
	192	When building kernels, an easy way to create a bootable cdrom that
	193	uses isolinux is to use the isoimage target which uses a bzimage
	194	image. Like zdisk and bzdisk, this target accepts the FDARGS
	195	parameter which can be used to set the kernel command line.
	196
	197	e.g.
	198	make isoimage FDARGS="root=/dev/nfs"
	199
	200	The resulting iso image will be arch/<ARCH>/boot/image.iso
	201	This can be written to a cdrom using a variety of tools including
	202	cdrecord.
	203
	204	e.g.
	205	cdrecord dev=ATAPI:1,0,0 arch/i386/boot/image.iso
	206
	207	For more information on isolinux, including how to create bootdisks
	208	for prebuilt kernels, see http://syslinux.zytor.com/
	209
	210	3.2) Using LILO
	211	When using LILO all the necessary command line parameters may be
	212	specified using the 'append=' directive in the LILO configuration
	213	file.
	214
	215	However, to use the 'root=' directive you also need to create
	216	a dummy root device, which may be removed after LILO is run.
	217
	218	mknod /dev/boot255 c 0 255
	219
	220	For information on configuring LILO, please refer to its documentation.
	221
	222	3.3) Using GRUB
	223	When using GRUB, kernel parameter are simply appended after the kernel
	224	specification: kernel <kernel> <parameters>
	225
	226	3.4) Using loadlin
	227	loadlin may be used to boot Linux from a DOS command prompt without
	228	requiring a local hard disk to mount as root. This has not been
	229	thoroughly tested by the authors of this document, but in general
	230	it should be possible configure the kernel command line similarly
	231	to the configuration of LILO.
	232
	233	Please refer to the loadlin documentation for further information.
	234
	235	3.5) Using a boot ROM
	236	This is probably the most elegant way of booting a diskless client.
	237	With a boot ROM the kernel is loaded using the TFTP protocol. The
	238	authors of this document are not aware of any no commercial boot
	239	ROMs that support booting Linux over the network. However, there
	240	are two free implementations of a boot ROM, netboot-nfs and
	241	etherboot, both of which are available on sunsite.unc.edu, and both
	242	of which contain everything you need to boot a diskless Linux client.
	243
	244	3.6) Using pxelinux
	245	Pxelinux may be used to boot linux using the PXE boot loader
	246	which is present on many modern network cards.
	247
	248	When using pxelinux, the kernel image is specified using
	249	"kernel <relative-path-below /tftpboot>". The nfsroot parameters
	250	are passed to the kernel by adding them to the "append" line.
	251	It is common to use serial console in conjunction with pxeliunx,
	252	see Documentation/serial-console.txt for more information.
	253
	254	For more information on isolinux, including how to create bootdisks
	255	for prebuilt kernels, see http://syslinux.zytor.com/
	256
	257
	258
	259
	260	4.) Credits
	261	-------
	262
	263	The nfsroot code in the kernel and the RARP support have been written
	264	by Gero Kuhlmann <gero@gkminix.han.de>.
	265
	266	The rest of the IP layer autoconfiguration code has been written
	267	by Martin Mares <mj@atrey.karlin.mff.cuni.cz>.
	268
	269	In order to write the initial version of nfsroot I would like to thank
	270	Jens-Uwe Mager <jum@anubis.han.de> for his help.
	271

Documentation/filesystems/rpc-cache.txt

Diff comments View file @ 14897e3

File was created	1	This document gives a brief introduction to the caching
	2	mechanisms in the sunrpc layer that is used, in particular,
	3	for NFS authentication.
	4
	5	CACHES
	6	======
	7	The caching replaces the old exports table and allows for
	8	a wide variety of values to be caches.
	9
	10	There are a number of caches that are similar in structure though
	11	quite possibly very different in content and use. There is a corpus
	12	of common code for managing these caches.
	13
	14	Examples of caches that are likely to be needed are:
	15	- mapping from IP address to client name
	16	- mapping from client name and filesystem to export options
	17	- mapping from UID to list of GIDs, to work around NFS's limitation
	18	of 16 gids.
	19	- mappings between local UID/GID and remote UID/GID for sites that
	20	do not have uniform uid assignment
	21	- mapping from network identify to public key for crypto authentication.
	22
	23	The common code handles such things as:
	24	- general cache lookup with correct locking
	25	- supporting 'NEGATIVE' as well as positive entries
	26	- allowing an EXPIRED time on cache items, and removing
	27	items after they expire, and are no longer in-use.
	28	- making requests to user-space to fill in cache entries
	29	- allowing user-space to directly set entries in the cache
	30	- delaying RPC requests that depend on as-yet incomplete
	31	cache entries, and replaying those requests when the cache entry
	32	is complete.
	33	- clean out old entries as they expire.
	34
	35	Creating a Cache
	36	----------------
	37
	38	1/ A cache needs a datum to store. This is in the form of a
	39	structure definition that must contain a
	40	struct cache_head
	41	as an element, usually the first.
	42	It will also contain a key and some content.
	43	Each cache element is reference counted and contains
	44	expiry and update times for use in cache management.
	45	2/ A cache needs a "cache_detail" structure that
	46	describes the cache. This stores the hash table, some
	47	parameters for cache management, and some operations detailing how
	48	to work with particular cache items.
	49	The operations requires are:
	50	struct cache_head *alloc(void)
	51	This simply allocates appropriate memory and returns
	52	a pointer to the cache_detail embedded within the
	53	structure
	54	void cache_put(struct kref *)
	55	This is called when the last reference to an item is
	56	dropped. The pointer passed is to the 'ref' field
	57	in the cache_head. cache_put should release any
	58	references create by 'cache_init' and, if CACHE_VALID
	59	is set, any references created by cache_update.
	60	It should then release the memory allocated by
	61	'alloc'.
	62	int match(struct cache_head orig, struct cache_head new)
	63	test if the keys in the two structures match. Return
	64	1 if they do, 0 if they don't.
	65	void init(struct cache_head orig, struct cache_head new)
	66	Set the 'key' fields in 'new' from 'orig'. This may
	67	include taking references to shared objects.
	68	void update(struct cache_head orig, struct cache_head new)
	69	Set the 'content' fileds in 'new' from 'orig'.
	70	int cache_show(struct seq_file m, struct cache_detail cd,
	71	struct cache_head *h)
	72	Optional. Used to provide a /proc file that lists the
	73	contents of a cache. This should show one item,
	74	usually on just one line.
	75	int cache_request(struct cache_detail cd, struct cache_head h,
	76	char *bpp, int blen)
	77	Format a request to be send to user-space for an item
	78	to be instantiated. bpp is a buffer of size blen.
	79	bpp should be moved forward over the encoded message,
	80	and *blen should be reduced to show how much free
	81	space remains. Return 0 on success or <0 if not
	82	enough room or other problem.
	83	int cache_parse(struct cache_detail cd, char buf, int len)
	84	A message from user space has arrived to fill out a
	85	cache entry. It is in 'buf' of length 'len'.
	86	cache_parse should parse this, find the item in the
	87	cache with sunrpc_cache_lookup, and update the item
	88	with sunrpc_cache_update.
	89
	90
	91	3/ A cache needs to be registered using cache_register(). This
	92	includes it on a list of caches that will be regularly
	93	cleaned to discard old data.
	94
	95	Using a cache
	96	-------------
	97
	98	To find a value in a cache, call sunrpc_cache_lookup passing a pointer
	99	to the cache_head in a sample item with the 'key' fields filled in.
	100	This will be passed to ->match to identify the target entry. If no
	101	entry is found, a new entry will be create, added to the cache, and
	102	marked as not containing valid data.
	103
	104	The item returned is typically passed to cache_check which will check
	105	if the data is valid, and may initiate an up-call to get fresh data.
	106	cache_check will return -ENOENT in the entry is negative or if an up
	107	call is needed but not possible, -EAGAIN if an upcall is pending,
	108	or 0 if the data is valid;
	109
	110	cache_check can be passed a "struct cache_req *". This structure is
	111	typically embedded in the actual request and can be used to create a
	112	deferred copy of the request (struct cache_deferred_req). This is
	113	done when the found cache item is not uptodate, but the is reason to
	114	believe that userspace might provide information soon. When the cache
	115	item does become valid, the deferred copy of the request will be
	116	revisited (->revisit). It is expected that this method will
	117	reschedule the request for processing.
	118
	119	The value returned by sunrpc_cache_lookup can also be passed to
	120	sunrpc_cache_update to set the content for the item. A second item is
	121	passed which should hold the content. If the item found by _lookup
	122	has valid data, then it is discarded and a new item is created. This
	123	saves any user of an item from worrying about content changing while
	124	it is being inspected. If the item found by _lookup does not contain
	125	valid data, then the content is copied across and CACHE_VALID is set.
	126
	127	Populating a cache
	128	------------------
	129
	130	Each cache has a name, and when the cache is registered, a directory
	131	with that name is created in /proc/net/rpc
	132
	133	This directory contains a file called 'channel' which is a channel
	134	for communicating between kernel and user for populating the cache.
	135	This directory may later contain other files of interacting
	136	with the cache.
	137
	138	The 'channel' works a bit like a datagram socket. Each 'write' is
	139	passed as a whole to the cache for parsing and interpretation.
	140	Each cache can treat the write requests differently, but it is
	141	expected that a message written will contain:
	142	- a key
	143	- an expiry time
	144	- a content.
	145	with the intention that an item in the cache with the give key
	146	should be create or updated to have the given content, and the
	147	expiry time should be set on that item.
	148
	149	Reading from a channel is a bit more interesting. When a cache
	150	lookup fails, or when it succeeds but finds an entry that may soon
	151	expire, a request is lodged for that cache item to be updated by
	152	user-space. These requests appear in the channel file.
	153
	154	Successive reads will return successive requests.
	155	If there are no more requests to return, read will return EOF, but a
	156	select or poll for read will block waiting for another request to be
	157	added.
	158
	159	Thus a user-space helper is likely to:
	160	open the channel.
	161	select for readable
	162	read a request
	163	write a response
	164	loop.
	165
	166	If it dies and needs to be restarted, any requests that have not been
	167	answered will still appear in the file and will be read by the new
	168	instance of the helper.
	169
	170	Each cache should define a "cache_parse" method which takes a message
	171	written from user-space and processes it. It should return an error
	172	(which propagates back to the write syscall) or 0.
	173
	174	Each cache should also define a "cache_request" method which
	175	takes a cache item and encodes a request into the buffer
	176	provided.
	177
	178	Note: If a cache has no active readers on the channel, and has had not
	179	active readers for more than 60 seconds, further requests will not be
	180	added to the channel but instead all lookups that do not find a valid
	181	entry will fail. This is partly for backward compatibility: The
	182	previous nfs exports table was deemed to be authoritative and a
	183	failed lookup meant a definite 'no'.
	184
	185	request/response format
	186	-----------------------
	187
	188	While each cache is free to use it's own format for requests
	189	and responses over channel, the following is recommended as
	190	appropriate and support routines are available to help:
	191	Each request or response record should be printable ASCII
	192	with precisely one newline character which should be at the end.
	193	Fields within the record should be separated by spaces, normally one.
	194	If spaces, newlines, or nul characters are needed in a field they
	195	much be quoted. two mechanisms are available:
	196	1/ If a field begins '\x' then it must contain an even number of
	197	hex digits, and pairs of these digits provide the bytes in the
	198	field.
	199	2/ otherwise a \ in the field must be followed by 3 octal digits
	200	which give the code for a byte. Other characters are treated
	201	as them selves. At the very least, space, newline, nul, and
	202	'\' must be quoted in this way.
	203

Documentation/filesystems/seq_file.txt

Diff comments View file @ 14897e3

File was created	1	The seq_file interface
	2
	3	Copyright 2003 Jonathan Corbet <corbet@lwn.net>
	4	This file is originally from the LWN.net Driver Porting series at
	5	http://lwn.net/Articles/driver-porting/
	6
	7
	8	There are numerous ways for a device driver (or other kernel component) to
	9	provide information to the user or system administrator. One useful
	10	technique is the creation of virtual files, in debugfs, /proc or elsewhere.
	11	Virtual files can provide human-readable output that is easy to get at
	12	without any special utility programs; they can also make life easier for
	13	script writers. It is not surprising that the use of virtual files has
	14	grown over the years.
	15
	16	Creating those files correctly has always been a bit of a challenge,
	17	however. It is not that hard to make a virtual file which returns a
	18	string. But life gets trickier if the output is long - anything greater
	19	than an application is likely to read in a single operation. Handling
	20	multiple reads (and seeks) requires careful attention to the reader's
	21	position within the virtual file - that position is, likely as not, in the
	22	middle of a line of output. The kernel has traditionally had a number of
	23	implementations that got this wrong.
	24
	25	The 2.6 kernel contains a set of functions (implemented by Alexander Viro)
	26	which are designed to make it easy for virtual file creators to get it
	27	right.
	28
	29	The seq_file interface is available via <linux/seq_file.h>. There are
	30	three aspects to seq_file:
	31
	32	* An iterator interface which lets a virtual file implementation
	33	step through the objects it is presenting.
	34
	35	* Some utility functions for formatting objects for output without
	36	needing to worry about things like output buffers.
	37
	38	* A set of canned file_operations which implement most operations on
	39	the virtual file.
	40
	41	We'll look at the seq_file interface via an extremely simple example: a
	42	loadable module which creates a file called /proc/sequence. The file, when
	43	read, simply produces a set of increasing integer values, one per line. The
	44	sequence will continue until the user loses patience and finds something
	45	better to do. The file is seekable, in that one can do something like the
	46	following:
	47
	48	dd if=/proc/sequence of=out1 count=1
	49	dd if=/proc/sequence skip=1 out=out2 count=1
	50
	51	Then concatenate the output files out1 and out2 and get the right
	52	result. Yes, it is a thoroughly useless module, but the point is to show
	53	how the mechanism works without getting lost in other details. (Those
	54	wanting to see the full source for this module can find it at
	55	http://lwn.net/Articles/22359/).
	56
	57
	58	The iterator interface
	59
	60	Modules implementing a virtual file with seq_file must implement a simple
	61	iterator object that allows stepping through the data of interest.
	62	Iterators must be able to move to a specific position - like the file they
	63	implement - but the interpretation of that position is up to the iterator
	64	itself. A seq_file implementation that is formatting firewall rules, for
	65	example, could interpret position N as the Nth rule in the chain.
	66	Positioning can thus be done in whatever way makes the most sense for the
	67	generator of the data, which need not be aware of how a position translates
	68	to an offset in the virtual file. The one obvious exception is that a
	69	position of zero should indicate the beginning of the file.
	70
	71	The /proc/sequence iterator just uses the count of the next number it
	72	will output as its position.
	73
	74	Four functions must be implemented to make the iterator work. The first,
	75	called start() takes a position as an argument and returns an iterator
	76	which will start reading at that position. For our simple sequence example,
	77	the start() function looks like:
	78
	79	static void ct_seq_start(struct seq_file s, loff_t *pos)
	80	{
	81	loff_t *spos = kmalloc(sizeof(loff_t), GFP_KERNEL);
	82	if (! spos)
	83	return NULL;
	84	spos = pos;
	85	return spos;
	86	}
	87
	88	The entire data structure for this iterator is a single loff_t value
	89	holding the current position. There is no upper bound for the sequence
	90	iterator, but that will not be the case for most other seq_file
	91	implementations; in most cases the start() function should check for a
	92	"past end of file" condition and return NULL if need be.
	93
	94	For more complicated applications, the private field of the seq_file
	95	structure can be used. There is also a special value whch can be returned
	96	by the start() function called SEQ_START_TOKEN; it can be used if you wish
	97	to instruct your show() function (described below) to print a header at the
	98	top of the output. SEQ_START_TOKEN should only be used if the offset is
	99	zero, however.
	100
	101	The next function to implement is called, amazingly, next(); its job is to
	102	move the iterator forward to the next position in the sequence. The
	103	example module can simply increment the position by one; more useful
	104	modules will do what is needed to step through some data structure. The
	105	next() function returns a new iterator, or NULL if the sequence is
	106	complete. Here's the example version:
	107
	108	static void ct_seq_next(struct seq_file s, void v, loff_t pos)
	109	{
	110	loff_t *spos = v;
	111	pos = ++spos;
	112	return spos;
	113	}
	114
	115	The stop() function is called when iteration is complete; its job, of
	116	course, is to clean up. If dynamic memory is allocated for the iterator,
	117	stop() is the place to free it.
	118
	119	static void ct_seq_stop(struct seq_file s, void v)
	120	{
	121	kfree(v);
	122	}
	123
	124	Finally, the show() function should format the object currently pointed to
	125	by the iterator for output. It should return zero, or an error code if
	126	something goes wrong. The example module's show() function is:
	127
	128	static int ct_seq_show(struct seq_file s, void v)
	129	{
	130	loff_t *spos = v;
	131	seq_printf(s, "%lld\n", (long long)*spos);
	132	return 0;
	133	}
	134
	135	We will look at seq_printf() in a moment. But first, the definition of the
	136	seq_file iterator is finished by creating a seq_operations structure with
	137	the four functions we have just defined:
	138
	139	static const struct seq_operations ct_seq_ops = {
	140	.start = ct_seq_start,
	141	.next = ct_seq_next,
	142	.stop = ct_seq_stop,
	143	.show = ct_seq_show
	144	};
	145
	146	This structure will be needed to tie our iterator to the /proc file in
	147	a little bit.
	148
	149	It's worth noting that the interator value returned by start() and
	150	manipulated by the other functions is considered to be completely opaque by
	151	the seq_file code. It can thus be anything that is useful in stepping
	152	through the data to be output. Counters can be useful, but it could also be
	153	a direct pointer into an array or linked list. Anything goes, as long as
	154	the programmer is aware that things can happen between calls to the
	155	iterator function. However, the seq_file code (by design) will not sleep
	156	between the calls to start() and stop(), so holding a lock during that time
	157	is a reasonable thing to do. The seq_file code will also avoid taking any
	158	other locks while the iterator is active.
	159
	160
	161	Formatted output
	162
	163	The seq_file code manages positioning within the output created by the
	164	iterator and getting it into the user's buffer. But, for that to work, that
	165	output must be passed to the seq_file code. Some utility functions have
	166	been defined which make this task easy.
	167
	168	Most code will simply use seq_printf(), which works pretty much like
	169	printk(), but which requires the seq_file pointer as an argument. It is
	170	common to ignore the return value from seq_printf(), but a function
	171	producing complicated output may want to check that value and quit if
	172	something non-zero is returned; an error return means that the seq_file
	173	buffer has been filled and further output will be discarded.
	174
	175	For straight character output, the following functions may be used:
	176
	177	int seq_putc(struct seq_file *m, char c);
	178	int seq_puts(struct seq_file m, const char s);
	179	int seq_escape(struct seq_file m, const char s, const char *esc);
	180
	181	The first two output a single character and a string, just like one would
	182	expect. seq_escape() is like seq_puts(), except that any character in s
	183	which is in the string esc will be represented in octal form in the output.
	184
	185	There is also a function for printing filenames:
	186
	187	int seq_path(struct seq_file m, struct path path, char *esc);
	188
	189	Here, path indicates the file of interest, and esc is a set of characters
	190	which should be escaped in the output.
	191
	192
	193	Making it all work
	194
	195	So far, we have a nice set of functions which can produce output within the
	196	seq_file system, but we have not yet turned them into a file that a user
	197	can see. Creating a file within the kernel requires, of course, the
	198	creation of a set of file_operations which implement the operations on that
	199	file. The seq_file interface provides a set of canned operations which do
	200	most of the work. The virtual file author still must implement the open()
	201	method, however, to hook everything up. The open function is often a single
	202	line, as in the example module:
	203
	204	static int ct_open(struct inode inode, struct file file)
	205	{
	206	return seq_open(file, &ct_seq_ops);
	207	}
	208
	209	Here, the call to seq_open() takes the seq_operations structure we created
	210	before, and gets set up to iterate through the virtual file.
	211
	212	On a successful open, seq_open() stores the struct seq_file pointer in
	213	file->private_data. If you have an application where the same iterator can
	214	be used for more than one file, you can store an arbitrary pointer in the
	215	private field of the seq_file structure; that value can then be retrieved
	216	by the iterator functions.
	217
	218	The other operations of interest - read(), llseek(), and release() - are
	219	all implemented by the seq_file code itself. So a virtual file's
	220	file_operations structure will look like:
	221
	222	static const struct file_operations ct_file_ops = {
	223	.owner = THIS_MODULE,
	224	.open = ct_open,
	225	.read = seq_read,
	226	.llseek = seq_lseek,
	227	.release = seq_release
	228	};
	229
	230	There is also a seq_release_private() which passes the contents of the
	231	seq_file private field to kfree() before releasing the structure.
	232
	233	The final step is the creation of the /proc file itself. In the example
	234	code, that is done in the initialization code in the usual way:
	235
	236	static int ct_init(void)
	237	{
	238	struct proc_dir_entry *entry;
	239
	240	entry = create_proc_entry("sequence", 0, NULL);
	241	if (entry)
	242	entry->proc_fops = &ct_file_ops;
	243	return 0;
	244	}
	245
	246	module_init(ct_init);
	247
	248	And that is pretty much it.
	249
	250
	251	seq_list
	252
	253	If your file will be iterating through a linked list, you may find these
	254	routines useful:
	255
	256	struct list_head seq_list_start(struct list_head head,
	257	loff_t pos);
	258	struct list_head seq_list_start_head(struct list_head head,
	259	loff_t pos);
	260	struct list_head seq_list_next(void v, struct list_head *head,
	261	loff_t *ppos);
	262
	263	These helpers will interpret pos as a position within the list and iterate
	264	accordingly. Your start() and next() functions need only invoke the
	265	seq_list_* helpers with a pointer to the appropriate list_head structure.
	266
	267
	268	The extra-simple version
	269
	270	For extremely simple virtual files, there is an even easier interface. A
	271	module can define only the show() function, which should create all the
	272	output that the virtual file will contain. The file's open() method then
	273	calls:
	274
	275	int single_open(struct file *file,
	276	int (show)(struct seq_file m, void *p),
	277	void *data);
	278
	279	When output time comes, the show() function will be called once. The data
	280	value given to single_open() can be found in the private field of the
	281	seq_file structure. When using single_open(), the programmer should use
	282	single_release() instead of seq_release() in the file_operations structure
	283	to avoid a memory leak.
	284

Documentation/hrtimers/highres.txt

Diff comments View file @ 14897e3

Documentation/kernel-parameters.txt

Diff comments View file @ 14897e3

Documentation/nfsroot.txt

View file @ 14897e3

1	Mounting the root filesystem via NFS (nfsroot)		File was deleted
2	===============================================
3
4	Written 1996 by Gero Kuhlmann <gero@gkminix.han.de>
5	Updated 1997 by Martin Mares <mj@atrey.karlin.mff.cuni.cz>
6	Updated 2006 by Nico Schottelius <nico-kernel-nfsroot@schottelius.org>
7	Updated 2006 by Horms <horms@verge.net.au>
8
9
10
11	In order to use a diskless system, such as an X-terminal or printer server
12	for example, it is necessary for the root filesystem to be present on a
13	non-disk device. This may be an initramfs (see Documentation/filesystems/
14	ramfs-rootfs-initramfs.txt), a ramdisk (see Documentation/initrd.txt) or a
15	filesystem mounted via NFS. The following text describes on how to use NFS
16	for the root filesystem. For the rest of this text 'client' means the
17	diskless system, and 'server' means the NFS server.
18
19
20
21
22	1.) Enabling nfsroot capabilities
23	-----------------------------
24
25	In order to use nfsroot, NFS client support needs to be selected as
26	built-in during configuration. Once this has been selected, the nfsroot
27	option will become available, which should also be selected.
28
29	In the networking options, kernel level autoconfiguration can be selected,
30	along with the types of autoconfiguration to support. Selecting all of
31	DHCP, BOOTP and RARP is safe.
32
33
34
35
36	2.) Kernel command line
37	-------------------
38
39	When the kernel has been loaded by a boot loader (see below) it needs to be
40	told what root fs device to use. And in the case of nfsroot, where to find
41	both the server and the name of the directory on the server to mount as root.
42	This can be established using the following kernel command line parameters:
43
44
45	root=/dev/nfs
46
47	This is necessary to enable the pseudo-NFS-device. Note that it's not a
48	real device but just a synonym to tell the kernel to use NFS instead of
49	a real device.
50
51
52	nfsroot=[<server-ip>:]<root-dir>[,<nfs-options>]
53
54	If the `nfsroot' parameter is NOT given on the command line,
55	the default "/tftpboot/%s" will be used.
56
57	<server-ip> Specifies the IP address of the NFS server.
58	The default address is determined by the `ip' parameter
59	(see below). This parameter allows the use of different
60	servers for IP autoconfiguration and NFS.
61
62	<root-dir> Name of the directory on the server to mount as root.
63	If there is a "%s" token in the string, it will be
64	replaced by the ASCII-representation of the client's
65	IP address.
66
67	<nfs-options> Standard NFS options. All options are separated by commas.
68	The following defaults are used:
69	port = as given by server portmap daemon
70	rsize = 4096
71	wsize = 4096
72	timeo = 7
73	retrans = 3
74	acregmin = 3
75	acregmax = 60
76	acdirmin = 30
77	acdirmax = 60
78	flags = hard, nointr, noposix, cto, ac
79
80
81	ip=<client-ip>:<server-ip>:<gw-ip>:<netmask>:<hostname>:<device>:<autoconf>
82
83	This parameter tells the kernel how to configure IP addresses of devices
84	and also how to set up the IP routing table. It was originally called
85	`nfsaddrs', but now the boot-time IP configuration works independently of
86	NFS, so it was renamed to `ip' and the old name remained as an alias for
87	compatibility reasons.
88
89	If this parameter is missing from the kernel command line, all fields are
90	assumed to be empty, and the defaults mentioned below apply. In general
91	this means that the kernel tries to configure everything using
92	autoconfiguration.
93
94	The <autoconf> parameter can appear alone as the value to the `ip'
95	parameter (without all the ':' characters before). If the value is
96	"ip=off" or "ip=none", no autoconfiguration will take place, otherwise
97	autoconfiguration will take place. The most common way to use this
98	is "ip=dhcp".
99
100	<client-ip> IP address of the client.
101
102	Default: Determined using autoconfiguration.
103
104	<server-ip> IP address of the NFS server. If RARP is used to determine
105	the client address and this parameter is NOT empty only
106	replies from the specified server are accepted.
107
108	Only required for for NFS root. That is autoconfiguration
109	will not be triggered if it is missing and NFS root is not
110	in operation.
111
112	Default: Determined using autoconfiguration.
113	The address of the autoconfiguration server is used.
114
115	<gw-ip> IP address of a gateway if the server is on a different subnet.
116
117	Default: Determined using autoconfiguration.
118
119	<netmask> Netmask for local network interface. If unspecified
120	the netmask is derived from the client IP address assuming
121	classful addressing.
122
123	Default: Determined using autoconfiguration.
124
125	<hostname> Name of the client. May be supplied by autoconfiguration,
126	but its absence will not trigger autoconfiguration.
127
128	Default: Client IP address is used in ASCII notation.
129
130	<device> Name of network device to use.
131
132	Default: If the host only has one device, it is used.
133	Otherwise the device is determined using
134	autoconfiguration. This is done by sending
135	autoconfiguration requests out of all devices,
136	and using the device that received the first reply.
137
138	<autoconf> Method to use for autoconfiguration. In the case of options
139	which specify multiple autoconfiguration protocols,
140	requests are sent using all protocols, and the first one
141	to reply is used.
142
143	Only autoconfiguration protocols that have been compiled
144	into the kernel will be used, regardless of the value of
145	this option.
146
147	off or none: don't use autoconfiguration
148	(do static IP assignment instead)
149	on or any: use any protocol available in the kernel
150	(default)
151	dhcp: use DHCP
152	bootp: use BOOTP
153	rarp: use RARP
154	both: use both BOOTP and RARP but not DHCP
155	(old option kept for backwards compatibility)
156
157	Default: any
158
159
160
161
162	3.) Boot Loader
163	----------
164
165	To get the kernel into memory different approaches can be used.
166	They depend on various facilities being available:
167
168
169	3.1) Booting from a floppy using syslinux
170
171	When building kernels, an easy way to create a boot floppy that uses
172	syslinux is to use the zdisk or bzdisk make targets which use
173	and bzimage images respectively. Both targets accept the
174	FDARGS parameter which can be used to set the kernel command line.
175
176	e.g.
177	make bzdisk FDARGS="root=/dev/nfs"
178
179	Note that the user running this command will need to have
180	access to the floppy drive device, /dev/fd0
181
182	For more information on syslinux, including how to create bootdisks
183	for prebuilt kernels, see http://syslinux.zytor.com/
184
185	N.B: Previously it was possible to write a kernel directly to
186	a floppy using dd, configure the boot device using rdev, and
187	boot using the resulting floppy. Linux no longer supports this
188	method of booting.
189
190	3.2) Booting from a cdrom using isolinux
191
192	When building kernels, an easy way to create a bootable cdrom that
193	uses isolinux is to use the isoimage target which uses a bzimage
194	image. Like zdisk and bzdisk, this target accepts the FDARGS
195	parameter which can be used to set the kernel command line.
196
197	e.g.
198	make isoimage FDARGS="root=/dev/nfs"
199
200	The resulting iso image will be arch/<ARCH>/boot/image.iso
201	This can be written to a cdrom using a variety of tools including
202	cdrecord.
203
204	e.g.
205	cdrecord dev=ATAPI:1,0,0 arch/i386/boot/image.iso
206
207	For more information on isolinux, including how to create bootdisks
208	for prebuilt kernels, see http://syslinux.zytor.com/
209
210	3.2) Using LILO
211	When using LILO all the necessary command line parameters may be
212	specified using the 'append=' directive in the LILO configuration
213	file.
214
215	However, to use the 'root=' directive you also need to create
216	a dummy root device, which may be removed after LILO is run.
217
218	mknod /dev/boot255 c 0 255
219
220	For information on configuring LILO, please refer to its documentation.
221
222	3.3) Using GRUB
223	When using GRUB, kernel parameter are simply appended after the kernel
224	specification: kernel <kernel> <parameters>
225
226	3.4) Using loadlin
227	loadlin may be used to boot Linux from a DOS command prompt without
228	requiring a local hard disk to mount as root. This has not been
229	thoroughly tested by the authors of this document, but in general
230	it should be possible configure the kernel command line similarly
231	to the configuration of LILO.
232
233	Please refer to the loadlin documentation for further information.
234
235	3.5) Using a boot ROM
236	This is probably the most elegant way of booting a diskless client.
237	With a boot ROM the kernel is loaded using the TFTP protocol. The
238	authors of this document are not aware of any no commercial boot
239	ROMs that support booting Linux over the network. However, there
240	are two free implementations of a boot ROM, netboot-nfs and
241	etherboot, both of which are available on sunsite.unc.edu, and both
242	of which contain everything you need to boot a diskless Linux client.
243
244	3.6) Using pxelinux
245	Pxelinux may be used to boot linux using the PXE boot loader
246	which is present on many modern network cards.
247
248	When using pxelinux, the kernel image is specified using
249	"kernel <relative-path-below /tftpboot>". The nfsroot parameters
250	are passed to the kernel by adding them to the "append" line.
251	It is common to use serial console in conjunction with pxeliunx,
252	see Documentation/serial-console.txt for more information.
253
254	For more information on isolinux, including how to create bootdisks
255	for prebuilt kernels, see http://syslinux.zytor.com/
256
257
258
259
260	4.) Credits
261	-------
262
263	The nfsroot code in the kernel and the RARP support have been written
264	by Gero Kuhlmann <gero@gkminix.han.de>.
265
266	The rest of the IP layer autoconfiguration code has been written
267	by Martin Mares <mj@atrey.karlin.mff.cuni.cz>.
268
269	In order to write the initial version of nfsroot I would like to thank
270	Jens-Uwe Mager <jum@anubis.han.de> for his help.
271		1	Mounting the root filesystem via NFS (nfsroot)

Documentation/rpc-cache.txt

View file @ 14897e3

1	This document gives a brief introduction to the caching		File was deleted
2	mechanisms in the sunrpc layer that is used, in particular,
3	for NFS authentication.
4
5	CACHES
6	======
7	The caching replaces the old exports table and allows for
8	a wide variety of values to be caches.
9
10	There are a number of caches that are similar in structure though
11	quite possibly very different in content and use. There is a corpus
12	of common code for managing these caches.
13
14	Examples of caches that are likely to be needed are:
15	- mapping from IP address to client name
16	- mapping from client name and filesystem to export options
17	- mapping from UID to list of GIDs, to work around NFS's limitation
18	of 16 gids.
19	- mappings between local UID/GID and remote UID/GID for sites that
20	do not have uniform uid assignment
21	- mapping from network identify to public key for crypto authentication.
22
23	The common code handles such things as:
24	- general cache lookup with correct locking
25	- supporting 'NEGATIVE' as well as positive entries
26	- allowing an EXPIRED time on cache items, and removing
27	items after they expire, and are no longer in-use.
28	- making requests to user-space to fill in cache entries
29	- allowing user-space to directly set entries in the cache
30	- delaying RPC requests that depend on as-yet incomplete
31	cache entries, and replaying those requests when the cache entry
32	is complete.
33	- clean out old entries as they expire.
34
35	Creating a Cache
36	----------------
37
38	1/ A cache needs a datum to store. This is in the form of a
39	structure definition that must contain a
40	struct cache_head
41	as an element, usually the first.
42	It will also contain a key and some content.
43	Each cache element is reference counted and contains
44	expiry and update times for use in cache management.
45	2/ A cache needs a "cache_detail" structure that
46	describes the cache. This stores the hash table, some
47	parameters for cache management, and some operations detailing how
48	to work with particular cache items.
49	The operations requires are:
50	struct cache_head *alloc(void)
51	This simply allocates appropriate memory and returns
52	a pointer to the cache_detail embedded within the
53	structure
54	void cache_put(struct kref *)
55	This is called when the last reference to an item is
56	dropped. The pointer passed is to the 'ref' field
57	in the cache_head. cache_put should release any
58	references create by 'cache_init' and, if CACHE_VALID
59	is set, any references created by cache_update.
60	It should then release the memory allocated by
61	'alloc'.
62	int match(struct cache_head orig, struct cache_head new)
63	test if the keys in the two structures match. Return
64	1 if they do, 0 if they don't.
65	void init(struct cache_head orig, struct cache_head new)
66	Set the 'key' fields in 'new' from 'orig'. This may
67	include taking references to shared objects.
68	void update(struct cache_head orig, struct cache_head new)
69	Set the 'content' fileds in 'new' from 'orig'.
70	int cache_show(struct seq_file m, struct cache_detail cd,
71	struct cache_head *h)
72	Optional. Used to provide a /proc file that lists the
73	contents of a cache. This should show one item,
74	usually on just one line.
75	int cache_request(struct cache_detail cd, struct cache_head h,
76	char *bpp, int blen)
77	Format a request to be send to user-space for an item
78	to be instantiated. bpp is a buffer of size blen.
79	bpp should be moved forward over the encoded message,
80	and *blen should be reduced to show how much free
81	space remains. Return 0 on success or <0 if not
82	enough room or other problem.
83	int cache_parse(struct cache_detail cd, char buf, int len)
84	A message from user space has arrived to fill out a
85	cache entry. It is in 'buf' of length 'len'.
86	cache_parse should parse this, find the item in the
87	cache with sunrpc_cache_lookup, and update the item
88	with sunrpc_cache_update.
89
90
91	3/ A cache needs to be registered using cache_register(). This
92	includes it on a list of caches that will be regularly
93	cleaned to discard old data.
94
95	Using a cache
96	-------------
97
98	To find a value in a cache, call sunrpc_cache_lookup passing a pointer
99	to the cache_head in a sample item with the 'key' fields filled in.
100	This will be passed to ->match to identify the target entry. If no
101	entry is found, a new entry will be create, added to the cache, and
102	marked as not containing valid data.
103
104	The item returned is typically passed to cache_check which will check
105	if the data is valid, and may initiate an up-call to get fresh data.
106	cache_check will return -ENOENT in the entry is negative or if an up
107	call is needed but not possible, -EAGAIN if an upcall is pending,
108	or 0 if the data is valid;
109
110	cache_check can be passed a "struct cache_req *". This structure is
111	typically embedded in the actual request and can be used to create a
112	deferred copy of the request (struct cache_deferred_req). This is
113	done when the found cache item is not uptodate, but the is reason to
114	believe that userspace might provide information soon. When the cache
115	item does become valid, the deferred copy of the request will be
116	revisited (->revisit). It is expected that this method will
117	reschedule the request for processing.
118
119	The value returned by sunrpc_cache_lookup can also be passed to
120	sunrpc_cache_update to set the content for the item. A second item is
121	passed which should hold the content. If the item found by _lookup
122	has valid data, then it is discarded and a new item is created. This
123	saves any user of an item from worrying about content changing while
124	it is being inspected. If the item found by _lookup does not contain
125	valid data, then the content is copied across and CACHE_VALID is set.
126
127	Populating a cache
128	------------------
129
130	Each cache has a name, and when the cache is registered, a directory
131	with that name is created in /proc/net/rpc
132
133	This directory contains a file called 'channel' which is a channel
134	for communicating between kernel and user for populating the cache.
135	This directory may later contain other files of interacting
136	with the cache.
137
138	The 'channel' works a bit like a datagram socket. Each 'write' is
139	passed as a whole to the cache for parsing and interpretation.
140	Each cache can treat the write requests differently, but it is
141	expected that a message written will contain:
142	- a key
143	- an expiry time
144	- a content.
145	with the intention that an item in the cache with the give key
146	should be create or updated to have the given content, and the
147	expiry time should be set on that item.
148
149	Reading from a channel is a bit more interesting. When a cache
150	lookup fails, or when it succeeds but finds an entry that may soon
151	expire, a request is lodged for that cache item to be updated by
152	user-space. These requests appear in the channel file.
153
154	Successive reads will return successive requests.
155	If there are no more requests to return, read will return EOF, but a
156	select or poll for read will block waiting for another request to be
157	added.
158
159	Thus a user-space helper is likely to:
160	open the channel.
161	select for readable
162	read a request
163	write a response
164	loop.
165
166	If it dies and needs to be restarted, any requests that have not been
167	answered will still appear in the file and will be read by the new
168	instance of the helper.
169
170	Each cache should define a "cache_parse" method which takes a message
171	written from user-space and processes it. It should return an error
172	(which propagates back to the write syscall) or 0.
173
174	Each cache should also define a "cache_request" method which
175	takes a cache item and encodes a request into the buffer
176	provided.
177
178	Note: If a cache has no active readers on the channel, and has had not
179	active readers for more than 60 seconds, further requests will not be
180	added to the channel but instead all lookups that do not find a valid
181	entry will fail. This is partly for backward compatibility: The
182	previous nfs exports table was deemed to be authoritative and a
183	failed lookup meant a definite 'no'.
184
185	request/response format
186	-----------------------
187
188	While each cache is free to use it's own format for requests
189	and responses over channel, the following is recommended as
190	appropriate and support routines are available to help:
191	Each request or response record should be printable ASCII
192	with precisely one newline character which should be at the end.
193	Fields within the record should be separated by spaces, normally one.
194	If spaces, newlines, or nul characters are needed in a field they
195	much be quoted. two mechanisms are available:
196	1/ If a field begins '\x' then it must contain an even number of
197	hex digits, and pairs of these digits provide the bytes in the
198	field.
199	2/ otherwise a \ in the field must be followed by 3 octal digits
200	which give the code for a byte. Other characters are treated
201	as them selves. At the very least, space, newline, nul, and
202	'\' must be quoted in this way.
203		1	This document gives a brief introduction to the caching

Documentation/sched-rt-group.txt

View file @ 14897e3

1			File was deleted
2
3	Real-Time group scheduling.
4
5	The problem space:
6
7	In order to schedule multiple groups of realtime tasks each group must
8	be assigned a fixed portion of the CPU time available. Without a minimum
9	guarantee a realtime group can obviously fall short. A fuzzy upper limit
10	is of no use since it cannot be relied upon. Which leaves us with just
11	the single fixed portion.
12
13	CPU time is divided by means of specifying how much time can be spent
14	running in a given period. Say a frame fixed realtime renderer must
15	deliver 25 frames a second, which yields a period of 0.04s. Now say
16	it will also have to play some music and respond to input, leaving it
17	with around 80% for the graphics. We can then give this group a runtime
18	of 0.8 * 0.04s = 0.032s.
19
20	This way the graphics group will have a 0.04s period with a 0.032s runtime
21	limit.
22
23	Now if the audio thread needs to refill the DMA buffer every 0.005s, but
24	needs only about 3% CPU time to do so, it can do with a 0.03 * 0.005s
25	= 0.00015s.
26
27
28	The Interface:
29
30	system wide:
31
32	/proc/sys/kernel/sched_rt_period_ms
33	/proc/sys/kernel/sched_rt_runtime_us
34
35	CONFIG_FAIR_USER_SCHED
36
37	/sys/kernel/uids/<uid>/cpu_rt_runtime_us
38
39	or
40
41	CONFIG_FAIR_CGROUP_SCHED
42
43	/cgroup/<cgroup>/cpu.rt_runtime_us
44
45	[ time is specified in us because the interface is s32; this gives an
46	operating range of ~35m to 1us ]
47
48	The period takes values in [ 1, INT_MAX ], runtime in [ -1, INT_MAX - 1 ].
49
50	A runtime of -1 specifies runtime == period, ie. no limit.
51
52	New groups get the period from /proc/sys/kernel/sched_rt_period_us and
53	a runtime of 0.
54
55	Settings are constrained to:
56
57	\Sum_{i} runtime_{i} / global_period <= global_runtime / global_period
58
59	in order to keep the configuration schedulable.
60		1

Documentation/scheduler/00-INDEX

Diff comments View file @ 14897e3

 00-INDEX
 	- this file.
 sched-arch.txt
 	- CPU Scheduler implementation hints for architecture specific code.
 sched-coding.txt
 	- reference for various scheduler-related methods in the O(1) scheduler.
 sched-design.txt
 	- goals, design and implementation of the Linux O(1) scheduler.
 sched-design-CFS.txt
 	- goals, design and implementation of the Complete Fair Scheduler.
 sched-domains.txt
 	- information on scheduling domains.
 sched-nice-design.txt
 	- How and why the scheduler's nice levels are implemented.
+sched-rt-group.txt
+	- real-time group scheduling.
 sched-stats.txt
 	- information on schedstats (Linux Scheduler Statistics).

Documentation/scheduler/sched-rt-group.txt

Diff comments View file @ 14897e3

File was created	1
	2
	3	Real-Time group scheduling.
	4
	5	The problem space:
	6
	7	In order to schedule multiple groups of realtime tasks each group must
	8	be assigned a fixed portion of the CPU time available. Without a minimum
	9	guarantee a realtime group can obviously fall short. A fuzzy upper limit
	10	is of no use since it cannot be relied upon. Which leaves us with just
	11	the single fixed portion.
	12
	13	CPU time is divided by means of specifying how much time can be spent
	14	running in a given period. Say a frame fixed realtime renderer must
	15	deliver 25 frames a second, which yields a period of 0.04s. Now say
	16	it will also have to play some music and respond to input, leaving it
	17	with around 80% for the graphics. We can then give this group a runtime
	18	of 0.8 * 0.04s = 0.032s.
	19
	20	This way the graphics group will have a 0.04s period with a 0.032s runtime
	21	limit.
	22
	23	Now if the audio thread needs to refill the DMA buffer every 0.005s, but
	24	needs only about 3% CPU time to do so, it can do with a 0.03 * 0.005s
	25	= 0.00015s.
	26
	27
	28	The Interface:
	29
	30	system wide:
	31
	32	/proc/sys/kernel/sched_rt_period_ms
	33	/proc/sys/kernel/sched_rt_runtime_us
	34
	35	CONFIG_FAIR_USER_SCHED
	36
	37	/sys/kernel/uids/<uid>/cpu_rt_runtime_us
	38
	39	or
	40
	41	CONFIG_FAIR_CGROUP_SCHED
	42
	43	/cgroup/<cgroup>/cpu.rt_runtime_us
	44
	45	[ time is specified in us because the interface is s32; this gives an
	46	operating range of ~35m to 1us ]
	47
	48	The period takes values in [ 1, INT_MAX ], runtime in [ -1, INT_MAX - 1 ].
	49
	50	A runtime of -1 specifies runtime == period, ie. no limit.
	51
	52	New groups get the period from /proc/sys/kernel/sched_rt_period_us and
	53	a runtime of 0.
	54
	55	Settings are constrained to:
	56
	57	\Sum_{i} runtime_{i} / global_period <= global_runtime / global_period
	58
	59	in order to keep the configuration schedulable.
	60

Documentation/spinlocks.txt

Diff comments View file @ 14897e3

 SPIN_LOCK_UNLOCKED and RW_LOCK_UNLOCKED defeat lockdep state tracking and
 are hence deprecated.
 Please use DEFINE_SPINLOCK()/DEFINE_RWLOCK() or
 __SPIN_LOCK_UNLOCKED()/__RW_LOCK_UNLOCKED() as appropriate for static
 initialization.
+Most of the time, you can simply turn:
+	static spinlock_t xxx_lock = SPIN_LOCK_UNLOCKED;
+into:
+	static DEFINE_SPINLOCK(xxx_lock);
+Static structure member variables go from:
+	struct foo bar {
+		.lock	=	SPIN_LOCK_UNLOCKED;
+	};
+to:
+	struct foo bar {
+		.lock	=	__SPIN_LOCK_UNLOCKED(bar.lock);
+	};
+Declaration of static rw_locks undergo a similar transformation.
 Dynamic initialization, when necessary, may be performed as
 demonstrated below.
    spinlock_t xxx_lock;
    rwlock_t xxx_rw_lock;
    static int __init xxx_init(void)
    {
    	spin_lock_init(&xxx_lock);
 	rwlock_init(&xxx_rw_lock);
 	...
    }
    module_init(xxx_init);
 The following discussion is still valid, however, with the dynamic
 initialization of spinlocks or with DEFINE_SPINLOCK, etc., used
 instead of SPIN_LOCK_UNLOCKED.
 -----------------------
 On Fri, 2 Jan 1998, Doug Ledford wrote:
 >
 > I'm working on making the aic7xxx driver more SMP friendly (as well as
 > importing the latest FreeBSD sequencer code to have 7895 support) and wanted
 > to get some info from you.  The goal here is to make the various routines
 > SMP safe as well as UP safe during interrupts and other manipulating
 > routines.  So far, I've added a spin_lock variable to things like my queue
 > structs.  Now, from what I recall, there are some spin lock functions I can
 > use to lock these spin locks from other use as opposed to a (nasty)
 > save_flags(); cli(); stuff; restore_flags(); construct.  Where do I find
 > these routines and go about making use of them?  Do they only lock on a
 > per-processor basis or can they also lock say an interrupt routine from
 > mucking with a queue if the queue routine was manipulating it when the
 > interrupt occurred, or should I still use a cli(); based construct on that
 > one?
 See <asm/spinlock.h>. The basic version is:
    spinlock_t xxx_lock = SPIN_LOCK_UNLOCKED;
 	unsigned long flags;
 	spin_lock_irqsave(&xxx_lock, flags);
 	... critical section here ..
 	spin_unlock_irqrestore(&xxx_lock, flags);
 and the above is always safe. It will disable interrupts _locally_, but the
 spinlock itself will guarantee the global lock, so it will guarantee that
 there is only one thread-of-control within the region(s) protected by that
 lock.
 Note that it works well even under UP - the above sequence under UP
 essentially is just the same as doing a
 	unsigned long flags;
 	save_flags(flags); cli();
 	 ... critical section ...
 	restore_flags(flags);
 so the code does _not_ need to worry about UP vs SMP issues: the spinlocks
 work correctly under both (and spinlocks are actually more efficient on
 architectures that allow doing the "save_flags + cli" in one go because I
 don't export that interface normally).
 NOTE NOTE NOTE! The reason the spinlock is so much faster than a global
 interrupt lock under SMP is exactly because it disables interrupts only on
 the local CPU. The spin-lock is safe only when you _also_ use the lock
 itself to do locking across CPU's, which implies that EVERYTHING that
 touches a shared variable has to agree about the spinlock they want to
 use.
 The above is usually pretty simple (you usually need and want only one
 spinlock for most things - using more than one spinlock can make things a
 lot more complex and even slower and is usually worth it only for
 sequences that you _know_ need to be split up: avoid it at all cost if you
 aren't sure). HOWEVER, it _does_ mean that if you have some code that does
 	cli();
 	.. critical section ..
 	sti();
 and another sequence that does
 	spin_lock_irqsave(flags);
 	.. critical section ..
 	spin_unlock_irqrestore(flags);
 then they are NOT mutually exclusive, and the critical regions can happen
 at the same time on two different CPU's. That's fine per se, but the
 critical regions had better be critical for different things (ie they
 can't stomp on each other).
 The above is a problem mainly if you end up mixing code - for example the
 routines in ll_rw_block() tend to use cli/sti to protect the atomicity of
 their actions, and if a driver uses spinlocks instead then you should
 think about issues like the above..
 This is really the only really hard part about spinlocks: once you start
 using spinlocks they tend to expand to areas you might not have noticed
 before, because you have to make sure the spinlocks correctly protect the
 shared data structures _everywhere_ they are used. The spinlocks are most
 easily added to places that are completely independent of other code (ie
 internal driver data structures that nobody else ever touches, for
 example).
 ----
 Lesson 2: reader-writer spinlocks.
 If your data accesses have a very natural pattern where you usually tend
 to mostly read from the shared variables, the reader-writer locks
 (rw_lock) versions of the spinlocks are often nicer. They allow multiple
 readers to be in the same critical region at once, but if somebody wants
 to change the variables it has to get an exclusive write lock. The
 routines look the same as above:
    rwlock_t xxx_lock = RW_LOCK_UNLOCKED;
 	unsigned long flags;
 	read_lock_irqsave(&xxx_lock, flags);
 	.. critical section that only reads the info ...
 	read_unlock_irqrestore(&xxx_lock, flags);
 	write_lock_irqsave(&xxx_lock, flags);
 	.. read and write exclusive access to the info ...
 	write_unlock_irqrestore(&xxx_lock, flags);
 The above kind of lock is useful for complex data structures like linked
 lists etc, especially when you know that most of the work is to just
 traverse the list searching for entries without changing the list itself,
 for example. Then you can use the read lock for that kind of list
 traversal, which allows many concurrent readers. Anything that _changes_
 the list will have to get the write lock.
 Note: you cannot "upgrade" a read-lock to a write-lock, so if you at _any_
 time need to do any changes (even if you don't do it every time), you have
 to get the write-lock at the very beginning. I could fairly easily add a
 primitive to create a "upgradeable" read-lock, but it hasn't been an issue
 yet. Tell me if you'd want one.
 ----
 Lesson 3: spinlocks revisited.
 The single spin-lock primitives above are by no means the only ones. They
 are the most safe ones, and the ones that work under all circumstances,
 but partly _because_ they are safe they are also fairly slow. They are
 much faster than a generic global cli/sti pair, but slower than they'd
 need to be, because they do have to disable interrupts (which is just a
 single instruction on a x86, but it's an expensive one - and on other
 architectures it can be worse).
 If you have a case where you have to protect a data structure across
 several CPU's and you want to use spinlocks you can potentially use
 cheaper versions of the spinlocks. IFF you know that the spinlocks are
 never used in interrupt handlers, you can use the non-irq versions:
 	spin_lock(&lock);
 	...
 	spin_unlock(&lock);
 (and the equivalent read-write versions too, of course). The spinlock will
 guarantee the same kind of exclusive access, and it will be much faster.
 This is useful if you know that the data in question is only ever
 manipulated from a "process context", ie no interrupts involved.
 The reasons you mustn't use these versions if you have interrupts that
 play with the spinlock is that you can get deadlocks:
 	spin_lock(&lock);
 	...
 		<- interrupt comes in:
 			spin_lock(&lock);
 where an interrupt tries to lock an already locked variable. This is ok if
 the other interrupt happens on another CPU, but it is _not_ ok if the
 interrupt happens on the same CPU that already holds the lock, because the
 lock will obviously never be released (because the interrupt is waiting
 for the lock, and the lock-holder is interrupted by the interrupt and will
 not continue until the interrupt has been processed).
 (This is also the reason why the irq-versions of the spinlocks only need
 to disable the _local_ interrupts - it's ok to use spinlocks in interrupts
 on other CPU's, because an interrupt on another CPU doesn't interrupt the
 CPU that holds the lock, so the lock-holder can continue and eventually
 releases the lock).
 Note that you can be clever with read-write locks and interrupts. For
 example, if you know that the interrupt only ever gets a read-lock, then
 you can use a non-irq version of read locks everywhere - because they
 don't block on each other (and thus there is no dead-lock wrt interrupts.
 But when you do the write-lock, you have to use the irq-safe version.
 For an example of being clever with rw-locks, see the "waitqueue_lock"
 handling in kernel/sched.c - nothing ever _changes_ a wait-queue from
 within an interrupt, they only read the queue in order to know whom to
 wake up. So read-locks are safe (which is good: they are very common
 indeed), while write-locks need to protect themselves against interrupts.
 		Linus

fs/Kconfig

Diff comments View file @ 14897e3

include/linux/spinlock.h

Diff comments View file @ 14897e3

 #ifndef __LINUX_SPINLOCK_H
 #define __LINUX_SPINLOCK_H
 /*
  * include/linux/spinlock.h - generic spinlock/rwlock declarations
  *
  * here's the role of the various spinlock/rwlock related include files:
  *
  * on SMP builds:
  *
  *  asm/spinlock_types.h: contains the raw_spinlock_t/raw_rwlock_t and the
  *                        initializers
  *
  *  linux/spinlock_types.h:
  *                        defines the generic type and initializers
  *
  *  asm/spinlock.h:       contains the __raw_spin_*()/etc. lowlevel
  *                        implementations, mostly inline assembly code
  *
  *   (also included on UP-debug builds:)
  *
  *  linux/spinlock_api_smp.h:
  *                        contains the prototypes for the _spin_*() APIs.
  *
  *  linux/spinlock.h:     builds the final spin_*() APIs.
  *
  * on UP builds:
  *
  *  linux/spinlock_type_up.h:
  *                        contains the generic, simplified UP spinlock type.
  *                        (which is an empty structure on non-debug builds)
  *
  *  linux/spinlock_types.h:
  *                        defines the generic type and initializers
  *
  *  linux/spinlock_up.h:
  *                        contains the __raw_spin_*()/etc. version of UP
  *                        builds. (which are NOPs on non-debug, non-preempt
  *                        builds)
  *
  *   (included on UP-non-debug builds:)
  *
  *  linux/spinlock_api_up.h:
  *                        builds the _spin_*() APIs.
  *
  *  linux/spinlock.h:     builds the final spin_*() APIs.
  */
 #include <linux/preempt.h>
 #include <linux/linkage.h>
 #include <linux/compiler.h>
 #include <linux/thread_info.h>
 #include <linux/kernel.h>
 #include <linux/stringify.h>
 #include <linux/bottom_half.h>
 #include <asm/system.h>
 /*
  * Must define these before including other files, inline functions need them
  */
 #define LOCK_SECTION_NAME ".text.lock."KBUILD_BASENAME
 #define LOCK_SECTION_START(extra)               \
         ".subsection 1\n\t"                     \
         extra                                   \
         ".ifndef " LOCK_SECTION_NAME "\n\t"     \
         LOCK_SECTION_NAME ":\n\t"               \
         ".endif\n"
 #define LOCK_SECTION_END                        \
         ".previous\n\t"
 #define __lockfunc __attribute__((section(".spinlock.text")))
 /*
  * Pull the raw_spinlock_t and raw_rwlock_t definitions:
  */
 #include <linux/spinlock_types.h>
 extern int __lockfunc generic__raw_read_trylock(raw_rwlock_t *lock);
 /*
  * Pull the __raw*() functions/declarations (UP-nondebug doesnt need them):
  */
 #ifdef CONFIG_SMP
 # include <asm/spinlock.h>
 #else
 # include <linux/spinlock_up.h>
 #endif
 #ifdef CONFIG_DEBUG_SPINLOCK
   extern void __spin_lock_init(spinlock_t *lock, const char *name,
 			       struct lock_class_key *key);
 # define spin_lock_init(lock)					\
 do {								\
 	static struct lock_class_key __key;			\
 								\
 	__spin_lock_init((lock), #lock, &__key);		\
 } while (0)
 #else
 # define spin_lock_init(lock)					\
 	do { *(lock) = SPIN_LOCK_UNLOCKED; } while (0)
 #endif
 #ifdef CONFIG_DEBUG_SPINLOCK
   extern void __rwlock_init(rwlock_t *lock, const char *name,
 			    struct lock_class_key *key);
 # define rwlock_init(lock)					\
 do {								\
 	static struct lock_class_key __key;			\
 								\
 	__rwlock_init((lock), #lock, &__key);			\
 } while (0)
 #else
 # define rwlock_init(lock)					\
 	do { *(lock) = RW_LOCK_UNLOCKED; } while (0)
 #endif
 #define spin_is_locked(lock)	__raw_spin_is_locked(&(lock)->raw_lock)
 #ifdef CONFIG_GENERIC_LOCKBREAK
 #define spin_is_contended(lock) ((lock)->break_lock)
 #else
 #define spin_is_contended(lock)	__raw_spin_is_contended(&(lock)->raw_lock)
 #endif
 /**
  * spin_unlock_wait - wait until the spinlock gets unlocked
  * @lock: the spinlock in question.
  */
 #define spin_unlock_wait(lock)	__raw_spin_unlock_wait(&(lock)->raw_lock)
 /*
  * Pull the _spin_*()/_read_*()/_write_*() functions/declarations:
  */
 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
 # include <linux/spinlock_api_smp.h>
 #else
 # include <linux/spinlock_api_up.h>
 #endif
 #ifdef CONFIG_DEBUG_SPINLOCK
  extern void _raw_spin_lock(spinlock_t *lock);
 #define _raw_spin_lock_flags(lock, flags) _raw_spin_lock(lock)
  extern int _raw_spin_trylock(spinlock_t *lock);
  extern void _raw_spin_unlock(spinlock_t *lock);
  extern void _raw_read_lock(rwlock_t *lock);
  extern int _raw_read_trylock(rwlock_t *lock);
  extern void _raw_read_unlock(rwlock_t *lock);
  extern void _raw_write_lock(rwlock_t *lock);
  extern int _raw_write_trylock(rwlock_t *lock);
  extern void _raw_write_unlock(rwlock_t *lock);
 #else
 # define _raw_spin_lock(lock)		__raw_spin_lock(&(lock)->raw_lock)
 # define _raw_spin_lock_flags(lock, flags) \
 		__raw_spin_lock_flags(&(lock)->raw_lock, *(flags))
 # define _raw_spin_trylock(lock)	__raw_spin_trylock(&(lock)->raw_lock)
 # define _raw_spin_unlock(lock)		__raw_spin_unlock(&(lock)->raw_lock)
 # define _raw_read_lock(rwlock)		__raw_read_lock(&(rwlock)->raw_lock)
 # define _raw_read_trylock(rwlock)	__raw_read_trylock(&(rwlock)->raw_lock)
 # define _raw_read_unlock(rwlock)	__raw_read_unlock(&(rwlock)->raw_lock)
 # define _raw_write_lock(rwlock)	__raw_write_lock(&(rwlock)->raw_lock)
 # define _raw_write_trylock(rwlock)	__raw_write_trylock(&(rwlock)->raw_lock)
 # define _raw_write_unlock(rwlock)	__raw_write_unlock(&(rwlock)->raw_lock)
 #endif
 #define read_can_lock(rwlock)		__raw_read_can_lock(&(rwlock)->raw_lock)
 #define write_can_lock(rwlock)		__raw_write_can_lock(&(rwlock)->raw_lock)
 /*
  * Define the various spin_lock and rw_lock methods.  Note we define these
  * regardless of whether CONFIG_SMP or CONFIG_PREEMPT are set. The various
  * methods are defined as nops in the case they are not required.
  */
 #define spin_trylock(lock)		__cond_lock(lock, _spin_trylock(lock))
 #define read_trylock(lock)		__cond_lock(lock, _read_trylock(lock))
 #define write_trylock(lock)		__cond_lock(lock, _write_trylock(lock))
 #define spin_lock(lock)			_spin_lock(lock)
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 # define spin_lock_nested(lock, subclass) _spin_lock_nested(lock, subclass)
 #else
 # define spin_lock_nested(lock, subclass) _spin_lock(lock)
 #endif
 #define write_lock(lock)		_write_lock(lock)
 #define read_lock(lock)			_read_lock(lock)
 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
 #define spin_lock_irqsave(lock, flags)	flags = _spin_lock_irqsave(lock)
 #define read_lock_irqsave(lock, flags)	flags = _read_lock_irqsave(lock)
 #define write_lock_irqsave(lock, flags)	flags = _write_lock_irqsave(lock)
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 #define spin_lock_irqsave_nested(lock, flags, subclass) \
 	flags = _spin_lock_irqsave_nested(lock, subclass)
 #else
 #define spin_lock_irqsave_nested(lock, flags, subclass) \
 	flags = _spin_lock_irqsave(lock)
 #endif
 #else
 #define spin_lock_irqsave(lock, flags)	_spin_lock_irqsave(lock, flags)
 #define read_lock_irqsave(lock, flags)	_read_lock_irqsave(lock, flags)
 #define write_lock_irqsave(lock, flags)	_write_lock_irqsave(lock, flags)
 #define spin_lock_irqsave_nested(lock, flags, subclass)	\
 	spin_lock_irqsave(lock, flags)
 #endif
 #define spin_lock_irq(lock)		_spin_lock_irq(lock)
 #define spin_lock_bh(lock)		_spin_lock_bh(lock)
 #define read_lock_irq(lock)		_read_lock_irq(lock)
 #define read_lock_bh(lock)		_read_lock_bh(lock)
 #define write_lock_irq(lock)		_write_lock_irq(lock)
 #define write_lock_bh(lock)		_write_lock_bh(lock)
 /*
  * We inline the unlock functions in the nondebug case:
  */
 #if defined(CONFIG_DEBUG_SPINLOCK) || defined(CONFIG_PREEMPT) || \
 	!defined(CONFIG_SMP)
 # define spin_unlock(lock)		_spin_unlock(lock)
 # define read_unlock(lock)		_read_unlock(lock)
 # define write_unlock(lock)		_write_unlock(lock)
 # define spin_unlock_irq(lock)		_spin_unlock_irq(lock)
 # define read_unlock_irq(lock)		_read_unlock_irq(lock)
 # define write_unlock_irq(lock)		_write_unlock_irq(lock)
 #else
 # define spin_unlock(lock) \
     do {__raw_spin_unlock(&(lock)->raw_lock); __release(lock); } while (0)
 # define read_unlock(lock) \
     do {__raw_read_unlock(&(lock)->raw_lock); __release(lock); } while (0)
 # define write_unlock(lock) \
     do {__raw_write_unlock(&(lock)->raw_lock); __release(lock); } while (0)
 # define spin_unlock_irq(lock)			\
 do {						\
 	__raw_spin_unlock(&(lock)->raw_lock);	\
 	__release(lock);			\
 	local_irq_enable();			\
 } while (0)
 # define read_unlock_irq(lock)			\
 do {						\
 	__raw_read_unlock(&(lock)->raw_lock);	\
 	__release(lock);			\
 	local_irq_enable();			\
 } while (0)
 # define write_unlock_irq(lock)			\
 do {						\
 	__raw_write_unlock(&(lock)->raw_lock);	\
 	__release(lock);			\
 	local_irq_enable();			\
 } while (0)
 #endif
 #define spin_unlock_irqrestore(lock, flags) \
 					_spin_unlock_irqrestore(lock, flags)
 #define spin_unlock_bh(lock)		_spin_unlock_bh(lock)
 #define read_unlock_irqrestore(lock, flags) \
 					_read_unlock_irqrestore(lock, flags)
 #define read_unlock_bh(lock)		_read_unlock_bh(lock)
 #define write_unlock_irqrestore(lock, flags) \
 					_write_unlock_irqrestore(lock, flags)
 #define write_unlock_bh(lock)		_write_unlock_bh(lock)
 #define spin_trylock_bh(lock)	__cond_lock(lock, _spin_trylock_bh(lock))
 #define spin_trylock_irq(lock) \
 ({ \
 	local_irq_disable(); \
 	spin_trylock(lock) ? \
 	1 : ({ local_irq_enable(); 0;  }); \
 })
 #define spin_trylock_irqsave(lock, flags) \
 ({ \
 	local_irq_save(flags); \
 	spin_trylock(lock) ? \
 	1 : ({ local_irq_restore(flags); 0; }); \
 })
 #define write_trylock_irqsave(lock, flags) \
 ({ \
 	local_irq_save(flags); \
 	write_trylock(lock) ? \
 	1 : ({ local_irq_restore(flags); 0; }); \
 })
 /*
  * Locks two spinlocks l1 and l2.
  * l1_first indicates if spinlock l1 should be taken first.
  */
 static inline void double_spin_lock(spinlock_t *l1, spinlock_t *l2,
 				    bool l1_first)
 	__acquires(l1)
 	__acquires(l2)
 {
 	if (l1_first) {
 		spin_lock(l1);
 		spin_lock(l2);
 	} else {
 		spin_lock(l2);
 		spin_lock(l1);
 	}
 }
 /*
  * Unlocks two spinlocks l1 and l2.
  * l1_taken_first indicates if spinlock l1 was taken first and therefore
  * should be released after spinlock l2.
  */
 static inline void double_spin_unlock(spinlock_t *l1, spinlock_t *l2,
 				      bool l1_taken_first)
 	__releases(l1)
 	__releases(l2)
 {
 	if (l1_taken_first) {
 		spin_unlock(l2);
 		spin_unlock(l1);
 	} else {
 		spin_unlock(l1);
 		spin_unlock(l2);
 	}
 }
 /*
  * Pull the atomic_t declaration:
  * (asm-mips/atomic.h needs above definitions)
  */
 #include <asm/atomic.h>
 /**
  * atomic_dec_and_lock - lock on reaching reference count zero
  * @atomic: the atomic counter
  * @lock: the spinlock in question
+ *
+ * Decrements @atomic by 1.  If the result is 0, returns true and locks
+ * @lock.  Returns false for all other cases.
  */
 extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
 #define atomic_dec_and_lock(atomic, lock) \
 		__cond_lock(lock, _atomic_dec_and_lock(atomic, lock))
 /**
  * spin_can_lock - would spin_trylock() succeed?
  * @lock: the spinlock in question.
  */
 #define spin_can_lock(lock)	(!spin_is_locked(lock))
 #endif /* __LINUX_SPINLOCK_H */

net/ipv4/Kconfig

Diff comments View file @ 14897e3

1	#	1	#
2	# IP configuration	2	# IP configuration
3	#	3	#
4	config IP_MULTICAST	4	config IP_MULTICAST
5	bool "IP: multicasting"	5	bool "IP: multicasting"
6	help	6	help
7	This is code for addressing several networked computers at once,	7	This is code for addressing several networked computers at once,
8	enlarging your kernel by about 2 KB. You need multicasting if you	8	enlarging your kernel by about 2 KB. You need multicasting if you
9	intend to participate in the MBONE, a high bandwidth network on top	9	intend to participate in the MBONE, a high bandwidth network on top
10	of the Internet which carries audio and video broadcasts. More	10	of the Internet which carries audio and video broadcasts. More
11	information about the MBONE is on the WWW at	11	information about the MBONE is on the WWW at
12	<http://www.savetz.com/mbone/>. Information about the multicast	12	<http://www.savetz.com/mbone/>. Information about the multicast
13	capabilities of the various network cards is contained in	13	capabilities of the various network cards is contained in
14	<file:Documentation/networking/multicast.txt>. For most people, it's	14	<file:Documentation/networking/multicast.txt>. For most people, it's
15	safe to say N.	15	safe to say N.
16		16
17	config IP_ADVANCED_ROUTER	17	config IP_ADVANCED_ROUTER
18	bool "IP: advanced router"	18	bool "IP: advanced router"
19	---help---	19	---help---
20	If you intend to run your Linux box mostly as a router, i.e. as a	20	If you intend to run your Linux box mostly as a router, i.e. as a
21	computer that forwards and redistributes network packets, say Y; you	21	computer that forwards and redistributes network packets, say Y; you
22	will then be presented with several options that allow more precise	22	will then be presented with several options that allow more precise
23	control about the routing process.	23	control about the routing process.
24		24
25	The answer to this question won't directly affect the kernel:	25	The answer to this question won't directly affect the kernel:
26	answering N will just cause the configurator to skip all the	26	answering N will just cause the configurator to skip all the
27	questions about advanced routing.	27	questions about advanced routing.
28		28
29	Note that your box can only act as a router if you enable IP	29	Note that your box can only act as a router if you enable IP
30	forwarding in your kernel; you can do that by saying Y to "/proc	30	forwarding in your kernel; you can do that by saying Y to "/proc
31	file system support" and "Sysctl support" below and executing the	31	file system support" and "Sysctl support" below and executing the
32	line	32	line
33		33
34	echo "1" > /proc/sys/net/ipv4/ip_forward	34	echo "1" > /proc/sys/net/ipv4/ip_forward
35		35
36	at boot time after the /proc file system has been mounted.	36	at boot time after the /proc file system has been mounted.
37		37
38	If you turn on IP forwarding, you will also get the rp_filter, which	38	If you turn on IP forwarding, you will also get the rp_filter, which
39	automatically rejects incoming packets if the routing table entry	39	automatically rejects incoming packets if the routing table entry
40	for their source address doesn't match the network interface they're	40	for their source address doesn't match the network interface they're
41	arriving on. This has security advantages because it prevents the	41	arriving on. This has security advantages because it prevents the
42	so-called IP spoofing, however it can pose problems if you use	42	so-called IP spoofing, however it can pose problems if you use
43	asymmetric routing (packets from you to a host take a different path	43	asymmetric routing (packets from you to a host take a different path
44	than packets from that host to you) or if you operate a non-routing	44	than packets from that host to you) or if you operate a non-routing
45	host which has several IP addresses on different interfaces. To turn	45	host which has several IP addresses on different interfaces. To turn
46	rp_filter on use:	46	rp_filter on use:
47		47
48	echo 1 > /proc/sys/net/ipv4/conf/<device>/rp_filter	48	echo 1 > /proc/sys/net/ipv4/conf/<device>/rp_filter
49	or	49	or
50	echo 1 > /proc/sys/net/ipv4/conf/all/rp_filter	50	echo 1 > /proc/sys/net/ipv4/conf/all/rp_filter
51		51
52	If unsure, say N here.	52	If unsure, say N here.
53		53
54	choice	54	choice
55	prompt "Choose IP: FIB lookup algorithm (choose FIB_HASH if unsure)"	55	prompt "Choose IP: FIB lookup algorithm (choose FIB_HASH if unsure)"
56	depends on IP_ADVANCED_ROUTER	56	depends on IP_ADVANCED_ROUTER
57	default ASK_IP_FIB_HASH	57	default ASK_IP_FIB_HASH
58		58
59	config ASK_IP_FIB_HASH	59	config ASK_IP_FIB_HASH
60	bool "FIB_HASH"	60	bool "FIB_HASH"
61	---help---	61	---help---
62	Current FIB is very proven and good enough for most users.	62	Current FIB is very proven and good enough for most users.
63		63
64	config IP_FIB_TRIE	64	config IP_FIB_TRIE
65	bool "FIB_TRIE"	65	bool "FIB_TRIE"
66	---help---	66	---help---
67	Use new experimental LC-trie as FIB lookup algorithm.	67	Use new experimental LC-trie as FIB lookup algorithm.
68	This improves lookup performance if you have a large	68	This improves lookup performance if you have a large
69	number of routes.	69	number of routes.
70		70
71	LC-trie is a longest matching prefix lookup algorithm which	71	LC-trie is a longest matching prefix lookup algorithm which
72	performs better than FIB_HASH for large routing tables.	72	performs better than FIB_HASH for large routing tables.
73	But, it consumes more memory and is more complex.	73	But, it consumes more memory and is more complex.
74		74
75	LC-trie is described in:	75	LC-trie is described in:
76		76
77	IP-address lookup using LC-tries. Stefan Nilsson and Gunnar Karlsson	77	IP-address lookup using LC-tries. Stefan Nilsson and Gunnar Karlsson
78	IEEE Journal on Selected Areas in Communications, 17(6):1083-1092, June 1999	78	IEEE Journal on Selected Areas in Communications, 17(6):1083-1092, June 1999
79	An experimental study of compression methods for dynamic tries	79	An experimental study of compression methods for dynamic tries
80	Stefan Nilsson and Matti Tikkanen. Algorithmica, 33(1):19-33, 2002.	80	Stefan Nilsson and Matti Tikkanen. Algorithmica, 33(1):19-33, 2002.
81	http://www.nada.kth.se/~snilsson/public/papers/dyntrie2/	81	http://www.nada.kth.se/~snilsson/public/papers/dyntrie2/
82		82
83	endchoice	83	endchoice
84		84
85	config IP_FIB_HASH	85	config IP_FIB_HASH
86	def_bool ASK_IP_FIB_HASH \|\| !IP_ADVANCED_ROUTER	86	def_bool ASK_IP_FIB_HASH \|\| !IP_ADVANCED_ROUTER
87		87
88	config IP_FIB_TRIE_STATS	88	config IP_FIB_TRIE_STATS
89	bool "FIB TRIE statistics"	89	bool "FIB TRIE statistics"
90	depends on IP_FIB_TRIE	90	depends on IP_FIB_TRIE
91	---help---	91	---help---
92	Keep track of statistics on structure of FIB TRIE table.	92	Keep track of statistics on structure of FIB TRIE table.
93	Useful for testing and measuring TRIE performance.	93	Useful for testing and measuring TRIE performance.
94		94
95	config IP_MULTIPLE_TABLES	95	config IP_MULTIPLE_TABLES
96	bool "IP: policy routing"	96	bool "IP: policy routing"
97	depends on IP_ADVANCED_ROUTER	97	depends on IP_ADVANCED_ROUTER
98	select FIB_RULES	98	select FIB_RULES
99	---help---	99	---help---
100	Normally, a router decides what to do with a received packet based	100	Normally, a router decides what to do with a received packet based
101	solely on the packet's final destination address. If you say Y here,	101	solely on the packet's final destination address. If you say Y here,
102	the Linux router will also be able to take the packet's source	102	the Linux router will also be able to take the packet's source
103	address into account. Furthermore, the TOS (Type-Of-Service) field	103	address into account. Furthermore, the TOS (Type-Of-Service) field
104	of the packet can be used for routing decisions as well.	104	of the packet can be used for routing decisions as well.
105		105
106	If you are interested in this, please see the preliminary	106	If you are interested in this, please see the preliminary
107	documentation at <http://www.compendium.com.ar/policy-routing.txt>	107	documentation at <http://www.compendium.com.ar/policy-routing.txt>
108	and <ftp://post.tepkom.ru/pub/vol2/Linux/docs/advanced-routing.tex>.	108	and <ftp://post.tepkom.ru/pub/vol2/Linux/docs/advanced-routing.tex>.
109	You will need supporting software from	109	You will need supporting software from
110	<ftp://ftp.tux.org/pub/net/ip-routing/>.	110	<ftp://ftp.tux.org/pub/net/ip-routing/>.
111		111
112	If unsure, say N.	112	If unsure, say N.
113		113
114	config IP_ROUTE_MULTIPATH	114	config IP_ROUTE_MULTIPATH
115	bool "IP: equal cost multipath"	115	bool "IP: equal cost multipath"
116	depends on IP_ADVANCED_ROUTER	116	depends on IP_ADVANCED_ROUTER
117	help	117	help
118	Normally, the routing tables specify a single action to be taken in	118	Normally, the routing tables specify a single action to be taken in
119	a deterministic manner for a given packet. If you say Y here	119	a deterministic manner for a given packet. If you say Y here
120	however, it becomes possible to attach several actions to a packet	120	however, it becomes possible to attach several actions to a packet
121	pattern, in effect specifying several alternative paths to travel	121	pattern, in effect specifying several alternative paths to travel
122	for those packets. The router considers all these paths to be of	122	for those packets. The router considers all these paths to be of
123	equal "cost" and chooses one of them in a non-deterministic fashion	123	equal "cost" and chooses one of them in a non-deterministic fashion
124	if a matching packet arrives.	124	if a matching packet arrives.
125		125
126	config IP_ROUTE_VERBOSE	126	config IP_ROUTE_VERBOSE
127	bool "IP: verbose route monitoring"	127	bool "IP: verbose route monitoring"
128	depends on IP_ADVANCED_ROUTER	128	depends on IP_ADVANCED_ROUTER
129	help	129	help
130	If you say Y here, which is recommended, then the kernel will print	130	If you say Y here, which is recommended, then the kernel will print
131	verbose messages regarding the routing, for example warnings about	131	verbose messages regarding the routing, for example warnings about
132	received packets which look strange and could be evidence of an	132	received packets which look strange and could be evidence of an
133	attack or a misconfigured system somewhere. The information is	133	attack or a misconfigured system somewhere. The information is
134	handled by the klogd daemon which is responsible for kernel messages	134	handled by the klogd daemon which is responsible for kernel messages
135	("man klogd").	135	("man klogd").
136		136
137	config IP_PNP	137	config IP_PNP
138	bool "IP: kernel level autoconfiguration"	138	bool "IP: kernel level autoconfiguration"
139	help	139	help
140	This enables automatic configuration of IP addresses of devices and	140	This enables automatic configuration of IP addresses of devices and
141	of the routing table during kernel boot, based on either information	141	of the routing table during kernel boot, based on either information
142	supplied on the kernel command line or by BOOTP or RARP protocols.	142	supplied on the kernel command line or by BOOTP or RARP protocols.
143	You need to say Y only for diskless machines requiring network	143	You need to say Y only for diskless machines requiring network
144	access to boot (in which case you want to say Y to "Root file system	144	access to boot (in which case you want to say Y to "Root file system
145	on NFS" as well), because all other machines configure the network	145	on NFS" as well), because all other machines configure the network
146	in their startup scripts.	146	in their startup scripts.
147		147
148	config IP_PNP_DHCP	148	config IP_PNP_DHCP
149	bool "IP: DHCP support"	149	bool "IP: DHCP support"
150	depends on IP_PNP	150	depends on IP_PNP
151	---help---	151	---help---
152	If you want your Linux box to mount its whole root file system (the	152	If you want your Linux box to mount its whole root file system (the
153	one containing the directory /) from some other computer over the	153	one containing the directory /) from some other computer over the
154	net via NFS and you want the IP address of your computer to be	154	net via NFS and you want the IP address of your computer to be
155	discovered automatically at boot time using the DHCP protocol (a	155	discovered automatically at boot time using the DHCP protocol (a
156	special protocol designed for doing this job), say Y here. In case	156	special protocol designed for doing this job), say Y here. In case
157	the boot ROM of your network card was designed for booting Linux and	157	the boot ROM of your network card was designed for booting Linux and
158	does DHCP itself, providing all necessary information on the kernel	158	does DHCP itself, providing all necessary information on the kernel
159	command line, you can say N here.	159	command line, you can say N here.
160		160
161	If unsure, say Y. Note that if you want to use DHCP, a DHCP server	161	If unsure, say Y. Note that if you want to use DHCP, a DHCP server
162	must be operating on your network. Read	162	must be operating on your network. Read
163	<file:Documentation/nfsroot.txt> for details.	163	<file:Documentation/filesystems/nfsroot.txt> for details.
164		164
165	config IP_PNP_BOOTP	165	config IP_PNP_BOOTP
166	bool "IP: BOOTP support"	166	bool "IP: BOOTP support"
167	depends on IP_PNP	167	depends on IP_PNP
168	---help---	168	---help---
169	If you want your Linux box to mount its whole root file system (the	169	If you want your Linux box to mount its whole root file system (the
170	one containing the directory /) from some other computer over the	170	one containing the directory /) from some other computer over the
171	net via NFS and you want the IP address of your computer to be	171	net via NFS and you want the IP address of your computer to be
172	discovered automatically at boot time using the BOOTP protocol (a	172	discovered automatically at boot time using the BOOTP protocol (a
173	special protocol designed for doing this job), say Y here. In case	173	special protocol designed for doing this job), say Y here. In case
174	the boot ROM of your network card was designed for booting Linux and	174	the boot ROM of your network card was designed for booting Linux and
175	does BOOTP itself, providing all necessary information on the kernel	175	does BOOTP itself, providing all necessary information on the kernel
176	command line, you can say N here. If unsure, say Y. Note that if you	176	command line, you can say N here. If unsure, say Y. Note that if you
177	want to use BOOTP, a BOOTP server must be operating on your network.	177	want to use BOOTP, a BOOTP server must be operating on your network.
178	Read <file:Documentation/nfsroot.txt> for details.	178	Read <file:Documentation/filesystems/nfsroot.txt> for details.
179		179
180	config IP_PNP_RARP	180	config IP_PNP_RARP
181	bool "IP: RARP support"	181	bool "IP: RARP support"
182	depends on IP_PNP	182	depends on IP_PNP
183	help	183	help
184	If you want your Linux box to mount its whole root file system (the	184	If you want your Linux box to mount its whole root file system (the
185	one containing the directory /) from some other computer over the	185	one containing the directory /) from some other computer over the
186	net via NFS and you want the IP address of your computer to be	186	net via NFS and you want the IP address of your computer to be
187	discovered automatically at boot time using the RARP protocol (an	187	discovered automatically at boot time using the RARP protocol (an
188	older protocol which is being obsoleted by BOOTP and DHCP), say Y	188	older protocol which is being obsoleted by BOOTP and DHCP), say Y
189	here. Note that if you want to use RARP, a RARP server must be	189	here. Note that if you want to use RARP, a RARP server must be
190	operating on your network. Read <file:Documentation/nfsroot.txt> for	190	operating on your network. Read
191	details.	191	<file:Documentation/filesystems/nfsroot.txt> for details.
192		192
193	# not yet ready..	193	# not yet ready..
194	# bool ' IP: ARP support' CONFIG_IP_PNP_ARP	194	# bool ' IP: ARP support' CONFIG_IP_PNP_ARP
195	config NET_IPIP	195	config NET_IPIP
196	tristate "IP: tunneling"	196	tristate "IP: tunneling"
197	select INET_TUNNEL	197	select INET_TUNNEL
198	---help---	198	---help---
199	Tunneling means encapsulating data of one protocol type within	199	Tunneling means encapsulating data of one protocol type within
200	another protocol and sending it over a channel that understands the	200	another protocol and sending it over a channel that understands the
201	encapsulating protocol. This particular tunneling driver implements	201	encapsulating protocol. This particular tunneling driver implements
202	encapsulation of IP within IP, which sounds kind of pointless, but	202	encapsulation of IP within IP, which sounds kind of pointless, but
203	can be useful if you want to make your (or some other) machine	203	can be useful if you want to make your (or some other) machine
204	appear on a different network than it physically is, or to use	204	appear on a different network than it physically is, or to use
205	mobile-IP facilities (allowing laptops to seamlessly move between	205	mobile-IP facilities (allowing laptops to seamlessly move between
206	networks without changing their IP addresses).	206	networks without changing their IP addresses).
207		207
208	Saying Y to this option will produce two modules ( = code which can	208	Saying Y to this option will produce two modules ( = code which can
209	be inserted in and removed from the running kernel whenever you	209	be inserted in and removed from the running kernel whenever you
210	want). Most people won't need this and can say N.	210	want). Most people won't need this and can say N.
211		211
212	config NET_IPGRE	212	config NET_IPGRE
213	tristate "IP: GRE tunnels over IP"	213	tristate "IP: GRE tunnels over IP"
214	help	214	help
215	Tunneling means encapsulating data of one protocol type within	215	Tunneling means encapsulating data of one protocol type within
216	another protocol and sending it over a channel that understands the	216	another protocol and sending it over a channel that understands the
217	encapsulating protocol. This particular tunneling driver implements	217	encapsulating protocol. This particular tunneling driver implements
218	GRE (Generic Routing Encapsulation) and at this time allows	218	GRE (Generic Routing Encapsulation) and at this time allows
219	encapsulating of IPv4 or IPv6 over existing IPv4 infrastructure.	219	encapsulating of IPv4 or IPv6 over existing IPv4 infrastructure.
220	This driver is useful if the other endpoint is a Cisco router: Cisco	220	This driver is useful if the other endpoint is a Cisco router: Cisco
221	likes GRE much better than the other Linux tunneling driver ("IP	221	likes GRE much better than the other Linux tunneling driver ("IP
222	tunneling" above). In addition, GRE allows multicast redistribution	222	tunneling" above). In addition, GRE allows multicast redistribution
223	through the tunnel.	223	through the tunnel.
224		224
225	config NET_IPGRE_BROADCAST	225	config NET_IPGRE_BROADCAST
226	bool "IP: broadcast GRE over IP"	226	bool "IP: broadcast GRE over IP"
227	depends on IP_MULTICAST && NET_IPGRE	227	depends on IP_MULTICAST && NET_IPGRE
228	help	228	help
229	One application of GRE/IP is to construct a broadcast WAN (Wide Area	229	One application of GRE/IP is to construct a broadcast WAN (Wide Area
230	Network), which looks like a normal Ethernet LAN (Local Area	230	Network), which looks like a normal Ethernet LAN (Local Area
231	Network), but can be distributed all over the Internet. If you want	231	Network), but can be distributed all over the Internet. If you want
232	to do that, say Y here and to "IP multicast routing" below.	232	to do that, say Y here and to "IP multicast routing" below.
233		233
234	config IP_MROUTE	234	config IP_MROUTE
235	bool "IP: multicast routing"	235	bool "IP: multicast routing"
236	depends on IP_MULTICAST	236	depends on IP_MULTICAST
237	help	237	help
238	This is used if you want your machine to act as a router for IP	238	This is used if you want your machine to act as a router for IP
239	packets that have several destination addresses. It is needed on the	239	packets that have several destination addresses. It is needed on the
240	MBONE, a high bandwidth network on top of the Internet which carries	240	MBONE, a high bandwidth network on top of the Internet which carries
241	audio and video broadcasts. In order to do that, you would most	241	audio and video broadcasts. In order to do that, you would most
242	likely run the program mrouted. Information about the multicast	242	likely run the program mrouted. Information about the multicast
243	capabilities of the various network cards is contained in	243	capabilities of the various network cards is contained in
244	<file:Documentation/networking/multicast.txt>. If you haven't heard	244	<file:Documentation/networking/multicast.txt>. If you haven't heard
245	about it, you don't need it.	245	about it, you don't need it.
246		246
247	config IP_PIMSM_V1	247	config IP_PIMSM_V1
248	bool "IP: PIM-SM version 1 support"	248	bool "IP: PIM-SM version 1 support"
249	depends on IP_MROUTE	249	depends on IP_MROUTE
250	help	250	help
251	Kernel side support for Sparse Mode PIM (Protocol Independent	251	Kernel side support for Sparse Mode PIM (Protocol Independent
252	Multicast) version 1. This multicast routing protocol is used widely	252	Multicast) version 1. This multicast routing protocol is used widely
253	because Cisco supports it. You need special software to use it	253	because Cisco supports it. You need special software to use it
254	(pimd-v1). Please see <http://netweb.usc.edu/pim/> for more	254	(pimd-v1). Please see <http://netweb.usc.edu/pim/> for more
255	information about PIM.	255	information about PIM.
256		256
257	Say Y if you want to use PIM-SM v1. Note that you can say N here if	257	Say Y if you want to use PIM-SM v1. Note that you can say N here if
258	you just want to use Dense Mode PIM.	258	you just want to use Dense Mode PIM.
259		259
260	config IP_PIMSM_V2	260	config IP_PIMSM_V2
261	bool "IP: PIM-SM version 2 support"	261	bool "IP: PIM-SM version 2 support"
262	depends on IP_MROUTE	262	depends on IP_MROUTE
263	help	263	help
264	Kernel side support for Sparse Mode PIM version 2. In order to use	264	Kernel side support for Sparse Mode PIM version 2. In order to use
265	this, you need an experimental routing daemon supporting it (pimd or	265	this, you need an experimental routing daemon supporting it (pimd or
266	gated-5). This routing protocol is not used widely, so say N unless	266	gated-5). This routing protocol is not used widely, so say N unless
267	you want to play with it.	267	you want to play with it.
268		268
269	config ARPD	269	config ARPD
270	bool "IP: ARP daemon support (EXPERIMENTAL)"	270	bool "IP: ARP daemon support (EXPERIMENTAL)"
271	depends on EXPERIMENTAL	271	depends on EXPERIMENTAL
272	---help---	272	---help---
273	Normally, the kernel maintains an internal cache which maps IP	273	Normally, the kernel maintains an internal cache which maps IP
274	addresses to hardware addresses on the local network, so that	274	addresses to hardware addresses on the local network, so that
275	Ethernet/Token Ring/ etc. frames are sent to the proper address on	275	Ethernet/Token Ring/ etc. frames are sent to the proper address on
276	the physical networking layer. For small networks having a few	276	the physical networking layer. For small networks having a few
277	hundred directly connected hosts or less, keeping this address	277	hundred directly connected hosts or less, keeping this address
278	resolution (ARP) cache inside the kernel works well. However,	278	resolution (ARP) cache inside the kernel works well. However,
279	maintaining an internal ARP cache does not work well for very large	279	maintaining an internal ARP cache does not work well for very large
280	switched networks, and will use a lot of kernel memory if TCP/IP	280	switched networks, and will use a lot of kernel memory if TCP/IP
281	connections are made to many machines on the network.	281	connections are made to many machines on the network.
282		282
283	If you say Y here, the kernel's internal ARP cache will never grow	283	If you say Y here, the kernel's internal ARP cache will never grow
284	to more than 256 entries (the oldest entries are expired in a LIFO	284	to more than 256 entries (the oldest entries are expired in a LIFO
285	manner) and communication will be attempted with the user space ARP	285	manner) and communication will be attempted with the user space ARP
286	daemon arpd. Arpd then answers the address resolution request either	286	daemon arpd. Arpd then answers the address resolution request either
287	from its own cache or by asking the net.	287	from its own cache or by asking the net.
288		288
289	This code is experimental and also obsolete. If you want to use it,	289	This code is experimental and also obsolete. If you want to use it,
290	you need to find a version of the daemon arpd on the net somewhere,	290	you need to find a version of the daemon arpd on the net somewhere,
291	and you should also say Y to "Kernel/User network link driver",	291	and you should also say Y to "Kernel/User network link driver",
292	below. If unsure, say N.	292	below. If unsure, say N.
293		293
294	config SYN_COOKIES	294	config SYN_COOKIES
295	bool "IP: TCP syncookie support (disabled per default)"	295	bool "IP: TCP syncookie support (disabled per default)"
296	---help---	296	---help---
297	Normal TCP/IP networking is open to an attack known as "SYN	297	Normal TCP/IP networking is open to an attack known as "SYN
298	flooding". This denial-of-service attack prevents legitimate remote	298	flooding". This denial-of-service attack prevents legitimate remote
299	users from being able to connect to your computer during an ongoing	299	users from being able to connect to your computer during an ongoing
300	attack and requires very little work from the attacker, who can	300	attack and requires very little work from the attacker, who can
301	operate from anywhere on the Internet.	301	operate from anywhere on the Internet.
302		302
303	SYN cookies provide protection against this type of attack. If you	303	SYN cookies provide protection against this type of attack. If you
304	say Y here, the TCP/IP stack will use a cryptographic challenge	304	say Y here, the TCP/IP stack will use a cryptographic challenge
305	protocol known as "SYN cookies" to enable legitimate users to	305	protocol known as "SYN cookies" to enable legitimate users to
306	continue to connect, even when your machine is under attack. There	306	continue to connect, even when your machine is under attack. There
307	is no need for the legitimate users to change their TCP/IP software;	307	is no need for the legitimate users to change their TCP/IP software;
308	SYN cookies work transparently to them. For technical information	308	SYN cookies work transparently to them. For technical information
309	about SYN cookies, check out <http://cr.yp.to/syncookies.html>.	309	about SYN cookies, check out <http://cr.yp.to/syncookies.html>.
310		310
311	If you are SYN flooded, the source address reported by the kernel is	311	If you are SYN flooded, the source address reported by the kernel is
312	likely to have been forged by the attacker; it is only reported as	312	likely to have been forged by the attacker; it is only reported as
313	an aid in tracing the packets to their actual source and should not	313	an aid in tracing the packets to their actual source and should not
314	be taken as absolute truth.	314	be taken as absolute truth.
315		315
316	SYN cookies may prevent correct error reporting on clients when the	316	SYN cookies may prevent correct error reporting on clients when the
317	server is really overloaded. If this happens frequently better turn	317	server is really overloaded. If this happens frequently better turn
318	them off.	318	them off.
319		319
320	If you say Y here, note that SYN cookies aren't enabled by default;	320	If you say Y here, note that SYN cookies aren't enabled by default;
321	you can enable them by saying Y to "/proc file system support" and	321	you can enable them by saying Y to "/proc file system support" and
322	"Sysctl support" below and executing the command	322	"Sysctl support" below and executing the command
323		323
324	echo 1 >/proc/sys/net/ipv4/tcp_syncookies	324	echo 1 >/proc/sys/net/ipv4/tcp_syncookies
325		325
326	at boot time after the /proc file system has been mounted.	326	at boot time after the /proc file system has been mounted.
327		327
328	If unsure, say N.	328	If unsure, say N.
329		329
330	config INET_AH	330	config INET_AH
331	tristate "IP: AH transformation"	331	tristate "IP: AH transformation"
332	select XFRM	332	select XFRM
333	select CRYPTO	333	select CRYPTO
334	select CRYPTO_HMAC	334	select CRYPTO_HMAC
335	select CRYPTO_MD5	335	select CRYPTO_MD5
336	select CRYPTO_SHA1	336	select CRYPTO_SHA1
337	---help---	337	---help---
338	Support for IPsec AH.	338	Support for IPsec AH.
339		339
340	If unsure, say Y.	340	If unsure, say Y.
341		341
342	config INET_ESP	342	config INET_ESP
343	tristate "IP: ESP transformation"	343	tristate "IP: ESP transformation"
344	select XFRM	344	select XFRM
345	select CRYPTO	345	select CRYPTO
346	select CRYPTO_AUTHENC	346	select CRYPTO_AUTHENC
347	select CRYPTO_HMAC	347	select CRYPTO_HMAC
348	select CRYPTO_MD5	348	select CRYPTO_MD5
349	select CRYPTO_CBC	349	select CRYPTO_CBC
350	select CRYPTO_SHA1	350	select CRYPTO_SHA1
351	select CRYPTO_DES	351	select CRYPTO_DES
352	---help---	352	---help---
353	Support for IPsec ESP.	353	Support for IPsec ESP.
354		354
355	If unsure, say Y.	355	If unsure, say Y.
356		356
357	config INET_IPCOMP	357	config INET_IPCOMP
358	tristate "IP: IPComp transformation"	358	tristate "IP: IPComp transformation"
359	select XFRM	359	select XFRM
360	select INET_XFRM_TUNNEL	360	select INET_XFRM_TUNNEL
361	select CRYPTO	361	select CRYPTO
362	select CRYPTO_DEFLATE	362	select CRYPTO_DEFLATE
363	---help---	363	---help---
364	Support for IP Payload Compression Protocol (IPComp) (RFC3173),	364	Support for IP Payload Compression Protocol (IPComp) (RFC3173),
365	typically needed for IPsec.	365	typically needed for IPsec.
366		366
367	If unsure, say Y.	367	If unsure, say Y.
368		368
369	config INET_XFRM_TUNNEL	369	config INET_XFRM_TUNNEL
370	tristate	370	tristate
371	select INET_TUNNEL	371	select INET_TUNNEL
372	default n	372	default n
373		373
374	config INET_TUNNEL	374	config INET_TUNNEL
375	tristate	375	tristate
376	default n	376	default n
377		377
378	config INET_XFRM_MODE_TRANSPORT	378	config INET_XFRM_MODE_TRANSPORT
379	tristate "IP: IPsec transport mode"	379	tristate "IP: IPsec transport mode"
380	default y	380	default y
381	select XFRM	381	select XFRM
382	---help---	382	---help---
383	Support for IPsec transport mode.	383	Support for IPsec transport mode.
384		384
385	If unsure, say Y.	385	If unsure, say Y.
386		386
387	config INET_XFRM_MODE_TUNNEL	387	config INET_XFRM_MODE_TUNNEL
388	tristate "IP: IPsec tunnel mode"	388	tristate "IP: IPsec tunnel mode"
389	default y	389	default y
390	select XFRM	390	select XFRM
391	---help---	391	---help---
392	Support for IPsec tunnel mode.	392	Support for IPsec tunnel mode.
393		393
394	If unsure, say Y.	394	If unsure, say Y.
395		395
396	config INET_XFRM_MODE_BEET	396	config INET_XFRM_MODE_BEET
397	tristate "IP: IPsec BEET mode"	397	tristate "IP: IPsec BEET mode"
398	default y	398	default y
399	select XFRM	399	select XFRM
400	---help---	400	---help---
401	Support for IPsec BEET mode.	401	Support for IPsec BEET mode.
402		402
403	If unsure, say Y.	403	If unsure, say Y.
404		404
405	config INET_LRO	405	config INET_LRO
406	tristate "Large Receive Offload (ipv4/tcp)"	406	tristate "Large Receive Offload (ipv4/tcp)"
407		407
408	---help---	408	---help---
409	Support for Large Receive Offload (ipv4/tcp).	409	Support for Large Receive Offload (ipv4/tcp).
410		410
411	If unsure, say Y.	411	If unsure, say Y.
412		412
413	config INET_DIAG	413	config INET_DIAG
414	tristate "INET: socket monitoring interface"	414	tristate "INET: socket monitoring interface"
415	default y	415	default y
416	---help---	416	---help---
417	Support for INET (TCP, DCCP, etc) socket monitoring interface used by	417	Support for INET (TCP, DCCP, etc) socket monitoring interface used by
418	native Linux tools such as ss. ss is included in iproute2, currently	418	native Linux tools such as ss. ss is included in iproute2, currently
419	downloadable at <http://linux-net.osdl.org/index.php/Iproute2>.	419	downloadable at <http://linux-net.osdl.org/index.php/Iproute2>.
420		420
421	If unsure, say Y.	421	If unsure, say Y.
422		422
423	config INET_TCP_DIAG	423	config INET_TCP_DIAG
424	depends on INET_DIAG	424	depends on INET_DIAG
425	def_tristate INET_DIAG	425	def_tristate INET_DIAG
426		426
427	menuconfig TCP_CONG_ADVANCED	427	menuconfig TCP_CONG_ADVANCED
428	bool "TCP: advanced congestion control"	428	bool "TCP: advanced congestion control"
429	---help---	429	---help---
430	Support for selection of various TCP congestion control	430	Support for selection of various TCP congestion control
431	modules.	431	modules.
432		432
433	Nearly all users can safely say no here, and a safe default	433	Nearly all users can safely say no here, and a safe default
434	selection will be made (CUBIC with new Reno as a fallback).	434	selection will be made (CUBIC with new Reno as a fallback).
435		435
436	If unsure, say N.	436	If unsure, say N.
437		437
438	if TCP_CONG_ADVANCED	438	if TCP_CONG_ADVANCED
439		439
440	config TCP_CONG_BIC	440	config TCP_CONG_BIC
441	tristate "Binary Increase Congestion (BIC) control"	441	tristate "Binary Increase Congestion (BIC) control"
442	default m	442	default m
443	---help---	443	---help---
444	BIC-TCP is a sender-side only change that ensures a linear RTT	444	BIC-TCP is a sender-side only change that ensures a linear RTT
445	fairness under large windows while offering both scalability and	445	fairness under large windows while offering both scalability and
446	bounded TCP-friendliness. The protocol combines two schemes	446	bounded TCP-friendliness. The protocol combines two schemes
447	called additive increase and binary search increase. When the	447	called additive increase and binary search increase. When the
448	congestion window is large, additive increase with a large	448	congestion window is large, additive increase with a large
449	increment ensures linear RTT fairness as well as good	449	increment ensures linear RTT fairness as well as good
450	scalability. Under small congestion windows, binary search	450	scalability. Under small congestion windows, binary search
451	increase provides TCP friendliness.	451	increase provides TCP friendliness.
452	See http://www.csc.ncsu.edu/faculty/rhee/export/bitcp/	452	See http://www.csc.ncsu.edu/faculty/rhee/export/bitcp/
453		453
454	config TCP_CONG_CUBIC	454	config TCP_CONG_CUBIC
455	tristate "CUBIC TCP"	455	tristate "CUBIC TCP"
456	default y	456	default y
457	---help---	457	---help---
458	This is version 2.0 of BIC-TCP which uses a cubic growth function	458	This is version 2.0 of BIC-TCP which uses a cubic growth function
459	among other techniques.	459	among other techniques.
460	See http://www.csc.ncsu.edu/faculty/rhee/export/bitcp/cubic-paper.pdf	460	See http://www.csc.ncsu.edu/faculty/rhee/export/bitcp/cubic-paper.pdf
461		461
462	config TCP_CONG_WESTWOOD	462	config TCP_CONG_WESTWOOD
463	tristate "TCP Westwood+"	463	tristate "TCP Westwood+"
464	default m	464	default m
465	---help---	465	---help---
466	TCP Westwood+ is a sender-side only modification of the TCP Reno	466	TCP Westwood+ is a sender-side only modification of the TCP Reno
467	protocol stack that optimizes the performance of TCP congestion	467	protocol stack that optimizes the performance of TCP congestion
468	control. It is based on end-to-end bandwidth estimation to set	468	control. It is based on end-to-end bandwidth estimation to set
469	congestion window and slow start threshold after a congestion	469	congestion window and slow start threshold after a congestion
470	episode. Using this estimation, TCP Westwood+ adaptively sets a	470	episode. Using this estimation, TCP Westwood+ adaptively sets a
471	slow start threshold and a congestion window which takes into	471	slow start threshold and a congestion window which takes into
472	account the bandwidth used at the time congestion is experienced.	472	account the bandwidth used at the time congestion is experienced.
473	TCP Westwood+ significantly increases fairness wrt TCP Reno in	473	TCP Westwood+ significantly increases fairness wrt TCP Reno in
474	wired networks and throughput over wireless links.	474	wired networks and throughput over wireless links.
475		475
476	config TCP_CONG_HTCP	476	config TCP_CONG_HTCP
477	tristate "H-TCP"	477	tristate "H-TCP"
478	default m	478	default m
479	---help---	479	---help---
480	H-TCP is a send-side only modifications of the TCP Reno	480	H-TCP is a send-side only modifications of the TCP Reno
481	protocol stack that optimizes the performance of TCP	481	protocol stack that optimizes the performance of TCP
482	congestion control for high speed network links. It uses a	482	congestion control for high speed network links. It uses a
483	modeswitch to change the alpha and beta parameters of TCP Reno	483	modeswitch to change the alpha and beta parameters of TCP Reno
484	based on network conditions and in a way so as to be fair with	484	based on network conditions and in a way so as to be fair with
485	other Reno and H-TCP flows.	485	other Reno and H-TCP flows.
486		486
487	config TCP_CONG_HSTCP	487	config TCP_CONG_HSTCP
488	tristate "High Speed TCP"	488	tristate "High Speed TCP"
489	depends on EXPERIMENTAL	489	depends on EXPERIMENTAL
490	default n	490	default n
491	---help---	491	---help---
492	Sally Floyd's High Speed TCP (RFC 3649) congestion control.	492	Sally Floyd's High Speed TCP (RFC 3649) congestion control.
493	A modification to TCP's congestion control mechanism for use	493	A modification to TCP's congestion control mechanism for use
494	with large congestion windows. A table indicates how much to	494	with large congestion windows. A table indicates how much to
495	increase the congestion window by when an ACK is received.	495	increase the congestion window by when an ACK is received.
496	For more detail see http://www.icir.org/floyd/hstcp.html	496	For more detail see http://www.icir.org/floyd/hstcp.html
497		497
498	config TCP_CONG_HYBLA	498	config TCP_CONG_HYBLA
499	tristate "TCP-Hybla congestion control algorithm"	499	tristate "TCP-Hybla congestion control algorithm"
500	depends on EXPERIMENTAL	500	depends on EXPERIMENTAL
501	default n	501	default n
502	---help---	502	---help---
503	TCP-Hybla is a sender-side only change that eliminates penalization of	503	TCP-Hybla is a sender-side only change that eliminates penalization of
504	long-RTT, large-bandwidth connections, like when satellite legs are	504	long-RTT, large-bandwidth connections, like when satellite legs are
505	involved, especially when sharing a common bottleneck with normal	505	involved, especially when sharing a common bottleneck with normal
506	terrestrial connections.	506	terrestrial connections.
507		507
508	config TCP_CONG_VEGAS	508	config TCP_CONG_VEGAS
509	tristate "TCP Vegas"	509	tristate "TCP Vegas"
510	depends on EXPERIMENTAL	510	depends on EXPERIMENTAL
511	default n	511	default n
512	---help---	512	---help---
513	TCP Vegas is a sender-side only change to TCP that anticipates	513	TCP Vegas is a sender-side only change to TCP that anticipates
514	the onset of congestion by estimating the bandwidth. TCP Vegas	514	the onset of congestion by estimating the bandwidth. TCP Vegas
515	adjusts the sending rate by modifying the congestion	515	adjusts the sending rate by modifying the congestion
516	window. TCP Vegas should provide less packet loss, but it is	516	window. TCP Vegas should provide less packet loss, but it is
517	not as aggressive as TCP Reno.	517	not as aggressive as TCP Reno.
518		518
519	config TCP_CONG_SCALABLE	519	config TCP_CONG_SCALABLE
520	tristate "Scalable TCP"	520	tristate "Scalable TCP"
521	depends on EXPERIMENTAL	521	depends on EXPERIMENTAL
522	default n	522	default n
523	---help---	523	---help---
524	Scalable TCP is a sender-side only change to TCP which uses a	524	Scalable TCP is a sender-side only change to TCP which uses a
525	MIMD congestion control algorithm which has some nice scaling	525	MIMD congestion control algorithm which has some nice scaling
526	properties, though is known to have fairness issues.	526	properties, though is known to have fairness issues.
527	See http://www.deneholme.net/tom/scalable/	527	See http://www.deneholme.net/tom/scalable/
528		528
529	config TCP_CONG_LP	529	config TCP_CONG_LP
530	tristate "TCP Low Priority"	530	tristate "TCP Low Priority"
531	depends on EXPERIMENTAL	531	depends on EXPERIMENTAL
532	default n	532	default n
533	---help---	533	---help---
534	TCP Low Priority (TCP-LP), a distributed algorithm whose goal is	534	TCP Low Priority (TCP-LP), a distributed algorithm whose goal is
535	to utilize only the excess network bandwidth as compared to the	535	to utilize only the excess network bandwidth as compared to the
536	``fair share`` of bandwidth as targeted by TCP.	536	``fair share`` of bandwidth as targeted by TCP.
537	See http://www-ece.rice.edu/networks/TCP-LP/	537	See http://www-ece.rice.edu/networks/TCP-LP/
538		538
539	config TCP_CONG_VENO	539	config TCP_CONG_VENO
540	tristate "TCP Veno"	540	tristate "TCP Veno"
541	depends on EXPERIMENTAL	541	depends on EXPERIMENTAL
542	default n	542	default n
543	---help---	543	---help---
544	TCP Veno is a sender-side only enhancement of TCP to obtain better	544	TCP Veno is a sender-side only enhancement of TCP to obtain better
545	throughput over wireless networks. TCP Veno makes use of state	545	throughput over wireless networks. TCP Veno makes use of state
546	distinguishing to circumvent the difficult judgment of the packet loss	546	distinguishing to circumvent the difficult judgment of the packet loss
547	type. TCP Veno cuts down less congestion window in response to random	547	type. TCP Veno cuts down less congestion window in response to random
548	loss packets.	548	loss packets.
549	See http://www.ntu.edu.sg/home5/ZHOU0022/papers/CPFu03a.pdf	549	See http://www.ntu.edu.sg/home5/ZHOU0022/papers/CPFu03a.pdf
550		550
551	config TCP_CONG_YEAH	551	config TCP_CONG_YEAH
552	tristate "YeAH TCP"	552	tristate "YeAH TCP"
553	depends on EXPERIMENTAL	553	depends on EXPERIMENTAL
554	select TCP_CONG_VEGAS	554	select TCP_CONG_VEGAS
555	default n	555	default n
556	---help---	556	---help---
557	YeAH-TCP is a sender-side high-speed enabled TCP congestion control	557	YeAH-TCP is a sender-side high-speed enabled TCP congestion control
558	algorithm, which uses a mixed loss/delay approach to compute the	558	algorithm, which uses a mixed loss/delay approach to compute the
559	congestion window. It's design goals target high efficiency,	559	congestion window. It's design goals target high efficiency,
560	internal, RTT and Reno fairness, resilience to link loss while	560	internal, RTT and Reno fairness, resilience to link loss while
561	keeping network elements load as low as possible.	561	keeping network elements load as low as possible.
562		562
563	For further details look here:	563	For further details look here:
564	http://wil.cs.caltech.edu/pfldnet2007/paper/YeAH_TCP.pdf	564	http://wil.cs.caltech.edu/pfldnet2007/paper/YeAH_TCP.pdf
565		565
566	config TCP_CONG_ILLINOIS	566	config TCP_CONG_ILLINOIS
567	tristate "TCP Illinois"	567	tristate "TCP Illinois"
568	depends on EXPERIMENTAL	568	depends on EXPERIMENTAL
569	default n	569	default n
570	---help---	570	---help---
571	TCP-Illinois is a sender-side modification of TCP Reno for	571	TCP-Illinois is a sender-side modification of TCP Reno for
572	high speed long delay links. It uses round-trip-time to	572	high speed long delay links. It uses round-trip-time to
573	adjust the alpha and beta parameters to achieve a higher average	573	adjust the alpha and beta parameters to achieve a higher average
574	throughput and maintain fairness.	574	throughput and maintain fairness.
575		575
576	For further details see:	576	For further details see:
577	http://www.ews.uiuc.edu/~shaoliu/tcpillinois/index.html	577	http://www.ews.uiuc.edu/~shaoliu/tcpillinois/index.html
578		578
579	choice	579	choice
580	prompt "Default TCP congestion control"	580	prompt "Default TCP congestion control"
581	default DEFAULT_CUBIC	581	default DEFAULT_CUBIC
582	help	582	help
583	Select the TCP congestion control that will be used by default	583	Select the TCP congestion control that will be used by default
584	for all connections.	584	for all connections.
585		585
586	config DEFAULT_BIC	586	config DEFAULT_BIC
587	bool "Bic" if TCP_CONG_BIC=y	587	bool "Bic" if TCP_CONG_BIC=y
588		588
589	config DEFAULT_CUBIC	589	config DEFAULT_CUBIC
590	bool "Cubic" if TCP_CONG_CUBIC=y	590	bool "Cubic" if TCP_CONG_CUBIC=y
591		591
592	config DEFAULT_HTCP	592	config DEFAULT_HTCP
593	bool "Htcp" if TCP_CONG_HTCP=y	593	bool "Htcp" if TCP_CONG_HTCP=y
594		594
595	config DEFAULT_VEGAS	595	config DEFAULT_VEGAS
596	bool "Vegas" if TCP_CONG_VEGAS=y	596	bool "Vegas" if TCP_CONG_VEGAS=y
597		597
598	config DEFAULT_WESTWOOD	598	config DEFAULT_WESTWOOD
599	bool "Westwood" if TCP_CONG_WESTWOOD=y	599	bool "Westwood" if TCP_CONG_WESTWOOD=y
600		600
601	config DEFAULT_RENO	601	config DEFAULT_RENO
602	bool "Reno"	602	bool "Reno"
603		603
604	endchoice	604	endchoice
605		605
606	endif	606	endif
607		607
608	config TCP_CONG_CUBIC	608	config TCP_CONG_CUBIC
609	tristate	609	tristate
610	depends on !TCP_CONG_ADVANCED	610	depends on !TCP_CONG_ADVANCED
611	default y	611	default y
612		612
613	config DEFAULT_TCP_CONG	613	config DEFAULT_TCP_CONG
614	string	614	string
615	default "bic" if DEFAULT_BIC	615	default "bic" if DEFAULT_BIC
616	default "cubic" if DEFAULT_CUBIC	616	default "cubic" if DEFAULT_CUBIC
617	default "htcp" if DEFAULT_HTCP	617	default "htcp" if DEFAULT_HTCP
618	default "vegas" if DEFAULT_VEGAS	618	default "vegas" if DEFAULT_VEGAS
619	default "westwood" if DEFAULT_WESTWOOD	619	default "westwood" if DEFAULT_WESTWOOD
620	default "reno" if DEFAULT_RENO	620	default "reno" if DEFAULT_RENO
621	default "cubic"	621	default "cubic"
622		622
623	config TCP_MD5SIG	623	config TCP_MD5SIG
624	bool "TCP: MD5 Signature Option support (RFC2385) (EXPERIMENTAL)"	624	bool "TCP: MD5 Signature Option support (RFC2385) (EXPERIMENTAL)"
625	depends on EXPERIMENTAL	625	depends on EXPERIMENTAL
626	select CRYPTO	626	select CRYPTO
627	select CRYPTO_MD5	627	select CRYPTO_MD5
628	---help---	628	---help---
629	RFC2385 specifies a method of giving MD5 protection to TCP sessions.	629	RFC2385 specifies a method of giving MD5 protection to TCP sessions.
630	Its main (only?) use is to protect BGP sessions between core routers	630	Its main (only?) use is to protect BGP sessions between core routers
631	on the Internet.	631	on the Internet.
632		632
633	If unsure, say N.	633	If unsure, say N.
634		634
635	source "net/ipv4/ipvs/Kconfig"	635	source "net/ipv4/ipvs/Kconfig"
636		636
637		637

net/ipv4/ipconfig.c

Diff comments View file @ 14897e3

1	/*	1	/*
2	* $Id: ipconfig.c,v 1.46 2002/02/01 22:01:04 davem Exp $	2	* $Id: ipconfig.c,v 1.46 2002/02/01 22:01:04 davem Exp $
3	*	3	*
4	* Automatic Configuration of IP -- use DHCP, BOOTP, RARP, or	4	* Automatic Configuration of IP -- use DHCP, BOOTP, RARP, or
5	* user-supplied information to configure own IP address and routes.	5	* user-supplied information to configure own IP address and routes.
6	*	6	*
7	* Copyright (C) 1996-1998 Martin Mares <mj@atrey.karlin.mff.cuni.cz>	7	* Copyright (C) 1996-1998 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
8	*	8	*
9	* Derived from network configuration code in fs/nfs/nfsroot.c,	9	* Derived from network configuration code in fs/nfs/nfsroot.c,
10	* originally Copyright (C) 1995, 1996 Gero Kuhlmann and me.	10	* originally Copyright (C) 1995, 1996 Gero Kuhlmann and me.
11	*	11	*
12	* BOOTP rewritten to construct and analyse packets itself instead	12	* BOOTP rewritten to construct and analyse packets itself instead
13	* of misusing the IP layer. num_bugs_causing_wrong_arp_replies--;	13	* of misusing the IP layer. num_bugs_causing_wrong_arp_replies--;
14	* -- MJ, December 1998	14	* -- MJ, December 1998
15	*	15	*
16	* Fixed ip_auto_config_setup calling at startup in the new "Linker Magic"	16	* Fixed ip_auto_config_setup calling at startup in the new "Linker Magic"
17	* initialization scheme.	17	* initialization scheme.
18	* - Arnaldo Carvalho de Melo <acme@conectiva.com.br>, 08/11/1999	18	* - Arnaldo Carvalho de Melo <acme@conectiva.com.br>, 08/11/1999
19	*	19	*
20	* DHCP support added. To users this looks like a whole separate	20	* DHCP support added. To users this looks like a whole separate
21	* protocol, but we know it's just a bag on the side of BOOTP.	21	* protocol, but we know it's just a bag on the side of BOOTP.
22	* -- Chip Salzenberg <chip@valinux.com>, May 2000	22	* -- Chip Salzenberg <chip@valinux.com>, May 2000
23	*	23	*
24	* Ported DHCP support from 2.2.16 to 2.4.0-test4	24	* Ported DHCP support from 2.2.16 to 2.4.0-test4
25	* -- Eric Biederman <ebiederman@lnxi.com>, 30 Aug 2000	25	* -- Eric Biederman <ebiederman@lnxi.com>, 30 Aug 2000
26	*	26	*
27	* Merged changes from 2.2.19 into 2.4.3	27	* Merged changes from 2.2.19 into 2.4.3
28	* -- Eric Biederman <ebiederman@lnxi.com>, 22 April Aug 2001	28	* -- Eric Biederman <ebiederman@lnxi.com>, 22 April Aug 2001
29	*	29	*
30	* Multiple Nameservers in /proc/net/pnp	30	* Multiple Nameservers in /proc/net/pnp
31	* -- Josef Siemes <jsiemes@web.de>, Aug 2002	31	* -- Josef Siemes <jsiemes@web.de>, Aug 2002
32	*/	32	*/
33		33
34	#include <linux/types.h>	34	#include <linux/types.h>
35	#include <linux/string.h>	35	#include <linux/string.h>
36	#include <linux/kernel.h>	36	#include <linux/kernel.h>
37	#include <linux/jiffies.h>	37	#include <linux/jiffies.h>
38	#include <linux/random.h>	38	#include <linux/random.h>
39	#include <linux/init.h>	39	#include <linux/init.h>
40	#include <linux/utsname.h>	40	#include <linux/utsname.h>
41	#include <linux/in.h>	41	#include <linux/in.h>
42	#include <linux/if.h>	42	#include <linux/if.h>
43	#include <linux/inet.h>	43	#include <linux/inet.h>
44	#include <linux/inetdevice.h>	44	#include <linux/inetdevice.h>
45	#include <linux/netdevice.h>	45	#include <linux/netdevice.h>
46	#include <linux/if_arp.h>	46	#include <linux/if_arp.h>
47	#include <linux/skbuff.h>	47	#include <linux/skbuff.h>
48	#include <linux/ip.h>	48	#include <linux/ip.h>
49	#include <linux/socket.h>	49	#include <linux/socket.h>
50	#include <linux/route.h>	50	#include <linux/route.h>
51	#include <linux/udp.h>	51	#include <linux/udp.h>
52	#include <linux/proc_fs.h>	52	#include <linux/proc_fs.h>
53	#include <linux/seq_file.h>	53	#include <linux/seq_file.h>
54	#include <linux/major.h>	54	#include <linux/major.h>
55	#include <linux/root_dev.h>	55	#include <linux/root_dev.h>
56	#include <linux/delay.h>	56	#include <linux/delay.h>
57	#include <linux/nfs_fs.h>	57	#include <linux/nfs_fs.h>
58	#include <net/net_namespace.h>	58	#include <net/net_namespace.h>
59	#include <net/arp.h>	59	#include <net/arp.h>
60	#include <net/ip.h>	60	#include <net/ip.h>
61	#include <net/ipconfig.h>	61	#include <net/ipconfig.h>
62	#include <net/route.h>	62	#include <net/route.h>
63		63
64	#include <asm/uaccess.h>	64	#include <asm/uaccess.h>
65	#include <net/checksum.h>	65	#include <net/checksum.h>
66	#include <asm/processor.h>	66	#include <asm/processor.h>
67		67
68	/* Define this to allow debugging output */	68	/* Define this to allow debugging output */
69	#undef IPCONFIG_DEBUG	69	#undef IPCONFIG_DEBUG
70		70
71	#ifdef IPCONFIG_DEBUG	71	#ifdef IPCONFIG_DEBUG
72	#define DBG(x) printk x	72	#define DBG(x) printk x
73	#else	73	#else
74	#define DBG(x) do { } while(0)	74	#define DBG(x) do { } while(0)
75	#endif	75	#endif
76		76
77	#if defined(CONFIG_IP_PNP_DHCP)	77	#if defined(CONFIG_IP_PNP_DHCP)
78	#define IPCONFIG_DHCP	78	#define IPCONFIG_DHCP
79	#endif	79	#endif
80	#if defined(CONFIG_IP_PNP_BOOTP) \|\| defined(CONFIG_IP_PNP_DHCP)	80	#if defined(CONFIG_IP_PNP_BOOTP) \|\| defined(CONFIG_IP_PNP_DHCP)
81	#define IPCONFIG_BOOTP	81	#define IPCONFIG_BOOTP
82	#endif	82	#endif
83	#if defined(CONFIG_IP_PNP_RARP)	83	#if defined(CONFIG_IP_PNP_RARP)
84	#define IPCONFIG_RARP	84	#define IPCONFIG_RARP
85	#endif	85	#endif
86	#if defined(IPCONFIG_BOOTP) \|\| defined(IPCONFIG_RARP)	86	#if defined(IPCONFIG_BOOTP) \|\| defined(IPCONFIG_RARP)
87	#define IPCONFIG_DYNAMIC	87	#define IPCONFIG_DYNAMIC
88	#endif	88	#endif
89		89
90	/* Define the friendly delay before and after opening net devices */	90	/* Define the friendly delay before and after opening net devices */
91	#define CONF_PRE_OPEN 500 /* Before opening: 1/2 second */	91	#define CONF_PRE_OPEN 500 /* Before opening: 1/2 second */
92	#define CONF_POST_OPEN 1 /* After opening: 1 second */	92	#define CONF_POST_OPEN 1 /* After opening: 1 second */
93		93
94	/* Define the timeout for waiting for a DHCP/BOOTP/RARP reply */	94	/* Define the timeout for waiting for a DHCP/BOOTP/RARP reply */
95	#define CONF_OPEN_RETRIES 2 /* (Re)open devices twice */	95	#define CONF_OPEN_RETRIES 2 /* (Re)open devices twice */
96	#define CONF_SEND_RETRIES 6 /* Send six requests per open */	96	#define CONF_SEND_RETRIES 6 /* Send six requests per open */
97	#define CONF_INTER_TIMEOUT (HZ/2) /* Inter-device timeout: 1/2 second */	97	#define CONF_INTER_TIMEOUT (HZ/2) /* Inter-device timeout: 1/2 second */
98	#define CONF_BASE_TIMEOUT (HZ2) / Initial timeout: 2 seconds */	98	#define CONF_BASE_TIMEOUT (HZ2) / Initial timeout: 2 seconds */
99	#define CONF_TIMEOUT_RANDOM (HZ) /* Maximum amount of randomization */	99	#define CONF_TIMEOUT_RANDOM (HZ) /* Maximum amount of randomization */
100	#define CONF_TIMEOUT_MULT 7/4 / Rate of timeout growth */	100	#define CONF_TIMEOUT_MULT 7/4 / Rate of timeout growth */
101	#define CONF_TIMEOUT_MAX (HZ30) / Maximum allowed timeout */	101	#define CONF_TIMEOUT_MAX (HZ30) / Maximum allowed timeout */
102	#define CONF_NAMESERVERS_MAX 3 /* Maximum number of nameservers	102	#define CONF_NAMESERVERS_MAX 3 /* Maximum number of nameservers
103	- '3' from resolv.h */	103	- '3' from resolv.h */
104		104
105	#define NONE __constant_htonl(INADDR_NONE)	105	#define NONE __constant_htonl(INADDR_NONE)
106	#define ANY __constant_htonl(INADDR_ANY)	106	#define ANY __constant_htonl(INADDR_ANY)
107		107
108	/*	108	/*
109	* Public IP configuration	109	* Public IP configuration
110	*/	110	*/
111		111
112	/* This is used by platforms which might be able to set the ipconfig	112	/* This is used by platforms which might be able to set the ipconfig
113	* variables using firmware environment vars. If this is set, it will	113	* variables using firmware environment vars. If this is set, it will
114	* ignore such firmware variables.	114	* ignore such firmware variables.
115	*/	115	*/
116	int ic_set_manually __initdata = 0; /* IPconfig parameters set manually */	116	int ic_set_manually __initdata = 0; /* IPconfig parameters set manually */
117		117
118	static int ic_enable __initdata = 0; /* IP config enabled? */	118	static int ic_enable __initdata = 0; /* IP config enabled? */
119		119
120	/* Protocol choice */	120	/* Protocol choice */
121	int ic_proto_enabled __initdata = 0	121	int ic_proto_enabled __initdata = 0
122	#ifdef IPCONFIG_BOOTP	122	#ifdef IPCONFIG_BOOTP
123	\| IC_BOOTP	123	\| IC_BOOTP
124	#endif	124	#endif
125	#ifdef CONFIG_IP_PNP_DHCP	125	#ifdef CONFIG_IP_PNP_DHCP
126	\| IC_USE_DHCP	126	\| IC_USE_DHCP
127	#endif	127	#endif
128	#ifdef IPCONFIG_RARP	128	#ifdef IPCONFIG_RARP
129	\| IC_RARP	129	\| IC_RARP
130	#endif	130	#endif
131	;	131	;
132		132
133	static int ic_host_name_set __initdata = 0; /* Host name set by us? */	133	static int ic_host_name_set __initdata = 0; /* Host name set by us? */
134		134
135	__be32 ic_myaddr = NONE; /* My IP address */	135	__be32 ic_myaddr = NONE; /* My IP address */
136	static __be32 ic_netmask = NONE; /* Netmask for local subnet */	136	static __be32 ic_netmask = NONE; /* Netmask for local subnet */
137	__be32 ic_gateway = NONE; /* Gateway IP address */	137	__be32 ic_gateway = NONE; /* Gateway IP address */
138		138
139	__be32 ic_servaddr = NONE; /* Boot server IP address */	139	__be32 ic_servaddr = NONE; /* Boot server IP address */
140		140
141	__be32 root_server_addr = NONE; /* Address of NFS server */	141	__be32 root_server_addr = NONE; /* Address of NFS server */
142	u8 root_server_path[256] = { 0, }; /* Path to mount as root */	142	u8 root_server_path[256] = { 0, }; /* Path to mount as root */
143		143
144	/* vendor class identifier */	144	/* vendor class identifier */
145	static char vendor_class_identifier[253] __initdata;	145	static char vendor_class_identifier[253] __initdata;
146		146
147	/* Persistent data: */	147	/* Persistent data: */
148		148
149	static int ic_proto_used; /* Protocol used, if any */	149	static int ic_proto_used; /* Protocol used, if any */
150	static __be32 ic_nameservers[CONF_NAMESERVERS_MAX]; /* DNS Server IP addresses */	150	static __be32 ic_nameservers[CONF_NAMESERVERS_MAX]; /* DNS Server IP addresses */
151	static u8 ic_domain[64]; /* DNS (not NIS) domain name */	151	static u8 ic_domain[64]; /* DNS (not NIS) domain name */
152		152
153	/*	153	/*
154	* Private state.	154	* Private state.
155	*/	155	*/
156		156
157	/* Name of user-selected boot device */	157	/* Name of user-selected boot device */
158	static char user_dev_name[IFNAMSIZ] __initdata = { 0, };	158	static char user_dev_name[IFNAMSIZ] __initdata = { 0, };
159		159
160	/* Protocols supported by available interfaces */	160	/* Protocols supported by available interfaces */
161	static int ic_proto_have_if __initdata = 0;	161	static int ic_proto_have_if __initdata = 0;
162		162
163	#ifdef IPCONFIG_DYNAMIC	163	#ifdef IPCONFIG_DYNAMIC
164	static DEFINE_SPINLOCK(ic_recv_lock);	164	static DEFINE_SPINLOCK(ic_recv_lock);
165	static volatile int ic_got_reply __initdata = 0; /* Proto(s) that replied */	165	static volatile int ic_got_reply __initdata = 0; /* Proto(s) that replied */
166	#endif	166	#endif
167	#ifdef IPCONFIG_DHCP	167	#ifdef IPCONFIG_DHCP
168	static int ic_dhcp_msgtype __initdata = 0; /* DHCP msg type received */	168	static int ic_dhcp_msgtype __initdata = 0; /* DHCP msg type received */
169	#endif	169	#endif
170		170
171		171
172	/*	172	/*
173	* Network devices	173	* Network devices
174	*/	174	*/
175		175
176	struct ic_device {	176	struct ic_device {
177	struct ic_device *next;	177	struct ic_device *next;
178	struct net_device *dev;	178	struct net_device *dev;
179	unsigned short flags;	179	unsigned short flags;
180	short able;	180	short able;
181	__be32 xid;	181	__be32 xid;
182	};	182	};
183		183
184	static struct ic_device ic_first_dev __initdata = NULL;/ List of open device */	184	static struct ic_device ic_first_dev __initdata = NULL;/ List of open device */
185	static struct net_device ic_dev __initdata = NULL; / Selected device */	185	static struct net_device ic_dev __initdata = NULL; / Selected device */
186		186
187	static int __init ic_open_devs(void)	187	static int __init ic_open_devs(void)
188	{	188	{
189	struct ic_device d, *last;	189	struct ic_device d, *last;
190	struct net_device *dev;	190	struct net_device *dev;
191	unsigned short oflags;	191	unsigned short oflags;
192		192
193	last = &ic_first_dev;	193	last = &ic_first_dev;
194	rtnl_lock();	194	rtnl_lock();
195		195
196	/* bring loopback device up first */	196	/* bring loopback device up first */
197	for_each_netdev(&init_net, dev) {	197	for_each_netdev(&init_net, dev) {
198	if (!(dev->flags & IFF_LOOPBACK))	198	if (!(dev->flags & IFF_LOOPBACK))
199	continue;	199	continue;
200	if (dev_change_flags(dev, dev->flags \| IFF_UP) < 0)	200	if (dev_change_flags(dev, dev->flags \| IFF_UP) < 0)
201	printk(KERN_ERR "IP-Config: Failed to open %s\n", dev->name);	201	printk(KERN_ERR "IP-Config: Failed to open %s\n", dev->name);
202	}	202	}
203		203
204	for_each_netdev(&init_net, dev) {	204	for_each_netdev(&init_net, dev) {
205	if (dev->flags & IFF_LOOPBACK)	205	if (dev->flags & IFF_LOOPBACK)
206	continue;	206	continue;
207	if (user_dev_name[0] ? !strcmp(dev->name, user_dev_name) :	207	if (user_dev_name[0] ? !strcmp(dev->name, user_dev_name) :
208	(!(dev->flags & IFF_LOOPBACK) &&	208	(!(dev->flags & IFF_LOOPBACK) &&
209	(dev->flags & (IFF_POINTOPOINT\|IFF_BROADCAST)) &&	209	(dev->flags & (IFF_POINTOPOINT\|IFF_BROADCAST)) &&
210	strncmp(dev->name, "dummy", 5))) {	210	strncmp(dev->name, "dummy", 5))) {
211	int able = 0;	211	int able = 0;
212	if (dev->mtu >= 364)	212	if (dev->mtu >= 364)
213	able \|= IC_BOOTP;	213	able \|= IC_BOOTP;
214	else	214	else
215	printk(KERN_WARNING "DHCP/BOOTP: Ignoring device %s, MTU %d too small", dev->name, dev->mtu);	215	printk(KERN_WARNING "DHCP/BOOTP: Ignoring device %s, MTU %d too small", dev->name, dev->mtu);
216	if (!(dev->flags & IFF_NOARP))	216	if (!(dev->flags & IFF_NOARP))
217	able \|= IC_RARP;	217	able \|= IC_RARP;
218	able &= ic_proto_enabled;	218	able &= ic_proto_enabled;
219	if (ic_proto_enabled && !able)	219	if (ic_proto_enabled && !able)
220	continue;	220	continue;
221	oflags = dev->flags;	221	oflags = dev->flags;
222	if (dev_change_flags(dev, oflags \| IFF_UP) < 0) {	222	if (dev_change_flags(dev, oflags \| IFF_UP) < 0) {
223	printk(KERN_ERR "IP-Config: Failed to open %s\n", dev->name);	223	printk(KERN_ERR "IP-Config: Failed to open %s\n", dev->name);
224	continue;	224	continue;
225	}	225	}
226	if (!(d = kmalloc(sizeof(struct ic_device), GFP_KERNEL))) {	226	if (!(d = kmalloc(sizeof(struct ic_device), GFP_KERNEL))) {
227	rtnl_unlock();	227	rtnl_unlock();
228	return -1;	228	return -1;
229	}	229	}
230	d->dev = dev;	230	d->dev = dev;
231	*last = d;	231	*last = d;
232	last = &d->next;	232	last = &d->next;
233	d->flags = oflags;	233	d->flags = oflags;
234	d->able = able;	234	d->able = able;
235	if (able & IC_BOOTP)	235	if (able & IC_BOOTP)
236	get_random_bytes(&d->xid, sizeof(__be32));	236	get_random_bytes(&d->xid, sizeof(__be32));
237	else	237	else
238	d->xid = 0;	238	d->xid = 0;
239	ic_proto_have_if \|= able;	239	ic_proto_have_if \|= able;
240	DBG(("IP-Config: %s UP (able=%d, xid=%08x)\n",	240	DBG(("IP-Config: %s UP (able=%d, xid=%08x)\n",
241	dev->name, able, d->xid));	241	dev->name, able, d->xid));
242	}	242	}
243	}	243	}
244	rtnl_unlock();	244	rtnl_unlock();
245		245
246	*last = NULL;	246	*last = NULL;
247		247
248	if (!ic_first_dev) {	248	if (!ic_first_dev) {
249	if (user_dev_name[0])	249	if (user_dev_name[0])
250	printk(KERN_ERR "IP-Config: Device `%s' not found.\n", user_dev_name);	250	printk(KERN_ERR "IP-Config: Device `%s' not found.\n", user_dev_name);
251	else	251	else
252	printk(KERN_ERR "IP-Config: No network devices available.\n");	252	printk(KERN_ERR "IP-Config: No network devices available.\n");
253	return -1;	253	return -1;
254	}	254	}
255	return 0;	255	return 0;
256	}	256	}
257		257
258	static void __init ic_close_devs(void)	258	static void __init ic_close_devs(void)
259	{	259	{
260	struct ic_device d, next;	260	struct ic_device d, next;
261	struct net_device *dev;	261	struct net_device *dev;
262		262
263	rtnl_lock();	263	rtnl_lock();
264	next = ic_first_dev;	264	next = ic_first_dev;
265	while ((d = next)) {	265	while ((d = next)) {
266	next = d->next;	266	next = d->next;
267	dev = d->dev;	267	dev = d->dev;
268	if (dev != ic_dev) {	268	if (dev != ic_dev) {
269	DBG(("IP-Config: Downing %s\n", dev->name));	269	DBG(("IP-Config: Downing %s\n", dev->name));
270	dev_change_flags(dev, d->flags);	270	dev_change_flags(dev, d->flags);
271	}	271	}
272	kfree(d);	272	kfree(d);
273	}	273	}
274	rtnl_unlock();	274	rtnl_unlock();
275	}	275	}
276		276
277	/*	277	/*
278	* Interface to various network functions.	278	* Interface to various network functions.
279	*/	279	*/
280		280
281	static inline void	281	static inline void
282	set_sockaddr(struct sockaddr_in *sin, __be32 addr, __be16 port)	282	set_sockaddr(struct sockaddr_in *sin, __be32 addr, __be16 port)
283	{	283	{
284	sin->sin_family = AF_INET;	284	sin->sin_family = AF_INET;
285	sin->sin_addr.s_addr = addr;	285	sin->sin_addr.s_addr = addr;
286	sin->sin_port = port;	286	sin->sin_port = port;
287	}	287	}
288		288
289	static int __init ic_dev_ioctl(unsigned int cmd, struct ifreq *arg)	289	static int __init ic_dev_ioctl(unsigned int cmd, struct ifreq *arg)
290	{	290	{
291	int res;	291	int res;
292		292
293	mm_segment_t oldfs = get_fs();	293	mm_segment_t oldfs = get_fs();
294	set_fs(get_ds());	294	set_fs(get_ds());
295	res = devinet_ioctl(cmd, (struct ifreq __user *) arg);	295	res = devinet_ioctl(cmd, (struct ifreq __user *) arg);
296	set_fs(oldfs);	296	set_fs(oldfs);
297	return res;	297	return res;
298	}	298	}
299		299
300	static int __init ic_route_ioctl(unsigned int cmd, struct rtentry *arg)	300	static int __init ic_route_ioctl(unsigned int cmd, struct rtentry *arg)
301	{	301	{
302	int res;	302	int res;
303		303
304	mm_segment_t oldfs = get_fs();	304	mm_segment_t oldfs = get_fs();
305	set_fs(get_ds());	305	set_fs(get_ds());
306	res = ip_rt_ioctl(&init_net, cmd, (void __user *) arg);	306	res = ip_rt_ioctl(&init_net, cmd, (void __user *) arg);
307	set_fs(oldfs);	307	set_fs(oldfs);
308	return res;	308	return res;
309	}	309	}
310		310
311	/*	311	/*
312	* Set up interface addresses and routes.	312	* Set up interface addresses and routes.
313	*/	313	*/
314		314
315	static int __init ic_setup_if(void)	315	static int __init ic_setup_if(void)
316	{	316	{
317	struct ifreq ir;	317	struct ifreq ir;
318	struct sockaddr_in sin = (void ) &ir.ifr_ifru.ifru_addr;	318	struct sockaddr_in sin = (void ) &ir.ifr_ifru.ifru_addr;
319	int err;	319	int err;
320		320
321	memset(&ir, 0, sizeof(ir));	321	memset(&ir, 0, sizeof(ir));
322	strcpy(ir.ifr_ifrn.ifrn_name, ic_dev->name);	322	strcpy(ir.ifr_ifrn.ifrn_name, ic_dev->name);
323	set_sockaddr(sin, ic_myaddr, 0);	323	set_sockaddr(sin, ic_myaddr, 0);
324	if ((err = ic_dev_ioctl(SIOCSIFADDR, &ir)) < 0) {	324	if ((err = ic_dev_ioctl(SIOCSIFADDR, &ir)) < 0) {
325	printk(KERN_ERR "IP-Config: Unable to set interface address (%d).\n", err);	325	printk(KERN_ERR "IP-Config: Unable to set interface address (%d).\n", err);
326	return -1;	326	return -1;
327	}	327	}
328	set_sockaddr(sin, ic_netmask, 0);	328	set_sockaddr(sin, ic_netmask, 0);
329	if ((err = ic_dev_ioctl(SIOCSIFNETMASK, &ir)) < 0) {	329	if ((err = ic_dev_ioctl(SIOCSIFNETMASK, &ir)) < 0) {
330	printk(KERN_ERR "IP-Config: Unable to set interface netmask (%d).\n", err);	330	printk(KERN_ERR "IP-Config: Unable to set interface netmask (%d).\n", err);
331	return -1;	331	return -1;
332	}	332	}
333	set_sockaddr(sin, ic_myaddr \| ~ic_netmask, 0);	333	set_sockaddr(sin, ic_myaddr \| ~ic_netmask, 0);
334	if ((err = ic_dev_ioctl(SIOCSIFBRDADDR, &ir)) < 0) {	334	if ((err = ic_dev_ioctl(SIOCSIFBRDADDR, &ir)) < 0) {
335	printk(KERN_ERR "IP-Config: Unable to set interface broadcast address (%d).\n", err);	335	printk(KERN_ERR "IP-Config: Unable to set interface broadcast address (%d).\n", err);
336	return -1;	336	return -1;
337	}	337	}
338	return 0;	338	return 0;
339	}	339	}
340		340
341	static int __init ic_setup_routes(void)	341	static int __init ic_setup_routes(void)
342	{	342	{
343	/* No need to setup device routes, only the default route... */	343	/* No need to setup device routes, only the default route... */
344		344
345	if (ic_gateway != NONE) {	345	if (ic_gateway != NONE) {
346	struct rtentry rm;	346	struct rtentry rm;
347	int err;	347	int err;
348		348
349	memset(&rm, 0, sizeof(rm));	349	memset(&rm, 0, sizeof(rm));
350	if ((ic_gateway ^ ic_myaddr) & ic_netmask) {	350	if ((ic_gateway ^ ic_myaddr) & ic_netmask) {
351	printk(KERN_ERR "IP-Config: Gateway not on directly connected network.\n");	351	printk(KERN_ERR "IP-Config: Gateway not on directly connected network.\n");
352	return -1;	352	return -1;
353	}	353	}
354	set_sockaddr((struct sockaddr_in *) &rm.rt_dst, 0, 0);	354	set_sockaddr((struct sockaddr_in *) &rm.rt_dst, 0, 0);
355	set_sockaddr((struct sockaddr_in *) &rm.rt_genmask, 0, 0);	355	set_sockaddr((struct sockaddr_in *) &rm.rt_genmask, 0, 0);
356	set_sockaddr((struct sockaddr_in *) &rm.rt_gateway, ic_gateway, 0);	356	set_sockaddr((struct sockaddr_in *) &rm.rt_gateway, ic_gateway, 0);
357	rm.rt_flags = RTF_UP \| RTF_GATEWAY;	357	rm.rt_flags = RTF_UP \| RTF_GATEWAY;
358	if ((err = ic_route_ioctl(SIOCADDRT, &rm)) < 0) {	358	if ((err = ic_route_ioctl(SIOCADDRT, &rm)) < 0) {
359	printk(KERN_ERR "IP-Config: Cannot add default route (%d).\n", err);	359	printk(KERN_ERR "IP-Config: Cannot add default route (%d).\n", err);
360	return -1;	360	return -1;
361	}	361	}
362	}	362	}
363		363
364	return 0;	364	return 0;
365	}	365	}
366		366
367	/*	367	/*
368	* Fill in default values for all missing parameters.	368	* Fill in default values for all missing parameters.
369	*/	369	*/
370		370
371	static int __init ic_defaults(void)	371	static int __init ic_defaults(void)
372	{	372	{
373	/*	373	/*
374	* At this point we have no userspace running so need not	374	* At this point we have no userspace running so need not
375	* claim locks on system_utsname	375	* claim locks on system_utsname
376	*/	376	*/
377		377
378	if (!ic_host_name_set)	378	if (!ic_host_name_set)
379	sprintf(init_utsname()->nodename, "%u.%u.%u.%u", NIPQUAD(ic_myaddr));	379	sprintf(init_utsname()->nodename, "%u.%u.%u.%u", NIPQUAD(ic_myaddr));
380		380
381	if (root_server_addr == NONE)	381	if (root_server_addr == NONE)
382	root_server_addr = ic_servaddr;	382	root_server_addr = ic_servaddr;
383		383
384	if (ic_netmask == NONE) {	384	if (ic_netmask == NONE) {
385	if (IN_CLASSA(ntohl(ic_myaddr)))	385	if (IN_CLASSA(ntohl(ic_myaddr)))
386	ic_netmask = htonl(IN_CLASSA_NET);	386	ic_netmask = htonl(IN_CLASSA_NET);
387	else if (IN_CLASSB(ntohl(ic_myaddr)))	387	else if (IN_CLASSB(ntohl(ic_myaddr)))
388	ic_netmask = htonl(IN_CLASSB_NET);	388	ic_netmask = htonl(IN_CLASSB_NET);
389	else if (IN_CLASSC(ntohl(ic_myaddr)))	389	else if (IN_CLASSC(ntohl(ic_myaddr)))
390	ic_netmask = htonl(IN_CLASSC_NET);	390	ic_netmask = htonl(IN_CLASSC_NET);
391	else {	391	else {
392	printk(KERN_ERR "IP-Config: Unable to guess netmask for address %u.%u.%u.%u\n",	392	printk(KERN_ERR "IP-Config: Unable to guess netmask for address %u.%u.%u.%u\n",
393	NIPQUAD(ic_myaddr));	393	NIPQUAD(ic_myaddr));
394	return -1;	394	return -1;
395	}	395	}
396	printk("IP-Config: Guessing netmask %u.%u.%u.%u\n", NIPQUAD(ic_netmask));	396	printk("IP-Config: Guessing netmask %u.%u.%u.%u\n", NIPQUAD(ic_netmask));
397	}	397	}
398		398
399	return 0;	399	return 0;
400	}	400	}
401		401
402	/*	402	/*
403	* RARP support.	403	* RARP support.
404	*/	404	*/
405		405
406	#ifdef IPCONFIG_RARP	406	#ifdef IPCONFIG_RARP
407		407
408	static int ic_rarp_recv(struct sk_buff skb, struct net_device dev, struct packet_type pt, struct net_device orig_dev);	408	static int ic_rarp_recv(struct sk_buff skb, struct net_device dev, struct packet_type pt, struct net_device orig_dev);
409		409
410	static struct packet_type rarp_packet_type __initdata = {	410	static struct packet_type rarp_packet_type __initdata = {
411	.type = __constant_htons(ETH_P_RARP),	411	.type = __constant_htons(ETH_P_RARP),
412	.func = ic_rarp_recv,	412	.func = ic_rarp_recv,
413	};	413	};
414		414
415	static inline void ic_rarp_init(void)	415	static inline void ic_rarp_init(void)
416	{	416	{
417	dev_add_pack(&rarp_packet_type);	417	dev_add_pack(&rarp_packet_type);
418	}	418	}
419		419
420	static inline void ic_rarp_cleanup(void)	420	static inline void ic_rarp_cleanup(void)
421	{	421	{
422	dev_remove_pack(&rarp_packet_type);	422	dev_remove_pack(&rarp_packet_type);
423	}	423	}
424		424
425	/*	425	/*
426	* Process received RARP packet.	426	* Process received RARP packet.
427	*/	427	*/
428	static int __init	428	static int __init
429	ic_rarp_recv(struct sk_buff skb, struct net_device dev, struct packet_type pt, struct net_device orig_dev)	429	ic_rarp_recv(struct sk_buff skb, struct net_device dev, struct packet_type pt, struct net_device orig_dev)
430	{	430	{
431	struct arphdr *rarp;	431	struct arphdr *rarp;
432	unsigned char *rarp_ptr;	432	unsigned char *rarp_ptr;
433	__be32 sip, tip;	433	__be32 sip, tip;
434	unsigned char sha, tha; /* s for "source", t for "target" */	434	unsigned char sha, tha; /* s for "source", t for "target" */
435	struct ic_device *d;	435	struct ic_device *d;
436		436
437	if (dev->nd_net != &init_net)	437	if (dev->nd_net != &init_net)
438	goto drop;	438	goto drop;
439		439
440	if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)	440	if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
441	return NET_RX_DROP;	441	return NET_RX_DROP;
442		442
443	if (!pskb_may_pull(skb, sizeof(struct arphdr)))	443	if (!pskb_may_pull(skb, sizeof(struct arphdr)))
444	goto drop;	444	goto drop;
445		445
446	/* Basic sanity checks can be done without the lock. */	446	/* Basic sanity checks can be done without the lock. */
447	rarp = (struct arphdr *)skb_transport_header(skb);	447	rarp = (struct arphdr *)skb_transport_header(skb);
448		448
449	/* If this test doesn't pass, it's not IP, or we should	449	/* If this test doesn't pass, it's not IP, or we should
450	* ignore it anyway.	450	* ignore it anyway.
451	*/	451	*/
452	if (rarp->ar_hln != dev->addr_len \|\| dev->type != ntohs(rarp->ar_hrd))	452	if (rarp->ar_hln != dev->addr_len \|\| dev->type != ntohs(rarp->ar_hrd))
453	goto drop;	453	goto drop;
454		454
455	/* If it's not a RARP reply, delete it. */	455	/* If it's not a RARP reply, delete it. */
456	if (rarp->ar_op != htons(ARPOP_RREPLY))	456	if (rarp->ar_op != htons(ARPOP_RREPLY))
457	goto drop;	457	goto drop;
458		458
459	/* If it's not Ethernet, delete it. */	459	/* If it's not Ethernet, delete it. */
460	if (rarp->ar_pro != htons(ETH_P_IP))	460	if (rarp->ar_pro != htons(ETH_P_IP))
461	goto drop;	461	goto drop;
462		462
463	if (!pskb_may_pull(skb,	463	if (!pskb_may_pull(skb,
464	sizeof(struct arphdr) +	464	sizeof(struct arphdr) +
465	(2 * dev->addr_len) +	465	(2 * dev->addr_len) +
466	(2 * 4)))	466	(2 * 4)))
467	goto drop;	467	goto drop;
468		468
469	/* OK, it is all there and looks valid, process... */	469	/* OK, it is all there and looks valid, process... */
470	rarp = (struct arphdr *)skb_transport_header(skb);	470	rarp = (struct arphdr *)skb_transport_header(skb);
471	rarp_ptr = (unsigned char *) (rarp + 1);	471	rarp_ptr = (unsigned char *) (rarp + 1);
472		472
473	/* One reply at a time, please. */	473	/* One reply at a time, please. */
474	spin_lock(&ic_recv_lock);	474	spin_lock(&ic_recv_lock);
475		475
476	/* If we already have a reply, just drop the packet */	476	/* If we already have a reply, just drop the packet */
477	if (ic_got_reply)	477	if (ic_got_reply)
478	goto drop_unlock;	478	goto drop_unlock;
479		479
480	/* Find the ic_device that the packet arrived on */	480	/* Find the ic_device that the packet arrived on */
481	d = ic_first_dev;	481	d = ic_first_dev;
482	while (d && d->dev != dev)	482	while (d && d->dev != dev)
483	d = d->next;	483	d = d->next;
484	if (!d)	484	if (!d)
485	goto drop_unlock; /* should never happen */	485	goto drop_unlock; /* should never happen */
486		486
487	/* Extract variable-width fields */	487	/* Extract variable-width fields */
488	sha = rarp_ptr;	488	sha = rarp_ptr;
489	rarp_ptr += dev->addr_len;	489	rarp_ptr += dev->addr_len;
490	memcpy(&sip, rarp_ptr, 4);	490	memcpy(&sip, rarp_ptr, 4);
491	rarp_ptr += 4;	491	rarp_ptr += 4;
492	tha = rarp_ptr;	492	tha = rarp_ptr;
493	rarp_ptr += dev->addr_len;	493	rarp_ptr += dev->addr_len;
494	memcpy(&tip, rarp_ptr, 4);	494	memcpy(&tip, rarp_ptr, 4);
495		495
496	/* Discard packets which are not meant for us. */	496	/* Discard packets which are not meant for us. */
497	if (memcmp(tha, dev->dev_addr, dev->addr_len))	497	if (memcmp(tha, dev->dev_addr, dev->addr_len))
498	goto drop_unlock;	498	goto drop_unlock;
499		499
500	/* Discard packets which are not from specified server. */	500	/* Discard packets which are not from specified server. */
501	if (ic_servaddr != NONE && ic_servaddr != sip)	501	if (ic_servaddr != NONE && ic_servaddr != sip)
502	goto drop_unlock;	502	goto drop_unlock;
503		503
504	/* We have a winner! */	504	/* We have a winner! */
505	ic_dev = dev;	505	ic_dev = dev;
506	if (ic_myaddr == NONE)	506	if (ic_myaddr == NONE)
507	ic_myaddr = tip;	507	ic_myaddr = tip;
508	ic_servaddr = sip;	508	ic_servaddr = sip;
509	ic_got_reply = IC_RARP;	509	ic_got_reply = IC_RARP;
510		510
511	drop_unlock:	511	drop_unlock:
512	/* Show's over. Nothing to see here. */	512	/* Show's over. Nothing to see here. */
513	spin_unlock(&ic_recv_lock);	513	spin_unlock(&ic_recv_lock);
514		514
515	drop:	515	drop:
516	/* Throw the packet out. */	516	/* Throw the packet out. */
517	kfree_skb(skb);	517	kfree_skb(skb);
518	return 0;	518	return 0;
519	}	519	}
520		520
521		521
522	/*	522	/*
523	* Send RARP request packet over a single interface.	523	* Send RARP request packet over a single interface.
524	*/	524	*/
525	static void __init ic_rarp_send_if(struct ic_device *d)	525	static void __init ic_rarp_send_if(struct ic_device *d)
526	{	526	{
527	struct net_device *dev = d->dev;	527	struct net_device *dev = d->dev;
528	arp_send(ARPOP_RREQUEST, ETH_P_RARP, 0, dev, 0, NULL,	528	arp_send(ARPOP_RREQUEST, ETH_P_RARP, 0, dev, 0, NULL,
529	dev->dev_addr, dev->dev_addr);	529	dev->dev_addr, dev->dev_addr);
530	}	530	}
531	#endif	531	#endif
532		532
533	/*	533	/*
534	* DHCP/BOOTP support.	534	* DHCP/BOOTP support.
535	*/	535	*/
536		536
537	#ifdef IPCONFIG_BOOTP	537	#ifdef IPCONFIG_BOOTP
538		538
539	struct bootp_pkt { /* BOOTP packet format */	539	struct bootp_pkt { /* BOOTP packet format */
540	struct iphdr iph; /* IP header */	540	struct iphdr iph; /* IP header */
541	struct udphdr udph; /* UDP header */	541	struct udphdr udph; /* UDP header */
542	u8 op; /* 1=request, 2=reply */	542	u8 op; /* 1=request, 2=reply */
543	u8 htype; /* HW address type */	543	u8 htype; /* HW address type */
544	u8 hlen; /* HW address length */	544	u8 hlen; /* HW address length */
545	u8 hops; /* Used only by gateways */	545	u8 hops; /* Used only by gateways */
546	__be32 xid; /* Transaction ID */	546	__be32 xid; /* Transaction ID */
547	__be16 secs; /* Seconds since we started */	547	__be16 secs; /* Seconds since we started */
548	__be16 flags; /* Just what it says */	548	__be16 flags; /* Just what it says */
549	__be32 client_ip; /* Client's IP address if known */	549	__be32 client_ip; /* Client's IP address if known */
550	__be32 your_ip; /* Assigned IP address */	550	__be32 your_ip; /* Assigned IP address */
551	__be32 server_ip; /* (Next, e.g. NFS) Server's IP address */	551	__be32 server_ip; /* (Next, e.g. NFS) Server's IP address */
552	__be32 relay_ip; /* IP address of BOOTP relay */	552	__be32 relay_ip; /* IP address of BOOTP relay */
553	u8 hw_addr[16]; /* Client's HW address */	553	u8 hw_addr[16]; /* Client's HW address */
554	u8 serv_name[64]; /* Server host name */	554	u8 serv_name[64]; /* Server host name */
555	u8 boot_file[128]; /* Name of boot file */	555	u8 boot_file[128]; /* Name of boot file */
556	u8 exten[312]; /* DHCP options / BOOTP vendor extensions */	556	u8 exten[312]; /* DHCP options / BOOTP vendor extensions */
557	};	557	};
558		558
559	/* packet ops */	559	/* packet ops */
560	#define BOOTP_REQUEST 1	560	#define BOOTP_REQUEST 1
561	#define BOOTP_REPLY 2	561	#define BOOTP_REPLY 2
562		562
563	/* DHCP message types */	563	/* DHCP message types */
564	#define DHCPDISCOVER 1	564	#define DHCPDISCOVER 1
565	#define DHCPOFFER 2	565	#define DHCPOFFER 2
566	#define DHCPREQUEST 3	566	#define DHCPREQUEST 3
567	#define DHCPDECLINE 4	567	#define DHCPDECLINE 4
568	#define DHCPACK 5	568	#define DHCPACK 5
569	#define DHCPNAK 6	569	#define DHCPNAK 6
570	#define DHCPRELEASE 7	570	#define DHCPRELEASE 7
571	#define DHCPINFORM 8	571	#define DHCPINFORM 8
572		572
573	static int ic_bootp_recv(struct sk_buff skb, struct net_device dev, struct packet_type pt, struct net_device orig_dev);	573	static int ic_bootp_recv(struct sk_buff skb, struct net_device dev, struct packet_type pt, struct net_device orig_dev);
574		574
575	static struct packet_type bootp_packet_type __initdata = {	575	static struct packet_type bootp_packet_type __initdata = {
576	.type = __constant_htons(ETH_P_IP),	576	.type = __constant_htons(ETH_P_IP),
577	.func = ic_bootp_recv,	577	.func = ic_bootp_recv,
578	};	578	};
579		579
580		580
581	/*	581	/*
582	* Initialize DHCP/BOOTP extension fields in the request.	582	* Initialize DHCP/BOOTP extension fields in the request.
583	*/	583	*/
584		584
585	static const u8 ic_bootp_cookie[4] = { 99, 130, 83, 99 };	585	static const u8 ic_bootp_cookie[4] = { 99, 130, 83, 99 };
586		586
587	#ifdef IPCONFIG_DHCP	587	#ifdef IPCONFIG_DHCP
588		588
589	static void __init	589	static void __init
590	ic_dhcp_init_options(u8 *options)	590	ic_dhcp_init_options(u8 *options)
591	{	591	{
592	u8 mt = ((ic_servaddr == NONE)	592	u8 mt = ((ic_servaddr == NONE)
593	? DHCPDISCOVER : DHCPREQUEST);	593	? DHCPDISCOVER : DHCPREQUEST);
594	u8 *e = options;	594	u8 *e = options;
595	int len;	595	int len;
596		596
597	#ifdef IPCONFIG_DEBUG	597	#ifdef IPCONFIG_DEBUG
598	printk("DHCP: Sending message type %d\n", mt);	598	printk("DHCP: Sending message type %d\n", mt);
599	#endif	599	#endif
600		600
601	memcpy(e, ic_bootp_cookie, 4); /* RFC1048 Magic Cookie */	601	memcpy(e, ic_bootp_cookie, 4); /* RFC1048 Magic Cookie */
602	e += 4;	602	e += 4;
603		603
604	e++ = 53; / DHCP message type */	604	e++ = 53; / DHCP message type */
605	*e++ = 1;	605	*e++ = 1;
606	*e++ = mt;	606	*e++ = mt;
607		607
608	if (mt == DHCPREQUEST) {	608	if (mt == DHCPREQUEST) {
609	e++ = 54; / Server ID (IP address) */	609	e++ = 54; / Server ID (IP address) */
610	*e++ = 4;	610	*e++ = 4;
611	memcpy(e, &ic_servaddr, 4);	611	memcpy(e, &ic_servaddr, 4);
612	e += 4;	612	e += 4;
613		613
614	e++ = 50; / Requested IP address */	614	e++ = 50; / Requested IP address */
615	*e++ = 4;	615	*e++ = 4;
616	memcpy(e, &ic_myaddr, 4);	616	memcpy(e, &ic_myaddr, 4);
617	e += 4;	617	e += 4;
618	}	618	}
619		619
620	/* always? */	620	/* always? */
621	{	621	{
622	static const u8 ic_req_params[] = {	622	static const u8 ic_req_params[] = {
623	1, /* Subnet mask */	623	1, /* Subnet mask */
624	3, /* Default gateway */	624	3, /* Default gateway */
625	6, /* DNS server */	625	6, /* DNS server */
626	12, /* Host name */	626	12, /* Host name */
627	15, /* Domain name */	627	15, /* Domain name */
628	17, /* Boot path */	628	17, /* Boot path */
629	40, /* NIS domain name */	629	40, /* NIS domain name */
630	};	630	};
631		631
632	e++ = 55; / Parameter request list */	632	e++ = 55; / Parameter request list */
633	*e++ = sizeof(ic_req_params);	633	*e++ = sizeof(ic_req_params);
634	memcpy(e, ic_req_params, sizeof(ic_req_params));	634	memcpy(e, ic_req_params, sizeof(ic_req_params));
635	e += sizeof(ic_req_params);	635	e += sizeof(ic_req_params);
636		636
637	if (*vendor_class_identifier) {	637	if (*vendor_class_identifier) {
638	printk(KERN_INFO "DHCP: sending class identifier \"%s\"\n",	638	printk(KERN_INFO "DHCP: sending class identifier \"%s\"\n",
639	vendor_class_identifier);	639	vendor_class_identifier);
640	e++ = 60; / Class-identifier */	640	e++ = 60; / Class-identifier */
641	len = strlen(vendor_class_identifier);	641	len = strlen(vendor_class_identifier);
642	*e++ = len;	642	*e++ = len;
643	memcpy(e, vendor_class_identifier, len);	643	memcpy(e, vendor_class_identifier, len);
644	e += len;	644	e += len;
645	}	645	}
646	}	646	}
647		647
648	e++ = 255; / End of the list */	648	e++ = 255; / End of the list */
649	}	649	}
650		650
651	#endif /* IPCONFIG_DHCP */	651	#endif /* IPCONFIG_DHCP */
652		652
653	static void __init ic_bootp_init_ext(u8 *e)	653	static void __init ic_bootp_init_ext(u8 *e)
654	{	654	{
655	memcpy(e, ic_bootp_cookie, 4); /* RFC1048 Magic Cookie */	655	memcpy(e, ic_bootp_cookie, 4); /* RFC1048 Magic Cookie */
656	e += 4;	656	e += 4;
657	e++ = 1; / Subnet mask request */	657	e++ = 1; / Subnet mask request */
658	*e++ = 4;	658	*e++ = 4;
659	e += 4;	659	e += 4;
660	e++ = 3; / Default gateway request */	660	e++ = 3; / Default gateway request */
661	*e++ = 4;	661	*e++ = 4;
662	e += 4;	662	e += 4;
663	e++ = 5; / Name server request */	663	e++ = 5; / Name server request */
664	*e++ = 8;	664	*e++ = 8;
665	e += 8;	665	e += 8;
666	e++ = 12; / Host name request */	666	e++ = 12; / Host name request */
667	*e++ = 32;	667	*e++ = 32;
668	e += 32;	668	e += 32;
669	e++ = 40; / NIS Domain name request */	669	e++ = 40; / NIS Domain name request */
670	*e++ = 32;	670	*e++ = 32;
671	e += 32;	671	e += 32;
672	e++ = 17; / Boot path */	672	e++ = 17; / Boot path */
673	*e++ = 40;	673	*e++ = 40;
674	e += 40;	674	e += 40;
675		675
676	e++ = 57; / set extension buffer size for reply */	676	e++ = 57; / set extension buffer size for reply */
677	*e++ = 2;	677	*e++ = 2;
678	e++ = 1; / 128+236+8+20+14, see dhcpd sources */	678	e++ = 1; / 128+236+8+20+14, see dhcpd sources */
679	*e++ = 150;	679	*e++ = 150;
680		680
681	e++ = 255; / End of the list */	681	e++ = 255; / End of the list */
682	}	682	}
683		683
684		684
685	/*	685	/*
686	* Initialize the DHCP/BOOTP mechanism.	686	* Initialize the DHCP/BOOTP mechanism.
687	*/	687	*/
688	static inline void ic_bootp_init(void)	688	static inline void ic_bootp_init(void)
689	{	689	{
690	int i;	690	int i;
691		691
692	for (i = 0; i < CONF_NAMESERVERS_MAX; i++)	692	for (i = 0; i < CONF_NAMESERVERS_MAX; i++)
693	ic_nameservers[i] = NONE;	693	ic_nameservers[i] = NONE;
694		694
695	dev_add_pack(&bootp_packet_type);	695	dev_add_pack(&bootp_packet_type);
696	}	696	}
697		697
698		698
699	/*	699	/*
700	* DHCP/BOOTP cleanup.	700	* DHCP/BOOTP cleanup.
701	*/	701	*/
702	static inline void ic_bootp_cleanup(void)	702	static inline void ic_bootp_cleanup(void)
703	{	703	{
704	dev_remove_pack(&bootp_packet_type);	704	dev_remove_pack(&bootp_packet_type);
705	}	705	}
706		706
707		707
708	/*	708	/*
709	* Send DHCP/BOOTP request to single interface.	709	* Send DHCP/BOOTP request to single interface.
710	*/	710	*/
711	static void __init ic_bootp_send_if(struct ic_device *d, unsigned long jiffies_diff)	711	static void __init ic_bootp_send_if(struct ic_device *d, unsigned long jiffies_diff)
712	{	712	{
713	struct net_device *dev = d->dev;	713	struct net_device *dev = d->dev;
714	struct sk_buff *skb;	714	struct sk_buff *skb;
715	struct bootp_pkt *b;	715	struct bootp_pkt *b;
716	int hh_len = LL_RESERVED_SPACE(dev);	716	int hh_len = LL_RESERVED_SPACE(dev);
717	struct iphdr *h;	717	struct iphdr *h;
718		718
719	/* Allocate packet */	719	/* Allocate packet */
720	skb = alloc_skb(sizeof(struct bootp_pkt) + hh_len + 15, GFP_KERNEL);	720	skb = alloc_skb(sizeof(struct bootp_pkt) + hh_len + 15, GFP_KERNEL);
721	if (!skb)	721	if (!skb)
722	return;	722	return;
723	skb_reserve(skb, hh_len);	723	skb_reserve(skb, hh_len);
724	b = (struct bootp_pkt *) skb_put(skb, sizeof(struct bootp_pkt));	724	b = (struct bootp_pkt *) skb_put(skb, sizeof(struct bootp_pkt));
725	memset(b, 0, sizeof(struct bootp_pkt));	725	memset(b, 0, sizeof(struct bootp_pkt));
726		726
727	/* Construct IP header */	727	/* Construct IP header */
728	skb_reset_network_header(skb);	728	skb_reset_network_header(skb);
729	h = ip_hdr(skb);	729	h = ip_hdr(skb);
730	h->version = 4;	730	h->version = 4;
731	h->ihl = 5;	731	h->ihl = 5;
732	h->tot_len = htons(sizeof(struct bootp_pkt));	732	h->tot_len = htons(sizeof(struct bootp_pkt));
733	h->frag_off = htons(IP_DF);	733	h->frag_off = htons(IP_DF);
734	h->ttl = 64;	734	h->ttl = 64;
735	h->protocol = IPPROTO_UDP;	735	h->protocol = IPPROTO_UDP;
736	h->daddr = htonl(INADDR_BROADCAST);	736	h->daddr = htonl(INADDR_BROADCAST);
737	h->check = ip_fast_csum((unsigned char *) h, h->ihl);	737	h->check = ip_fast_csum((unsigned char *) h, h->ihl);
738		738
739	/* Construct UDP header */	739	/* Construct UDP header */
740	b->udph.source = htons(68);	740	b->udph.source = htons(68);
741	b->udph.dest = htons(67);	741	b->udph.dest = htons(67);
742	b->udph.len = htons(sizeof(struct bootp_pkt) - sizeof(struct iphdr));	742	b->udph.len = htons(sizeof(struct bootp_pkt) - sizeof(struct iphdr));
743	/* UDP checksum not calculated -- explicitly allowed in BOOTP RFC */	743	/* UDP checksum not calculated -- explicitly allowed in BOOTP RFC */
744		744
745	/* Construct DHCP/BOOTP header */	745	/* Construct DHCP/BOOTP header */
746	b->op = BOOTP_REQUEST;	746	b->op = BOOTP_REQUEST;
747	if (dev->type < 256) /* check for false types */	747	if (dev->type < 256) /* check for false types */
748	b->htype = dev->type;	748	b->htype = dev->type;
749	else if (dev->type == ARPHRD_IEEE802_TR) /* fix for token ring */	749	else if (dev->type == ARPHRD_IEEE802_TR) /* fix for token ring */
750	b->htype = ARPHRD_IEEE802;	750	b->htype = ARPHRD_IEEE802;
751	else if (dev->type == ARPHRD_FDDI)	751	else if (dev->type == ARPHRD_FDDI)
752	b->htype = ARPHRD_ETHER;	752	b->htype = ARPHRD_ETHER;
753	else {	753	else {
754	printk("Unknown ARP type 0x%04x for device %s\n", dev->type, dev->name);	754	printk("Unknown ARP type 0x%04x for device %s\n", dev->type, dev->name);
755	b->htype = dev->type; /* can cause undefined behavior */	755	b->htype = dev->type; /* can cause undefined behavior */
756	}	756	}
757		757
758	/* server_ip and your_ip address are both already zero per RFC2131 */	758	/* server_ip and your_ip address are both already zero per RFC2131 */
759	b->hlen = dev->addr_len;	759	b->hlen = dev->addr_len;
760	memcpy(b->hw_addr, dev->dev_addr, dev->addr_len);	760	memcpy(b->hw_addr, dev->dev_addr, dev->addr_len);
761	b->secs = htons(jiffies_diff / HZ);	761	b->secs = htons(jiffies_diff / HZ);
762	b->xid = d->xid;	762	b->xid = d->xid;
763		763
764	/* add DHCP options or BOOTP extensions */	764	/* add DHCP options or BOOTP extensions */
765	#ifdef IPCONFIG_DHCP	765	#ifdef IPCONFIG_DHCP
766	if (ic_proto_enabled & IC_USE_DHCP)	766	if (ic_proto_enabled & IC_USE_DHCP)
767	ic_dhcp_init_options(b->exten);	767	ic_dhcp_init_options(b->exten);
768	else	768	else
769	#endif	769	#endif
770	ic_bootp_init_ext(b->exten);	770	ic_bootp_init_ext(b->exten);
771		771
772	/* Chain packet down the line... */	772	/* Chain packet down the line... */
773	skb->dev = dev;	773	skb->dev = dev;
774	skb->protocol = htons(ETH_P_IP);	774	skb->protocol = htons(ETH_P_IP);
775	if (dev_hard_header(skb, dev, ntohs(skb->protocol),	775	if (dev_hard_header(skb, dev, ntohs(skb->protocol),
776	dev->broadcast, dev->dev_addr, skb->len) < 0 \|\|	776	dev->broadcast, dev->dev_addr, skb->len) < 0 \|\|
777	dev_queue_xmit(skb) < 0)	777	dev_queue_xmit(skb) < 0)
778	printk("E");	778	printk("E");
779	}	779	}
780		780
781		781
782	/*	782	/*
783	* Copy BOOTP-supplied string if not already set.	783	* Copy BOOTP-supplied string if not already set.
784	*/	784	*/
785	static int __init ic_bootp_string(char dest, char src, int len, int max)	785	static int __init ic_bootp_string(char dest, char src, int len, int max)
786	{	786	{
787	if (!len)	787	if (!len)
788	return 0;	788	return 0;
789	if (len > max-1)	789	if (len > max-1)
790	len = max-1;	790	len = max-1;
791	memcpy(dest, src, len);	791	memcpy(dest, src, len);
792	dest[len] = '\0';	792	dest[len] = '\0';
793	return 1;	793	return 1;
794	}	794	}
795		795
796		796
797	/*	797	/*
798	* Process BOOTP extensions.	798	* Process BOOTP extensions.
799	*/	799	*/
800	static void __init ic_do_bootp_ext(u8 *ext)	800	static void __init ic_do_bootp_ext(u8 *ext)
801	{	801	{
802	u8 servers;	802	u8 servers;
803	int i;	803	int i;
804		804
805	#ifdef IPCONFIG_DEBUG	805	#ifdef IPCONFIG_DEBUG
806	u8 *c;	806	u8 *c;
807		807
808	printk("DHCP/BOOTP: Got extension %d:",*ext);	808	printk("DHCP/BOOTP: Got extension %d:",*ext);
809	for (c=ext+2; c<ext+2+ext[1]; c++)	809	for (c=ext+2; c<ext+2+ext[1]; c++)
810	printk(" %02x", *c);	810	printk(" %02x", *c);
811	printk("\n");	811	printk("\n");
812	#endif	812	#endif
813		813
814	switch (*ext++) {	814	switch (*ext++) {
815	case 1: /* Subnet mask */	815	case 1: /* Subnet mask */
816	if (ic_netmask == NONE)	816	if (ic_netmask == NONE)
817	memcpy(&ic_netmask, ext+1, 4);	817	memcpy(&ic_netmask, ext+1, 4);
818	break;	818	break;
819	case 3: /* Default gateway */	819	case 3: /* Default gateway */
820	if (ic_gateway == NONE)	820	if (ic_gateway == NONE)
821	memcpy(&ic_gateway, ext+1, 4);	821	memcpy(&ic_gateway, ext+1, 4);
822	break;	822	break;
823	case 6: /* DNS server */	823	case 6: /* DNS server */
824	servers= *ext/4;	824	servers= *ext/4;
825	if (servers > CONF_NAMESERVERS_MAX)	825	if (servers > CONF_NAMESERVERS_MAX)
826	servers = CONF_NAMESERVERS_MAX;	826	servers = CONF_NAMESERVERS_MAX;
827	for (i = 0; i < servers; i++) {	827	for (i = 0; i < servers; i++) {
828	if (ic_nameservers[i] == NONE)	828	if (ic_nameservers[i] == NONE)
829	memcpy(&ic_nameservers[i], ext+1+4*i, 4);	829	memcpy(&ic_nameservers[i], ext+1+4*i, 4);
830	}	830	}
831	break;	831	break;
832	case 12: /* Host name */	832	case 12: /* Host name */
833	ic_bootp_string(utsname()->nodename, ext+1, *ext, __NEW_UTS_LEN);	833	ic_bootp_string(utsname()->nodename, ext+1, *ext, __NEW_UTS_LEN);
834	ic_host_name_set = 1;	834	ic_host_name_set = 1;
835	break;	835	break;
836	case 15: /* Domain name (DNS) */	836	case 15: /* Domain name (DNS) */
837	ic_bootp_string(ic_domain, ext+1, *ext, sizeof(ic_domain));	837	ic_bootp_string(ic_domain, ext+1, *ext, sizeof(ic_domain));
838	break;	838	break;
839	case 17: /* Root path */	839	case 17: /* Root path */
840	if (!root_server_path[0])	840	if (!root_server_path[0])
841	ic_bootp_string(root_server_path, ext+1, *ext, sizeof(root_server_path));	841	ic_bootp_string(root_server_path, ext+1, *ext, sizeof(root_server_path));
842	break;	842	break;
843	case 40: /* NIS Domain name (_not_ DNS) */	843	case 40: /* NIS Domain name (_not_ DNS) */
844	ic_bootp_string(utsname()->domainname, ext+1, *ext, __NEW_UTS_LEN);	844	ic_bootp_string(utsname()->domainname, ext+1, *ext, __NEW_UTS_LEN);
845	break;	845	break;
846	}	846	}
847	}	847	}
848		848
849		849
850	/*	850	/*
851	* Receive BOOTP reply.	851	* Receive BOOTP reply.
852	*/	852	*/
853	static int __init ic_bootp_recv(struct sk_buff skb, struct net_device dev, struct packet_type pt, struct net_device orig_dev)	853	static int __init ic_bootp_recv(struct sk_buff skb, struct net_device dev, struct packet_type pt, struct net_device orig_dev)
854	{	854	{
855	struct bootp_pkt *b;	855	struct bootp_pkt *b;
856	struct iphdr *h;	856	struct iphdr *h;
857	struct ic_device *d;	857	struct ic_device *d;
858	int len, ext_len;	858	int len, ext_len;
859		859
860	if (dev->nd_net != &init_net)	860	if (dev->nd_net != &init_net)
861	goto drop;	861	goto drop;
862		862
863	/* Perform verifications before taking the lock. */	863	/* Perform verifications before taking the lock. */
864	if (skb->pkt_type == PACKET_OTHERHOST)	864	if (skb->pkt_type == PACKET_OTHERHOST)
865	goto drop;	865	goto drop;
866		866
867	if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)	867	if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
868	return NET_RX_DROP;	868	return NET_RX_DROP;
869		869
870	if (!pskb_may_pull(skb,	870	if (!pskb_may_pull(skb,
871	sizeof(struct iphdr) +	871	sizeof(struct iphdr) +
872	sizeof(struct udphdr)))	872	sizeof(struct udphdr)))
873	goto drop;	873	goto drop;
874		874
875	b = (struct bootp_pkt *)skb_network_header(skb);	875	b = (struct bootp_pkt *)skb_network_header(skb);
876	h = &b->iph;	876	h = &b->iph;
877		877
878	if (h->ihl != 5 \|\| h->version != 4 \|\| h->protocol != IPPROTO_UDP)	878	if (h->ihl != 5 \|\| h->version != 4 \|\| h->protocol != IPPROTO_UDP)
879	goto drop;	879	goto drop;
880		880
881	/* Fragments are not supported */	881	/* Fragments are not supported */
882	if (h->frag_off & htons(IP_OFFSET \| IP_MF)) {	882	if (h->frag_off & htons(IP_OFFSET \| IP_MF)) {
883	if (net_ratelimit())	883	if (net_ratelimit())
884	printk(KERN_ERR "DHCP/BOOTP: Ignoring fragmented "	884	printk(KERN_ERR "DHCP/BOOTP: Ignoring fragmented "
885	"reply.\n");	885	"reply.\n");
886	goto drop;	886	goto drop;
887	}	887	}
888		888
889	if (skb->len < ntohs(h->tot_len))	889	if (skb->len < ntohs(h->tot_len))
890	goto drop;	890	goto drop;
891		891
892	if (ip_fast_csum((char *) h, h->ihl))	892	if (ip_fast_csum((char *) h, h->ihl))
893	goto drop;	893	goto drop;
894		894
895	if (b->udph.source != htons(67) \|\| b->udph.dest != htons(68))	895	if (b->udph.source != htons(67) \|\| b->udph.dest != htons(68))
896	goto drop;	896	goto drop;
897		897
898	if (ntohs(h->tot_len) < ntohs(b->udph.len) + sizeof(struct iphdr))	898	if (ntohs(h->tot_len) < ntohs(b->udph.len) + sizeof(struct iphdr))
899	goto drop;	899	goto drop;
900		900
901	len = ntohs(b->udph.len) - sizeof(struct udphdr);	901	len = ntohs(b->udph.len) - sizeof(struct udphdr);
902	ext_len = len - (sizeof(*b) -	902	ext_len = len - (sizeof(*b) -
903	sizeof(struct iphdr) -	903	sizeof(struct iphdr) -
904	sizeof(struct udphdr) -	904	sizeof(struct udphdr) -
905	sizeof(b->exten));	905	sizeof(b->exten));
906	if (ext_len < 0)	906	if (ext_len < 0)
907	goto drop;	907	goto drop;
908		908
909	/* Ok the front looks good, make sure we can get at the rest. */	909	/* Ok the front looks good, make sure we can get at the rest. */
910	if (!pskb_may_pull(skb, skb->len))	910	if (!pskb_may_pull(skb, skb->len))
911	goto drop;	911	goto drop;
912		912
913	b = (struct bootp_pkt *)skb_network_header(skb);	913	b = (struct bootp_pkt *)skb_network_header(skb);
914	h = &b->iph;	914	h = &b->iph;
915		915
916	/* One reply at a time, please. */	916	/* One reply at a time, please. */
917	spin_lock(&ic_recv_lock);	917	spin_lock(&ic_recv_lock);
918		918
919	/* If we already have a reply, just drop the packet */	919	/* If we already have a reply, just drop the packet */
920	if (ic_got_reply)	920	if (ic_got_reply)
921	goto drop_unlock;	921	goto drop_unlock;
922		922
923	/* Find the ic_device that the packet arrived on */	923	/* Find the ic_device that the packet arrived on */
924	d = ic_first_dev;	924	d = ic_first_dev;
925	while (d && d->dev != dev)	925	while (d && d->dev != dev)
926	d = d->next;	926	d = d->next;
927	if (!d)	927	if (!d)
928	goto drop_unlock; /* should never happen */	928	goto drop_unlock; /* should never happen */
929		929
930	/* Is it a reply to our BOOTP request? */	930	/* Is it a reply to our BOOTP request? */
931	if (b->op != BOOTP_REPLY \|\|	931	if (b->op != BOOTP_REPLY \|\|
932	b->xid != d->xid) {	932	b->xid != d->xid) {
933	if (net_ratelimit())	933	if (net_ratelimit())
934	printk(KERN_ERR "DHCP/BOOTP: Reply not for us, "	934	printk(KERN_ERR "DHCP/BOOTP: Reply not for us, "
935	"op[%x] xid[%x]\n",	935	"op[%x] xid[%x]\n",
936	b->op, b->xid);	936	b->op, b->xid);
937	goto drop_unlock;	937	goto drop_unlock;
938	}	938	}
939		939
940	/* Parse extensions */	940	/* Parse extensions */
941	if (ext_len >= 4 &&	941	if (ext_len >= 4 &&
942	!memcmp(b->exten, ic_bootp_cookie, 4)) { /* Check magic cookie */	942	!memcmp(b->exten, ic_bootp_cookie, 4)) { /* Check magic cookie */
943	u8 end = (u8 ) b + ntohs(b->iph.tot_len);	943	u8 end = (u8 ) b + ntohs(b->iph.tot_len);
944	u8 *ext;	944	u8 *ext;
945		945
946	#ifdef IPCONFIG_DHCP	946	#ifdef IPCONFIG_DHCP
947	if (ic_proto_enabled & IC_USE_DHCP) {	947	if (ic_proto_enabled & IC_USE_DHCP) {
948	__be32 server_id = NONE;	948	__be32 server_id = NONE;
949	int mt = 0;	949	int mt = 0;
950		950
951	ext = &b->exten[4];	951	ext = &b->exten[4];
952	while (ext < end && *ext != 0xff) {	952	while (ext < end && *ext != 0xff) {
953	u8 *opt = ext++;	953	u8 *opt = ext++;
954	if (opt == 0) / Padding */	954	if (opt == 0) / Padding */
955	continue;	955	continue;
956	ext += *ext + 1;	956	ext += *ext + 1;
957	if (ext >= end)	957	if (ext >= end)
958	break;	958	break;
959	switch (*opt) {	959	switch (*opt) {
960	case 53: /* Message type */	960	case 53: /* Message type */
961	if (opt[1])	961	if (opt[1])
962	mt = opt[2];	962	mt = opt[2];
963	break;	963	break;
964	case 54: /* Server ID (IP address) */	964	case 54: /* Server ID (IP address) */
965	if (opt[1] >= 4)	965	if (opt[1] >= 4)
966	memcpy(&server_id, opt + 2, 4);	966	memcpy(&server_id, opt + 2, 4);
967	break;	967	break;
968	}	968	}
969	}	969	}
970		970
971	#ifdef IPCONFIG_DEBUG	971	#ifdef IPCONFIG_DEBUG
972	printk("DHCP: Got message type %d\n", mt);	972	printk("DHCP: Got message type %d\n", mt);
973	#endif	973	#endif
974		974
975	switch (mt) {	975	switch (mt) {
976	case DHCPOFFER:	976	case DHCPOFFER:
977	/* While in the process of accepting one offer,	977	/* While in the process of accepting one offer,
978	* ignore all others.	978	* ignore all others.
979	*/	979	*/
980	if (ic_myaddr != NONE)	980	if (ic_myaddr != NONE)
981	goto drop_unlock;	981	goto drop_unlock;
982		982
983	/* Let's accept that offer. */	983	/* Let's accept that offer. */
984	ic_myaddr = b->your_ip;	984	ic_myaddr = b->your_ip;
985	ic_servaddr = server_id;	985	ic_servaddr = server_id;
986	#ifdef IPCONFIG_DEBUG	986	#ifdef IPCONFIG_DEBUG
987	printk("DHCP: Offered address %u.%u.%u.%u",	987	printk("DHCP: Offered address %u.%u.%u.%u",
988	NIPQUAD(ic_myaddr));	988	NIPQUAD(ic_myaddr));
989	printk(" by server %u.%u.%u.%u\n",	989	printk(" by server %u.%u.%u.%u\n",
990	NIPQUAD(ic_servaddr));	990	NIPQUAD(ic_servaddr));
991	#endif	991	#endif
992	/* The DHCP indicated server address takes	992	/* The DHCP indicated server address takes
993	* precedence over the bootp header one if	993	* precedence over the bootp header one if
994	* they are different.	994	* they are different.
995	*/	995	*/
996	if ((server_id != NONE) &&	996	if ((server_id != NONE) &&
997	(b->server_ip != server_id))	997	(b->server_ip != server_id))
998	b->server_ip = ic_servaddr;	998	b->server_ip = ic_servaddr;
999	break;	999	break;
1000		1000
1001	case DHCPACK:	1001	case DHCPACK:
1002	if (memcmp(dev->dev_addr, b->hw_addr, dev->addr_len) != 0)	1002	if (memcmp(dev->dev_addr, b->hw_addr, dev->addr_len) != 0)
1003	goto drop_unlock;	1003	goto drop_unlock;
1004		1004
1005	/* Yeah! */	1005	/* Yeah! */
1006	break;	1006	break;
1007		1007
1008	default:	1008	default:
1009	/* Urque. Forget it*/	1009	/* Urque. Forget it*/
1010	ic_myaddr = NONE;	1010	ic_myaddr = NONE;
1011	ic_servaddr = NONE;	1011	ic_servaddr = NONE;
1012	goto drop_unlock;	1012	goto drop_unlock;
1013	}	1013	}
1014		1014
1015	ic_dhcp_msgtype = mt;	1015	ic_dhcp_msgtype = mt;
1016		1016
1017	}	1017	}
1018	#endif /* IPCONFIG_DHCP */	1018	#endif /* IPCONFIG_DHCP */
1019		1019
1020	ext = &b->exten[4];	1020	ext = &b->exten[4];
1021	while (ext < end && *ext != 0xff) {	1021	while (ext < end && *ext != 0xff) {
1022	u8 *opt = ext++;	1022	u8 *opt = ext++;
1023	if (opt == 0) / Padding */	1023	if (opt == 0) / Padding */
1024	continue;	1024	continue;
1025	ext += *ext + 1;	1025	ext += *ext + 1;
1026	if (ext < end)	1026	if (ext < end)
1027	ic_do_bootp_ext(opt);	1027	ic_do_bootp_ext(opt);
1028	}	1028	}
1029	}	1029	}
1030		1030
1031	/* We have a winner! */	1031	/* We have a winner! */
1032	ic_dev = dev;	1032	ic_dev = dev;
1033	ic_myaddr = b->your_ip;	1033	ic_myaddr = b->your_ip;
1034	ic_servaddr = b->server_ip;	1034	ic_servaddr = b->server_ip;
1035	if (ic_gateway == NONE && b->relay_ip)	1035	if (ic_gateway == NONE && b->relay_ip)
1036	ic_gateway = b->relay_ip;	1036	ic_gateway = b->relay_ip;
1037	if (ic_nameservers[0] == NONE)	1037	if (ic_nameservers[0] == NONE)
1038	ic_nameservers[0] = ic_servaddr;	1038	ic_nameservers[0] = ic_servaddr;
1039	ic_got_reply = IC_BOOTP;	1039	ic_got_reply = IC_BOOTP;
1040		1040
1041	drop_unlock:	1041	drop_unlock:
1042	/* Show's over. Nothing to see here. */	1042	/* Show's over. Nothing to see here. */
1043	spin_unlock(&ic_recv_lock);	1043	spin_unlock(&ic_recv_lock);
1044		1044
1045	drop:	1045	drop:
1046	/* Throw the packet out. */	1046	/* Throw the packet out. */
1047	kfree_skb(skb);	1047	kfree_skb(skb);
1048		1048
1049	return 0;	1049	return 0;
1050	}	1050	}
1051		1051
1052		1052
1053	#endif	1053	#endif
1054		1054
1055		1055
1056	/*	1056	/*
1057	* Dynamic IP configuration -- DHCP, BOOTP, RARP.	1057	* Dynamic IP configuration -- DHCP, BOOTP, RARP.
1058	*/	1058	*/
1059		1059
1060	#ifdef IPCONFIG_DYNAMIC	1060	#ifdef IPCONFIG_DYNAMIC
1061		1061
1062	static int __init ic_dynamic(void)	1062	static int __init ic_dynamic(void)
1063	{	1063	{
1064	int retries;	1064	int retries;
1065	struct ic_device *d;	1065	struct ic_device *d;
1066	unsigned long start_jiffies, timeout, jiff;	1066	unsigned long start_jiffies, timeout, jiff;
1067	int do_bootp = ic_proto_have_if & IC_BOOTP;	1067	int do_bootp = ic_proto_have_if & IC_BOOTP;
1068	int do_rarp = ic_proto_have_if & IC_RARP;	1068	int do_rarp = ic_proto_have_if & IC_RARP;
1069		1069
1070	/*	1070	/*
1071	* If none of DHCP/BOOTP/RARP was selected, return with an error.	1071	* If none of DHCP/BOOTP/RARP was selected, return with an error.
1072	* This routine gets only called when some pieces of information	1072	* This routine gets only called when some pieces of information
1073	* are missing, and without DHCP/BOOTP/RARP we are unable to get it.	1073	* are missing, and without DHCP/BOOTP/RARP we are unable to get it.
1074	*/	1074	*/
1075	if (!ic_proto_enabled) {	1075	if (!ic_proto_enabled) {
1076	printk(KERN_ERR "IP-Config: Incomplete network configuration information.\n");	1076	printk(KERN_ERR "IP-Config: Incomplete network configuration information.\n");
1077	return -1;	1077	return -1;
1078	}	1078	}
1079		1079
1080	#ifdef IPCONFIG_BOOTP	1080	#ifdef IPCONFIG_BOOTP
1081	if ((ic_proto_enabled ^ ic_proto_have_if) & IC_BOOTP)	1081	if ((ic_proto_enabled ^ ic_proto_have_if) & IC_BOOTP)
1082	printk(KERN_ERR "DHCP/BOOTP: No suitable device found.\n");	1082	printk(KERN_ERR "DHCP/BOOTP: No suitable device found.\n");
1083	#endif	1083	#endif
1084	#ifdef IPCONFIG_RARP	1084	#ifdef IPCONFIG_RARP
1085	if ((ic_proto_enabled ^ ic_proto_have_if) & IC_RARP)	1085	if ((ic_proto_enabled ^ ic_proto_have_if) & IC_RARP)
1086	printk(KERN_ERR "RARP: No suitable device found.\n");	1086	printk(KERN_ERR "RARP: No suitable device found.\n");
1087	#endif	1087	#endif
1088		1088
1089	if (!ic_proto_have_if)	1089	if (!ic_proto_have_if)
1090	/* Error message already printed */	1090	/* Error message already printed */
1091	return -1;	1091	return -1;
1092		1092
1093	/*	1093	/*
1094	* Setup protocols	1094	* Setup protocols
1095	*/	1095	*/
1096	#ifdef IPCONFIG_BOOTP	1096	#ifdef IPCONFIG_BOOTP
1097	if (do_bootp)	1097	if (do_bootp)
1098	ic_bootp_init();	1098	ic_bootp_init();
1099	#endif	1099	#endif
1100	#ifdef IPCONFIG_RARP	1100	#ifdef IPCONFIG_RARP
1101	if (do_rarp)	1101	if (do_rarp)
1102	ic_rarp_init();	1102	ic_rarp_init();
1103	#endif	1103	#endif
1104		1104
1105	/*	1105	/*
1106	* Send requests and wait, until we get an answer. This loop	1106	* Send requests and wait, until we get an answer. This loop
1107	* seems to be a terrible waste of CPU time, but actually there is	1107	* seems to be a terrible waste of CPU time, but actually there is
1108	* only one process running at all, so we don't need to use any	1108	* only one process running at all, so we don't need to use any
1109	* scheduler functions.	1109	* scheduler functions.
1110	* [Actually we could now, but the nothing else running note still	1110	* [Actually we could now, but the nothing else running note still
1111	* applies.. - AC]	1111	* applies.. - AC]
1112	*/	1112	*/
1113	printk(KERN_NOTICE "Sending %s%s%s requests .",	1113	printk(KERN_NOTICE "Sending %s%s%s requests .",
1114	do_bootp	1114	do_bootp
1115	? ((ic_proto_enabled & IC_USE_DHCP) ? "DHCP" : "BOOTP") : "",	1115	? ((ic_proto_enabled & IC_USE_DHCP) ? "DHCP" : "BOOTP") : "",
1116	(do_bootp && do_rarp) ? " and " : "",	1116	(do_bootp && do_rarp) ? " and " : "",
1117	do_rarp ? "RARP" : "");	1117	do_rarp ? "RARP" : "");
1118		1118
1119	start_jiffies = jiffies;	1119	start_jiffies = jiffies;
1120	d = ic_first_dev;	1120	d = ic_first_dev;
1121	retries = CONF_SEND_RETRIES;	1121	retries = CONF_SEND_RETRIES;
1122	get_random_bytes(&timeout, sizeof(timeout));	1122	get_random_bytes(&timeout, sizeof(timeout));
1123	timeout = CONF_BASE_TIMEOUT + (timeout % (unsigned) CONF_TIMEOUT_RANDOM);	1123	timeout = CONF_BASE_TIMEOUT + (timeout % (unsigned) CONF_TIMEOUT_RANDOM);
1124	for (;;) {	1124	for (;;) {
1125	#ifdef IPCONFIG_BOOTP	1125	#ifdef IPCONFIG_BOOTP
1126	if (do_bootp && (d->able & IC_BOOTP))	1126	if (do_bootp && (d->able & IC_BOOTP))
1127	ic_bootp_send_if(d, jiffies - start_jiffies);	1127	ic_bootp_send_if(d, jiffies - start_jiffies);
1128	#endif	1128	#endif
1129	#ifdef IPCONFIG_RARP	1129	#ifdef IPCONFIG_RARP
1130	if (do_rarp && (d->able & IC_RARP))	1130	if (do_rarp && (d->able & IC_RARP))
1131	ic_rarp_send_if(d);	1131	ic_rarp_send_if(d);
1132	#endif	1132	#endif
1133		1133
1134	jiff = jiffies + (d->next ? CONF_INTER_TIMEOUT : timeout);	1134	jiff = jiffies + (d->next ? CONF_INTER_TIMEOUT : timeout);
1135	while (time_before(jiffies, jiff) && !ic_got_reply)	1135	while (time_before(jiffies, jiff) && !ic_got_reply)
1136	schedule_timeout_uninterruptible(1);	1136	schedule_timeout_uninterruptible(1);
1137	#ifdef IPCONFIG_DHCP	1137	#ifdef IPCONFIG_DHCP
1138	/* DHCP isn't done until we get a DHCPACK. */	1138	/* DHCP isn't done until we get a DHCPACK. */
1139	if ((ic_got_reply & IC_BOOTP)	1139	if ((ic_got_reply & IC_BOOTP)
1140	&& (ic_proto_enabled & IC_USE_DHCP)	1140	&& (ic_proto_enabled & IC_USE_DHCP)
1141	&& ic_dhcp_msgtype != DHCPACK)	1141	&& ic_dhcp_msgtype != DHCPACK)
1142	{	1142	{
1143	ic_got_reply = 0;	1143	ic_got_reply = 0;
1144	printk(",");	1144	printk(",");
1145	continue;	1145	continue;
1146	}	1146	}
1147	#endif /* IPCONFIG_DHCP */	1147	#endif /* IPCONFIG_DHCP */
1148		1148
1149	if (ic_got_reply) {	1149	if (ic_got_reply) {
1150	printk(" OK\n");	1150	printk(" OK\n");
1151	break;	1151	break;
1152	}	1152	}
1153		1153
1154	if ((d = d->next))	1154	if ((d = d->next))
1155	continue;	1155	continue;
1156		1156
1157	if (! --retries) {	1157	if (! --retries) {
1158	printk(" timed out!\n");	1158	printk(" timed out!\n");
1159	break;	1159	break;
1160	}	1160	}
1161		1161
1162	d = ic_first_dev;	1162	d = ic_first_dev;
1163		1163
1164	timeout = timeout CONF_TIMEOUT_MULT;	1164	timeout = timeout CONF_TIMEOUT_MULT;
1165	if (timeout > CONF_TIMEOUT_MAX)	1165	if (timeout > CONF_TIMEOUT_MAX)
1166	timeout = CONF_TIMEOUT_MAX;	1166	timeout = CONF_TIMEOUT_MAX;
1167		1167
1168	printk(".");	1168	printk(".");
1169	}	1169	}
1170		1170
1171	#ifdef IPCONFIG_BOOTP	1171	#ifdef IPCONFIG_BOOTP
1172	if (do_bootp)	1172	if (do_bootp)
1173	ic_bootp_cleanup();	1173	ic_bootp_cleanup();
1174	#endif	1174	#endif
1175	#ifdef IPCONFIG_RARP	1175	#ifdef IPCONFIG_RARP
1176	if (do_rarp)	1176	if (do_rarp)
1177	ic_rarp_cleanup();	1177	ic_rarp_cleanup();
1178	#endif	1178	#endif
1179		1179
1180	if (!ic_got_reply) {	1180	if (!ic_got_reply) {
1181	ic_myaddr = NONE;	1181	ic_myaddr = NONE;
1182	return -1;	1182	return -1;
1183	}	1183	}
1184		1184
1185	printk("IP-Config: Got %s answer from %u.%u.%u.%u, ",	1185	printk("IP-Config: Got %s answer from %u.%u.%u.%u, ",
1186	((ic_got_reply & IC_RARP) ? "RARP"	1186	((ic_got_reply & IC_RARP) ? "RARP"
1187	: (ic_proto_enabled & IC_USE_DHCP) ? "DHCP" : "BOOTP"),	1187	: (ic_proto_enabled & IC_USE_DHCP) ? "DHCP" : "BOOTP"),
1188	NIPQUAD(ic_servaddr));	1188	NIPQUAD(ic_servaddr));
1189	printk("my address is %u.%u.%u.%u\n", NIPQUAD(ic_myaddr));	1189	printk("my address is %u.%u.%u.%u\n", NIPQUAD(ic_myaddr));
1190		1190
1191	return 0;	1191	return 0;
1192	}	1192	}
1193		1193
1194	#endif /* IPCONFIG_DYNAMIC */	1194	#endif /* IPCONFIG_DYNAMIC */
1195		1195
1196	#ifdef CONFIG_PROC_FS	1196	#ifdef CONFIG_PROC_FS
1197		1197
1198	static int pnp_seq_show(struct seq_file seq, void v)	1198	static int pnp_seq_show(struct seq_file seq, void v)
1199	{	1199	{
1200	int i;	1200	int i;
1201		1201
1202	if (ic_proto_used & IC_PROTO)	1202	if (ic_proto_used & IC_PROTO)
1203	seq_printf(seq, "#PROTO: %s\n",	1203	seq_printf(seq, "#PROTO: %s\n",
1204	(ic_proto_used & IC_RARP) ? "RARP"	1204	(ic_proto_used & IC_RARP) ? "RARP"
1205	: (ic_proto_used & IC_USE_DHCP) ? "DHCP" : "BOOTP");	1205	: (ic_proto_used & IC_USE_DHCP) ? "DHCP" : "BOOTP");
1206	else	1206	else
1207	seq_puts(seq, "#MANUAL\n");	1207	seq_puts(seq, "#MANUAL\n");
1208		1208
1209	if (ic_domain[0])	1209	if (ic_domain[0])
1210	seq_printf(seq,	1210	seq_printf(seq,
1211	"domain %s\n", ic_domain);	1211	"domain %s\n", ic_domain);
1212	for (i = 0; i < CONF_NAMESERVERS_MAX; i++) {	1212	for (i = 0; i < CONF_NAMESERVERS_MAX; i++) {
1213	if (ic_nameservers[i] != NONE)	1213	if (ic_nameservers[i] != NONE)
1214	seq_printf(seq,	1214	seq_printf(seq,
1215	"nameserver %u.%u.%u.%u\n",	1215	"nameserver %u.%u.%u.%u\n",
1216	NIPQUAD(ic_nameservers[i]));	1216	NIPQUAD(ic_nameservers[i]));
1217	}	1217	}
1218	if (ic_servaddr != NONE)	1218	if (ic_servaddr != NONE)
1219	seq_printf(seq,	1219	seq_printf(seq,
1220	"bootserver %u.%u.%u.%u\n",	1220	"bootserver %u.%u.%u.%u\n",
1221	NIPQUAD(ic_servaddr));	1221	NIPQUAD(ic_servaddr));
1222	return 0;	1222	return 0;
1223	}	1223	}
1224		1224
1225	static int pnp_seq_open(struct inode indoe, struct file file)	1225	static int pnp_seq_open(struct inode indoe, struct file file)
1226	{	1226	{
1227	return single_open(file, pnp_seq_show, NULL);	1227	return single_open(file, pnp_seq_show, NULL);
1228	}	1228	}
1229		1229
1230	static const struct file_operations pnp_seq_fops = {	1230	static const struct file_operations pnp_seq_fops = {
1231	.owner = THIS_MODULE,	1231	.owner = THIS_MODULE,
1232	.open = pnp_seq_open,	1232	.open = pnp_seq_open,
1233	.read = seq_read,	1233	.read = seq_read,
1234	.llseek = seq_lseek,	1234	.llseek = seq_lseek,
1235	.release = single_release,	1235	.release = single_release,
1236	};	1236	};
1237	#endif /* CONFIG_PROC_FS */	1237	#endif /* CONFIG_PROC_FS */
1238		1238
1239	/*	1239	/*
1240	* Extract IP address from the parameter string if needed. Note that we	1240	* Extract IP address from the parameter string if needed. Note that we
1241	* need to have root_server_addr set _before_ IPConfig gets called as it	1241	* need to have root_server_addr set _before_ IPConfig gets called as it
1242	* can override it.	1242	* can override it.
1243	*/	1243	*/
1244	__be32 __init root_nfs_parse_addr(char *name)	1244	__be32 __init root_nfs_parse_addr(char *name)
1245	{	1245	{
1246	__be32 addr;	1246	__be32 addr;
1247	int octets = 0;	1247	int octets = 0;
1248	char cp, cq;	1248	char cp, cq;
1249		1249
1250	cp = cq = name;	1250	cp = cq = name;
1251	while (octets < 4) {	1251	while (octets < 4) {
1252	while (cp >= '0' && cp <= '9')	1252	while (cp >= '0' && cp <= '9')
1253	cp++;	1253	cp++;
1254	if (cp == cq \|\| cp - cq > 3)	1254	if (cp == cq \|\| cp - cq > 3)
1255	break;	1255	break;
1256	if (*cp == '.' \|\| octets == 3)	1256	if (*cp == '.' \|\| octets == 3)
1257	octets++;	1257	octets++;
1258	if (octets < 4)	1258	if (octets < 4)
1259	cp++;	1259	cp++;
1260	cq = cp;	1260	cq = cp;
1261	}	1261	}
1262	if (octets == 4 && (cp == ':' \|\| cp == '\0')) {	1262	if (octets == 4 && (cp == ':' \|\| cp == '\0')) {
1263	if (*cp == ':')	1263	if (*cp == ':')
1264	*cp++ = '\0';	1264	*cp++ = '\0';
1265	addr = in_aton(name);	1265	addr = in_aton(name);
1266	memmove(name, cp, strlen(cp) + 1);	1266	memmove(name, cp, strlen(cp) + 1);
1267	} else	1267	} else
1268	addr = NONE;	1268	addr = NONE;
1269		1269
1270	return addr;	1270	return addr;
1271	}	1271	}
1272		1272
1273	/*	1273	/*
1274	* IP Autoconfig dispatcher.	1274	* IP Autoconfig dispatcher.
1275	*/	1275	*/
1276		1276
1277	static int __init ip_auto_config(void)	1277	static int __init ip_auto_config(void)
1278	{	1278	{
1279	__be32 addr;	1279	__be32 addr;
1280		1280
1281	#ifdef CONFIG_PROC_FS	1281	#ifdef CONFIG_PROC_FS
1282	proc_net_fops_create(&init_net, "pnp", S_IRUGO, &pnp_seq_fops);	1282	proc_net_fops_create(&init_net, "pnp", S_IRUGO, &pnp_seq_fops);
1283	#endif /* CONFIG_PROC_FS */	1283	#endif /* CONFIG_PROC_FS */
1284		1284
1285	if (!ic_enable)	1285	if (!ic_enable)
1286	return 0;	1286	return 0;
1287		1287
1288	DBG(("IP-Config: Entered.\n"));	1288	DBG(("IP-Config: Entered.\n"));
1289	#ifdef IPCONFIG_DYNAMIC	1289	#ifdef IPCONFIG_DYNAMIC
1290	try_try_again:	1290	try_try_again:
1291	#endif	1291	#endif
1292	/* Give hardware a chance to settle */	1292	/* Give hardware a chance to settle */
1293	msleep(CONF_PRE_OPEN);	1293	msleep(CONF_PRE_OPEN);
1294		1294
1295	/* Setup all network devices */	1295	/* Setup all network devices */
1296	if (ic_open_devs() < 0)	1296	if (ic_open_devs() < 0)
1297	return -1;	1297	return -1;
1298		1298
1299	/* Give drivers a chance to settle */	1299	/* Give drivers a chance to settle */
1300	ssleep(CONF_POST_OPEN);	1300	ssleep(CONF_POST_OPEN);
1301		1301
1302	/*	1302	/*
1303	* If the config information is insufficient (e.g., our IP address or	1303	* If the config information is insufficient (e.g., our IP address or
1304	* IP address of the boot server is missing or we have multiple network	1304	* IP address of the boot server is missing or we have multiple network
1305	* interfaces and no default was set), use BOOTP or RARP to get the	1305	* interfaces and no default was set), use BOOTP or RARP to get the
1306	* missing values.	1306	* missing values.
1307	*/	1307	*/
1308	if (ic_myaddr == NONE \|\|	1308	if (ic_myaddr == NONE \|\|
1309	#ifdef CONFIG_ROOT_NFS	1309	#ifdef CONFIG_ROOT_NFS
1310	(root_server_addr == NONE	1310	(root_server_addr == NONE
1311	&& ic_servaddr == NONE	1311	&& ic_servaddr == NONE
1312	&& ROOT_DEV == Root_NFS) \|\|	1312	&& ROOT_DEV == Root_NFS) \|\|
1313	#endif	1313	#endif
1314	ic_first_dev->next) {	1314	ic_first_dev->next) {
1315	#ifdef IPCONFIG_DYNAMIC	1315	#ifdef IPCONFIG_DYNAMIC
1316		1316
1317	int retries = CONF_OPEN_RETRIES;	1317	int retries = CONF_OPEN_RETRIES;
1318		1318
1319	if (ic_dynamic() < 0) {	1319	if (ic_dynamic() < 0) {
1320	ic_close_devs();	1320	ic_close_devs();
1321		1321
1322	/*	1322	/*
1323	* I don't know why, but sometimes the	1323	* I don't know why, but sometimes the
1324	* eepro100 driver (at least) gets upset and	1324	* eepro100 driver (at least) gets upset and
1325	* doesn't work the first time it's opened.	1325	* doesn't work the first time it's opened.
1326	* But then if you close it and reopen it, it	1326	* But then if you close it and reopen it, it
1327	* works just fine. So we need to try that at	1327	* works just fine. So we need to try that at
1328	* least once before giving up.	1328	* least once before giving up.
1329	*	1329	*
1330	* Also, if the root will be NFS-mounted, we	1330	* Also, if the root will be NFS-mounted, we
1331	* have nowhere to go if DHCP fails. So we	1331	* have nowhere to go if DHCP fails. So we
1332	* just have to keep trying forever.	1332	* just have to keep trying forever.
1333	*	1333	*
1334	* -- Chip	1334	* -- Chip
1335	*/	1335	*/
1336	#ifdef CONFIG_ROOT_NFS	1336	#ifdef CONFIG_ROOT_NFS
1337	if (ROOT_DEV == Root_NFS) {	1337	if (ROOT_DEV == Root_NFS) {
1338	printk(KERN_ERR	1338	printk(KERN_ERR
1339	"IP-Config: Retrying forever (NFS root)...\n");	1339	"IP-Config: Retrying forever (NFS root)...\n");
1340	goto try_try_again;	1340	goto try_try_again;
1341	}	1341	}
1342	#endif	1342	#endif
1343		1343
1344	if (--retries) {	1344	if (--retries) {
1345	printk(KERN_ERR	1345	printk(KERN_ERR
1346	"IP-Config: Reopening network devices...\n");	1346	"IP-Config: Reopening network devices...\n");
1347	goto try_try_again;	1347	goto try_try_again;
1348	}	1348	}
1349		1349
1350	/* Oh, well. At least we tried. */	1350	/* Oh, well. At least we tried. */
1351	printk(KERN_ERR "IP-Config: Auto-configuration of network failed.\n");	1351	printk(KERN_ERR "IP-Config: Auto-configuration of network failed.\n");
1352	return -1;	1352	return -1;
1353	}	1353	}
1354	#else /* !DYNAMIC */	1354	#else /* !DYNAMIC */
1355	printk(KERN_ERR "IP-Config: Incomplete network configuration information.\n");	1355	printk(KERN_ERR "IP-Config: Incomplete network configuration information.\n");
1356	ic_close_devs();	1356	ic_close_devs();
1357	return -1;	1357	return -1;
1358	#endif /* IPCONFIG_DYNAMIC */	1358	#endif /* IPCONFIG_DYNAMIC */
1359	} else {	1359	} else {
1360	/* Device selected manually or only one device -> use it */	1360	/* Device selected manually or only one device -> use it */
1361	ic_dev = ic_first_dev->dev;	1361	ic_dev = ic_first_dev->dev;
1362	}	1362	}
1363		1363
1364	addr = root_nfs_parse_addr(root_server_path);	1364	addr = root_nfs_parse_addr(root_server_path);
1365	if (root_server_addr == NONE)	1365	if (root_server_addr == NONE)
1366	root_server_addr = addr;	1366	root_server_addr = addr;
1367		1367
1368	/*	1368	/*
1369	* Use defaults whereever applicable.	1369	* Use defaults whereever applicable.
1370	*/	1370	*/
1371	if (ic_defaults() < 0)	1371	if (ic_defaults() < 0)
1372	return -1;	1372	return -1;
1373		1373
1374	/*	1374	/*
1375	* Close all network devices except the device we've	1375	* Close all network devices except the device we've
1376	* autoconfigured and set up routes.	1376	* autoconfigured and set up routes.
1377	*/	1377	*/
1378	ic_close_devs();	1378	ic_close_devs();
1379	if (ic_setup_if() < 0 \|\| ic_setup_routes() < 0)	1379	if (ic_setup_if() < 0 \|\| ic_setup_routes() < 0)
1380	return -1;	1380	return -1;
1381		1381
1382	/*	1382	/*
1383	* Record which protocol was actually used.	1383	* Record which protocol was actually used.
1384	*/	1384	*/
1385	#ifdef IPCONFIG_DYNAMIC	1385	#ifdef IPCONFIG_DYNAMIC
1386	ic_proto_used = ic_got_reply \| (ic_proto_enabled & IC_USE_DHCP);	1386	ic_proto_used = ic_got_reply \| (ic_proto_enabled & IC_USE_DHCP);
1387	#endif	1387	#endif
1388		1388
1389	#ifndef IPCONFIG_SILENT	1389	#ifndef IPCONFIG_SILENT
1390	/*	1390	/*
1391	* Clue in the operator.	1391	* Clue in the operator.
1392	*/	1392	*/
1393	printk("IP-Config: Complete:");	1393	printk("IP-Config: Complete:");
1394	printk("\n device=%s", ic_dev->name);	1394	printk("\n device=%s", ic_dev->name);
1395	printk(", addr=%u.%u.%u.%u", NIPQUAD(ic_myaddr));	1395	printk(", addr=%u.%u.%u.%u", NIPQUAD(ic_myaddr));
1396	printk(", mask=%u.%u.%u.%u", NIPQUAD(ic_netmask));	1396	printk(", mask=%u.%u.%u.%u", NIPQUAD(ic_netmask));
1397	printk(", gw=%u.%u.%u.%u", NIPQUAD(ic_gateway));	1397	printk(", gw=%u.%u.%u.%u", NIPQUAD(ic_gateway));
1398	printk(",\n host=%s, domain=%s, nis-domain=%s",	1398	printk(",\n host=%s, domain=%s, nis-domain=%s",
1399	utsname()->nodename, ic_domain, utsname()->domainname);	1399	utsname()->nodename, ic_domain, utsname()->domainname);
1400	printk(",\n bootserver=%u.%u.%u.%u", NIPQUAD(ic_servaddr));	1400	printk(",\n bootserver=%u.%u.%u.%u", NIPQUAD(ic_servaddr));
1401	printk(", rootserver=%u.%u.%u.%u", NIPQUAD(root_server_addr));	1401	printk(", rootserver=%u.%u.%u.%u", NIPQUAD(root_server_addr));
1402	printk(", rootpath=%s", root_server_path);	1402	printk(", rootpath=%s", root_server_path);
1403	printk("\n");	1403	printk("\n");
1404	#endif /* !SILENT */	1404	#endif /* !SILENT */
1405		1405
1406	return 0;	1406	return 0;
1407	}	1407	}
1408		1408
1409	late_initcall(ip_auto_config);	1409	late_initcall(ip_auto_config);
1410		1410
1411		1411
1412	/*	1412	/*
1413	* Decode any IP configuration options in the "ip=" or "nfsaddrs=" kernel	1413	* Decode any IP configuration options in the "ip=" or "nfsaddrs=" kernel
1414	* command line parameter. See Documentation/nfsroot.txt.	1414	* command line parameter. See Documentation/filesystems/nfsroot.txt.
1415	*/	1415	*/
1416	static int __init ic_proto_name(char *name)	1416	static int __init ic_proto_name(char *name)
1417	{	1417	{
1418	if (!strcmp(name, "on") \|\| !strcmp(name, "any")) {	1418	if (!strcmp(name, "on") \|\| !strcmp(name, "any")) {
1419	return 1;	1419	return 1;
1420	}	1420	}
1421	if (!strcmp(name, "off") \|\| !strcmp(name, "none")) {	1421	if (!strcmp(name, "off") \|\| !strcmp(name, "none")) {
1422	return 0;	1422	return 0;
1423	}	1423	}
1424	#ifdef CONFIG_IP_PNP_DHCP	1424	#ifdef CONFIG_IP_PNP_DHCP
1425	else if (!strcmp(name, "dhcp")) {	1425	else if (!strcmp(name, "dhcp")) {
1426	ic_proto_enabled &= ~IC_RARP;	1426	ic_proto_enabled &= ~IC_RARP;
1427	return 1;	1427	return 1;
1428	}	1428	}
1429	#endif	1429	#endif
1430	#ifdef CONFIG_IP_PNP_BOOTP	1430	#ifdef CONFIG_IP_PNP_BOOTP
1431	else if (!strcmp(name, "bootp")) {	1431	else if (!strcmp(name, "bootp")) {
1432	ic_proto_enabled &= ~(IC_RARP \| IC_USE_DHCP);	1432	ic_proto_enabled &= ~(IC_RARP \| IC_USE_DHCP);
1433	return 1;	1433	return 1;
1434	}	1434	}
1435	#endif	1435	#endif
1436	#ifdef CONFIG_IP_PNP_RARP	1436	#ifdef CONFIG_IP_PNP_RARP
1437	else if (!strcmp(name, "rarp")) {	1437	else if (!strcmp(name, "rarp")) {
1438	ic_proto_enabled &= ~(IC_BOOTP \| IC_USE_DHCP);	1438	ic_proto_enabled &= ~(IC_BOOTP \| IC_USE_DHCP);
1439	return 1;	1439	return 1;
1440	}	1440	}
1441	#endif	1441	#endif
1442	#ifdef IPCONFIG_DYNAMIC	1442	#ifdef IPCONFIG_DYNAMIC
1443	else if (!strcmp(name, "both")) {	1443	else if (!strcmp(name, "both")) {
1444	ic_proto_enabled &= ~IC_USE_DHCP; /* backward compat :-( */	1444	ic_proto_enabled &= ~IC_USE_DHCP; /* backward compat :-( */
1445	return 1;	1445	return 1;
1446	}	1446	}
1447	#endif	1447	#endif
1448	return 0;	1448	return 0;
1449	}	1449	}
1450		1450
1451	static int __init ip_auto_config_setup(char *addrs)	1451	static int __init ip_auto_config_setup(char *addrs)
1452	{	1452	{
1453	char cp, ip, *dp;	1453	char cp, ip, *dp;
1454	int num = 0;	1454	int num = 0;
1455		1455
1456	ic_set_manually = 1;	1456	ic_set_manually = 1;
1457	ic_enable = 1;	1457	ic_enable = 1;
1458		1458
1459	/*	1459	/*
1460	* If any dhcp, bootp etc options are set, leave autoconfig on	1460	* If any dhcp, bootp etc options are set, leave autoconfig on
1461	* and skip the below static IP processing.	1461	* and skip the below static IP processing.
1462	*/	1462	*/
1463	if (ic_proto_name(addrs))	1463	if (ic_proto_name(addrs))
1464	return 1;	1464	return 1;
1465		1465
1466	/* If no static IP is given, turn off autoconfig and bail. */	1466	/* If no static IP is given, turn off autoconfig and bail. */
1467	if (*addrs == 0 \|\|	1467	if (*addrs == 0 \|\|
1468	strcmp(addrs, "off") == 0 \|\|	1468	strcmp(addrs, "off") == 0 \|\|
1469	strcmp(addrs, "none") == 0) {	1469	strcmp(addrs, "none") == 0) {
1470	ic_enable = 0;	1470	ic_enable = 0;
1471	return 1;	1471	return 1;
1472	}	1472	}
1473		1473
1474	/* Parse string for static IP assignment. */	1474	/* Parse string for static IP assignment. */
1475	ip = addrs;	1475	ip = addrs;
1476	while (ip && *ip) {	1476	while (ip && *ip) {
1477	if ((cp = strchr(ip, ':')))	1477	if ((cp = strchr(ip, ':')))
1478	*cp++ = '\0';	1478	*cp++ = '\0';
1479	if (strlen(ip) > 0) {	1479	if (strlen(ip) > 0) {
1480	DBG(("IP-Config: Parameter #%d: `%s'\n", num, ip));	1480	DBG(("IP-Config: Parameter #%d: `%s'\n", num, ip));
1481	switch (num) {	1481	switch (num) {
1482	case 0:	1482	case 0:
1483	if ((ic_myaddr = in_aton(ip)) == ANY)	1483	if ((ic_myaddr = in_aton(ip)) == ANY)
1484	ic_myaddr = NONE;	1484	ic_myaddr = NONE;
1485	break;	1485	break;
1486	case 1:	1486	case 1:
1487	if ((ic_servaddr = in_aton(ip)) == ANY)	1487	if ((ic_servaddr = in_aton(ip)) == ANY)
1488	ic_servaddr = NONE;	1488	ic_servaddr = NONE;
1489	break;	1489	break;
1490	case 2:	1490	case 2:
1491	if ((ic_gateway = in_aton(ip)) == ANY)	1491	if ((ic_gateway = in_aton(ip)) == ANY)
1492	ic_gateway = NONE;	1492	ic_gateway = NONE;
1493	break;	1493	break;
1494	case 3:	1494	case 3:
1495	if ((ic_netmask = in_aton(ip)) == ANY)	1495	if ((ic_netmask = in_aton(ip)) == ANY)
1496	ic_netmask = NONE;	1496	ic_netmask = NONE;
1497	break;	1497	break;
1498	case 4:	1498	case 4:
1499	if ((dp = strchr(ip, '.'))) {	1499	if ((dp = strchr(ip, '.'))) {
1500	*dp++ = '\0';	1500	*dp++ = '\0';
1501	strlcpy(utsname()->domainname, dp,	1501	strlcpy(utsname()->domainname, dp,
1502	sizeof(utsname()->domainname));	1502	sizeof(utsname()->domainname));
1503	}	1503	}
1504	strlcpy(utsname()->nodename, ip,	1504	strlcpy(utsname()->nodename, ip,
1505	sizeof(utsname()->nodename));	1505	sizeof(utsname()->nodename));
1506	ic_host_name_set = 1;	1506	ic_host_name_set = 1;
1507	break;	1507	break;
1508	case 5:	1508	case 5:
1509	strlcpy(user_dev_name, ip, sizeof(user_dev_name));	1509	strlcpy(user_dev_name, ip, sizeof(user_dev_name));
1510	break;	1510	break;
1511	case 6:	1511	case 6:
1512	if (ic_proto_name(ip) == 0 &&	1512	if (ic_proto_name(ip) == 0 &&
1513	ic_myaddr == NONE) {	1513	ic_myaddr == NONE) {
1514	ic_enable = 0;	1514	ic_enable = 0;
1515	}	1515	}
1516	break;	1516	break;
1517	}	1517	}
1518	}	1518	}
1519	ip = cp;	1519	ip = cp;
1520	num++;	1520	num++;
1521	}	1521	}
1522		1522
1523	return 1;	1523	return 1;
1524	}	1524	}
1525		1525
1526	static int __init nfsaddrs_config_setup(char *addrs)	1526	static int __init nfsaddrs_config_setup(char *addrs)
1527	{	1527	{
1528	return ip_auto_config_setup(addrs);	1528	return ip_auto_config_setup(addrs);
1529	}	1529	}
1530		1530
1531	static int __init vendor_class_identifier_setup(char *addrs)	1531	static int __init vendor_class_identifier_setup(char *addrs)
1532	{	1532	{
1533	if (strlcpy(vendor_class_identifier, addrs,	1533	if (strlcpy(vendor_class_identifier, addrs,
1534	sizeof(vendor_class_identifier))	1534	sizeof(vendor_class_identifier))
1535	>= sizeof(vendor_class_identifier))	1535	>= sizeof(vendor_class_identifier))
1536	printk(KERN_WARNING "DHCP: vendorclass too long, truncated to \"%s\"",	1536	printk(KERN_WARNING "DHCP: vendorclass too long, truncated to \"%s\"",
1537	vendor_class_identifier);	1537	vendor_class_identifier);
1538	return 1;	1538	return 1;
1539	}	1539	}
1540		1540
1541	__setup("ip=", ip_auto_config_setup);	1541	__setup("ip=", ip_auto_config_setup);
1542	__setup("nfsaddrs=", nfsaddrs_config_setup);	1542	__setup("nfsaddrs=", nfsaddrs_config_setup);
1543	__setup("dhcpclass=", vendor_class_identifier_setup);	1543	__setup("dhcpclass=", vendor_class_identifier_setup);
1544		1544