Merge git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc-merge
authorLinus Torvalds <torvalds@g5.osdl.org>
Tue, 10 Jan 2006 16:28:32 +0000 (08:28 -0800)
committerLinus Torvalds <torvalds@g5.osdl.org>
Tue, 10 Jan 2006 16:28:32 +0000 (08:28 -0800)
467 files changed:
Documentation/CodingStyle
Documentation/DocBook/.gitignore [new file with mode: 0644]
Documentation/DocBook/kernel-api.tmpl
Documentation/applying-patches.txt
Documentation/filesystems/ext3.txt
Documentation/hrtimers.txt [new file with mode: 0644]
Documentation/kbuild/makefiles.txt
Documentation/kdump/kdump.txt
Documentation/kernel-parameters.txt
Documentation/locks.txt
Documentation/stable_kernel_rules.txt
Kbuild
MAINTAINERS
Makefile
arch/alpha/kernel/alpha_ksyms.c
arch/alpha/mm/init.c
arch/arm/plat-omap/dma.c
arch/arm26/kernel/armksyms.c
arch/cris/kernel/crisksyms.c
arch/cris/kernel/process.c
arch/frv/Kconfig
arch/frv/boot/Makefile
arch/frv/kernel/frv_ksyms.c
arch/frv/kernel/process.c
arch/h8300/kernel/gpio.c
arch/h8300/kernel/h8300_ksyms.c
arch/h8300/kernel/process.c
arch/h8300/platform/h8300h/ptrace_h8300h.c
arch/h8300/platform/h8s/ints.c
arch/h8300/platform/h8s/ints_h8s.c
arch/i386/Kconfig
arch/i386/Makefile
arch/i386/boot/Makefile
arch/i386/boot/install.sh
arch/i386/boot/video.S
arch/i386/kernel/Makefile
arch/i386/kernel/crash.c
arch/i386/kernel/crash_dump.c [new file with mode: 0644]
arch/i386/kernel/kprobes.c
arch/i386/kernel/setup.c
arch/i386/kernel/traps.c
arch/ia64/Makefile
arch/ia64/ia32/Makefile
arch/ia64/ia32/ia32_entry.S
arch/ia64/ia32/ia32_ioctl.c [deleted file]
arch/ia64/ia32/sys_ia32.c
arch/ia64/kernel/kprobes.c
arch/m32r/Kconfig
arch/m32r/kernel/m32r_ksyms.c
arch/m32r/kernel/process.c
arch/m68k/kernel/m68k_ksyms.c
arch/m68knommu/kernel/m68k_ksyms.c
arch/m68knommu/kernel/process.c
arch/mips/kernel/Makefile
arch/mips/kernel/ioctl32.c [deleted file]
arch/parisc/kernel/Makefile
arch/parisc/kernel/ioctl32.c [deleted file]
arch/powerpc/Makefile
arch/powerpc/configs/ppc64_defconfig
arch/powerpc/kernel/Makefile
arch/powerpc/kernel/ioctl32.c [deleted file]
arch/powerpc/kernel/kprobes.c
arch/powerpc/kernel/sys_ppc32.c
arch/powerpc/kernel/systbl.S
arch/powerpc/platforms/cell/spufs/inode.c
arch/ppc/Makefile
arch/ppc/kernel/machine_kexec.c
arch/s390/Kconfig
arch/s390/kernel/Makefile
arch/s390/kernel/compat_ioctl.c [deleted file]
arch/s390/kernel/compat_linux.c
arch/s390/kernel/compat_wrapper.S
arch/s390/kernel/crash.c
arch/s390/kernel/process.c
arch/s390/kernel/s390_ksyms.c
arch/sh/kernel/process.c
arch/sh/kernel/sh_ksyms.c
arch/sh64/Kconfig
arch/sh64/kernel/process.c
arch/sh64/kernel/sh_ksyms.c
arch/sparc/kernel/sparc_ksyms.c
arch/sparc64/kernel/Makefile
arch/sparc64/kernel/binfmt_aout32.c
arch/sparc64/kernel/ioctl32.c [deleted file]
arch/sparc64/kernel/kprobes.c
arch/sparc64/kernel/sparc64_ksyms.c
arch/sparc64/kernel/sys_sparc32.c
arch/sparc64/kernel/systbls.S
arch/um/drivers/chan_kern.c
arch/um/kernel/time.c
arch/v850/kernel/process.c
arch/v850/kernel/v850_ksyms.c
arch/x86_64/Kconfig
arch/x86_64/Makefile
arch/x86_64/boot/Makefile
arch/x86_64/boot/install.sh
arch/x86_64/ia32/Makefile
arch/x86_64/ia32/ia32_ioctl.c [deleted file]
arch/x86_64/ia32/ia32entry.S
arch/x86_64/ia32/sys_ia32.c
arch/x86_64/kernel/Makefile
arch/x86_64/kernel/crash.c
arch/x86_64/kernel/crash_dump.c [moved from kernel/crash_dump.c with 60% similarity]
arch/x86_64/kernel/e820.c
arch/x86_64/kernel/kprobes.c
arch/x86_64/kernel/setup.c
arch/x86_64/kernel/x8664_ksyms.c
arch/xtensa/Kconfig
drivers/base/core.c
drivers/base/cpu.c
drivers/bluetooth/hci_ldisc.c
drivers/char/Kconfig
drivers/char/Makefile
drivers/char/amiserial.c
drivers/char/cs5535_gpio.c [new file with mode: 0644]
drivers/char/cyclades.c
drivers/char/drm/drm_ioc32.c
drivers/char/drm/i915_ioc32.c
drivers/char/drm/mga_ioc32.c
drivers/char/drm/r128_ioc32.c
drivers/char/drm/radeon_ioc32.c
drivers/char/epca.c
drivers/char/esp.c
drivers/char/hvc_console.c
drivers/char/hvcs.c
drivers/char/hvsi.c
drivers/char/ip2/i2lib.c
drivers/char/ip2main.c
drivers/char/ipmi/ipmi_msghandler.c
drivers/char/ipmi/ipmi_poweroff.c
drivers/char/isicom.c
drivers/char/istallion.c
drivers/char/moxa.c
drivers/char/mxser.c
drivers/char/n_hdlc.c
drivers/char/n_r3964.c
drivers/char/n_tty.c
drivers/char/nvram.c
drivers/char/pcmcia/synclink_cs.c
drivers/char/pty.c
drivers/char/rio/rio_linux.c
drivers/char/rio/riointr.c
drivers/char/riscom8.c
drivers/char/rocket.c
drivers/char/selection.c
drivers/char/ser_a2232.c
drivers/char/serial167.c
drivers/char/specialix.c
drivers/char/stallion.c
drivers/char/sx.c
drivers/char/synclink.c
drivers/char/synclink_gt.c
drivers/char/synclinkmp.c
drivers/char/tty_io.c
drivers/char/viocons.c
drivers/char/vme_scc.c
drivers/char/vr41xx_rtc.c
drivers/char/vt.c
drivers/connector/cn_proc.c
drivers/ide/pci/pdc202xx_new.c
drivers/ieee1394/amdtp.c
drivers/ieee1394/dv1394.c
drivers/ieee1394/video1394.c
drivers/input/serio/serport.c
drivers/isdn/capi/capi.c
drivers/isdn/i4l/isdn_common.c
drivers/isdn/i4l/isdn_common.h
drivers/isdn/i4l/isdn_tty.c
drivers/md/multipath.c
drivers/media/radio/radio-maestro.c
drivers/message/fusion/mptctl.c
drivers/mtd/nand/au1550nd.c
drivers/mtd/nand/rtc_from4.c
drivers/mtd/nand/spia.c
drivers/net/8139too.c
drivers/net/hamradio/6pack.c
drivers/net/hamradio/mkiss.c
drivers/net/irda/irport.c
drivers/net/irda/irtty-sir.c
drivers/net/pci-skeleton.c
drivers/net/ppp_async.c
drivers/net/ppp_synctty.c
drivers/net/r8169.c
drivers/net/sis190.c
drivers/net/slip.c
drivers/net/wan/pc300_tty.c
drivers/net/wan/x25_asy.c
drivers/net/wireless/strip.c
drivers/s390/block/dasd.c
drivers/s390/block/dasd_int.h
drivers/s390/block/dasd_ioctl.c
drivers/s390/char/con3215.c
drivers/s390/char/fs3270.c
drivers/s390/char/sclp_tty.c
drivers/s390/char/sclp_vt220.c
drivers/s390/char/tape_char.c
drivers/s390/crypto/z90main.c
drivers/s390/net/ctctty.c
drivers/scsi/aacraid/linit.c
drivers/scsi/ch.c
drivers/scsi/megaraid/megaraid_mm.h
drivers/serial/21285.c
drivers/serial/68328serial.c
drivers/serial/68360serial.c
drivers/serial/8250.c
drivers/serial/Kconfig
drivers/serial/amba-pl010.c
drivers/serial/amba-pl011.c
drivers/serial/au1x00_uart.c
drivers/serial/clps711x.c
drivers/serial/dz.c
drivers/serial/icom.c
drivers/serial/imx.c
drivers/serial/ioc4_serial.c
drivers/serial/ip22zilog.c
drivers/serial/m32r_sio.c
drivers/serial/mcfserial.c
drivers/serial/mpc52xx_uart.c
drivers/serial/mpsc.c
drivers/serial/mux.c
drivers/serial/pmac_zilog.c
drivers/serial/pxa.c
drivers/serial/s3c2410.c
drivers/serial/sa1100.c
drivers/serial/serial_lh7a40x.c
drivers/serial/serial_txx9.c
drivers/serial/sh-sci.c
drivers/serial/sn_console.c
drivers/serial/sunsab.c
drivers/serial/sunsu.c
drivers/serial/sunzilog.c
drivers/serial/vr41xx_siu.c
drivers/usb/atm/speedtch.c
drivers/usb/class/cdc-acm.c
drivers/usb/gadget/serial.c
drivers/usb/image/microtek.c
drivers/usb/serial/Kconfig
drivers/usb/serial/cyberjack.c
drivers/usb/serial/cypress_m8.c
drivers/usb/serial/digi_acceleport.c
drivers/usb/serial/empeg.c
drivers/usb/serial/ftdi_sio.c
drivers/usb/serial/garmin_gps.c
drivers/usb/serial/generic.c
drivers/usb/serial/io_edgeport.c
drivers/usb/serial/io_ti.c
drivers/usb/serial/ipaq.c
drivers/usb/serial/ipw.c
drivers/usb/serial/kl5kusb105.c
drivers/usb/serial/kobil_sct.c
drivers/usb/serial/option.c
drivers/usb/serial/pl2303.c
drivers/usb/serial/ti_usb_3410_5052.c
drivers/usb/serial/visor.c
drivers/usb/serial/whiteheat.c
drivers/video/Kconfig
drivers/video/arcfb.c
drivers/video/asiliantfb.c
drivers/video/aty/Makefile
drivers/video/aty/atyfb.h
drivers/video/aty/atyfb_base.c
drivers/video/aty/mach64_ct.c
drivers/video/aty/xlinit.c [deleted file]
drivers/video/console/bitblit.c
drivers/video/console/fbcon.c
drivers/video/console/fbcon.h
drivers/video/console/fbcon_ccw.c
drivers/video/console/fbcon_cw.c
drivers/video/console/fbcon_rotate.c
drivers/video/console/fbcon_rotate.h
drivers/video/console/fbcon_ud.c
drivers/video/console/softcursor.c
drivers/video/console/tileblit.c
drivers/video/fbcvt.c
drivers/video/fbmem.c
drivers/video/fbmon.c
drivers/video/fbsysfs.c
drivers/video/hgafb.c
drivers/video/i810/i810-i2c.c
drivers/video/i810/i810_accel.c
drivers/video/i810/i810_gtf.c
drivers/video/i810/i810_main.c
drivers/video/i810/i810_main.h
drivers/video/imsttfb.c
drivers/video/kyro/STG4000InitDevice.c
drivers/video/kyro/STG4000Interface.h
drivers/video/kyro/STG4000OverlayDevice.c
drivers/video/kyro/fbdev.c
drivers/video/matrox/matroxfb_base.h
drivers/video/matrox/matroxfb_g450.c
drivers/video/matrox/matroxfb_misc.c
drivers/video/neofb.c
drivers/video/nvidia/nv_hw.c
drivers/video/nvidia/nv_i2c.c
drivers/video/nvidia/nv_proto.h
drivers/video/nvidia/nv_setup.c
drivers/video/nvidia/nvidia.c
drivers/video/pm2fb.c
drivers/video/riva/fbdev.c
drivers/video/riva/rivafb-i2c.c
drivers/video/s3c2410fb.c
drivers/video/savage/savagefb-i2c.c
drivers/video/savage/savagefb_accel.c
drivers/video/savage/savagefb_driver.c
drivers/video/skeletonfb.c
drivers/video/sstfb.c
drivers/video/tdfxfb.c
drivers/video/vesafb.c
drivers/video/vga16fb.c
drivers/video/vgastate.c
fs/9p/vfs_super.c
fs/Kconfig
fs/Makefile
fs/autofs4/root.c
fs/binfmt_aout.c
fs/binfmt_elf.c
fs/binfmt_elf_fdpic.c
fs/binfmt_flat.c
fs/cifs/cifs_uniupr.h
fs/compat_ioctl.c
fs/dcache.c
fs/exec.c
fs/ext2/bitmap.c
fs/ext2/xattr.c
fs/ext2/xattr_trusted.c
fs/ext2/xattr_user.c
fs/ext3/balloc.c
fs/ext3/bitmap.c
fs/ext3/bitmap.h [deleted file]
fs/ext3/ialloc.c
fs/ext3/xattr.c
fs/ext3/xattr_trusted.c
fs/ext3/xattr_user.c
fs/hfsplus/hfsplus_fs.h
fs/hfsplus/inode.c
fs/hfsplus/super.c
fs/inode.c
fs/jfs/xattr.c
fs/namespace.c
fs/ncpfs/file.c
fs/nfs/inode.c
fs/nfsd/vfs.c
fs/ntfs/file.c
fs/ntfs/inode.c
fs/ntfs/super.c
fs/ocfs2/mmap.c
fs/pipe.c
fs/proc/array.c
fs/proc/vmcore.c
fs/reiserfs/file.c
fs/reiserfs/xattr.c
fs/reiserfs/xattr_user.c
fs/xattr.c
fs/xfs/Kbuild [new file with mode: 0644]
fs/xfs/linux-2.6/xfs_ioctl.c
fs/xfs/linux-2.6/xfs_ioctl32.c
fs/xfs/linux-2.6/xfs_iops.c
fs/xfs/linux-2.6/xfs_lrw.c
fs/xfs/xfs_attr.c
include/asm-arm/ioctl.h
include/asm-arm26/ioctl.h
include/asm-cris/ioctl.h
include/asm-frv/ioctl.h
include/asm-generic/ioctl.h [new file with mode: 0644]
include/asm-h8300/ioctl.h
include/asm-i386/ioctl.h
include/asm-i386/kexec.h
include/asm-i386/kprobes.h
include/asm-ia64/ioctl.h
include/asm-ia64/kprobes.h
include/asm-m32r/ioctl.h
include/asm-m68k/ioctl.h
include/asm-m68knommu/ioctl.h
include/asm-powerpc/kexec.h
include/asm-powerpc/kprobes.h
include/asm-s390/ioctl.h
include/asm-s390/kexec.h
include/asm-sh/ioctl.h
include/asm-sh64/io.h
include/asm-sh64/ioctl.h
include/asm-sh64/mmu_context.h
include/asm-sh64/pgalloc.h
include/asm-sh64/pgtable.h
include/asm-sh64/processor.h
include/asm-sh64/system.h
include/asm-sh64/tlbflush.h
include/asm-sh64/uaccess.h
include/asm-sparc64/kprobes.h
include/asm-um/processor-generic.h
include/asm-v850/ioctl.h
include/asm-x86_64/e820.h
include/asm-x86_64/ioctl.h
include/asm-x86_64/kexec.h
include/asm-x86_64/kprobes.h
include/asm-xtensa/ioctl.h
include/linux/calc64.h [new file with mode: 0644]
include/linux/compat_ioctl.h
include/linux/fs.h
include/linux/hrtimer.h [new file with mode: 0644]
include/linux/isicom.h
include/linux/jiffies.h
include/linux/kbd_kern.h
include/linux/kernel.h
include/linux/kexec.h
include/linux/kprobes.h
include/linux/ktime.h [new file with mode: 0644]
include/linux/list.h
include/linux/mount.h
include/linux/namei.h
include/linux/pci_ids.h
include/linux/posix-timers.h
include/linux/rio_drv.h
include/linux/sched.h
include/linux/screen_info.h
include/linux/time.h
include/linux/timer.h
include/linux/tty.h
include/linux/tty_flip.h
include/linux/tty_ldisc.h
include/linux/xattr.h
include/linux/zlib.h
include/sound/core.h
include/video/kyro.h
include/video/neomagic.h
include/video/newport.h
include/video/sstfb.h
include/video/tdfx.h
init/Kconfig
init/main.c
kernel/Makefile
kernel/compat.c
kernel/exit.c
kernel/fork.c
kernel/hrtimer.c [new file with mode: 0644]
kernel/itimer.c
kernel/kexec.c
kernel/kprobes.c
kernel/ksysfs.c
kernel/posix-cpu-timers.c
kernel/posix-timers.c
kernel/resource.c
kernel/stop_machine.c
kernel/time.c
kernel/timer.c
lib/Kconfig.debug
lib/spinlock_debug.c
lib/zlib_deflate/deflate.c
lib/zlib_deflate/deflate_syms.c
lib/zlib_inflate/infblock.c
lib/zlib_inflate/infblock.h
lib/zlib_inflate/inflate_syms.c
lib/zlib_inflate/inflate_sync.c
mm/filemap.c
mm/filemap_xip.c
net/bluetooth/rfcomm/tty.c
net/core/net-sysfs.c
net/sunrpc/clnt.c
scripts/Kbuild.include
scripts/Makefile.build
scripts/kconfig/lxdialog/Makefile
scripts/kconfig/lxdialog/check-lxdialog.sh [new file with mode: 0644]
scripts/kernel-doc
scripts/mod/file2alias.c
scripts/reference_discarded.pl
scripts/setlocalversion
security/selinux/ss/services.c
sound/pci/cs5535audio/cs5535audio.c

index ce780ef648f1d5c5e0504f8f290add2b5e738876..ce5d2c038cf54603d76c32b25e563456ebcf6711 100644 (file)
@@ -199,7 +199,7 @@ The rationale is:
     modifications are prevented
 - saves the compiler work to optimize redundant code away ;)
 
-int fun(int )
+int fun(int a)
 {
        int result = 0;
        char *buffer = kmalloc(SIZE);
diff --git a/Documentation/DocBook/.gitignore b/Documentation/DocBook/.gitignore
new file mode 100644 (file)
index 0000000..c102c02
--- /dev/null
@@ -0,0 +1,6 @@
+*.xml
+*.ps
+*.pdf
+*.html
+*.9.gz
+*.9
index 3c47a3f0dc552ed5e0e24e20d3651eab82d2f9e7..8c9c6704e85bab5e26b6f28b2240e96346cc5660 100644 (file)
 !Iinclude/linux/sched.h
 !Ekernel/sched.c
 !Ekernel/timer.c
+     </sect1>
+     <sect1><title>High-resolution timers</title>
+!Iinclude/linux/ktime.h
+!Iinclude/linux/hrtimer.h
+!Ekernel/hrtimer.c
      </sect1>
      <sect1><title>Internal Functions</title>
 !Ikernel/exit.c
index 05a08c2c18897d0125c488671bf5da6616c0aee0..a083ba35d1adf8f0b6f676f468a21853be3ddf0e 100644 (file)
@@ -3,8 +3,7 @@
        ------------------------------------
 
        Original by: Jesper Juhl, August 2005
-       Last update: 2005-12-02
-
+       Last update: 2006-01-05
 
 
 A frequently asked question on the Linux Kernel Mailing List is how to apply
@@ -77,7 +76,7 @@ instead:
 
 If you wish to uncompress the patch file by hand first before applying it
 (what I assume you've done in the examples below), then you simply run
-gunzip or bunzip2 on the file - like this:
+gunzip or bunzip2 on the file -- like this:
        gunzip patch-x.y.z.gz
        bunzip2 patch-x.y.z.bz2
 
@@ -95,7 +94,7 @@ Common errors when patching
 ---
  When patch applies a patch file it attempts to verify the sanity of the
 file in different ways.
-Checking that the file looks like a valid patch file, checking the code
+Checking that the file looks like a valid patch file & checking the code
 around the bits being modified matches the context provided in the patch are
 just two of the basic sanity checks patch does.
 
@@ -122,7 +121,7 @@ outright and leaves a file with a .rej extension (a reject file). You can
 read this file to see exactly what change couldn't be applied, so you can
 go fix it up by hand if you wish.
 
-If you don't have any third party patches applied to your kernel source, but
+If you don't have any third-party patches applied to your kernel source, but
 only patches from kernel.org and you apply the patches in the correct order,
 and have made no modifications yourself to the source files, then you should
 never see a fuzz or reject message from patch. If you do see such messages
@@ -137,7 +136,7 @@ If patch stops and presents a "File to patch:" prompt, then patch could not
 find a file to be patched. Most likely you forgot to specify -p1 or you are
 in the wrong directory. Less often, you'll find patches that need to be
 applied with -p0 instead of -p1 (reading the patch file should reveal if
-this is the case - if so, then this is an error by the person who created
+this is the case -- if so, then this is an error by the person who created
 the patch but is not fatal).
 
 If you get "Hunk #2 succeeded at 1887 with fuzz 2 (offset 7 lines)." or a
@@ -168,13 +167,17 @@ the patch will in fact apply it.
 
 A message similar to "patch: **** unexpected end of file in patch" or "patch
 unexpectedly ends in middle of line" means that patch could make no sense of
-the file you fed to it. Either your download is broken or you tried to feed
-patch a compressed patch file without uncompressing it first.
+the file you fed to it. Either your download is broken, you tried to feed
+patch a compressed patch file without uncompressing it first, or the patch
+file that you are using has been mangled by a mail client or mail transfer
+agent along the way somewhere, e.g., by splitting a long line into two lines.
+Often these warnings can easily be fixed by joining (concatenating) the
+two lines that had been split.
 
 As I already mentioned above, these errors should never happen if you apply
 a patch from kernel.org to the correct version of an unmodified source tree.
 So if you get these errors with kernel.org patches then you should probably
-assume that either your patch file or your tree is broken and I'd advice you
+assume that either your patch file or your tree is broken and I'd advise you
 to start over with a fresh download of a full kernel tree and the patch you
 wish to apply.
 
@@ -200,10 +203,10 @@ do the additional steps since interdiff can get things wrong in some cases.
  Another alternative is `ketchup', which is a python script for automatic
 downloading and applying of patches (http://www.selenic.com/ketchup/).
 
- Other nice tools are diffstat which shows a summary of changes made by a
-patch, lsdiff which displays a short listing of affected files in a patch
-file, along with (optionally) the line numbers of the start of each patch
-and grepdiff which displays a list of the files modified by a patch where
+ Other nice tools are diffstat, which shows a summary of changes made by a
+patch; lsdiff, which displays a short listing of affected files in a patch
+file, along with (optionally) the line numbers of the start of each patch;
+and grepdiff, which displays a list of the files modified by a patch where
 the patch contains a given regular expression.
 
 
@@ -228,8 +231,8 @@ The -mm kernels live at
 In place of ftp.kernel.org you can use ftp.cc.kernel.org, where cc is a
 country code. This way you'll be downloading from a mirror site that's most
 likely geographically closer to you, resulting in faster downloads for you,
-less bandwidth used globally and less load on the main kernel.org servers -
-these are good things, do use mirrors when possible.
+less bandwidth used globally and less load on the main kernel.org servers --
+these are good things, so do use mirrors when possible.
 
 
 The 2.6.x kernels
@@ -237,14 +240,14 @@ The 2.6.x kernels
  These are the base stable releases released by Linus. The highest numbered
 release is the most recent.
 
-If regressions or other serious flaws are found then a -stable fix patch
+If regressions or other serious flaws are found, then a -stable fix patch
 will be released (see below) on top of this base. Once a new 2.6.x base
 kernel is released, a patch is made available that is a delta between the
 previous 2.6.x kernel and the new one.
 
-To apply a patch moving from 2.6.11 to 2.6.12 you'd do the following (note
+To apply a patch moving from 2.6.11 to 2.6.12, you'd do the following (note
 that such patches do *NOT* apply on top of 2.6.x.y kernels but on top of the
-base 2.6.x kernel - if you need to move from 2.6.x.y to 2.6.x+1 you need to
+base 2.6.x kernel -- if you need to move from 2.6.x.y to 2.6.x+1 you need to
 first revert the 2.6.x.y patch).
 
 Here are some examples:
@@ -266,7 +269,7 @@ $ mv linux-2.6.11.1 linux-2.6.12            # rename source dir
 
 The 2.6.x.y kernels
 ---
- Kernels with 4 digit versions are -stable kernels. They contain small(ish)
+ Kernels with 4-digit versions are -stable kernels. They contain small(ish)
 critical fixes for security problems or significant regressions discovered
 in a given 2.6.x kernel.
 
@@ -277,9 +280,14 @@ versions.
 If no 2.6.x.y kernel is available, then the highest numbered 2.6.x kernel is
 the current stable kernel.
 
+ note: the -stable team usually do make incremental patches available as well
+ as patches against the latest mainline release, but I only cover the
+ non-incremental ones below. The incremental ones can be found at
+ ftp://ftp.kernel.org/pub/linux/kernel/v2.6/incr/
+
 These patches are not incremental, meaning that for example the 2.6.12.3
 patch does not apply on top of the 2.6.12.2 kernel source, but rather on top
-of the base 2.6.12 kernel source.
+of the base 2.6.12 kernel source .
 So, in order to apply the 2.6.12.3 patch to your existing 2.6.12.2 kernel
 source you have to first back out the 2.6.12.2 patch (so you are left with a
 base 2.6.12 kernel source) and then apply the new 2.6.12.3 patch.
@@ -345,12 +353,12 @@ The -git kernels
 repository, hence the name).
 
 These patches are usually released daily and represent the current state of
-Linus' tree. They are more experimental than -rc kernels since they are
+Linus's tree. They are more experimental than -rc kernels since they are
 generated automatically without even a cursory glance to see if they are
 sane.
 
 -git patches are not incremental and apply either to a base 2.6.x kernel or
-a base 2.6.x-rc kernel - you can see which from their name.
+a base 2.6.x-rc kernel -- you can see which from their name.
 A patch named 2.6.12-git1 applies to the 2.6.12 kernel source and a patch
 named 2.6.13-rc3-git2 applies to the source of the 2.6.13-rc3 kernel.
 
@@ -393,12 +401,12 @@ You should generally strive to get your patches into mainline via -mm to
 ensure maximum testing.
 
 This branch is in constant flux and contains many experimental features, a
-lot of debugging patches not appropriate for mainline etc and is the most
+lot of debugging patches not appropriate for mainline etc., and is the most
 experimental of the branches described in this document.
 
 These kernels are not appropriate for use on systems that are supposed to be
 stable and they are more risky to run than any of the other branches (make
-sure you have up-to-date backups - that goes for any experimental kernel but
+sure you have up-to-date backups -- that goes for any experimental kernel but
 even more so for -mm kernels).
 
 These kernels in addition to all the other experimental patches they contain
index 22e4040564d51d51a7d123e57e855f40d044dab6..f4d0de6bac636306135b1ae19dd003a1f6adf67b 100644 (file)
@@ -2,11 +2,11 @@
 Ext3 Filesystem
 ===============
 
-ext3 was originally released in September 1999. Written by Stephen Tweedie
-for 2.2 branch, and ported to 2.4 kernels by Peter Braam, Andreas Dilger, 
+Ext3 was originally released in September 1999. Written by Stephen Tweedie
+for the 2.2 branch, and ported to 2.4 kernels by Peter Braam, Andreas Dilger,
 Andrew Morton, Alexander Viro, Ted Ts'o and Stephen Tweedie.
 
-ext3 is ext2 filesystem enhanced with journalling capabilities. 
+Ext3 is the ext2 filesystem enhanced with journalling capabilities.
 
 Options
 =======
@@ -14,69 +14,71 @@ Options
 When mounting an ext3 filesystem, the following option are accepted:
 (*) == default
 
-jounal=update          Update the ext3 file system's journal to the 
-                       current format.
+journal=update         Update the ext3 file system's journal to the current
+                       format.
 
-journal=inum           When a journal already exists, this option is 
-                       ignored. Otherwise, it specifies the number of
-                       the inode which will represent the ext3 file
-                       system's journal file.
+journal=inum           When a journal already exists, this option is ignored.
+                       Otherwise, it specifies the number of the inode which
+                       will represent the ext3 file system's journal file.
 
 journal_dev=devnum     When the external journal device's major/minor numbers
-                       have changed, this option allows to specify the new
-                       journal location. The journal device is identified
-                       through its new major/minor numbers encoded in devnum.
+                       have changed, this option allows the user to specify
+                       the new journal location.  The journal device is
+                       identified through its new major/minor numbers encoded
+                       in devnum.
 
 noload                 Don't load the journal on mounting.
 
-data=journal           All data are committed into the journal prior
-                       to being written into the main file system.
+data=journal           All data are committed into the journal prior to being
+                       written into the main file system.
 
 data=ordered   (*)     All data are forced directly out to the main file
-                       system prior to its metadata being committed to
-                       the journal.
+                       system prior to its metadata being committed to the
+                       journal.
 
-data=writeback         Data ordering is not preserved, data may be
-                       written into the main file system after its
-                       metadata has been committed to the journal.
+data=writeback         Data ordering is not preserved, data may be written
+                       into the main file system after its metadata has been
+                       committed to the journal.
 
 commit=nrsec   (*)     Ext3 can be told to sync all its data and metadata
                        every 'nrsec' seconds. The default value is 5 seconds.
-                       This means that if you lose your power, you will lose,
-                       as much, the latest 5 seconds of work (your filesystem
-                       will not be damaged though, thanks to journaling). This
-                       default value (or any low value) will hurt performance,
-                       but it's good for data-safety. Setting it to 0 will
-                       have the same effect than leaving the default 5 sec.
+                       This means that if you lose your power, you will lose
+                       as much as the latest 5 seconds of work (your
+                       filesystem will not be damaged though, thanks to the
+                       journaling).  This default value (or any low value)
+                       will hurt performance, but it's good for data-safety.
+                       Setting it to 0 will have the same effect as leaving
+                       it at the default (5 seconds).
                        Setting it to very large values will improve
                        performance.
 
-barrier=1              This enables/disables barriers. barrier=0 disables it,
-                       barrier=1 enables it.
+barrier=1              This enables/disables barriers.  barrier=0 disables
+                       it, barrier=1 enables it.
 
-orlov          (*)     This enables the new Orlov block allocator. It's enabled
-                       by default.
+orlov          (*)     This enables the new Orlov block allocator. It is
+                       enabled by default.
 
-oldalloc               This disables the Orlov block allocator and enables the
-                       old block allocator. Orlov should have better performance,
-                       we'd like to get some feedback if it's the contrary for
-                       you.
+oldalloc               This disables the Orlov block allocator and enables
+                       the old block allocator.  Orlov should have better
+                       performance - we'd like to get some feedback if it's
+                       the contrary for you.
 
-user_xattr             Enables Extended User Attributes. Additionally, you need
-                       to have extended attribute support enabled in the kernel
-                       configuration (CONFIG_EXT3_FS_XATTR). See the attr(5)
-                       manual page and http://acl.bestbits.at to learn more
-                       about extended attributes.
+user_xattr             Enables Extended User Attributes.  Additionally, you
+                       need to have extended attribute support enabled in the
+                       kernel configuration (CONFIG_EXT3_FS_XATTR).  See the
+                       attr(5) manual page and http://acl.bestbits.at/ to
+                       learn more about extended attributes.
 
 nouser_xattr           Disables Extended User Attributes.
 
-acl                    Enables POSIX Access Control Lists support.  Additionally,
-                       you need to have ACL support enabled in the kernel
-                       configuration (CONFIG_EXT3_FS_POSIX_ACL). See the acl(5)
-                       manual page and http://acl.bestbits.at for more
-                       information.
+acl                    Enables POSIX Access Control Lists support.
+                       Additionally, you need to have ACL support enabled in
+                       the kernel configuration (CONFIG_EXT3_FS_POSIX_ACL).
+                       See the acl(5) manual page and http://acl.bestbits.at/
+                       for more information.
 
-noacl                  This option disables POSIX Access Control List support.
+noacl                  This option disables POSIX Access Control List
+                       support.
 
 reservation
 
@@ -88,7 +90,7 @@ bsddf                 (*)     Make 'df' act like BSD.
 minixdf                        Make 'df' act like Minix.
 
 check=none             Don't do extra checking of bitmaps on mount.
-nocheck                
+nocheck
 
 debug                  Extra debugging information is sent to syslog.
 
@@ -97,7 +99,7 @@ errors=continue               Keep going on a filesystem error.
 errors=panic           Panic and halt the machine if an error occurs.
 
 grpid                  Give objects the same group ID as their creator.
-bsdgroups              
+bsdgroups
 
 nogrpid                (*)     New objects have the group ID of their creator.
 sysvgroups
@@ -108,81 +110,81 @@ resuid=n          The user ID which may use the reserved blocks.
 
 sb=n                   Use alternate superblock at this location.
 
-quota                  Quota options are currently silently ignored.
-noquota                        (see fs/ext3/super.c, line 594)
+quota
+noquota
 grpquota
 usrquota
 
 
 Specification
 =============
-ext3 shares all disk implementation with ext2 filesystem, and add
-transactions capabilities to ext2.  Journaling is done by the
-Journaling block device layer.
+Ext3 shares all disk implementation with the ext2 filesystem, and adds
+transactions capabilities to ext2.  Journaling is done by the Journaling Block
+Device layer.
 
 Journaling Block Device layer
 -----------------------------
-The Journaling Block Device layer (JBD) isn't ext3 specific.  It was
-design to add journaling capabilities on a block device.  The ext3
-filesystem code will inform the JBD of modifications it is performing
-(Call a transaction).  the journal support the transactions start and
-stop, and in case of crash, the journal can replayed the transactions
-to put the partition on a consistent state fastly.
+The Journaling Block Device layer (JBD) isn't ext3 specific.  It was design to
+add journaling capabilities on a block device.  The ext3 filesystem code will
+inform the JBD of modifications it is performing (called a transaction).  The
+journal supports the transactions start and stop, and in case of crash, the
+journal can replayed the transactions to put the partition back in a
+consistent state fast.
 
-handles represent a single atomic update to a filesystem.  JBD can
-handle external journal on a block device.
+Handles represent a single atomic update to a filesystem.  JBD can handle an
+external journal on a block device.
 
 Data Mode
 ---------
-There's 3 different data modes:
+There are 3 different data modes:
 
 * writeback mode
-In data=writeback mode, ext3 does not journal data at all.  This mode
-provides a similar level of journaling as XFS, JFS, and ReiserFS in its
-default mode - metadata journaling.  A crash+recovery can cause
-incorrect data to appear in files which were written shortly before the
-crash.  This mode will typically provide the best ext3 performance.
+In data=writeback mode, ext3 does not journal data at all.  This mode provides
+a similar level of journaling as that of XFS, JFS, and ReiserFS in its default
+mode - metadata journaling.  A crash+recovery can cause incorrect data to
+appear in files which were written shortly before the crash.  This mode will
+typically provide the best ext3 performance.
 
 * ordered mode
-In data=ordered mode, ext3 only officially journals metadata, but it
-logically groups metadata and data blocks into a single unit called a
-transaction.  When it's time to write the new metadata out to disk, the
-associated data blocks are written first.  In general, this mode
-perform slightly slower than writeback but significantly faster than
-journal mode.
+In data=ordered mode, ext3 only officially journals metadata, but it logically
+groups metadata and data blocks into a single unit called a transaction.  When
+it's time to write the new metadata out to disk, the associated data blocks
+are written first.  In general, this mode performs slightly slower than
+writeback but significantly faster than journal mode.
 
 * journal mode
-data=journal mode provides full data and metadata journaling.  All new
-data is written to the journal first, and then to its final location. 
-In the event of a crash, the journal can be replayed, bringing both
-data and metadata into a consistent state.  This mode is the slowest
-except when data needs to be read from and written to disk at the same
-time where it outperform all others mode.
+data=journal mode provides full data and metadata journaling.  All new data is
+written to the journal first, and then to its final location.
+In the event of a crash, the journal can be replayed, bringing both data and
+metadata into a consistent state.  This mode is the slowest except when data
+needs to be read from and written to disk at the same time where it
+outperforms all others modes.
 
 Compatibility
 -------------
 
 Ext2 partitions can be easily convert to ext3, with `tune2fs -j <dev>`.
-Ext3 is fully compatible with Ext2.  Ext3 partitions can easily be
-mounted as Ext2.
+Ext3 is fully compatible with Ext2.  Ext3 partitions can easily be mounted as
+Ext2.
+
 
 External Tools
 ==============
-see manual pages to know more.
+See manual pages to learn more.
+
+tune2fs:       create a ext3 journal on a ext2 partition with the -j flag.
+mke2fs:        create a ext3 partition with the -j flag.
+debugfs:       ext2 and ext3 file system debugger.
 
-tune2fs:       create a ext3 journal on a ext2 partition with the -j flags
-mke2fs:        create a ext3 partition with the -j flags
-debugfs:       ext2 and ext3 file system debugger
 
 References
 ==========
 
-kernel source: file:/usr/src/linux/fs/ext3
-               file:/usr/src/linux/fs/jbd
+kernel source: <file:fs/ext3/>
+               <file:fs/jbd/>
 
-programs:      http://e2fsprogs.sourceforge.net
+programs:      http://e2fsprogs.sourceforge.net/
 
-useful link:
-               http://www.zip.com.au/~akpm/linux/ext3/ext3-usage.html
+useful links:  http://www.zip.com.au/~akpm/linux/ext3/ext3-usage.html
                http://www-106.ibm.com/developerworks/linux/library/l-fs7/
                http://www-106.ibm.com/developerworks/linux/library/l-fs8/
diff --git a/Documentation/hrtimers.txt b/Documentation/hrtimers.txt
new file mode 100644 (file)
index 0000000..7620ff7
--- /dev/null
@@ -0,0 +1,178 @@
+
+hrtimers - subsystem for high-resolution kernel timers
+----------------------------------------------------
+
+This patch introduces a new subsystem for high-resolution kernel timers.
+
+One might ask the question: we already have a timer subsystem
+(kernel/timers.c), why do we need two timer subsystems? After a lot of
+back and forth trying to integrate high-resolution and high-precision
+features into the existing timer framework, and after testing various
+such high-resolution timer implementations in practice, we came to the
+conclusion that the timer wheel code is fundamentally not suitable for
+such an approach. We initially didnt believe this ('there must be a way
+to solve this'), and spent a considerable effort trying to integrate
+things into the timer wheel, but we failed. In hindsight, there are
+several reasons why such integration is hard/impossible:
+
+- the forced handling of low-resolution and high-resolution timers in
+  the same way leads to a lot of compromises, macro magic and #ifdef
+  mess. The timers.c code is very "tightly coded" around jiffies and
+  32-bitness assumptions, and has been honed and micro-optimized for a
+  relatively narrow use case (jiffies in a relatively narrow HZ range)
+  for many years - and thus even small extensions to it easily break
+  the wheel concept, leading to even worse compromises. The timer wheel
+  code is very good and tight code, there's zero problems with it in its
+  current usage - but it is simply not suitable to be extended for
+  high-res timers.
+
+- the unpredictable [O(N)] overhead of cascading leads to delays which
+  necessiate a more complex handling of high resolution timers, which
+  in turn decreases robustness. Such a design still led to rather large
+  timing inaccuracies. Cascading is a fundamental property of the timer
+  wheel concept, it cannot be 'designed out' without unevitably
+  degrading other portions of the timers.c code in an unacceptable way.
+
+- the implementation of the current posix-timer subsystem on top of
+  the timer wheel has already introduced a quite complex handling of
+  the required readjusting of absolute CLOCK_REALTIME timers at
+  settimeofday or NTP time - further underlying our experience by
+  example: that the timer wheel data structure is too rigid for high-res
+  timers.
+
+- the timer wheel code is most optimal for use cases which can be
+  identified as "timeouts". Such timeouts are usually set up to cover
+  error conditions in various I/O paths, such as networking and block
+  I/O. The vast majority of those timers never expire and are rarely
+  recascaded because the expected correct event arrives in time so they
+  can be removed from the timer wheel before any further processing of
+  them becomes necessary. Thus the users of these timeouts can accept
+  the granularity and precision tradeoffs of the timer wheel, and
+  largely expect the timer subsystem to have near-zero overhead.
+  Accurate timing for them is not a core purpose - in fact most of the
+  timeout values used are ad-hoc. For them it is at most a necessary
+  evil to guarantee the processing of actual timeout completions
+  (because most of the timeouts are deleted before completion), which
+  should thus be as cheap and unintrusive as possible.
+
+The primary users of precision timers are user-space applications that
+utilize nanosleep, posix-timers and itimer interfaces. Also, in-kernel
+users like drivers and subsystems which require precise timed events
+(e.g. multimedia) can benefit from the availability of a seperate
+high-resolution timer subsystem as well.
+
+While this subsystem does not offer high-resolution clock sources just
+yet, the hrtimer subsystem can be easily extended with high-resolution
+clock capabilities, and patches for that exist and are maturing quickly.
+The increasing demand for realtime and multimedia applications along
+with other potential users for precise timers gives another reason to
+separate the "timeout" and "precise timer" subsystems.
+
+Another potential benefit is that such a seperation allows even more
+special-purpose optimization of the existing timer wheel for the low
+resolution and low precision use cases - once the precision-sensitive
+APIs are separated from the timer wheel and are migrated over to
+hrtimers. E.g. we could decrease the frequency of the timeout subsystem
+from 250 Hz to 100 HZ (or even smaller).
+
+hrtimer subsystem implementation details
+----------------------------------------
+
+the basic design considerations were:
+
+- simplicity
+
+- data structure not bound to jiffies or any other granularity. All the
+  kernel logic works at 64-bit nanoseconds resolution - no compromises.
+
+- simplification of existing, timing related kernel code
+
+another basic requirement was the immediate enqueueing and ordering of
+timers at activation time. After looking at several possible solutions
+such as radix trees and hashes, we chose the red black tree as the basic
+data structure. Rbtrees are available as a library in the kernel and are
+used in various performance-critical areas of e.g. memory management and
+file systems. The rbtree is solely used for time sorted ordering, while
+a separate list is used to give the expiry code fast access to the
+queued timers, without having to walk the rbtree.
+
+(This seperate list is also useful for later when we'll introduce
+high-resolution clocks, where we need seperate pending and expired
+queues while keeping the time-order intact.)
+
+Time-ordered enqueueing is not purely for the purposes of
+high-resolution clocks though, it also simplifies the handling of
+absolute timers based on a low-resolution CLOCK_REALTIME. The existing
+implementation needed to keep an extra list of all armed absolute
+CLOCK_REALTIME timers along with complex locking. In case of
+settimeofday and NTP, all the timers (!) had to be dequeued, the
+time-changing code had to fix them up one by one, and all of them had to
+be enqueued again. The time-ordered enqueueing and the storage of the
+expiry time in absolute time units removes all this complex and poorly
+scaling code from the posix-timer implementation - the clock can simply
+be set without having to touch the rbtree. This also makes the handling
+of posix-timers simpler in general.
+
+The locking and per-CPU behavior of hrtimers was mostly taken from the
+existing timer wheel code, as it is mature and well suited. Sharing code
+was not really a win, due to the different data structures. Also, the
+hrtimer functions now have clearer behavior and clearer names - such as
+hrtimer_try_to_cancel() and hrtimer_cancel() [which are roughly
+equivalent to del_timer() and del_timer_sync()] - so there's no direct
+1:1 mapping between them on the algorithmical level, and thus no real
+potential for code sharing either.
+
+Basic data types: every time value, absolute or relative, is in a
+special nanosecond-resolution type: ktime_t. The kernel-internal
+representation of ktime_t values and operations is implemented via
+macros and inline functions, and can be switched between a "hybrid
+union" type and a plain "scalar" 64bit nanoseconds representation (at
+compile time). The hybrid union type optimizes time conversions on 32bit
+CPUs. This build-time-selectable ktime_t storage format was implemented
+to avoid the performance impact of 64-bit multiplications and divisions
+on 32bit CPUs. Such operations are frequently necessary to convert
+between the storage formats provided by kernel and userspace interfaces
+and the internal time format. (See include/linux/ktime.h for further
+details.)
+
+hrtimers - rounding of timer values
+-----------------------------------
+
+the hrtimer code will round timer events to lower-resolution clocks
+because it has to. Otherwise it will do no artificial rounding at all.
+
+one question is, what resolution value should be returned to the user by
+the clock_getres() interface. This will return whatever real resolution
+a given clock has - be it low-res, high-res, or artificially-low-res.
+
+hrtimers - testing and verification
+----------------------------------
+
+We used the high-resolution clock subsystem ontop of hrtimers to verify
+the hrtimer implementation details in praxis, and we also ran the posix
+timer tests in order to ensure specification compliance. We also ran
+tests on low-resolution clocks.
+
+The hrtimer patch converts the following kernel functionality to use
+hrtimers:
+
+ - nanosleep
+ - itimers
+ - posix-timers
+
+The conversion of nanosleep and posix-timers enabled the unification of
+nanosleep and clock_nanosleep.
+
+The code was successfully compiled for the following platforms:
+
+ i386, x86_64, ARM, PPC, PPC64, IA64
+
+The code was run-tested on the following platforms:
+
+ i386(UP/SMP), x86_64(UP/SMP), ARM, PPC
+
+hrtimers were also integrated into the -rt tree, along with a
+hrtimers-based high-resolution clock implementation, so the hrtimers
+code got a healthy amount of testing and use in practice.
+
+       Thomas Gleixner, Ingo Molnar
index d802ce88bedc923e5d5a6f49ec9bdc2deacb85bc..443230b43e092804b7573a16619e4b668803d864 100644 (file)
@@ -1033,9 +1033,9 @@ When kbuild executes the following steps are followed (roughly):
 
        Example:
                #arch/i386/Makefile
-               GCC_VERSION := $(call cc-version)
                cflags-y += $(shell \
-               if [ $(GCC_VERSION) -ge 0300 ] ; then echo "-mregparm=3"; fi ;)
+               if [ $(call cc-version) -ge 0300 ] ; then \
+                       echo "-mregparm=3"; fi ;)
 
        In the above example -mregparm=3 is only used for gcc version greater
        than or equal to gcc 3.0.
index 5f08f9ce60464bdb03e7dd6c82398c79c0bd2eba..212cf3c21abf8849e39b5964607263e23da8e77f 100644 (file)
@@ -4,10 +4,10 @@ Documentation for kdump - the kexec-based crash dumping solution
 DESIGN
 ======
 
-Kdump uses kexec to reboot to a second kernel whenever a dump needs to be taken.
-This second kernel is booted with very little memory. The first kernel reserves
-the section of memory that the second kernel uses. This ensures that on-going
-DMA from the first kernel does not corrupt the second kernel.
+Kdump uses kexec to reboot to a second kernel whenever a dump needs to be
+taken. This second kernel is booted with very little memory. The first kernel
+reserves the section of memory that the second kernel uses. This ensures that
+on-going DMA from the first kernel does not corrupt the second kernel.
 
 All the necessary information about Core image is encoded in ELF format and
 stored in reserved area of memory before crash. Physical address of start of
@@ -35,77 +35,82 @@ In the second kernel, "old memory" can be accessed in two ways.
 SETUP
 =====
 
-1) Download http://www.xmission.com/~ebiederm/files/kexec/kexec-tools-1.101.tar.gz
-   and apply http://lse.sourceforge.net/kdump/patches/kexec-tools-1.101-kdump.patch
-   and after that build the source.
+1) Download the upstream kexec-tools userspace package from
+   http://www.xmission.com/~ebiederm/files/kexec/kexec-tools-1.101.tar.gz.
 
-2) Download and build the appropriate (2.6.13-rc1 onwards) vanilla kernel.
+   Apply the latest consolidated kdump patch on top of kexec-tools-1.101
+   from http://lse.sourceforge.net/kdump/. This arrangment has been made
+   till all the userspace patches supporting kdump are integrated with
+   upstream kexec-tools userspace.
 
+2) Download and build the appropriate (2.6.13-rc1 onwards) vanilla kernels.
    Two kernels need to be built in order to get this feature working.
+   Following are the steps to properly configure the two kernels specific
+   to kexec and kdump features:
 
-  A) First kernel:
+  A) First kernel or regular kernel:
+  ----------------------------------
    a) Enable "kexec system call" feature (in Processor type and features).
-       CONFIG_KEXEC=y
-   b) This kernel's physical load address should be the default value of
-      0x100000 (0x100000, 1 MB) (in Processor type and features).
-       CONFIG_PHYSICAL_START=0x100000
-   c) Enable "sysfs file system support" (in Pseudo filesystems).
-       CONFIG_SYSFS=y
+      CONFIG_KEXEC=y
+   b) Enable "sysfs file system support" (in Pseudo filesystems).
+      CONFIG_SYSFS=y
+   c) make
    d) Boot into first kernel with the command line parameter "crashkernel=Y@X".
       Use appropriate values for X and Y. Y denotes how much memory to reserve
-      for the second kernel, and X denotes at what physical address the reserved
-      memory section starts. For example: "crashkernel=64M@16M".
-
-  B) Second kernel:
-   a) Enable "kernel crash dumps" feature (in Processor type and features).
-       CONFIG_CRASH_DUMP=y
-   b) Specify a suitable value for "Physical address where the kernel is
-      loaded" (in Processor type and features). Typically this value
-      should be same as X (See option d) above, e.g., 16 MB or 0x1000000.
-       CONFIG_PHYSICAL_START=0x1000000
-   c) Enable "/proc/vmcore support" (Optional, in Pseudo filesystems).
-       CONFIG_PROC_VMCORE=y
-   d) Disable SMP support and build a UP kernel (Until it is fixed).
-       CONFIG_SMP=n
-   e) Enable "Local APIC support on uniprocessors".
-       CONFIG_X86_UP_APIC=y
-   f) Enable "IO-APIC support on uniprocessors"
-       CONFIG_X86_UP_IOAPIC=y
-
-  Note:   i) Options a) and b) depend upon "Configure standard kernel features
-            (for small systems)" (under General setup).
-        ii) Option a) also depends on CONFIG_HIGHMEM (under Processor
-               type and features).
-       iii) Both option a) and b) are under "Processor type and features".
-
-3) Boot into the first kernel. You are now ready to try out kexec-based crash
-   dumps.
-
-4) Load the second kernel to be booted using:
+      for the second kernel, and X denotes at what physical address the
+      reserved memory section starts. For example: "crashkernel=64M@16M".
+
+
+  B) Second kernel or dump capture kernel:
+  ---------------------------------------
+   a) For i386 architecture enable Highmem support
+      CONFIG_HIGHMEM=y
+   b) Enable "kernel crash dumps" feature (under "Processor type and features")
+      CONFIG_CRASH_DUMP=y
+   c) Make sure a suitable value for "Physical address where the kernel is
+      loaded" (under "Processor type and features"). By default this value
+      is 0x1000000 (16MB) and it should be same as X (See option d above),
+      e.g., 16 MB or 0x1000000.
+      CONFIG_PHYSICAL_START=0x1000000
+   d) Enable "/proc/vmcore support" (Optional, under "Pseudo filesystems").
+      CONFIG_PROC_VMCORE=y
+
+3) After booting to regular kernel or first kernel, load the second kernel
+   using the following command:
 
    kexec -p <second-kernel> --args-linux --elf32-core-headers
-   --append="root=<root-dev> init 1 irqpoll"
-
-   Note: i) <second-kernel> has to be a vmlinux image. bzImage will not work,
-           as of now.
-       ii) By default ELF headers are stored in ELF64 format. Option
-           --elf32-core-headers forces generation of ELF32 headers. gdb can
-           not open ELF64 headers on 32 bit systems. So creating ELF32
-           headers can come handy for users who have got non-PAE systems and
-           hence have memory less than 4GB.
-       iii) Specify "irqpoll" as command line parameter. This reduces driver
-            initialization failures in second kernel due to shared interrupts.
-        iv) <root-dev> needs to be specified in a format corresponding to
-            the root device name in the output of mount command.
-         v) If you have built the drivers required to mount root file
-            system as modules in <second-kernel>, then, specify
-            --initrd=<initrd-for-second-kernel>.
-
-5) System reboots into the second kernel when a panic occurs. A module can be
-   written to force the panic or "ALT-SysRq-c" can be used initiate a crash
-   dump for testing purposes.
-
-6) Write out the dump file using
+   --append="root=<root-dev> init 1 irqpoll maxcpus=1"
+
+   Notes:
+   ======
+     i) <second-kernel> has to be a vmlinux image ie uncompressed elf image.
+        bzImage will not work, as of now.
+    ii) --args-linux has to be speicfied as if kexec it loading an elf image,
+        it needs to know that the arguments supplied are of linux type.
+   iii) By default ELF headers are stored in ELF64 format to support systems
+        with more than 4GB memory. Option --elf32-core-headers forces generation
+        of ELF32 headers. The reason for this option being, as of now gdb can
+        not open vmcore file with ELF64 headers on a 32 bit systems. So ELF32
+        headers can be used if one has non-PAE systems and hence memory less
+        than 4GB.
+    iv) Specify "irqpoll" as command line parameter. This reduces driver
+         initialization failures in second kernel due to shared interrupts.
+     v) <root-dev> needs to be specified in a format corresponding to the root
+        device name in the output of mount command.
+    vi) If you have built the drivers required to mount root file system as
+        modules in <second-kernel>, then, specify
+        --initrd=<initrd-for-second-kernel>.
+   vii) Specify maxcpus=1 as, if during first kernel run, if panic happens on
+        non-boot cpus, second kernel doesn't seem to be boot up all the cpus.
+        The other option is to always built the second kernel without SMP
+        support ie CONFIG_SMP=n
+
+4) After successfully loading the second kernel as above, if a panic occurs
+   system reboots into the second kernel. A module can be written to force
+   the panic or "ALT-SysRq-c" can be used initiate a crash dump for testing
+   purposes.
+
+5) Once the second kernel has booted, write out the dump file using
 
    cp /proc/vmcore <dump-file>
 
@@ -119,9 +124,9 @@ SETUP
 
    Entire memory:  dd if=/dev/oldmem of=oldmem.001
 
+
 ANALYSIS
 ========
-
 Limited analysis can be done using gdb on the dump file copied out of
 /proc/vmcore. Use vmlinux built with -g and run
 
@@ -132,15 +137,19 @@ work fine.
 
 Note: gdb cannot analyse core files generated in ELF64 format for i386.
 
+Latest "crash" (crash-4.0-2.18) as available on Dave Anderson's site
+http://people.redhat.com/~anderson/ works well with kdump format.
+
+
 TODO
 ====
-
 1) Provide a kernel pages filtering mechanism so that core file size is not
    insane on systems having huge memory banks.
-2) Modify "crash" tool to make it recognize this dump.
+2) Relocatable kernel can help in maintaining multiple kernels for crashdump
+   and same kernel as the first kernel can be used to capture the dump.
+
 
 CONTACT
 =======
-
 Vivek Goyal (vgoyal@in.ibm.com)
 Maneesh Soni (maneesh@in.ibm.com)
index 0dc848bf0b56bb59b0c69eacfc3fb4d6a593fb7c..dd0bfc291a682e60c39441d07ef0be026dceabee 100644 (file)
@@ -475,10 +475,11 @@ running once the system is up.
                        See Documentation/block/as-iosched.txt and
                        Documentation/block/deadline-iosched.txt for details.
 
-       elfcorehdr=     [IA-32]
+       elfcorehdr=     [IA-32, X86_64]
                        Specifies physical address of start of kernel core
-                       image elf header.
-                       See Documentation/kdump.txt for details.
+                       image elf header. Generally kexec loader will
+                       pass this option to capture kernel.
+                       See Documentation/kdump/kdump.txt for details.
 
        enforcing       [SELINUX] Set initial enforcing status.
                        Format: {"0" | "1"}
@@ -832,7 +833,7 @@ running once the system is up.
        mem=nopentium   [BUGS=IA-32] Disable usage of 4MB pages for kernel
                        memory.
 
-       memmap=exactmap [KNL,IA-32] Enable setting of an exact
+       memmap=exactmap [KNL,IA-32,X86_64] Enable setting of an exact
                        E820 memory map, as specified by the user.
                        Such memmap=exactmap lines can be constructed based on
                        BIOS output or other requirements. See the memmap=nn@ss
index ce1be79edfb8e0f3143c3c2f41bff99ecc7742ed..e3b402ef33bd9f3da6614bf45f09e13b72b29cd1 100644 (file)
@@ -65,20 +65,3 @@ The default is to disallow mandatory locking. The intention is that
 mandatory locking only be enabled on a local filesystem as the specific need
 arises.
 
-Until an updated version of mount(8) becomes available you may have to apply
-this patch to the mount sources (based on the version distributed with Rick
-Faith's util-linux-2.5 package):
-
-*** mount.c.orig       Sat Jun  8 09:14:31 1996
---- mount.c    Sat Jun  8 09:13:02 1996
-***************
-*** 100,105 ****
---- 100,107 ----
-    { "noauto",        0, MS_NOAUTO    },      /* Can  only be mounted explicitly */
-    { "user",  0, MS_USER      },      /* Allow ordinary user to mount */
-    { "nouser",        1, MS_USER      },      /* Forbid ordinary user to mount */
-+   { "mand",  0, MS_MANDLOCK  },      /* Allow mandatory locks on this FS */
-+   { "nomand",        1, MS_MANDLOCK  },      /* Forbid mandatory locks on this FS */
-    /* add new options here */
-  #ifdef MS_NOSUB
-    { "sub",   1, MS_NOSUB     },      /* allow submounts */
index 2c81305090dffa5abe196add167f24a51ba796d8..e409e5d0748601db721967bbaf631a87e3020832 100644 (file)
@@ -1,58 +1,56 @@
 Everything you ever wanted to know about Linux 2.6 -stable releases.
 
-Rules on what kind of patches are accepted, and what ones are not, into
-the "-stable" tree:
+Rules on what kind of patches are accepted, and which ones are not, into the
+"-stable" tree:
 
  - It must be obviously correct and tested.
- - It can not bigger than 100 lines, with context.
+ - It can not be bigger than 100 lines, with context.
  - It must fix only one thing.
  - It must fix a real bug that bothers people (not a, "This could be a
-   problem..." type thing.)
+   problem..." type thing).
  - It must fix a problem that causes a build error (but not for things
    marked CONFIG_BROKEN), an oops, a hang, data corruption, a real
-   security issue, or some "oh, that's not good" issue.  In short,
-   something critical.
- - No "theoretical race condition" issues, unless an explanation of how
-   the race can be exploited.
+   security issue, or some "oh, that's not good" issue.  In short, something
+   critical.
+ - No "theoretical race condition" issues, unless an explanation of how the
+   race can be exploited is also provided.
  - It can not contain any "trivial" fixes in it (spelling changes,
-   whitespace cleanups, etc.)
+   whitespace cleanups, etc).
  - It must be accepted by the relevant subsystem maintainer.
- - It must follow Documentation/SubmittingPatches rules.
+ - It must follow the Documentation/SubmittingPatches rules.
 
 
 Procedure for submitting patches to the -stable tree:
 
  - Send the patch, after verifying that it follows the above rules, to
    stable@kernel.org.
- - The sender will receive an ack when the patch has been accepted into
-   the queue, or a nak if the patch is rejected.  This response might
-   take a few days, according to the developer's schedules.
- - If accepted, the patch will be added to the -stable queue, for review
-   by other developers.
+ - The sender will receive an ACK when the patch has been accepted into the
+   queue, or a NAK if the patch is rejected.  This response might take a few
+   days, according to the developer's schedules.
+ - If accepted, the patch will be added to the -stable queue, for review by
+   other developers.
  - Security patches should not be sent to this alias, but instead to the
-   documented security@kernel.org.
+   documented security@kernel.org address.
 
 
 Review cycle:
 
- - When the -stable maintainers decide for a review cycle, the patches
-   will be sent to the review committee, and the maintainer of the
-   affected area of the patch (unless the submitter is the maintainer of
-   the area) and CC: to the linux-kernel mailing list.
- - The review committee has 48 hours in which to ack or nak the patch.
+ - When the -stable maintainers decide for a review cycle, the patches will be
+   sent to the review committee, and the maintainer of the affected area of
+   the patch (unless the submitter is the maintainer of the area) and CC: to
+   the linux-kernel mailing list.
+ - The review committee has 48 hours in which to ACK or NAK the patch.
  - If the patch is rejected by a member of the committee, or linux-kernel
-   members object to the patch, bringing up issues that the maintainers
-   and members did not realize, the patch will be dropped from the
-   queue.
- - At the end of the review cycle, the acked patches will be added to
-   the latest -stable release, and a new -stable release will happen.
- - Security patches will be accepted into the -stable tree directly from
-   the security kernel team, and not go through the normal review cycle.
+   members object to the patch, bringing up issues that the maintainers and
+   members did not realize, the patch will be dropped from the queue.
+ - At the end of the review cycle, the ACKed patches will be added to the
+   latest -stable release, and a new -stable release will happen.
+ - Security patches will be accepted into the -stable tree directly from the
+   security kernel team, and not go through the normal review cycle.
    Contact the kernel security team for more details on this procedure.
 
 
 Review committe:
 
- - This will be made up of a number of kernel developers who have
-   volunteered for this task, and a few that haven't.
-
+ - This is made up of a number of kernel developers who have volunteered for
+   this task, and a few that haven't.
diff --git a/Kbuild b/Kbuild
index 79003918f37f2593e157778734f2bb83d131abb1..95d6a00bace08c0ac50b80356847d5f19f6dc55a 100644 (file)
--- a/Kbuild
+++ b/Kbuild
@@ -22,8 +22,6 @@ sed-$(CONFIG_MIPS) := "/^@@@/s///p"
 
 quiet_cmd_offsets = GEN     $@
 define cmd_offsets
-       mkdir -p $(dir $@); \
-       cat $< | \
        (set -e; \
         echo "#ifndef __ASM_OFFSETS_H__"; \
         echo "#define __ASM_OFFSETS_H__"; \
@@ -34,7 +32,7 @@ define cmd_offsets
         echo " *"; \
         echo " */"; \
         echo ""; \
-        sed -ne $(sed-y); \
+        sed -ne $(sed-y) $<; \
         echo ""; \
         echo "#endif" ) > $@
 endef
@@ -45,5 +43,6 @@ arch/$(ARCH)/kernel/asm-offsets.s: arch/$(ARCH)/kernel/asm-offsets.c FORCE
        $(call if_changed_dep,cc_s_c)
 
 $(obj)/$(offsets-file): arch/$(ARCH)/kernel/asm-offsets.s Kbuild
+       $(Q)mkdir -p $(dir $@)
        $(call cmd,offsets)
 
index 07420161e669054211c639cedf55c56127ccb943..090e10b65b093d77cdf199d4e5b218df10ed6bf5 100644 (file)
@@ -804,6 +804,7 @@ S:  Maintained
 DOCBOOK FOR DOCUMENTATION
 P:     Martin Waitz
 M:     tali@admingilde.org
+T:     git http://tali.admingilde.org/git/linux-docbook.git
 S:     Maintained
 
 DOUBLETALK DRIVER
index fb497ea8bc748d00f72c842861c0be9aad46d57b..deedaf79cdca2325936f63b511b3744163587bd6 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -141,24 +141,6 @@ VPATH              := $(srctree)
 
 export srctree objtree VPATH TOPDIR
 
-nullstring :=
-space      := $(nullstring) # end of line
-
-# Take the contents of any files called localversion* and the config
-# variable CONFIG_LOCALVERSION and append them to KERNELRELEASE. Be
-# careful not to include files twice if building in the source
-# directory. LOCALVERSION from the command line override all of this
-
-localver := $(objtree)/localversion* $(srctree)/localversion*
-localver := $(sort $(wildcard $(localver)))
-# skip backup files (containing '~')
-localver := $(foreach f, $(localver), $(if $(findstring ~, $(f)),,$(f)))
-
-LOCALVERSION = $(subst $(space),, \
-              $(shell cat /dev/null $(localver)) \
-              $(patsubst "%",%,$(CONFIG_LOCALVERSION)))
-
-KERNELRELEASE=$(VERSION).$(PATCHLEVEL).$(SUBLEVEL)$(EXTRAVERSION)$(LOCALVERSION)
 
 # SUBARCH tells the usermode build what the underlying arch is.  That is set
 # first, and if a usermode build is happening, the "ARCH=um" on the command
@@ -353,7 +335,10 @@ CFLAGS             := -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs \
                   -ffreestanding
 AFLAGS         := -D__ASSEMBLY__
 
-export VERSION PATCHLEVEL SUBLEVEL EXTRAVERSION LOCALVERSION KERNELRELEASE \
+# Read KERNELRELEASE from .kernelrelease (if it exists)
+KERNELRELEASE = $(shell cat .kernelrelease 2> /dev/null)
+
+export VERSION PATCHLEVEL SUBLEVEL KERNELRELEASE \
        ARCH CONFIG_SHELL HOSTCC HOSTCFLAGS CROSS_COMPILE AS LD CC \
        CPP AR NM STRIP OBJCOPY OBJDUMP MAKE AWK GENKSYMS PERL UTS_MACHINE \
        HOSTCXX HOSTCXXFLAGS LDFLAGS_MODULE CHECK CHECKFLAGS
@@ -551,26 +536,6 @@ export KBUILD_IMAGE ?= vmlinux
 # images. Default is /boot, but you can set it to other values
 export INSTALL_PATH ?= /boot
 
-# If CONFIG_LOCALVERSION_AUTO is set, we automatically perform some tests
-# and try to determine if the current source tree is a release tree, of any sort,
-# or if is a pure development tree.
-#
-# A 'release tree' is any tree with a git TAG associated
-# with it.  The primary goal of this is to make it safe for a native
-# git/CVS/SVN user to build a release tree (i.e, 2.6.9) and also to
-# continue developing against the current Linus tree, without having the Linus
-# tree overwrite the 2.6.9 tree when installed.
-#
-# Currently, only git is supported.
-# Other SCMs can edit scripts/setlocalversion and add the appropriate
-# checks as needed.
-
-
-ifdef CONFIG_LOCALVERSION_AUTO
-       localversion-auto := $(shell $(PERL) $(srctree)/scripts/setlocalversion $(srctree))
-       LOCALVERSION := $(LOCALVERSION)$(localversion-auto)
-endif
-
 #
 # INSTALL_MOD_PATH specifies a prefix to MODLIB for module directory
 # relocations required by build roots.  This is not defined in the
@@ -782,6 +747,50 @@ $(sort $(vmlinux-init) $(vmlinux-main)) $(vmlinux-lds): $(vmlinux-dirs) ;
 $(vmlinux-dirs): prepare scripts
        $(Q)$(MAKE) $(build)=$@
 
+# Build the kernel release string
+# The KERNELRELEASE is stored in a file named .kernelrelease
+# to be used when executing for example make install or make modules_install
+#
+# Take the contents of any files called localversion* and the config
+# variable CONFIG_LOCALVERSION and append them to KERNELRELEASE.
+# LOCALVERSION from the command line override all of this
+
+nullstring :=
+space      := $(nullstring) # end of line
+
+___localver = $(objtree)/localversion* $(srctree)/localversion*
+__localver  = $(sort $(wildcard $(___localver)))
+# skip backup files (containing '~')
+_localver = $(foreach f, $(__localver), $(if $(findstring ~, $(f)),,$(f)))
+
+localver = $(subst $(space),, \
+          $(shell cat /dev/null $(_localver)) \
+          $(patsubst "%",%,$(CONFIG_LOCALVERSION)))
+              
+# If CONFIG_LOCALVERSION_AUTO is set scripts/setlocalversion is called
+# and if the SCM is know a tag from the SCM is appended.
+# The appended tag is determinded by the SCM used.
+#
+# Currently, only git is supported.
+# Other SCMs can edit scripts/setlocalversion and add the appropriate
+# checks as needed.
+ifdef CONFIG_LOCALVERSION_AUTO
+       _localver-auto = $(shell $(CONFIG_SHELL) \
+                         $(srctree)/scripts/setlocalversion $(srctree))
+       localver-auto  = $(LOCALVERSION)$(_localver-auto)
+endif
+
+localver-full = $(localver)$(localver-auto)
+
+# Store (new) KERNELRELASE string in .kernelrelease
+kernelrelease = \
+       $(VERSION).$(PATCHLEVEL).$(SUBLEVEL)$(EXTRAVERSION)$(localver-full)
+.kernelrelease: FORCE
+       $(Q)rm -f .kernelrelease
+       $(Q)echo $(kernelrelease) > .kernelrelease
+       $(Q)echo "  Building kernel $(kernelrelease)"
+
+
 # Things we need to do before we recursively start building the kernel
 # or the modules are listed in "prepare".
 # A multi level approach is used. prepareN is processed before prepareN-1.
@@ -798,8 +807,7 @@ $(vmlinux-dirs): prepare scripts
 # and if so do:
 # 1) Check that make has not been executed in the kernel src $(srctree)
 # 2) Create the include2 directory, used for the second asm symlink
-
-prepare3:
+prepare3: .kernelrelease
 ifneq ($(KBUILD_SRC),)
        @echo '  Using $(srctree) as source for kernel'
        $(Q)if [ -f $(srctree)/.config ]; then \
@@ -984,9 +992,9 @@ CLEAN_FILES +=      vmlinux System.map \
 
 # Directories & files removed with 'make mrproper'
 MRPROPER_DIRS  += include/config include2
-MRPROPER_FILES += .config .config.old include/asm .version \
+MRPROPER_FILES += .config .config.old include/asm .version .old_version \
                   include/linux/autoconf.h include/linux/version.h \
-                  Module.symvers tags TAGS cscope*
+                 .kernelrelease Module.symvers tags TAGS cscope*
 
 # clean - Delete most, but leave enough to build external modules
 #
@@ -1072,6 +1080,7 @@ help:
        @echo  '  tags/TAGS       - Generate tags file for editors'
        @echo  '  cscope          - Generate cscope index'
        @echo  '  kernelrelease   - Output the release version string'
+       @echo  '  kernelversion   - Output the version stored in Makefile'
        @echo  ''
        @echo  'Static analysers'
        @echo  '  buildcheck      - List dangling references to vmlinux discarded sections'
@@ -1293,6 +1302,8 @@ checkstack:
 
 kernelrelease:
        @echo $(KERNELRELEASE)
+kernelversion:
+       @echo $(VERSION).$(PATCHLEVEL).$(SUBLEVEL)$(EXTRAVERSION)
 
 # FIXME Should go into a make.lib or something 
 # ===========================================================================
index f3e98f837784b13d7226d907e31032eb68f75970..1898ea79d0e29f3bdbb922b2d9d0af1c0462078b 100644 (file)
@@ -40,7 +40,6 @@
 #include <asm/unistd.h>
 
 extern struct hwrpb_struct *hwrpb;
-extern void dump_thread(struct pt_regs *, struct user *);
 extern spinlock_t rtc_lock;
 
 /* these are C runtime functions with special calling conventions: */
index 90752f6d88679984151930d36beba92c8010a578..486d7945583d1d59fde2dbff8e2f919f1ef06273 100644 (file)
@@ -7,6 +7,7 @@
 /* 2.3.x zone allocator, 1999 Andrea Arcangeli <andrea@suse.de> */
 
 #include <linux/config.h>
+#include <linux/pagemap.h>
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
index f5cc21ad09565cba72c2e1c46fd921919b8e1612..a4e5ac77f6dfc7be5fb546271a9b68569410040e 100644 (file)
@@ -64,7 +64,7 @@ static int dma_chan_count;
 static spinlock_t dma_chan_lock;
 static struct omap_dma_lch dma_chan[OMAP_LOGICAL_DMA_CH_COUNT];
 
-const static u8 omap1_dma_irq[OMAP_LOGICAL_DMA_CH_COUNT] = {
+static const u8 omap1_dma_irq[OMAP_LOGICAL_DMA_CH_COUNT] = {
        INT_DMA_CH0_6, INT_DMA_CH1_7, INT_DMA_CH2_8, INT_DMA_CH3,
        INT_DMA_CH4, INT_DMA_CH5, INT_1610_DMA_CH6, INT_1610_DMA_CH7,
        INT_1610_DMA_CH8, INT_1610_DMA_CH9, INT_1610_DMA_CH10,
index 35514b398e2e26ce7f2e52401f39428ce3f284b4..811a6376c6243d79cc8876b27acbdf216aadcc4e 100644 (file)
@@ -35,7 +35,6 @@
 #include <asm/checksum.h>
 #include <asm/mach-types.h>
 
-extern void dump_thread(struct pt_regs *, struct user *);
 extern int dump_fpu(struct pt_regs *, struct user_fp_struct *);
 extern void inswb(unsigned int port, void *to, int len);
 extern void outswb(unsigned int port, const void *to, int len);
index 85833d704ebb2579a137779893830a96c0e5080b..de39725da9202e1940230bb42eb66203ad71d1b4 100644 (file)
@@ -21,7 +21,6 @@
 #include <asm/pgtable.h>
 #include <asm/fasttimer.h>
 
-extern void dump_thread(struct pt_regs *, struct user *);
 extern unsigned long get_cmos_time(void);
 extern void __Udiv(void);
 extern void __Umod(void);
@@ -33,7 +32,6 @@ extern void __lshrdi3(void);
 extern void iounmap(volatile void * __iomem);
 
 /* Platform dependent support */
-EXPORT_SYMBOL(dump_thread);
 EXPORT_SYMBOL(kernel_thread);
 EXPORT_SYMBOL(get_cmos_time);
 EXPORT_SYMBOL(loops_per_usec);
index 7c80afb1046077d2fb219d2542c3b815c7d3916d..4ab3e87115b602a513e72495e3f6d34d0ad73cc1 100644 (file)
@@ -257,34 +257,6 @@ void flush_thread(void)
 {
 }
 
-/*
- * fill in the user structure for a core dump..
- */
-void dump_thread(struct pt_regs * regs, struct user * dump)
-{
-#if 0
-       int i;
-
-       /* changed the size calculations - should hopefully work better. lbt */
-       dump->magic = CMAGIC;
-       dump->start_code = 0;
-       dump->start_stack = regs->esp & ~(PAGE_SIZE - 1);
-       dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
-       dump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1))) >> PAGE_SHIFT;
-       dump->u_dsize -= dump->u_tsize;
-       dump->u_ssize = 0;
-       for (i = 0; i < 8; i++)
-               dump->u_debugreg[i] = current->debugreg[i];  
-
-       if (dump->start_stack < TASK_SIZE)
-               dump->u_ssize = ((unsigned long) (TASK_SIZE - dump->start_stack)) >> PAGE_SHIFT;
-
-       dump->regs = *regs;
-
-       dump->u_fpvalid = dump_fpu (regs, &dump->i387);
-#endif 
-}
-
 /* Fill in the fpu structure for a core dump. */
 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
 {
index 61261b78ced7617571f349edbb683050d2f51741..60a617aff8ba465d83b38f09ebf9cbdc1dbe684c 100644 (file)
@@ -6,10 +6,6 @@ config FRV
        bool
        default y
 
-config UID16
-       bool
-       default y
-
 config RWSEM_GENERIC_SPINLOCK
        bool
        default y
index d75e0d7713660fcadc21afb72b78428bc827e87f..5dfc93fd945a9c25dff66c2b2c17c4a09946d6b9 100644 (file)
@@ -57,10 +57,10 @@ initrd:
 # installation
 #
 install: $(CONFIGURE) Image
-       sh ./install.sh $(VERSION).$(PATCHLEVEL).$(SUBLEVEL)$(EXTRAVERSION) Image $(TOPDIR)/System.map "$(INSTALL_PATH)"
+       sh ./install.sh $(KERNELRELEASE) Image $(TOPDIR)/System.map "$(INSTALL_PATH)"
 
 zinstall: $(CONFIGURE) zImage
-       sh ./install.sh $(VERSION).$(PATCHLEVEL).$(SUBLEVEL)$(EXTRAVERSION) zImage $(TOPDIR)/System.map "$(INSTALL_PATH)"
+       sh ./install.sh $(KERNELRELEASE) zImage $(TOPDIR)/System.map "$(INSTALL_PATH)"
 
 #
 # miscellany
index 5f118c89d091f82a5dedcaf2f3a4696fdf5117f6..0f1c6cbc4f50706e50267be0f41b666784afa83e 100644 (file)
@@ -18,7 +18,6 @@
 #include <asm/hardirq.h>
 #include <asm/cacheflush.h>
 
-extern void dump_thread(struct pt_regs *, struct user *);
 extern long __memcpy_user(void *dst, const void *src, size_t count);
 extern long __memset_user(void *dst, const void *src, size_t count);
 
@@ -27,7 +26,6 @@ extern long __memset_user(void *dst, const void *src, size_t count);
 EXPORT_SYMBOL(__ioremap);
 EXPORT_SYMBOL(iounmap);
 
-EXPORT_SYMBOL(dump_thread);
 EXPORT_SYMBOL(strnlen);
 EXPORT_SYMBOL(strrchr);
 EXPORT_SYMBOL(strstr);
index 54a452136f00e8f93cabd0bcdf8e5a450d662b26..c4488379ac3bf022998274d629f78baccb03f513 100644 (file)
@@ -243,28 +243,6 @@ int copy_thread(int nr, unsigned long clone_flags,
        return 0;
 } /* end copy_thread() */
 
-/*
- * fill in the user structure for a core dump..
- */
-void dump_thread(struct pt_regs *regs, struct user *dump)
-{
-#if 0
-       /* changed the size calculations - should hopefully work better. lbt */
-       dump->magic = CMAGIC;
-       dump->start_code = 0;
-       dump->start_stack = user_stack(regs) & ~(PAGE_SIZE - 1);
-       dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
-       dump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1))) >> PAGE_SHIFT;
-       dump->u_dsize -= dump->u_tsize;
-       dump->u_ssize = 0;
-
-       if (dump->start_stack < TASK_SIZE)
-               dump->u_ssize = ((unsigned long) (TASK_SIZE - dump->start_stack)) >> PAGE_SHIFT;
-
-       dump->regs = *(struct user_context *) regs;
-#endif
-}
-
 /*
  * sys_execve() executes a new program.
  */
index 795682b873e201e3af44149fcfb51f302735b086..d195568ca8a27ed1a44ed3897d47eb53cafe97a8 100644 (file)
@@ -122,7 +122,7 @@ int h8300_get_gpio_dir(int port_bit)
 static char *port_status(int portno)
 {
        static char result[10];
-       const static char io[2]={'I','O'};
+       static const char io[2]={'I','O'};
        char *rp;
        int c;
        unsigned char used,ddr;
@@ -143,7 +143,7 @@ static int gpio_proc_read(char *buf, char **start, off_t offset,
                           int len, int *unused_i, void *unused_v)
 {
        int c,outlen;
-       const static char port_name[]="123456789ABCDEFGH";
+       static const char port_name[]="123456789ABCDEFGH";
        outlen = 0;
        for (c = 0; c < MAX_PORT; c++) {
                if (ddrs[c] == NULL)
index 5a630233112ff2e77bdb5788a61813bb415eff77..3e0d80ea4464b4023d876a70f897e432a5fa73e4 100644 (file)
 //asmlinkage long long __lshrdi3 (long long, int);
 extern char h8300_debug_device[];
 
-extern void dump_thread(struct pt_regs *, struct user *);
-
 /* platform dependent support */
 
-EXPORT_SYMBOL(dump_thread);
 EXPORT_SYMBOL(strnlen);
 EXPORT_SYMBOL(strrchr);
 EXPORT_SYMBOL(strstr);
index fe21adf3e75e8c26e2619e71bbc5167edabc84a7..585ed5efd0f719fa5d490c6f65a7fb318dbf5550 100644 (file)
@@ -207,34 +207,6 @@ int copy_thread(int nr, unsigned long clone_flags,
        return 0;
 }
 
-/*
- * fill in the user structure for a core dump..
- */
-void dump_thread(struct pt_regs * regs, struct user * dump)
-{
-/* changed the size calculations - should hopefully work better. lbt */
-       dump->magic = CMAGIC;
-       dump->start_code = 0;
-       dump->start_stack = rdusp() & ~(PAGE_SIZE - 1);
-       dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
-       dump->u_dsize = ((unsigned long) (current->mm->brk +
-                                         (PAGE_SIZE-1))) >> PAGE_SHIFT;
-       dump->u_dsize -= dump->u_tsize;
-       dump->u_ssize = 0;
-
-       dump->u_ar0 = (struct user_regs_struct *)(((int)(&dump->regs)) -((int)(dump)));
-       dump->regs.er0 = regs->er0;
-       dump->regs.er1 = regs->er1;
-       dump->regs.er2 = regs->er2;
-       dump->regs.er3 = regs->er3;
-       dump->regs.er4 = regs->er4;
-       dump->regs.er5 = regs->er5;
-       dump->regs.er6 = regs->er6;
-       dump->regs.orig_er0 = regs->orig_er0;
-       dump->regs.ccr = regs->ccr;
-       dump->regs.pc  = regs->pc;
-}
-
 /*
  * sys_execve() executes a new program.
  */
index 6ac93c05a1ae9cff1e03d797d87ee67e5ad155d5..746b1ae672a11b9af40e1afec28a84601c960bef 100644 (file)
@@ -98,7 +98,7 @@ struct optable {
                .type       = jmp, \
        }
 
-const static struct optable optable_0[] = {
+static const struct optable optable_0[] = {
        OPTABLE(0x00,0xff, 1,none), /* 0x00 */
        OPTABLE(0x01,0xff,-1,none), /* 0x01 */
        OPTABLE(0x02,0xfe, 1,none), /* 0x02-0x03 */
@@ -131,31 +131,31 @@ const static struct optable optable_0[] = {
        OPTABLE(0x80,0x80, 1,none), /* 0x80-0xff */
 };
 
-const static struct optable optable_1[] = {
+static const struct optable optable_1[] = {
        OPTABLE(0x00,0xff,-3,none), /* 0x0100 */
        OPTABLE(0x40,0xf0,-3,none), /* 0x0140-0x14f */
        OPTABLE(0x80,0xf0, 1,none), /* 0x0180-0x018f */
        OPTABLE(0xc0,0xc0, 2,none), /* 0x01c0-0x01ff */
 };
 
-const static struct optable optable_2[] = {
+static const struct optable optable_2[] = {
        OPTABLE(0x00,0x20, 2,none), /* 0x6a0?/0x6a8?/0x6b0?/0x6b8? */
        OPTABLE(0x20,0x20, 3,none), /* 0x6a2?/0x6aa?/0x6b2?/0x6ba? */
 };
 
-const static struct optable optable_3[] = {
+static const struct optable optable_3[] = {
        OPTABLE(0x69,0xfb, 2,none), /* 0x010069/0x01006d/014069/0x01406d */
        OPTABLE(0x6b,0xff,-4,none), /* 0x01006b/0x01406b */
        OPTABLE(0x6f,0xff, 3,none), /* 0x01006f/0x01406f */
        OPTABLE(0x78,0xff, 5,none), /* 0x010078/0x014078 */
 };
 
-const static struct optable optable_4[] = {
+static const struct optable optable_4[] = {
        OPTABLE(0x00,0x78, 3,none), /* 0x0100690?/0x01006d0?/0140690/0x01406d0?/0x0100698?/0x01006d8?/0140698?/0x01406d8? */
        OPTABLE(0x20,0x78, 4,none), /* 0x0100692?/0x01006d2?/0140692/0x01406d2?/0x010069a?/0x01006da?/014069a?/0x01406da? */
 };
 
-const static struct optables_list {
+static const struct optables_list {
        const struct optable *ptr;
        int size;
 } optables[] = {
index 5441cdd12a3996d46464380aba12679394cde975..f6ed663bdde0ed184874e72c02cfc435e7a86d0b 100644 (file)
@@ -52,7 +52,7 @@ struct irq_pins {
        unsigned char bit_no;
 };
 /* ISTR = 0 */
-const static struct irq_pins irq_assign_table0[16]={
+static const struct irq_pins irq_assign_table0[16]={
         {H8300_GPIO_P5,H8300_GPIO_B0},{H8300_GPIO_P5,H8300_GPIO_B1},
        {H8300_GPIO_P5,H8300_GPIO_B2},{H8300_GPIO_P5,H8300_GPIO_B3},
        {H8300_GPIO_P5,H8300_GPIO_B4},{H8300_GPIO_P5,H8300_GPIO_B5},
@@ -63,7 +63,7 @@ const static struct irq_pins irq_assign_table0[16]={
        {H8300_GPIO_PF,H8300_GPIO_B1},{H8300_GPIO_PF,H8300_GPIO_B2},
 };
 /* ISTR = 1 */
-const static struct irq_pins irq_assign_table1[16]={
+static const struct irq_pins irq_assign_table1[16]={
        {H8300_GPIO_P8,H8300_GPIO_B0},{H8300_GPIO_P8,H8300_GPIO_B1},
        {H8300_GPIO_P8,H8300_GPIO_B2},{H8300_GPIO_P8,H8300_GPIO_B3},
        {H8300_GPIO_P8,H8300_GPIO_B4},{H8300_GPIO_P8,H8300_GPIO_B5},
index f53de493e3e80c0107d44430351ca27bd603ac2e..8268dfd12f1f3c1a54ae9d943a6ed03fda099057 100644 (file)
@@ -42,7 +42,7 @@ struct irq_pins {
        unsigned char bit_no;
 } __attribute__((aligned(1),packed));
 /* ISTR = 0 */
-const static struct irq_pins irq_assign_table0[16]={
+static const struct irq_pins irq_assign_table0[16]={
         {H8300_GPIO_P5,H8300_GPIO_B0},{H8300_GPIO_P5,H8300_GPIO_B1},
        {H8300_GPIO_P5,H8300_GPIO_B2},{H8300_GPIO_P5,H8300_GPIO_B3},
        {H8300_GPIO_P5,H8300_GPIO_B4},{H8300_GPIO_P5,H8300_GPIO_B5},
@@ -53,7 +53,7 @@ const static struct irq_pins irq_assign_table0[16]={
        {H8300_GPIO_PF,H8300_GPIO_B1},{H8300_GPIO_PF,H8300_GPIO_B2},
 }; 
 /* ISTR = 1 */
-const static struct irq_pins irq_assign_table1[16]={
+static const struct irq_pins irq_assign_table1[16]={
        {H8300_GPIO_P8,H8300_GPIO_B0},{H8300_GPIO_P8,H8300_GPIO_B1},
        {H8300_GPIO_P8,H8300_GPIO_B2},{H8300_GPIO_P8,H8300_GPIO_B3},
        {H8300_GPIO_P8,H8300_GPIO_B4},{H8300_GPIO_P8,H8300_GPIO_B5},
index d849c6870e3a3a7e7a44014020f709a3286874bf..815878ebd30f0d9e1699d040e45b854320ab054a 100644 (file)
@@ -645,17 +645,6 @@ config SECCOMP
 
 source kernel/Kconfig.hz
 
-config PHYSICAL_START
-       hex "Physical address where the kernel is loaded" if EMBEDDED
-       default "0x100000"
-       help
-         This gives the physical address where the kernel is loaded.
-         Primarily used in the case of kexec on panic where the
-         fail safe kernel needs to run at a different address than
-         the panic-ed kernel.
-
-         Don't change this unless you know what you are doing.
-
 config KEXEC
        bool "kexec system call (EXPERIMENTAL)"
        depends on EXPERIMENTAL
@@ -675,11 +664,31 @@ config KEXEC
 
 config CRASH_DUMP
        bool "kernel crash dumps (EXPERIMENTAL)"
-       depends on EMBEDDED
        depends on EXPERIMENTAL
        depends on HIGHMEM
        help
          Generate crash dump after being started by kexec.
+
+config PHYSICAL_START
+       hex "Physical address where the kernel is loaded" if (EMBEDDED || CRASH_DUMP)
+
+       default "0x1000000" if CRASH_DUMP
+       default "0x100000"
+       help
+         This gives the physical address where the kernel is loaded. Normally
+         for regular kernels this value is 0x100000 (1MB). But in the case
+         of kexec on panic the fail safe kernel needs to run at a different
+         address than the panic-ed kernel. This option is used to set the load
+         address for kernels used to capture crash dump on being kexec'ed
+         after panic. The default value for crash dump kernels is
+         0x1000000 (16MB). This can also be set based on the "X" value as
+         specified in the "crashkernel=YM@XM" command line boot parameter
+         passed to the panic-ed kernel. Typically this parameter is set as
+         crashkernel=64M@16M. Please take a look at
+         Documentation/kdump/kdump.txt for more details about crash dumps.
+
+         Don't change this unless you know what you are doing.
+
 endmenu
 
 
@@ -1051,3 +1060,7 @@ config X86_TRAMPOLINE
        bool
        depends on X86_SMP || (X86_VOYAGER && SMP)
        default y
+
+config KTIME_SCALAR
+       bool
+       default y
index b84119f9cc63a1ff2df55dd1e3fad00e5211b3b6..d3c0409d201cebcd2a258c1ab2bb1983959e5d23 100644 (file)
@@ -37,7 +37,10 @@ CFLAGS += $(call cc-option,-mpreferred-stack-boundary=2)
 # CPU-specific tuning. Anything which can be shared with UML should go here.
 include $(srctree)/arch/i386/Makefile.cpu
 
-cflags-$(CONFIG_REGPARM)       += -mregparm=3
+# -mregparm=3 works ok on gcc-3.0 and later
+#
+cflags-$(CONFIG_REGPARM) += $(shell if [ $(call cc-version) -ge 0300 ] ; then \
+                            echo "-mregparm=3"; fi ;)
 
 # Disable unit-at-a-time mode, it makes gcc use a lot more stack
 # due to the lack of sharing of stacklots.
@@ -100,7 +103,7 @@ AFLAGS += $(mflags-y)
 boot := arch/i386/boot
 
 .PHONY: zImage bzImage compressed zlilo bzlilo \
-       zdisk bzdisk fdimage fdimage144 fdimage288 install kernel_install
+       zdisk bzdisk fdimage fdimage144 fdimage288 install
 
 all: bzImage
 
@@ -122,8 +125,7 @@ zdisk bzdisk: vmlinux
 fdimage fdimage144 fdimage288: vmlinux
        $(Q)$(MAKE) $(build)=$(boot) BOOTIMAGE=$(KBUILD_IMAGE) $@
 
-install: vmlinux
-install kernel_install:
+install:
        $(Q)$(MAKE) $(build)=$(boot) BOOTIMAGE=$(KBUILD_IMAGE) install
 
 archclean:
index 1e71382d413a99b40f3a1e759ee0254acff94539..0fea75dd4e318569f0dad27c126c50cc94636261 100644 (file)
@@ -100,5 +100,5 @@ zlilo: $(BOOTIMAGE)
        cp System.map $(INSTALL_PATH)/
        if [ -x /sbin/lilo ]; then /sbin/lilo; else /etc/lilo/install; fi
 
-install: $(BOOTIMAGE)
+install:
        sh $(srctree)/$(src)/install.sh $(KERNELRELEASE) $< System.map "$(INSTALL_PATH)"
index f17b40dfc0f4bde512541ded9c67a88570eb3460..5e44c736eea81700dc7559c97462b21514e25850 100644 (file)
 #   $4 - default install path (blank if root directory)
 #
 
+verify () {
+       if [ ! -f "$1" ]; then
+               echo ""                                                   1>&2
+               echo " *** Missing file: $1"                              1>&2
+               echo ' *** You need to run "make" before "make install".' 1>&2
+               echo ""                                                   1>&2
+               exit 1
+       fi
+}
+
+# Make sure the files actually exist
+verify "$2"
+verify "$3"
+
 # User may have a custom install script
 
 if [ -x ~/bin/${CROSS_COMPILE}installkernel ]; then exec ~/bin/${CROSS_COMPILE}installkernel "$@"; fi
index 92f6694701420a1ef102f9155d2c1e1c349c91f5..2ac40c8244c47145fb1d7feae7c42b9fe03bf1d8 100644 (file)
@@ -97,7 +97,6 @@
 #define PARAM_VESAPM_OFF       0x30
 #define PARAM_LFB_PAGES                0x32
 #define PARAM_VESA_ATTRIB      0x34
-#define PARAM_CAPABILITIES      0x36
 
 /* Define DO_STORE according to CONFIG_VIDEO_RETAIN */
 #ifdef CONFIG_VIDEO_RETAIN
@@ -234,10 +233,6 @@ mopar_gr:
        movw    18(%di), %ax
        movl    %eax, %fs:(PARAM_LFB_SIZE)
 
-# store mode capabilities
-       movl    10(%di), %eax
-       movl    %eax, %fs:(PARAM_CAPABILITIES)
-
 # switching the DAC to 8-bit is for <= 8 bpp only
        movw    %fs:(PARAM_LFB_DEPTH), %ax
        cmpw    $8, %ax
index be1880bb75b48ddace3a08ceb642b803b37413a0..60c3f76dfca42efa00e71f9ae34a85d837511e27 100644 (file)
@@ -25,6 +25,7 @@ obj-$(CONFIG_X86_LOCAL_APIC)  += apic.o nmi.o
 obj-$(CONFIG_X86_IO_APIC)      += io_apic.o
 obj-$(CONFIG_X86_REBOOTFIXUPS) += reboot_fixups.o
 obj-$(CONFIG_KEXEC)            += machine_kexec.o relocate_kernel.o crash.o
+obj-$(CONFIG_CRASH_DUMP)       += crash_dump.o
 obj-$(CONFIG_X86_NUMAQ)                += numaq.o
 obj-$(CONFIG_X86_SUMMIT_NUMA)  += summit.o
 obj-$(CONFIG_KPROBES)          += kprobes.o
index 0248e084017ceddd74bcc7e92052cef801b897ff..d49dbe8dc96b345efa52c579e96782db3ecc3b3b 100644 (file)
@@ -25,7 +25,6 @@
 #include <mach_ipi.h>
 
 
-note_buf_t crash_notes[NR_CPUS];
 /* This keeps a track of which one is crashing cpu. */
 static int crashing_cpu;
 
@@ -72,7 +71,9 @@ static void crash_save_this_cpu(struct pt_regs *regs, int cpu)
         * squirrelled away.  ELF notes happen to provide
         * all of that that no need to invent something new.
         */
-       buf = &crash_notes[cpu][0];
+       buf = (u32*)per_cpu_ptr(crash_notes, cpu);
+       if (!buf)
+               return;
        memset(&prstatus, 0, sizeof(prstatus));
        prstatus.pr_pid = current->pid;
        elf_core_copy_regs(&prstatus.pr_reg, regs);
@@ -81,51 +82,12 @@ static void crash_save_this_cpu(struct pt_regs *regs, int cpu)
        final_note(buf);
 }
 
-static void crash_get_current_regs(struct pt_regs *regs)
-{
-       __asm__ __volatile__("movl %%ebx,%0" : "=m"(regs->ebx));
-       __asm__ __volatile__("movl %%ecx,%0" : "=m"(regs->ecx));
-       __asm__ __volatile__("movl %%edx,%0" : "=m"(regs->edx));
-       __asm__ __volatile__("movl %%esi,%0" : "=m"(regs->esi));
-       __asm__ __volatile__("movl %%edi,%0" : "=m"(regs->edi));
-       __asm__ __volatile__("movl %%ebp,%0" : "=m"(regs->ebp));
-       __asm__ __volatile__("movl %%eax,%0" : "=m"(regs->eax));
-       __asm__ __volatile__("movl %%esp,%0" : "=m"(regs->esp));
-       __asm__ __volatile__("movw %%ss, %%ax;" :"=a"(regs->xss));
-       __asm__ __volatile__("movw %%cs, %%ax;" :"=a"(regs->xcs));
-       __asm__ __volatile__("movw %%ds, %%ax;" :"=a"(regs->xds));
-       __asm__ __volatile__("movw %%es, %%ax;" :"=a"(regs->xes));
-       __asm__ __volatile__("pushfl; popl %0" :"=m"(regs->eflags));
-
-       regs->eip = (unsigned long)current_text_addr();
-}
-
-/* CPU does not save ss and esp on stack if execution is already
- * running in kernel mode at the time of NMI occurrence. This code
- * fixes it.
- */
-static void crash_setup_regs(struct pt_regs *newregs, struct pt_regs *oldregs)
-{
-       memcpy(newregs, oldregs, sizeof(*newregs));
-       newregs->esp = (unsigned long)&(oldregs->esp);
-       __asm__ __volatile__("xorl %eax, %eax;");
-       __asm__ __volatile__ ("movw %%ss, %%ax;" :"=a"(newregs->xss));
-}
-
-/* We may have saved_regs from where the error came from
- * or it is NULL if via a direct panic().
- */
-static void crash_save_self(struct pt_regs *saved_regs)
+static void crash_save_self(struct pt_regs *regs)
 {
-       struct pt_regs regs;
        int cpu;
 
        cpu = smp_processor_id();
-       if (saved_regs)
-               crash_setup_regs(&regs, saved_regs);
-       else
-               crash_get_current_regs(&regs);
-       crash_save_this_cpu(&regs, cpu);
+       crash_save_this_cpu(regs, cpu);
 }
 
 #ifdef CONFIG_SMP
@@ -144,7 +106,7 @@ static int crash_nmi_callback(struct pt_regs *regs, int cpu)
        local_irq_disable();
 
        if (!user_mode(regs)) {
-               crash_setup_regs(&fixed_regs, regs);
+               crash_fixup_ss_esp(&fixed_regs, regs);
                regs = &fixed_regs;
        }
        crash_save_this_cpu(regs, cpu);
diff --git a/arch/i386/kernel/crash_dump.c b/arch/i386/kernel/crash_dump.c
new file mode 100644 (file)
index 0000000..3f532df
--- /dev/null
@@ -0,0 +1,74 @@
+/*
+ *     kernel/crash_dump.c - Memory preserving reboot related code.
+ *
+ *     Created by: Hariprasad Nellitheertha (hari@in.ibm.com)
+ *     Copyright (C) IBM Corporation, 2004. All rights reserved
+ */
+
+#include <linux/errno.h>
+#include <linux/highmem.h>
+#include <linux/crash_dump.h>
+
+#include <asm/uaccess.h>
+
+static void *kdump_buf_page;
+
+/**
+ * copy_oldmem_page - copy one page from "oldmem"
+ * @pfn: page frame number to be copied
+ * @buf: target memory address for the copy; this can be in kernel address
+ *     space or user address space (see @userbuf)
+ * @csize: number of bytes to copy
+ * @offset: offset in bytes into the page (based on pfn) to begin the copy
+ * @userbuf: if set, @buf is in user address space, use copy_to_user(),
+ *     otherwise @buf is in kernel address space, use memcpy().
+ *
+ * Copy a page from "oldmem". For this page, there is no pte mapped
+ * in the current kernel. We stitch up a pte, similar to kmap_atomic.
+ *
+ * Calling copy_to_user() in atomic context is not desirable. Hence first
+ * copying the data to a pre-allocated kernel page and then copying to user
+ * space in non-atomic context.
+ */
+ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
+                               size_t csize, unsigned long offset, int userbuf)
+{
+       void  *vaddr;
+
+       if (!csize)
+               return 0;
+
+       vaddr = kmap_atomic_pfn(pfn, KM_PTE0);
+
+       if (!userbuf) {
+               memcpy(buf, (vaddr + offset), csize);
+               kunmap_atomic(vaddr, KM_PTE0);
+       } else {
+               if (!kdump_buf_page) {
+                       printk(KERN_WARNING "Kdump: Kdump buffer page not"
+                               " allocated\n");
+                       return -EFAULT;
+               }
+               copy_page(kdump_buf_page, vaddr);
+               kunmap_atomic(vaddr, KM_PTE0);
+               if (copy_to_user(buf, (kdump_buf_page + offset), csize))
+                       return -EFAULT;
+       }
+
+       return csize;
+}
+
+static int __init kdump_buf_page_init(void)
+{
+       int ret = 0;
+
+       kdump_buf_page = kmalloc(PAGE_SIZE, GFP_KERNEL);
+       if (!kdump_buf_page) {
+               printk(KERN_WARNING "Kdump: Failed to allocate kdump buffer"
+                        " page\n");
+               ret = -ENOMEM;
+       }
+
+       return ret;
+}
+arch_initcall(kdump_buf_page_init);
index 19edcd526ba4800f9c71c66ef7ad18da5eb1b7bc..2f372dbd34fd54a80c77b6a6380fc5794b3ba781 100644 (file)
@@ -57,14 +57,10 @@ static inline int is_IF_modifier(kprobe_opcode_t opcode)
 }
 
 int __kprobes arch_prepare_kprobe(struct kprobe *p)
-{
-       return 0;
-}
-
-void __kprobes arch_copy_kprobe(struct kprobe *p)
 {
        memcpy(p->ainsn.insn, p->addr, MAX_INSN_SIZE * sizeof(kprobe_opcode_t));
        p->opcode = *p->addr;
+       return 0;
 }
 
 void __kprobes arch_arm_kprobe(struct kprobe *p)
@@ -81,10 +77,6 @@ void __kprobes arch_disarm_kprobe(struct kprobe *p)
                           (unsigned long) p->addr + sizeof(kprobe_opcode_t));
 }
 
-void __kprobes arch_remove_kprobe(struct kprobe *p)
-{
-}
-
 static inline void save_previous_kprobe(struct kprobe_ctlblk *kcb)
 {
        kcb->prev_kprobe.kp = kprobe_running();
index 27c956db0461508f1d0e64d108d47990e3709d9d..f685637a100d7ab266f013ed7973197be297d6bc 100644 (file)
@@ -898,7 +898,7 @@ static void __init parse_cmdline_early (char ** cmdline_p)
                        }
                }
 #endif
-#ifdef CONFIG_CRASH_DUMP
+#ifdef CONFIG_PROC_VMCORE
                /* elfcorehdr= specifies the location of elf core header
                 * stored by the crashed kernel.
                 */
index 53ad954e3ba489a5929871812f3a7bb3f7f1c5bf..b9f0030a2ebbc38494bfaee9ae47656672ac0336 100644 (file)
@@ -120,7 +120,7 @@ static inline unsigned long print_context_stack(struct thread_info *tinfo,
 #ifdef CONFIG_FRAME_POINTER
        while (valid_stack_ptr(tinfo, (void *)ebp)) {
                addr = *(unsigned long *)(ebp + 4);
-               printk(" [<%08lx>] ", addr);
+               printk(KERN_EMERG " [<%08lx>] ", addr);
                print_symbol("%s", addr);
                printk("\n");
                ebp = *(unsigned long *)ebp;
@@ -129,7 +129,7 @@ static inline unsigned long print_context_stack(struct thread_info *tinfo,
        while (valid_stack_ptr(tinfo, stack)) {
                addr = *stack++;
                if (__kernel_text_address(addr)) {
-                       printk(" [<%08lx>]", addr);
+                       printk(KERN_EMERG " [<%08lx>]", addr);
                        print_symbol(" %s", addr);
                        printk("\n");
                }
@@ -161,7 +161,7 @@ void show_trace(struct task_struct *task, unsigned long * stack)
                stack = (unsigned long*)context->previous_esp;
                if (!stack)
                        break;
-               printk(" =======================\n");
+               printk(KERN_EMERG " =======================\n");
        }
 }
 
@@ -178,14 +178,15 @@ void show_stack(struct task_struct *task, unsigned long *esp)
        }
 
        stack = esp;
+       printk(KERN_EMERG);
        for(i = 0; i < kstack_depth_to_print; i++) {
                if (kstack_end(stack))
                        break;
                if (i && ((i % 8) == 0))
-                       printk("\n       ");
+                       printk("\n" KERN_EMERG "       ");
                printk("%08lx ", *stack++);
        }
-       printk("\nCall Trace:\n");
+       printk("\n" KERN_EMERG "Call Trace:\n");
        show_trace(task, esp);
 }
 
@@ -216,18 +217,18 @@ void show_registers(struct pt_regs *regs)
                ss = regs->xss & 0xffff;
        }
        print_modules();
-       printk("CPU:    %d\nEIP:    %04x:[<%08lx>]    %s VLI\nEFLAGS: %08lx"
-                       "   (%s) \n",
+       printk(KERN_EMERG "CPU:    %d\nEIP:    %04x:[<%08lx>]    %s VLI\n"
+                       "EFLAGS: %08lx   (%s) \n",
                smp_processor_id(), 0xffff & regs->xcs, regs->eip,
                print_tainted(), regs->eflags, system_utsname.release);
-       print_symbol("EIP is at %s\n", regs->eip);
-       printk("eax: %08lx   ebx: %08lx   ecx: %08lx   edx: %08lx\n",
+       print_symbol(KERN_EMERG "EIP is at %s\n", regs->eip);
+       printk(KERN_EMERG "eax: %08lx   ebx: %08lx   ecx: %08lx   edx: %08lx\n",
                regs->eax, regs->ebx, regs->ecx, regs->edx);
-       printk("esi: %08lx   edi: %08lx   ebp: %08lx   esp: %08lx\n",
+       printk(KERN_EMERG "esi: %08lx   edi: %08lx   ebp: %08lx   esp: %08lx\n",
                regs->esi, regs->edi, regs->ebp, esp);
-       printk("ds: %04x   es: %04x   ss: %04x\n",
+       printk(KERN_EMERG "ds: %04x   es: %04x   ss: %04x\n",
                regs->xds & 0xffff, regs->xes & 0xffff, ss);
-       printk("Process %s (pid: %d, threadinfo=%p task=%p)",
+       printk(KERN_EMERG "Process %s (pid: %d, threadinfo=%p task=%p)",
                current->comm, current->pid, current_thread_info(), current);
        /*
         * When in-kernel, we also print out the stack and code at the
@@ -236,10 +237,10 @@ void show_registers(struct pt_regs *regs)
        if (in_kernel) {
                u8 __user *eip;
 
-               printk("\nStack: ");
+               printk("\n" KERN_EMERG "Stack: ");
                show_stack(NULL, (unsigned long*)esp);
 
-               printk("Code: ");
+               printk(KERN_EMERG "Code: ");
 
                eip = (u8 __user *)regs->eip - 43;
                for (i = 0; i < 64; i++, eip++) {
@@ -280,15 +281,15 @@ static void handle_BUG(struct pt_regs *regs)
                (unsigned long)file < PAGE_OFFSET || __get_user(c, file))
                file = "<bad filename>";
 
-       printk("------------[ cut here ]------------\n");
-       printk(KERN_ALERT "kernel BUG at %s:%d!\n", file, line);
+       printk(KERN_EMERG "------------[ cut here ]------------\n");
+       printk(KERN_EMERG "kernel BUG at %s:%d!\n", file, line);
 
 no_bug:
        return;
 
        /* Here we know it was a BUG but file-n-line is unavailable */
 bug:
-       printk("Kernel BUG\n");
+       printk(KERN_EMERG "Kernel BUG\n");
 }
 
 /* This is gone through when something in the kernel
@@ -321,16 +322,20 @@ void die(const char * str, struct pt_regs * regs, long err)
        if (++die.lock_owner_depth < 3) {
                int nl = 0;
                handle_BUG(regs);
-               printk(KERN_ALERT "%s: %04lx [#%d]\n", str, err & 0xffff, ++die_counter);
+               printk(KERN_EMERG "%s: %04lx [#%d]\n", str, err & 0xffff, ++die_counter);
 #ifdef CONFIG_PREEMPT
-               printk("PREEMPT ");
+               printk(KERN_EMERG "PREEMPT ");
                nl = 1;
 #endif
 #ifdef CONFIG_SMP
+               if (!nl)
+                       printk(KERN_EMERG);
                printk("SMP ");
                nl = 1;
 #endif
 #ifdef CONFIG_DEBUG_PAGEALLOC
+               if (!nl)
+                       printk(KERN_EMERG);
                printk("DEBUG_PAGEALLOC");
                nl = 1;
 #endif
@@ -339,7 +344,7 @@ void die(const char * str, struct pt_regs * regs, long err)
        notify_die(DIE_OOPS, (char *)str, regs, err, 255, SIGSEGV);
                show_registers(regs);
        } else
-               printk(KERN_ERR "Recursive die() failure, output suppressed\n");
+               printk(KERN_EMERG "Recursive die() failure, output suppressed\n");
 
        bust_spinlocks(0);
        die.lock_owner = -1;
@@ -527,8 +532,10 @@ gp_in_kernel:
 
 static void mem_parity_error(unsigned char reason, struct pt_regs * regs)
 {
-       printk("Uhhuh. NMI received. Dazed and confused, but trying to continue\n");
-       printk("You probably have a hardware problem with your RAM chips\n");
+       printk(KERN_EMERG "Uhhuh. NMI received. Dazed and confused, but trying "
+                       "to continue\n");
+       printk(KERN_EMERG "You probably have a hardware problem with your RAM "
+                       "chips\n");
 
        /* Clear and disable the memory parity error line. */
        clear_mem_error(reason);
@@ -538,7 +545,7 @@ static void io_check_error(unsigned char reason, struct pt_regs * regs)
 {
        unsigned long i;
 
-       printk("NMI: IOCK error (debug interrupt?)\n");
+       printk(KERN_EMERG "NMI: IOCK error (debug interrupt?)\n");
        show_registers(regs);
 
        /* Re-enable the IOCK line, wait for a few seconds */
@@ -580,11 +587,11 @@ void die_nmi (struct pt_regs *regs, const char *msg)
        * to get a message out.
        */
        bust_spinlocks(1);
-       printk(msg);
+       printk(KERN_EMERG "%s", msg);
        printk(" on CPU%d, eip %08lx, registers:\n",
                smp_processor_id(), regs->eip);
        show_registers(regs);
-       printk("console shuts up ...\n");
+       printk(KERN_EMERG "console shuts up ...\n");
        console_silent();
        spin_unlock(&nmi_print_lock);
        bust_spinlocks(0);
@@ -990,8 +997,8 @@ asmlinkage void math_state_restore(struct pt_regs regs)
 
 asmlinkage void math_emulate(long arg)
 {
-       printk("math-emulation not enabled and no coprocessor found.\n");
-       printk("killing %s.\n",current->comm);
+       printk(KERN_EMERG "math-emulation not enabled and no coprocessor found.\n");
+       printk(KERN_EMERG "killing %s.\n",current->comm);
        force_sig(SIGFPE,current);
        schedule();
 }
index 57b047c27e4641e092dd485b7c09e6fba1d28fc5..f722e1a25948018826db23c9b482707c20ba8393 100644 (file)
@@ -25,7 +25,6 @@ cflags-y      := -pipe $(EXTRA) -ffixed-r13 -mfixed-range=f12-f15,f32-f127 \
                   -falign-functions=32 -frename-registers -fno-optimize-sibling-calls
 CFLAGS_KERNEL  := -mconstant-gp
 
-GCC_VERSION     := $(call cc-version)
 GAS_STATUS     = $(shell $(srctree)/arch/ia64/scripts/check-gas "$(CC)" "$(OBJDUMP)")
 CPPFLAGS += $(shell $(srctree)/arch/ia64/scripts/toolchain-flags "$(CC)" "$(OBJDUMP)" "$(READELF)")
 
@@ -37,7 +36,7 @@ $(error Sorry, you need a newer version of the assember, one that is built from
                ftp://ftp.hpl.hp.com/pub/linux-ia64/gas-030124.tar.gz)
 endif
 
-ifeq ($(GCC_VERSION),0304)
+ifeq ($(call cc-version),0304)
        cflags-$(CONFIG_ITANIUM)        += -mtune=merced
        cflags-$(CONFIG_MCKINLEY)       += -mtune=mckinley
 endif
index 2ed90da81166ff6b9ce0126a94f41eee120f29a8..61cb60affd95aec8c828a92a7540bffa6bc7bfba 100644 (file)
@@ -2,11 +2,9 @@
 # Makefile for the ia32 kernel emulation subsystem.
 #
 
-obj-y := ia32_entry.o sys_ia32.o ia32_ioctl.o ia32_signal.o \
+obj-y := ia32_entry.o sys_ia32.o ia32_signal.o \
         ia32_support.o ia32_traps.o binfmt_elf32.o ia32_ldt.o
 
-CFLAGS_ia32_ioctl.o += -Ifs/
-
 # Don't let GCC uses f16-f31 so that save_ia32_fpstate_live() and
 # restore_ia32_fpstate_live() can be sure the live register contain user-level state.
 CFLAGS_ia32_signal.o += -mfixed-range=f16-f31
index 494fad6bf376dfdc845b2c25f3dcdfb40a02ac93..95fe04400f6b65f7cfe10eb5a6c0fac95cf9e51f 100644 (file)
@@ -469,7 +469,7 @@ ia32_syscall_table:
        data8 sys32_epoll_wait
        data8 sys_remap_file_pages
        data8 sys_set_tid_address
-       data8 sys32_timer_create
+       data8 compat_sys_timer_create
        data8 compat_sys_timer_settime  /* 260 */
        data8 compat_sys_timer_gettime
        data8 sys_timer_getoverrun
diff --git a/arch/ia64/ia32/ia32_ioctl.c b/arch/ia64/ia32/ia32_ioctl.c
deleted file mode 100644 (file)
index 8873939..0000000
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * IA32 Architecture-specific ioctl shim code
- *
- * Copyright (C) 2000 VA Linux Co
- * Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
- * Copyright (C) 2001-2003 Hewlett-Packard Co
- *     David Mosberger-Tang <davidm@hpl.hp.com>
- */
-
-#include <linux/signal.h>      /* argh, msdos_fs.h isn't self-contained... */
-#include <linux/syscalls.h>
-#include "ia32priv.h"
-  
-#define        INCLUDES
-#include "compat_ioctl.c"
-
-#define IOCTL_NR(a)    ((a) & ~(_IOC_SIZEMASK << _IOC_SIZESHIFT))
-
-#define DO_IOCTL(fd, cmd, arg) ({                      \
-       int _ret;                                       \
-       mm_segment_t _old_fs = get_fs();                \
-                                                       \
-       set_fs(KERNEL_DS);                              \
-       _ret = sys_ioctl(fd, cmd, (unsigned long)arg);  \
-       set_fs(_old_fs);                                \
-       _ret;                                           \
-})
-
-#define CODE
-#include "compat_ioctl.c"
-
-#define COMPATIBLE_IOCTL(cmd)          HANDLE_IOCTL((cmd),sys_ioctl)
-#define HANDLE_IOCTL(cmd,handler)      { (cmd), (ioctl_trans_handler_t)(handler), NULL },
-#define IOCTL_TABLE_START \
-       struct ioctl_trans ioctl_start[] = {
-#define IOCTL_TABLE_END \
-       };
-
-IOCTL_TABLE_START
-#define DECLARES
-#include "compat_ioctl.c"
-#include <linux/compat_ioctl.h>
-IOCTL_TABLE_END
-
-int ioctl_table_size = ARRAY_SIZE(ioctl_start);
index 9f8e8d5588731066475d8dc235a3f8bc7d608e34..5ea38286d8d5856dc5005a4f159295c834322f9c 100644 (file)
@@ -2553,34 +2553,6 @@ sys32_get_thread_area (struct ia32_user_desc __user *u_info)
        return 0;
 }
 
-asmlinkage long
-sys32_timer_create(u32 clock, struct compat_sigevent __user *se32, timer_t __user *timer_id)
-{
-       struct sigevent se;
-       mm_segment_t oldfs;
-       timer_t t;
-       long err;
-
-       if (se32 == NULL)
-               return sys_timer_create(clock, NULL, timer_id);
-
-       if (get_compat_sigevent(&se, se32))
-               return -EFAULT;
-
-       if (!access_ok(VERIFY_WRITE,timer_id,sizeof(timer_t)))
-               return -EFAULT;
-
-       oldfs = get_fs();
-       set_fs(KERNEL_DS);
-       err = sys_timer_create(clock, (struct sigevent __user *) &se, (timer_t __user *) &t);
-       set_fs(oldfs);
-
-       if (!err)
-               err = __put_user (t, timer_id);
-
-       return err;
-}
-
 long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high, 
                        __u32 len_low, __u32 len_high, int advice)
 { 
index 89a70400c4f638efa3ed6face511777cf90bb5b4..4de7f6759093720595fe958f0b757d5adb884cd5 100644 (file)
@@ -467,10 +467,6 @@ void __kprobes arch_disarm_kprobe(struct kprobe *p)
        flush_icache_range(arm_addr, arm_addr + sizeof(bundle_t));
 }
 
-void __kprobes arch_remove_kprobe(struct kprobe *p)
-{
-}
-
 /*
  * We are resuming execution after a single step fault, so the pt_regs
  * structure reflects the register state after we executed the instruction
index fae67bbb52f614fa27566636ad7952db512a81cb..a3dcc3fab4b736660ab3b621d3321c730949f501 100644 (file)
@@ -12,10 +12,6 @@ config M32R
 config SBUS
        bool
 
-config UID16
-       bool
-       default n
-
 config GENERIC_ISA_DMA
        bool
        default y
index e5ec134d81d98baa12ca8c3e6741e75d9e794a95..dbc8a392105fba65faa118e5c4670b8a806c6b1a 100644 (file)
@@ -18,8 +18,6 @@
 #include <asm/irq.h>
 #include <asm/tlbflush.h>
 
-extern void dump_thread(struct pt_regs *, struct user *);
-
 #if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_HD) || defined(CONFIG_BLK_DEV_IDE_MODULE) || defined(CONFIG_BLK_DEV_HD_MODULE)
 extern struct drive_info_struct drive_info;
 EXPORT_SYMBOL(drive_info);
@@ -27,7 +25,6 @@ EXPORT_SYMBOL(drive_info);
 
 /* platform dependent support */
 EXPORT_SYMBOL(boot_cpu_data);
-EXPORT_SYMBOL(dump_thread);
 EXPORT_SYMBOL(dump_fpu);
 EXPORT_SYMBOL(__ioremap);
 EXPORT_SYMBOL(iounmap);
index 3bf55d92933f62f635c1c1be3290f5fa13cc4348..2a1f250349b7027f057a2386c5ed555f0fafa171 100644 (file)
@@ -260,14 +260,6 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long spu,
        return 0;
 }
 
-/*
- * fill in the user structure for a core dump..
- */
-void dump_thread(struct pt_regs * regs, struct user * dump)
-{
-       /* M32R_FIXME */
-}
-
 /*
  * Capture the user space registers if the task is not running (in user space)
  */
index 73e2f5e168ddd17706a22333303e3e6c486e872b..3d7f2000b7146dcff56f1927ff58f3d5cdf71097 100644 (file)
@@ -23,8 +23,6 @@ asmlinkage long long __lshrdi3 (long long, int);
 asmlinkage long long __muldi3 (long long, long long);
 extern char m68k_debug_device[];
 
-extern void dump_thread(struct pt_regs *, struct user *);
-
 /* platform dependent support */
 
 EXPORT_SYMBOL(m68k_machtype);
index b2c62eeb3bab6624807c0ee1f05e4041eb371cfa..eddb8d3e130ab116e7957349e2a17beb0566646b 100644 (file)
@@ -18,7 +18,6 @@
 #include <asm/checksum.h>
 #include <asm/current.h>
 
-extern void dump_thread(struct pt_regs *, struct user *);
 extern int dump_fpu(struct pt_regs *, elf_fpregset_t *);
 
 /* platform dependent support */
@@ -26,7 +25,6 @@ extern int dump_fpu(struct pt_regs *, elf_fpregset_t *);
 EXPORT_SYMBOL(__ioremap);
 EXPORT_SYMBOL(iounmap);
 EXPORT_SYMBOL(dump_fpu);
-EXPORT_SYMBOL(dump_thread);
 EXPORT_SYMBOL(strnlen);
 EXPORT_SYMBOL(strrchr);
 EXPORT_SYMBOL(strstr);
index 82e7ec8888064589dcf642e336f11d32e209dd0b..8b3cf57ba706f04043a3da3f11e590ea5d7052a0 100644 (file)
@@ -275,52 +275,6 @@ int dump_fpu(struct pt_regs *regs, struct user_m68kfp_struct *fpu)
        return 1;
 }
 
-/*
- * fill in the user structure for a core dump..
- */
-void dump_thread(struct pt_regs * regs, struct user * dump)
-{
-       struct switch_stack *sw;
-
-       /* changed the size calculations - should hopefully work better. lbt */
-       dump->magic = CMAGIC;
-       dump->start_code = 0;
-       dump->start_stack = rdusp() & ~(PAGE_SIZE - 1);
-       dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
-       dump->u_dsize = ((unsigned long) (current->mm->brk +
-                                         (PAGE_SIZE-1))) >> PAGE_SHIFT;
-       dump->u_dsize -= dump->u_tsize;
-       dump->u_ssize = 0;
-
-       if (dump->start_stack < TASK_SIZE)
-               dump->u_ssize = ((unsigned long) (TASK_SIZE - dump->start_stack)) >> PAGE_SHIFT;
-
-       dump->u_ar0 = (struct user_regs_struct *)((int)&dump->regs - (int)dump);
-       sw = ((struct switch_stack *)regs) - 1;
-       dump->regs.d1 = regs->d1;
-       dump->regs.d2 = regs->d2;
-       dump->regs.d3 = regs->d3;
-       dump->regs.d4 = regs->d4;
-       dump->regs.d5 = regs->d5;
-       dump->regs.d6 = sw->d6;
-       dump->regs.d7 = sw->d7;
-       dump->regs.a0 = regs->a0;
-       dump->regs.a1 = regs->a1;
-       dump->regs.a2 = regs->a2;
-       dump->regs.a3 = sw->a3;
-       dump->regs.a4 = sw->a4;
-       dump->regs.a5 = sw->a5;
-       dump->regs.a6 = sw->a6;
-       dump->regs.d0 = regs->d0;
-       dump->regs.orig_d0 = regs->orig_d0;
-       dump->regs.stkadj = regs->stkadj;
-       dump->regs.sr = regs->sr;
-       dump->regs.pc = regs->pc;
-       dump->regs.fmtvec = (regs->format << 12) | regs->vector;
-       /* dump floating point stuff */
-       dump->u_fpvalid = dump_fpu (regs, &dump->m68kfp);
-}
-
 /*
  *     Generic dumping code. Used for panic and debug.
  */
index 72f2126ad19d95fb3cc724ad6d4728971e2eb9ef..f36c4f20ee8af09bbeca3658cf96ba15a410d8b2 100644 (file)
@@ -50,7 +50,7 @@ obj-$(CONFIG_MIPS_BOARDS_GEN) += irq-msc01.o
 obj-$(CONFIG_32BIT)            += scall32-o32.o
 obj-$(CONFIG_64BIT)            += scall64-64.o
 obj-$(CONFIG_BINFMT_IRIX)      += binfmt_irix.o
-obj-$(CONFIG_MIPS32_COMPAT)    += ioctl32.o linux32.o signal32.o
+obj-$(CONFIG_MIPS32_COMPAT)    += linux32.o signal32.o
 obj-$(CONFIG_MIPS32_N32)       += binfmt_elfn32.o scall64-n32.o signal_n32.o
 obj-$(CONFIG_MIPS32_O32)       += binfmt_elfo32.o scall64-o32.o ptrace32.o
 
@@ -60,6 +60,5 @@ obj-$(CONFIG_PROC_FS)         += proc.o
 obj-$(CONFIG_64BIT)            += cpu-bugs64.o
 
 CFLAGS_cpu-bugs64.o    = $(shell if $(CC) $(CFLAGS) -Wa,-mdaddi -c -o /dev/null -xc /dev/null >/dev/null 2>&1; then echo "-DHAVE_AS_SET_DADDI"; fi)
-CFLAGS_ioctl32.o       += -Ifs/
 
 EXTRA_AFLAGS := $(CFLAGS)
diff --git a/arch/mips/kernel/ioctl32.c b/arch/mips/kernel/ioctl32.c
deleted file mode 100644 (file)
index 9ea1fc7..0000000
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
- *
- * Copyright (C) 2000 Silicon Graphics, Inc.
- * Written by Ulf Carlsson (ulfc@engr.sgi.com)
- * Copyright (C) 2000, 2004 Ralf Baechle
- * Copyright (C) 2002, 2003  Maciej W. Rozycki
- */
-#define INCLUDES
-#include "compat_ioctl.c"
-
-#include <linux/config.h>
-#include <linux/types.h>
-#include <linux/compat.h>
-#include <linux/ioctl32.h>
-#include <linux/syscalls.h>
-
-#ifdef CONFIG_SIBYTE_TBPROF
-#include <asm/sibyte/trace_prof.h>
-#endif
-
-#define A(__x) ((unsigned long)(__x))
-
-long sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg);
-
-#define CODE
-#include "compat_ioctl.c"
-
-#define COMPATIBLE_IOCTL(cmd)          HANDLE_IOCTL((cmd),sys_ioctl)
-#define HANDLE_IOCTL(cmd,handler)      { (cmd), (ioctl_trans_handler_t)(handler), NULL },
-#define IOCTL_TABLE_START \
-       struct ioctl_trans ioctl_start[] = {
-#define IOCTL_TABLE_END \
-       };
-
-IOCTL_TABLE_START
-
-#include <linux/compat_ioctl.h>
-#define DECLARES
-#include "compat_ioctl.c"
-
-/*HANDLE_IOCTL(RTC_IRQP_READ, w_long)
-COMPATIBLE_IOCTL(RTC_IRQP_SET)
-HANDLE_IOCTL(RTC_EPOCH_READ, w_long)
-COMPATIBLE_IOCTL(RTC_EPOCH_SET)
-*/
-
-IOCTL_TABLE_END
-
-int ioctl_table_size = ARRAY_SIZE(ioctl_start);
index 171f9c239f60c8c80e7cfa856c0591268f5bf891..27827bc3717e8fcf4b1e8ae0d6cf5b6771debf60 100644 (file)
@@ -6,7 +6,6 @@ extra-y                 := init_task.o head.o vmlinux.lds
 
 AFLAGS_entry.o := -traditional
 AFLAGS_pacache.o := -traditional
-CFLAGS_ioctl32.o := -Ifs/
 
 obj-y          := cache.o pacache.o setup.o traps.o time.o irq.o \
                   pa7300lc.o syscall.o entry.o sys_parisc.o firmware.o \
@@ -19,6 +18,6 @@ obj-$(CONFIG_SMP)     += smp.o
 obj-$(CONFIG_PA11)     += pci-dma.o
 obj-$(CONFIG_PCI)      += pci.o
 obj-$(CONFIG_MODULES)  += module.o
-obj-$(CONFIG_64BIT)    += binfmt_elf32.o sys_parisc32.o ioctl32.o signal32.o
+obj-$(CONFIG_64BIT)    += binfmt_elf32.o sys_parisc32.o signal32.o
 # only supported for PCX-W/U in 64-bit mode at the moment
 obj-$(CONFIG_64BIT)    += perf.o perf_asm.o
diff --git a/arch/parisc/kernel/ioctl32.c b/arch/parisc/kernel/ioctl32.c
deleted file mode 100644 (file)
index 4eada1b..0000000
+++ /dev/null
@@ -1,60 +0,0 @@
-/* $Id: ioctl32.c,v 1.5 2002/10/18 00:21:43 varenet Exp $
- * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
- *
- * Copyright (C) 1997-2000  Jakub Jelinek  (jakub@redhat.com)
- * Copyright (C) 1998  Eddie C. Dost  (ecd@skynet.be)
- *
- * These routines maintain argument size conversion between 32bit and 64bit
- * ioctls.
- */
-
-#include <linux/syscalls.h>
-
-#define INCLUDES
-#include "compat_ioctl.c"
-
-#include <asm/perf.h>
-#include <asm/ioctls.h>
-
-#define CODE
-#include "compat_ioctl.c"
-
-#define HANDLE_IOCTL(cmd, handler) { cmd, (ioctl_trans_handler_t)handler, NULL },
-#define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL(cmd, sys_ioctl) 
-
-#define IOCTL_TABLE_START  struct ioctl_trans ioctl_start[] = {
-#define IOCTL_TABLE_END    };
-
-IOCTL_TABLE_START
-#include <linux/compat_ioctl.h>
-
-#define DECLARES
-#include "compat_ioctl.c"
-
-/* And these ioctls need translation */
-HANDLE_IOCTL(SIOCGPPPSTATS, dev_ifsioc)
-HANDLE_IOCTL(SIOCGPPPCSTATS, dev_ifsioc)
-HANDLE_IOCTL(SIOCGPPPVER, dev_ifsioc)
-
-#if defined(CONFIG_GEN_RTC)
-COMPATIBLE_IOCTL(RTC_AIE_ON)
-COMPATIBLE_IOCTL(RTC_AIE_OFF)
-COMPATIBLE_IOCTL(RTC_UIE_ON)
-COMPATIBLE_IOCTL(RTC_UIE_OFF)
-COMPATIBLE_IOCTL(RTC_PIE_ON)
-COMPATIBLE_IOCTL(RTC_PIE_OFF)
-COMPATIBLE_IOCTL(RTC_WIE_ON)
-COMPATIBLE_IOCTL(RTC_WIE_OFF)
-COMPATIBLE_IOCTL(RTC_ALM_SET)   /* struct rtc_time only has ints */
-COMPATIBLE_IOCTL(RTC_ALM_READ)  /* struct rtc_time only has ints */
-COMPATIBLE_IOCTL(RTC_RD_TIME)   /* struct rtc_time only has ints */
-COMPATIBLE_IOCTL(RTC_SET_TIME)  /* struct rtc_time only has ints */
-HANDLE_IOCTL(RTC_IRQP_READ, w_long)
-COMPATIBLE_IOCTL(RTC_IRQP_SET)
-HANDLE_IOCTL(RTC_EPOCH_READ, w_long)
-COMPATIBLE_IOCTL(RTC_EPOCH_SET)
-#endif
-
-IOCTL_TABLE_END
-
-int ioctl_table_size = ARRAY_SIZE(ioctl_start);
index 5f80e58e5cb34aa4d20e1c0a8c2d13e8c04b2fb3..d3654a264ef7533a8811f9e170fb4f7b4c5499ab 100644 (file)
@@ -76,8 +76,7 @@ LINUXINCLUDE    += $(LINUXINCLUDE-y)
 CHECKFLAGS     += -m$(SZ) -D__powerpc__ -D__powerpc$(SZ)__
 
 ifeq ($(CONFIG_PPC64),y)
-GCC_VERSION     := $(call cc-version)
-GCC_BROKEN_VEC := $(shell if [ $(GCC_VERSION) -lt 0400 ] ; then echo "y"; fi)
+GCC_BROKEN_VEC := $(shell if [ $(call cc-version) -lt 0400 ] ; then echo "y"; fi)
 
 ifeq ($(CONFIG_POWER4_ONLY),y)
 ifeq ($(CONFIG_ALTIVEC),y)
@@ -189,10 +188,9 @@ TOUT       := .tmp_gas_check
 # Ensure this is binutils 2.12.1 (or 2.12.90.0.7) or later for altivec
 # instructions.
 # gcc-3.4 and binutils-2.14 are a fatal combination.
-GCC_VERSION    := $(call cc-version)
 
 checkbin:
-       @if test "$(GCC_VERSION)" = "0304" ; then \
+       @if test "$(call cc-version)" = "0304" ; then \
                if ! /bin/echo mftb 5 | $(AS) -v -mppc -many -o $(TOUT) >/dev/null 2>&1 ; then \
                        echo -n '*** ${VERSION}.${PATCHLEVEL} kernels no longer build '; \
                        echo 'correctly with gcc-3.4 and your version of binutils.'; \
index 509399eab6f58e8717587916799ad13719fc4a25..347f4391db8d656092c35fec26f8ec210d74ee63 100644 (file)
@@ -861,7 +861,7 @@ CONFIG_SERIAL_CORE=y
 CONFIG_SERIAL_CORE_CONSOLE=y
 # CONFIG_SERIAL_PMACZILOG is not set
 CONFIG_SERIAL_ICOM=m
-CONFIG_SERIAL_JSM=m
+# CONFIG_SERIAL_JSM is not set
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
index 0faf95c93ef86bdea8b8cf3a053be954944a5439..144e284d21dde7889b1353f1c14ce1a558bd66cc 100644 (file)
@@ -4,7 +4,6 @@
 
 ifeq ($(CONFIG_PPC64),y)
 EXTRA_CFLAGS   += -mno-minimal-toc
-CFLAGS_ioctl32.o += -Ifs/
 endif
 ifeq ($(CONFIG_PPC32),y)
 CFLAGS_prom_init.o      += -fPIC
@@ -16,7 +15,7 @@ obj-y                         := semaphore.o cputable.o ptrace.o syscalls.o \
 obj-y                          += vdso32/
 obj-$(CONFIG_PPC64)            += setup_64.o binfmt_elf32.o sys_ppc32.o \
                                   signal_64.o ptrace32.o systbl.o \
-                                  paca.o ioctl32.o cpu_setup_power4.o \
+                                  paca.o cpu_setup_power4.o \
                                   firmware.o sysfs.o idle_64.o
 obj-$(CONFIG_PPC64)            += vdso64/
 obj-$(CONFIG_ALTIVEC)          += vecemu.o vector.o
diff --git a/arch/powerpc/kernel/ioctl32.c b/arch/powerpc/kernel/ioctl32.c
deleted file mode 100644 (file)
index 0fa3d27..0000000
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
- *
- * Based on sparc64 ioctl32.c by:
- *
- * Copyright (C) 1997-2000  Jakub Jelinek  (jakub@redhat.com)
- * Copyright (C) 1998  Eddie C. Dost  (ecd@skynet.be)
- *
- * ppc64 changes:
- *
- * Copyright (C) 2000  Ken Aaker (kdaaker@rchland.vnet.ibm.com)
- * Copyright (C) 2001  Anton Blanchard (antonb@au.ibm.com)
- *
- * These routines maintain argument size conversion between 32bit and 64bit
- * ioctls.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- */
-
-#define INCLUDES
-#include "compat_ioctl.c"
-#include <linux/syscalls.h>
-
-#define CODE
-#include "compat_ioctl.c"
-
-#define HANDLE_IOCTL(cmd,handler) { cmd, (ioctl_trans_handler_t)handler, NULL },
-#define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL(cmd,sys_ioctl)
-
-#define IOCTL_TABLE_START \
-       struct ioctl_trans ioctl_start[] = {
-#define IOCTL_TABLE_END \
-       };
-
-IOCTL_TABLE_START
-#include <linux/compat_ioctl.h>
-#define DECLARES
-#include "compat_ioctl.c"
-
-IOCTL_TABLE_END
-
-int ioctl_table_size = ARRAY_SIZE(ioctl_start);
index 5368f9c2e6bff7707c040812f1260c8269d1373d..27b0c40601fb5d6db8a13b9915ad2d626152173f 100644 (file)
@@ -35,7 +35,6 @@
 #include <asm/kdebug.h>
 #include <asm/sstep.h>
 
-static DECLARE_MUTEX(kprobe_mutex);
 DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;
 DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
 
@@ -54,19 +53,17 @@ int __kprobes arch_prepare_kprobe(struct kprobe *p)
 
        /* insn must be on a special executable page on ppc64 */
        if (!ret) {
-               down(&kprobe_mutex);
                p->ainsn.insn = get_insn_slot();
-               up(&kprobe_mutex);
                if (!p->ainsn.insn)
                        ret = -ENOMEM;
        }
-       return ret;
-}
 
-void __kprobes arch_copy_kprobe(struct kprobe *p)
-{
-       memcpy(p->ainsn.insn, p->addr, MAX_INSN_SIZE * sizeof(kprobe_opcode_t));
-       p->opcode = *p->addr;
+       if (!ret) {
+               memcpy(p->ainsn.insn, p->addr, MAX_INSN_SIZE * sizeof(kprobe_opcode_t));
+               p->opcode = *p->addr;
+       }
+
+       return ret;
 }
 
 void __kprobes arch_arm_kprobe(struct kprobe *p)
index 9b6d965fb13e7e21334828baa73faa4ae94feeae..475249dc2350db4f735761252db0aff01c13b0ec 100644 (file)
@@ -932,38 +932,6 @@ long ppc32_fadvise64(int fd, u32 unused, u32 offset_high, u32 offset_low,
                             advice);
 }
 
-long ppc32_timer_create(clockid_t clock,
-                       struct compat_sigevent __user *ev32,
-                       timer_t __user *timer_id)
-{
-       sigevent_t event;
-       timer_t t;
-       long err;
-       mm_segment_t savefs;
-
-       if (ev32 == NULL)
-               return sys_timer_create(clock, NULL, timer_id);
-
-       if (get_compat_sigevent(&event, ev32))
-               return -EFAULT;
-
-       if (!access_ok(VERIFY_WRITE, timer_id, sizeof(timer_t)))
-               return -EFAULT;
-
-       savefs = get_fs();
-       set_fs(KERNEL_DS);
-       /* The __user pointer casts are valid due to the set_fs() */
-       err = sys_timer_create(clock,
-               (sigevent_t __user *) &event,
-               (timer_t __user *) &t);
-       set_fs(savefs);
-
-       if (err == 0)
-               err = __put_user(t, timer_id);
-
-       return err;
-}
-
 asmlinkage long compat_sys_add_key(const char __user *_type,
                              const char __user *_description,
                              const void __user *_payload,
index c3ae74b1bf2da61221a0677cadf9b857bb8d7b76..68013179a503ca5fe4c2a3bd1157e06a198d58db 100644 (file)
@@ -281,7 +281,7 @@ SYSCALL(epoll_create)
 SYSCALL(epoll_ctl)
 SYSCALL(epoll_wait)
 SYSCALL(remap_file_pages)
-SYSX(sys_timer_create,ppc32_timer_create,sys_timer_create)
+SYSX(sys_timer_create,compat_sys_timer_create,sys_timer_create)
 COMPAT_SYS(timer_settime)
 COMPAT_SYS(timer_gettime)
 SYSCALL(timer_getoverrun)
index d2ba358c6e3896694c2ce46dd88ce403b1cc04e6..b3962c3a03480ca16a36dcdb98c44cf4dc6839ad 100644 (file)
@@ -138,7 +138,7 @@ static void spufs_prune_dir(struct dentry *dir)
 {
        struct dentry *dentry, *tmp;
        mutex_lock(&dir->d_inode->i_mutex);
-       list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_child) {
+       list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_u.d_child) {
                spin_lock(&dcache_lock);
                spin_lock(&dentry->d_lock);
                if (!(d_unhashed(dentry)) && dentry->d_inode) {
index e719a4933af1e1bff7d820f42225dda557f310af..98e940beeb3bfe632ca979ae7addaeadd3655579 100644 (file)
@@ -128,10 +128,9 @@ TOUT       := .tmp_gas_check
 # Ensure this is binutils 2.12.1 (or 2.12.90.0.7) or later for altivec
 # instructions.
 # gcc-3.4 and binutils-2.14 are a fatal combination.
-GCC_VERSION    := $(call cc-version)
 
 checkbin:
-       @if test "$(GCC_VERSION)" = "0304" ; then \
+       @if test "$(call cc-version)" = "0304" ; then \
                if ! /bin/echo mftb 5 | $(AS) -v -mppc -many -o $(TOUT) >/dev/null 2>&1 ; then \
                        echo -n '*** ${VERSION}.${PATCHLEVEL} kernels no longer build '; \
                        echo 'correctly with gcc-3.4 and your version of binutils.'; \
index a882b0dbe8de3e4b28b4216b5d6ed25076b69253..84d65a87191ed6048a81eee508e43d1629055f9b 100644 (file)
@@ -28,12 +28,6 @@ typedef NORET_TYPE void (*relocate_new_kernel_t)(
 const extern unsigned char relocate_new_kernel[];
 const extern unsigned int relocate_new_kernel_size;
 
-/*
- * Provide a dummy crash_notes definition while crash dump arrives to ppc.
- * This prevents breakage of crash_notes attribute in kernel/ksysfs.c.
- */
-note_buf_t crash_notes[NR_CPUS];
-
 void machine_shutdown(void)
 {
        if (ppc_md.machine_shutdown)
index 6fe532d82417d8acf89bc3a97217999cd5b09344..b66602ad7b33073fe7a5b0d307703f9d0c6768f9 100644 (file)
@@ -27,11 +27,6 @@ config S390
        bool
        default y
 
-config UID16
-       bool
-       default y
-       depends on !64BIT
-
 source "init/Kconfig"
 
 menu "Base setup"
index 4865e4b494647a3474f6820deb4eef054790f5a6..9269b5788facaf1ce05d7d5dcdc52b55b83d62c9 100644 (file)
@@ -17,8 +17,7 @@ obj-$(CONFIG_MODULES)         += s390_ksyms.o module.o
 obj-$(CONFIG_SMP)              += smp.o
 
 obj-$(CONFIG_COMPAT)           += compat_linux.o compat_signal.o \
-                                       compat_ioctl.o compat_wrapper.o \
-                                       compat_exec_domain.o
+                                       compat_wrapper.o compat_exec_domain.o
 obj-$(CONFIG_BINFMT_ELF32)     += binfmt_elf32.o
 
 obj-$(CONFIG_VIRT_TIMER)       += vtime.o
diff --git a/arch/s390/kernel/compat_ioctl.c b/arch/s390/kernel/compat_ioctl.c
deleted file mode 100644 (file)
index 6504c4e..0000000
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
- *
- *  S390 version
- *    Copyright (C) 2000-2003 IBM Deutschland Entwicklung GmbH, IBM Corporation
- *    Author(s): Gerhard Tonn (ton@de.ibm.com)
- *               Arnd Bergmann (arndb@de.ibm.com)
- *
- * Original implementation from 32-bit Sparc compat code which is
- * Copyright (C) 2000 Silicon Graphics, Inc.
- * Written by Ulf Carlsson (ulfc@engr.sgi.com) 
- */
-
-#include "compat_linux.h"
-#define INCLUDES
-#define CODE
-#include "../../../fs/compat_ioctl.c"
-#include <asm/dasd.h>
-#include <asm/cmb.h>
-#include <asm/tape390.h>
-#include <asm/ccwdev.h>
-#include "../../../drivers/s390/char/raw3270.h"
-
-static int do_ioctl32_pointer(unsigned int fd, unsigned int cmd,
-                               unsigned long arg, struct file *f)
-{
-       return sys_ioctl(fd, cmd, (unsigned long)compat_ptr(arg));
-}
-
-static int do_ioctl32_ulong(unsigned int fd, unsigned int cmd,
-                               unsigned long arg, struct file *f)
-{
-       return sys_ioctl(fd, cmd, arg);
-}
-
-#define COMPATIBLE_IOCTL(cmd)          HANDLE_IOCTL((cmd),(ioctl_trans_handler_t)do_ioctl32_pointer)
-#define ULONG_IOCTL(cmd)               HANDLE_IOCTL((cmd),(ioctl_trans_handler_t)do_ioctl32_ulong)
-#define HANDLE_IOCTL(cmd,handler)      { (cmd), (ioctl_trans_handler_t)(handler), NULL },
-
-struct ioctl_trans ioctl_start[] = {
-/* architecture independent ioctls */
-#include <linux/compat_ioctl.h>
-#define DECLARES
-#include "../../../fs/compat_ioctl.c"
-
-/* s390 only ioctls */
-COMPATIBLE_IOCTL(DASDAPIVER)
-COMPATIBLE_IOCTL(BIODASDDISABLE)
-COMPATIBLE_IOCTL(BIODASDENABLE)
-COMPATIBLE_IOCTL(BIODASDRSRV)
-COMPATIBLE_IOCTL(BIODASDRLSE)
-COMPATIBLE_IOCTL(BIODASDSLCK)
-COMPATIBLE_IOCTL(BIODASDINFO)
-COMPATIBLE_IOCTL(BIODASDINFO2)
-COMPATIBLE_IOCTL(BIODASDFMT)
-COMPATIBLE_IOCTL(BIODASDPRRST)
-COMPATIBLE_IOCTL(BIODASDQUIESCE)
-COMPATIBLE_IOCTL(BIODASDRESUME)
-COMPATIBLE_IOCTL(BIODASDPRRD)
-COMPATIBLE_IOCTL(BIODASDPSRD)
-COMPATIBLE_IOCTL(BIODASDGATTR)
-COMPATIBLE_IOCTL(BIODASDSATTR)
-COMPATIBLE_IOCTL(BIODASDCMFENABLE)
-COMPATIBLE_IOCTL(BIODASDCMFDISABLE)
-COMPATIBLE_IOCTL(BIODASDREADALLCMB)
-
-COMPATIBLE_IOCTL(TUBICMD)
-COMPATIBLE_IOCTL(TUBOCMD)
-COMPATIBLE_IOCTL(TUBGETI)
-COMPATIBLE_IOCTL(TUBGETO)
-COMPATIBLE_IOCTL(TUBSETMOD)
-COMPATIBLE_IOCTL(TUBGETMOD)
-
-COMPATIBLE_IOCTL(TAPE390_DISPLAY)
-
-/* s390 doesn't need handlers here */
-COMPATIBLE_IOCTL(TIOCGSERIAL)
-COMPATIBLE_IOCTL(TIOCSSERIAL)
-};
-
-int ioctl_table_size = ARRAY_SIZE(ioctl_start);
index 41b197a3f3a390c58fcac826dd20f2dfc482f910..cd3b3c3e7a9fe9438c423db548214337d01206af 100644 (file)
@@ -1013,38 +1013,6 @@ asmlinkage long sys32_clone(struct pt_regs regs)
                       parent_tidptr, child_tidptr);
 }
 
-/*
- * Wrapper function for sys_timer_create.
- */
-extern asmlinkage long
-sys_timer_create(clockid_t, struct sigevent *, timer_t *);
-
-asmlinkage long
-sys32_timer_create(clockid_t which_clock, struct compat_sigevent *se32,
-               timer_t *timer_id)
-{
-       struct sigevent se;
-       timer_t ktimer_id;
-       mm_segment_t old_fs;
-       long ret;
-
-       if (se32 == NULL)
-               return sys_timer_create(which_clock, NULL, timer_id);
-
-       if (get_compat_sigevent(&se, se32))
-               return -EFAULT;
-
-       old_fs = get_fs();
-       set_fs(KERNEL_DS);
-       ret = sys_timer_create(which_clock, &se, &ktimer_id);
-       set_fs(old_fs);
-
-       if (!ret)
-               ret = put_user (ktimer_id, timer_id);
-
-       return ret;
-}
-
 /*
  * 31 bit emulation wrapper functions for sys_fadvise64/fadvise64_64.
  * These need to rewrite the advise values for POSIX_FADV_{DONTNEED,NOREUSE}
index 23fe94e58688ec4d6659f16fa06287ac6e8cb174..cfde1905d07d77c5d2513e14a3c019e1d56f01d6 100644 (file)
@@ -1289,7 +1289,7 @@ sys32_timer_create_wrapper:
        lgfr    %r2,%r2                 # timer_t (int)
        llgtr   %r3,%r3                 # struct compat_sigevent *
        llgtr   %r4,%r4                 # timer_t *
-       jg      sys32_timer_create
+       jg      compat_sys_timer_create
 
        .globl  sys32_timer_settime_wrapper
 sys32_timer_settime_wrapper:
index 7bd169c58b0c229ba636be895444fbaf1ee5dc29..926cceeae0faa27c7d6cb6a44b5141f83aaf46ae 100644 (file)
@@ -10,8 +10,6 @@
 #include <linux/threads.h>
 #include <linux/kexec.h>
 
-note_buf_t crash_notes[NR_CPUS];
-
 void machine_crash_shutdown(struct pt_regs *regs)
 {
 }
index a942bf2d58e91b12836a4b59094f0ada9b127c15..7dd58f8ac6b59848cec44f18fb5931b6d6ee2a47 100644 (file)
@@ -352,27 +352,6 @@ int dump_fpu (struct pt_regs * regs, s390_fp_regs *fpregs)
        return 1;
 }
 
-/*
- * fill in the user structure for a core dump..
- */
-void dump_thread(struct pt_regs * regs, struct user * dump)
-{
-
-/* changed the size calculations - should hopefully work better. lbt */
-       dump->magic = CMAGIC;
-       dump->start_code = 0;
-       dump->start_stack = regs->gprs[15] & ~(PAGE_SIZE - 1);
-       dump->u_tsize = current->mm->end_code >> PAGE_SHIFT;
-       dump->u_dsize = (current->mm->brk + PAGE_SIZE - 1) >> PAGE_SHIFT;
-       dump->u_dsize -= dump->u_tsize;
-       dump->u_ssize = 0;
-       if (dump->start_stack < TASK_SIZE)
-               dump->u_ssize = (TASK_SIZE - dump->start_stack) >> PAGE_SHIFT;
-       memcpy(&dump->regs, regs, sizeof(s390_regs));
-       dump_fpu (regs, &dump->regs.fp_regs);
-       dump->regs.per_info = current->thread.per_info;
-}
-
 unsigned long get_wchan(struct task_struct *p)
 {
        struct stack_frame *sf, *low, *high;
index bee654abb6d38fe23cc06983748d897ced735a59..4176c77670c41f222f22311376fc633e48f901d1 100644 (file)
@@ -10,7 +10,6 @@
 #include <linux/smp.h>
 #include <linux/syscalls.h>
 #include <linux/interrupt.h>
-#include <linux/ioctl32.h>
 #include <asm/checksum.h>
 #include <asm/cpcmd.h>
 #include <asm/delay.h>
index fd4f240b833d5fc55af05e6de0520eaf9847d248..8a2bea34ddd2635ca344ea564385483c9919c59d 100644 (file)
@@ -305,26 +305,6 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
        return 0;
 }
 
-/*
- * fill in the user structure for a core dump..
- */
-void dump_thread(struct pt_regs * regs, struct user * dump)
-{
-       dump->magic = CMAGIC;
-       dump->start_code = current->mm->start_code;
-       dump->start_data  = current->mm->start_data;
-       dump->start_stack = regs->regs[15] & ~(PAGE_SIZE - 1);
-       dump->u_tsize = (current->mm->end_code - dump->start_code) >> PAGE_SHIFT;
-       dump->u_dsize = (current->mm->brk + (PAGE_SIZE-1) - dump->start_data) >> PAGE_SHIFT;
-       dump->u_ssize = (current->mm->start_stack - dump->start_stack +
-                        PAGE_SIZE - 1) >> PAGE_SHIFT;
-       /* Debug registers will come here. */
-
-       dump->regs = *regs;
-
-       dump->u_fpvalid = dump_fpu(regs, &dump->fpu);
-}
-
 /* Tracing by user break controller.  */
 static void
 ubc_set_tracing(int asid, unsigned long pc)
index 6954fd62470ae8ace2c382c4044375151bf8c9c9..1cf94a618be3c97fa21207b4811e36e88634f780 100644 (file)
 #include <asm/cacheflush.h>
 #include <asm/checksum.h>
 
-extern void dump_thread(struct pt_regs *, struct user *);
 extern int dump_fpu(struct pt_regs *, elf_fpregset_t *);
 extern struct hw_interrupt_type no_irq_type;
 
 EXPORT_SYMBOL(sh_mv);
 
 /* platform dependent support */
-EXPORT_SYMBOL(dump_thread);
 EXPORT_SYMBOL(dump_fpu);
 EXPORT_SYMBOL(iounmap);
 EXPORT_SYMBOL(enable_irq);
index fb35b45dc130074b3fd6d0170c58588f17885f1e..07b172deb872b46478d5d44df926efcddf2acc98 100644 (file)
@@ -17,10 +17,6 @@ config MMU
        bool
        default y
 
-config UID16
-       bool
-       default y
-
 config RWSEM_GENERIC_SPINLOCK
        bool
        default y
index b95d041418554196350b64096a7486e1a7d6a4cb..419b5a71044116c9f6d4d5a396be7e42263286c5 100644 (file)
@@ -775,26 +775,6 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
        return 0;
 }
 
-/*
- * fill in the user structure for a core dump..
- */
-void dump_thread(struct pt_regs * regs, struct user * dump)
-{
-       dump->magic = CMAGIC;
-       dump->start_code = current->mm->start_code;
-       dump->start_data  = current->mm->start_data;
-       dump->start_stack = regs->regs[15] & ~(PAGE_SIZE - 1);
-       dump->u_tsize = (current->mm->end_code - dump->start_code) >> PAGE_SHIFT;
-       dump->u_dsize = (current->mm->brk + (PAGE_SIZE-1) - dump->start_data) >> PAGE_SHIFT;
-       dump->u_ssize = (current->mm->start_stack - dump->start_stack +
-                        PAGE_SIZE - 1) >> PAGE_SHIFT;
-       /* Debug registers will come here. */
-
-       dump->regs = *regs;
-
-       dump->u_fpvalid = dump_fpu(regs, &dump->fpu);
-}
-
 asmlinkage int sys_fork(unsigned long r2, unsigned long r3,
                        unsigned long r4, unsigned long r5,
                        unsigned long r6, unsigned long r7,
index 0b5497d70bd3766ac40754fad936c53594522c4f..472b450e61be5384bdd9211c8d485796e73f33b3 100644 (file)
@@ -29,7 +29,6 @@
 #include <asm/delay.h>
 #include <asm/irq.h>
 
-extern void dump_thread(struct pt_regs *, struct user *);
 extern int dump_fpu(struct pt_regs *, elf_fpregset_t *);
 
 #if 0
@@ -41,7 +40,6 @@ EXPORT_SYMBOL(drive_info);
 #endif
 
 /* platform dependent support */
-EXPORT_SYMBOL(dump_thread);
 EXPORT_SYMBOL(dump_fpu);
 EXPORT_SYMBOL(iounmap);
 EXPORT_SYMBOL(enable_irq);
index 1c8fd0fd930590ce218d915cbcc4cf128fc4b66d..0b0d492c953b0118114d925cf1672b11500f0926 100644 (file)
@@ -82,8 +82,6 @@ extern int __lshrdi3(int, int);
 extern int __muldi3(int, int);
 extern int __divdi3(int, int);
 
-extern void dump_thread(struct pt_regs *, struct user *);
-
 /* Private functions with odd calling conventions. */
 extern void ___atomic24_add(void);
 extern void ___atomic24_sub(void);
index 6f00ab8b9d23ab6b79897acca6899b559c4dbaa4..83d67eb188952efbd941b265b55b005df879e260 100644 (file)
@@ -16,7 +16,7 @@ obj-y         := process.o setup.o cpu.o idprom.o \
 obj-$(CONFIG_PCI)       += ebus.o isa.o pci_common.o pci_iommu.o \
                            pci_psycho.o pci_sabre.o pci_schizo.o
 obj-$(CONFIG_SMP)       += smp.o trampoline.o
-obj-$(CONFIG_SPARC32_COMPAT) += sys32.o sys_sparc32.o signal32.o ioctl32.o
+obj-$(CONFIG_SPARC32_COMPAT) += sys32.o sys_sparc32.o signal32.o
 obj-$(CONFIG_BINFMT_ELF32) += binfmt_elf32.o
 obj-$(CONFIG_BINFMT_AOUT32) += binfmt_aout32.o
 obj-$(CONFIG_MODULES) += module.o
@@ -40,5 +40,3 @@ endif
 
 head.o: head.S ttable.S itlb_base.S dtlb_base.S dtlb_backend.S dtlb_prot.S \
        etrap.S rtrap.S winfixup.S entry.S
-
-CFLAGS_ioctl32.o += -Ifs/
index edf52d06b28042312c796ac0227884312194658d..202a80c24b6f789cdd11dd7db964158a35a88e56 100644 (file)
@@ -36,8 +36,6 @@ static int load_aout32_binary(struct linux_binprm *, struct pt_regs * regs);
 static int load_aout32_library(struct file*);
 static int aout32_core_dump(long signr, struct pt_regs * regs, struct file *file);
 
-extern void dump_thread(struct pt_regs *, struct user *);
-
 static struct linux_binfmt aout32_format = {
        NULL, THIS_MODULE, load_aout32_binary, load_aout32_library, aout32_core_dump,
        PAGE_SIZE
diff --git a/arch/sparc64/kernel/ioctl32.c b/arch/sparc64/kernel/ioctl32.c
deleted file mode 100644 (file)
index 196b208..0000000
+++ /dev/null
@@ -1,39 +0,0 @@
-/* $Id: ioctl32.c,v 1.136 2002/01/14 09:49:52 davem Exp $
- * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
- *
- * Copyright (C) 1997-2000  Jakub Jelinek  (jakub@redhat.com)
- * Copyright (C) 1998  Eddie C. Dost  (ecd@skynet.be)
- * Copyright (C) 2003  Pavel Machek (pavel@suse.cz)
- *
- * These routines maintain argument size conversion between 32bit and 64bit
- * ioctls.
- */
-
-#define INCLUDES
-#include "compat_ioctl.c"
-#include <linux/syscalls.h>
-
-#define CODE
-#include "compat_ioctl.c"
-
-#define COMPATIBLE_IOCTL(cmd)          HANDLE_IOCTL((cmd),sys_ioctl)
-#define HANDLE_IOCTL(cmd,handler)      { (cmd), (ioctl_trans_handler_t)(handler), NULL },
-#define IOCTL_TABLE_START \
-       struct ioctl_trans ioctl_start[] = {
-#define IOCTL_TABLE_END \
-       };
-
-IOCTL_TABLE_START
-#include <linux/compat_ioctl.h>
-#define DECLARES
-#include "compat_ioctl.c"
-#if 0
-HANDLE_IOCTL(RTC32_IRQP_READ, do_rtc_ioctl)
-HANDLE_IOCTL(RTC32_IRQP_SET, do_rtc_ioctl)
-HANDLE_IOCTL(RTC32_EPOCH_READ, do_rtc_ioctl)
-HANDLE_IOCTL(RTC32_EPOCH_SET, do_rtc_ioctl)
-#endif
-/* take care of sizeof(sizeof()) breakage */
-IOCTL_TABLE_END
-
-int ioctl_table_size = ARRAY_SIZE(ioctl_start);
index a97b0f0727ab15be8ee7678848b5d81ebf282ded..ff5e9d5cad50ed7f2507f3c9a1935e518d34d937 100644 (file)
@@ -42,15 +42,11 @@ DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;
 DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
 
 int __kprobes arch_prepare_kprobe(struct kprobe *p)
-{
-       return 0;
-}
-
-void __kprobes arch_copy_kprobe(struct kprobe *p)
 {
        p->ainsn.insn[0] = *p->addr;
        p->ainsn.insn[1] = BREAKPOINT_INSTRUCTION_2;
        p->opcode = *p->addr;
+       return 0;
 }
 
 void __kprobes arch_arm_kprobe(struct kprobe *p)
@@ -65,10 +61,6 @@ void __kprobes arch_disarm_kprobe(struct kprobe *p)
        flushi(p->addr);
 }
 
-void __kprobes arch_remove_kprobe(struct kprobe *p)
-{
-}
-
 static inline void save_previous_kprobe(struct kprobe_ctlblk *kcb)
 {
        kcb->prev_kprobe.kp = kprobe_running();
index fb7a5370dbfcf7c0a8d9c2fda0a70fc736ad30a4..d177d7e5c9d30b26cf5f456e0ba7da88445fbf04 100644 (file)
@@ -94,7 +94,6 @@ extern void (*prom_palette)(int);
 
 extern int __ashrdi3(int, int);
 
-extern void dump_thread(struct pt_regs *, struct user *);
 extern int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs);
 
 extern unsigned long phys_base;
@@ -241,7 +240,6 @@ EXPORT_SYMBOL(io_remap_pfn_range);
 EXPORT_SYMBOL(_sigpause_common);
 EXPORT_SYMBOL(verify_compat_iovec);
 
-EXPORT_SYMBOL(dump_thread);
 EXPORT_SYMBOL(dump_fpu);
 EXPORT_SYMBOL(pte_alloc_one_kernel);
 #ifndef CONFIG_SMP
index 7f6239ed252142e52c45f2921de58b339d770086..de342ee3116b05b5412e4e91e01815805872e15e 100644 (file)
@@ -1120,39 +1120,3 @@ long sys32_lookup_dcookie(unsigned long cookie_high,
        return sys_lookup_dcookie((cookie_high << 32) | cookie_low,
                                  buf, len);
 }
-
-extern asmlinkage long
-sys_timer_create(clockid_t which_clock,
-                struct sigevent __user *timer_event_spec,
-                timer_t __user *created_timer_id);
-
-long
-sys32_timer_create(u32 clock, struct compat_sigevent __user *se32,
-                  timer_t __user *timer_id)
-{
-       struct sigevent se;
-       mm_segment_t oldfs;
-       timer_t t;
-       long err;
-
-       if (se32 == NULL)
-               return sys_timer_create(clock, NULL, timer_id);
-
-       if (get_compat_sigevent(&se, se32))
-               return -EFAULT;
-
-       if (!access_ok(VERIFY_WRITE,timer_id,sizeof(timer_t)))
-               return -EFAULT;
-
-       oldfs = get_fs();
-       set_fs(KERNEL_DS);
-       err = sys_timer_create(clock,
-                              (struct sigevent __user *) &se,
-                              (timer_t __user *) &t);
-       set_fs(oldfs);
-
-       if (!err)
-               err = __put_user (t, timer_id);
-
-       return err;
-}
index 53eaf2345fe97aa01aeaab2b528a64c6bfd39b2e..37e9acc9e58740d5307cee3dcba670bdabc77f42 100644 (file)
@@ -73,7 +73,7 @@ sys_call_table32:
 /*250*/        .word sys32_mremap, sys32_sysctl, sys32_getsid, sys_fdatasync, sys32_nfsservctl
        .word sys_ni_syscall, sys32_clock_settime, compat_sys_clock_gettime, compat_sys_clock_getres, sys32_clock_nanosleep
 /*260*/        .word compat_sys_sched_getaffinity, compat_sys_sched_setaffinity, sys32_timer_settime, compat_sys_timer_gettime, sys_timer_getoverrun
-       .word sys_timer_delete, sys32_timer_create, sys_ni_syscall, compat_sys_io_setup, sys_io_destroy
+       .word sys_timer_delete, compat_sys_timer_create, sys_ni_syscall, compat_sys_io_setup, sys_io_destroy
 /*270*/        .word sys32_io_submit, sys_io_cancel, compat_sys_io_getevents, sys32_mq_open, sys_mq_unlink
        .word compat_sys_mq_timedsend, compat_sys_mq_timedreceive, compat_sys_mq_notify, compat_sys_mq_getsetattr, compat_sys_waitid
 /*280*/        .word sys_ni_syscall, sys_add_key, sys_request_key, sys_keyctl
index cd13b91b9ff6a9702126282fb6e9dbc7fc0f9f90..ab0d0b17081677eb9a2d2f0b0ddc21c28c1fbdb6 100644 (file)
@@ -186,9 +186,6 @@ static void tty_receive_char(struct tty_struct *tty, char ch)
                }
        }
 
-       if((tty->flip.flag_buf_ptr == NULL) ||
-          (tty->flip.char_buf_ptr == NULL))
-               return;
        tty_insert_flip_char(tty, ch, TTY_NORMAL);
 }
 
@@ -653,8 +650,7 @@ void chan_interrupt(struct list_head *chans, struct work_struct *task,
                chan = list_entry(ele, struct chan, list);
                if(!chan->input || (chan->ops->read == NULL)) continue;
                do {
-                       if((tty != NULL) &&
-                          (tty->flip.count >= TTY_FLIPBUF_SIZE)){
+                       if (tty && !tty_buffer_request_room(tty, 1)) {
                                schedule_delayed_work(task, 1);
                                goto out;
                        }
index 11f518a7e1562538e1cf75e5b87af1c609d50009..8fa2ae7f30261b3c749f2c1f4a666f210dd0f896 100644 (file)
@@ -99,7 +99,8 @@ void uml_idle_timer(void)
        set_interval(ITIMER_REAL);
 }
 
-extern int do_posix_clock_monotonic_gettime(struct timespec *tp);
+extern void ktime_get_ts(struct timespec *ts);
+#define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
 
 void time_init(void)
 {
@@ -114,8 +115,8 @@ void time_init(void)
        wall_to_monotonic.tv_nsec = -now.tv_nsec;
 }
 
-/* Declared in linux/time.h, which can't be included here */
-extern void clock_was_set(void);
+/* Defined in linux/ktimer.h, which can't be included here */
+#define clock_was_set()                do { } while (0)
 
 void do_gettimeofday(struct timeval *tv)
 {
index 39cf247cdae4ef4dcbe4d4fa3563432a520f1531..062ffa0a9998100205dcf30f0f503c448e604e89 100644 (file)
@@ -163,30 +163,6 @@ int copy_thread (int nr, unsigned long clone_flags,
        return 0;
 }
 
-/*
- * fill in the user structure for a core dump..
- */
-void dump_thread (struct pt_regs *regs, struct user *dump)
-{
-#if 0  /* Later.  XXX */
-       dump->magic = CMAGIC;
-       dump->start_code = 0;
-       dump->start_stack = regs->gpr[GPR_SP];
-       dump->u_tsize = ((unsigned long) current->mm->end_code) >> PAGE_SHIFT;
-       dump->u_dsize = ((unsigned long) (current->mm->brk +
-                                         (PAGE_SIZE-1))) >> PAGE_SHIFT;
-       dump->u_dsize -= dump->u_tsize;
-       dump->u_ssize = 0;
-
-       if (dump->start_stack < TASK_SIZE)
-               dump->u_ssize = ((unsigned long) (TASK_SIZE - dump->start_stack)) >> PAGE_SHIFT;
-
-       dump->u_ar0 = (struct user_regs_struct *)((int)&dump->regs - (int)dump);
-       dump->regs = *regs;
-       dump->u_fpvalid = 0;
-#endif
-}
-
 /*
  * sys_execve() executes a new program.
  */
index 0ca64900dd913c40ec3682b58d921ed99767453f..8ffc29c1c89df749f71e0d3954e01642ede3770d 100644 (file)
@@ -21,8 +21,6 @@ extern void *trap_table;
 EXPORT_SYMBOL (trap_table);
 
 /* platform dependent support */
-extern void dump_thread (struct pt_regs *, struct user *);
-EXPORT_SYMBOL (dump_thread);
 EXPORT_SYMBOL (kernel_thread);
 EXPORT_SYMBOL (enable_irq);
 EXPORT_SYMBOL (disable_irq);
index 4f3e925962c36576f9d2c7ee04fedbcdaf591d21..348b4a0d0d6f69c459240d6fc4d75c152440b132 100644 (file)
@@ -399,17 +399,6 @@ config X86_MCE_AMD
           Additional support for AMD specific MCE features such as
           the DRAM Error Threshold.
 
-config PHYSICAL_START
-       hex "Physical address where the kernel is loaded" if EMBEDDED
-       default "0x100000"
-       help
-         This gives the physical address where the kernel is loaded.
-         Primarily used in the case of kexec on panic where the
-         fail safe kernel needs to run at a different address than
-         the panic-ed kernel.
-
-         Don't change this unless you know what you are doing.
-
 config KEXEC
        bool "kexec system call (EXPERIMENTAL)"
        depends on EXPERIMENTAL
@@ -427,6 +416,31 @@ config KEXEC
          support.  As of this writing the exact hardware interface is
          strongly in flux, so no good recommendation can be made.
 
+config CRASH_DUMP
+       bool "kernel crash dumps (EXPERIMENTAL)"
+       depends on EXPERIMENTAL
+       help
+               Generate crash dump after being started by kexec.
+
+config PHYSICAL_START
+       hex "Physical address where the kernel is loaded" if (EMBEDDED || CRASH_DUMP)
+       default "0x1000000" if CRASH_DUMP
+       default "0x100000"
+       help
+         This gives the physical address where the kernel is loaded. Normally
+         for regular kernels this value is 0x100000 (1MB). But in the case
+         of kexec on panic the fail safe kernel needs to run at a different
+         address than the panic-ed kernel. This option is used to set the load
+         address for kernels used to capture crash dump on being kexec'ed
+         after panic. The default value for crash dump kernels is
+         0x1000000 (16MB). This can also be set based on the "X" value as
+         specified in the "crashkernel=YM@XM" command line boot parameter
+         passed to the panic-ed kernel. Typically this parameter is set as
+         crashkernel=64M@16M. Please take a look at
+         Documentation/kdump/kdump.txt for more details about crash dumps.
+
+         Don't change this unless you know what you are doing.
+
 config SECCOMP
        bool "Enable seccomp to safely compute untrusted bytecode"
        depends on PROC_FS
index a9cd42e61828d8860c41c06b71ed58e1dfb6956f..51d83288d62b499d8b863113a7094ff71f954cc4 100644 (file)
@@ -80,9 +80,12 @@ bzlilo: vmlinux
 bzdisk: vmlinux
        $(Q)$(MAKE) $(build)=$(boot) BOOTIMAGE=$(BOOTIMAGE) zdisk
 
-install fdimage fdimage144 fdimage288: vmlinux
+fdimage fdimage144 fdimage288: vmlinux
        $(Q)$(MAKE) $(build)=$(boot) BOOTIMAGE=$(BOOTIMAGE) $@
 
+install:
+       $(Q)$(MAKE) $(build)=$(boot) BOOTIMAGE=$(BOOTIMAGE) $@ 
+
 archclean:
        $(Q)$(MAKE) $(clean)=$(boot)
 
index 18c6e915d69b84260a43b979b28e5058c60a193a..29f8396ed151c9d0dc12725dc19d4fc729971f2c 100644 (file)
@@ -98,5 +98,5 @@ zlilo: $(BOOTIMAGE)
        cp System.map $(INSTALL_PATH)/
        if [ -x /sbin/lilo ]; then /sbin/lilo; else /etc/lilo/install; fi
 
-install: $(BOOTIMAGE)
+install:
        sh $(srctree)/$(src)/install.sh $(KERNELRELEASE) $(BOOTIMAGE) System.map "$(INSTALL_PATH)"
index 198af15a77586c1abb2cd9c0159cb3e0e0da1643..baaa2369bdb8d8c0c8a7558b7ba4e065c6f194bf 100644 (file)
@@ -1,40 +1,2 @@
 #!/bin/sh
-#
-# arch/x86_64/boot/install.sh
-#
-# This file is subject to the terms and conditions of the GNU General Public
-# License.  See the file "COPYING" in the main directory of this archive
-# for more details.
-#
-# Copyright (C) 1995 by Linus Torvalds
-#
-# Adapted from code in arch/i386/boot/Makefile by H. Peter Anvin
-#
-# "make install" script for i386 architecture
-#
-# Arguments:
-#   $1 - kernel version
-#   $2 - kernel image file
-#   $3 - kernel map file
-#   $4 - default install path (blank if root directory)
-#
-
-# User may have a custom install script
-
-if [ -x ~/bin/${CROSS_COMPILE}installkernel ]; then exec ~/bin/${CROSS_COMPILE}installkernel "$@"; fi
-if [ -x /sbin/${CROSS_COMPILE}installkernel ]; then exec /sbin/${CROSS_COMPILE}installkernel "$@"; fi
-
-# Default install - same as make zlilo
-
-if [ -f $4/vmlinuz ]; then
-       mv $4/vmlinuz $4/vmlinuz.old
-fi
-
-if [ -f $4/System.map ]; then
-       mv $4/System.map $4/System.old
-fi
-
-cat $2 > $4/vmlinuz
-cp $3 $4/System.map
-
-if [ -x /sbin/lilo ]; then /sbin/lilo; else /etc/lilo/install; fi
+. $srctree/arch/i386/boot/install.sh
index f76217d8f5799dd3ca888d6da91680182bf746d5..051608d559208e663851c0d8dd1e9e8d2cdf937c 100644 (file)
@@ -2,8 +2,7 @@
 # Makefile for the ia32 kernel emulation subsystem.
 #
 
-obj-$(CONFIG_IA32_EMULATION) := ia32entry.o sys_ia32.o ia32_ioctl.o \
-       ia32_signal.o tls32.o \
+obj-$(CONFIG_IA32_EMULATION) := ia32entry.o sys_ia32.o ia32_signal.o tls32.o \
        ia32_binfmt.o fpu32.o ptrace32.o syscall32.o syscall32_syscall.o
 
 sysv-$(CONFIG_SYSVIPC) := ipc32.o
@@ -29,4 +28,3 @@ $(obj)/vsyscall-%.so: $(src)/vsyscall.lds $(obj)/vsyscall-%.o FORCE
 
 AFLAGS_vsyscall-sysenter.o = -m32
 AFLAGS_vsyscall-syscall.o = -m32
-CFLAGS_ia32_ioctl.o += -Ifs/
diff --git a/arch/x86_64/ia32/ia32_ioctl.c b/arch/x86_64/ia32/ia32_ioctl.c
deleted file mode 100644 (file)
index e335bd0..0000000
+++ /dev/null
@@ -1,79 +0,0 @@
-/* $Id: ia32_ioctl.c,v 1.25 2002/10/11 07:17:06 ak Exp $
- * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
- *
- * Copyright (C) 1997-2000  Jakub Jelinek  (jakub@redhat.com)
- * Copyright (C) 1998  Eddie C. Dost  (ecd@skynet.be)
- * Copyright (C) 2001,2002  Andi Kleen, SuSE Labs 
- *
- * These routines maintain argument size conversion between 32bit and 64bit
- * ioctls.
- */
-
-#define INCLUDES
-#include <linux/syscalls.h>
-#include "compat_ioctl.c"
-#include <asm/ia32.h>
-
-#define CODE
-#include "compat_ioctl.c"
-  
-#define RTC_IRQP_READ32        _IOR('p', 0x0b, unsigned int)    /* Read IRQ rate   */
-#define RTC_IRQP_SET32 _IOW('p', 0x0c, unsigned int)    /* Set IRQ rate    */
-#define RTC_EPOCH_READ32       _IOR('p', 0x0d, unsigned)        /* Read epoch      */
-#define RTC_EPOCH_SET32                _IOW('p', 0x0e, unsigned)        /* Set epoch       */
-
-static int rtc32_ioctl(unsigned fd, unsigned cmd, unsigned long arg) 
-{ 
-       unsigned long val;
-       mm_segment_t oldfs = get_fs(); 
-       int ret; 
-       
-       switch (cmd) { 
-       case RTC_IRQP_READ32: 
-               set_fs(KERNEL_DS); 
-               ret = sys_ioctl(fd, RTC_IRQP_READ, (unsigned long)&val); 
-               set_fs(oldfs); 
-               if (!ret)
-                       ret = put_user(val, (unsigned int __user *) arg); 
-               return ret; 
-
-       case RTC_IRQP_SET32: 
-               cmd = RTC_IRQP_SET; 
-               break; 
-
-       case RTC_EPOCH_READ32:
-               set_fs(KERNEL_DS); 
-               ret = sys_ioctl(fd, RTC_EPOCH_READ, (unsigned long) &val); 
-               set_fs(oldfs); 
-               if (!ret)
-                       ret = put_user(val, (unsigned int __user *) arg); 
-               return ret; 
-
-       case RTC_EPOCH_SET32:
-               cmd = RTC_EPOCH_SET; 
-               break; 
-       } 
-       return sys_ioctl(fd,cmd,arg); 
-} 
-
-
-#define HANDLE_IOCTL(cmd,handler) { (cmd), (ioctl_trans_handler_t)(handler) }, 
-#define COMPATIBLE_IOCTL(cmd) HANDLE_IOCTL(cmd,sys_ioctl)
-
-struct ioctl_trans ioctl_start[] = { 
-#include <linux/compat_ioctl.h>
-#define DECLARES
-#include "compat_ioctl.c"
-
-/* And these ioctls need translation */
-/* realtime device */
-HANDLE_IOCTL(RTC_IRQP_READ,  rtc32_ioctl)
-HANDLE_IOCTL(RTC_IRQP_READ32,rtc32_ioctl)
-HANDLE_IOCTL(RTC_IRQP_SET32, rtc32_ioctl)
-HANDLE_IOCTL(RTC_EPOCH_READ32, rtc32_ioctl)
-HANDLE_IOCTL(RTC_EPOCH_SET32, rtc32_ioctl)
-/* take care of sizeof(sizeof()) breakage */
-}; 
-
-int ioctl_table_size = ARRAY_SIZE(ioctl_start);
-
index 1f0ff5adc80e1b0babda930850aa29eb16e4bab0..2ff07b47ea9cfe99318f90663ba601287e36c52d 100644 (file)
@@ -608,7 +608,7 @@ ia32_sys_call_table:
        .quad sys_epoll_wait
        .quad sys_remap_file_pages
        .quad sys_set_tid_address
-       .quad sys32_timer_create
+       .quad compat_sys_timer_create
        .quad compat_sys_timer_settime  /* 260 */
        .quad compat_sys_timer_gettime
        .quad sys_timer_getoverrun
index 5389df610e78277d0a6329f98a16d3f1f52c27d0..54481af5344ab2c19be4427fa1c576bd17b2a5e7 100644 (file)
@@ -969,25 +969,6 @@ long sys32_kill(int pid, int sig)
        return sys_kill(pid, sig);
 }
  
-extern asmlinkage long
-sys_timer_create(clockid_t which_clock,
-                struct sigevent __user *timer_event_spec,
-                timer_t __user * created_timer_id);
-
-long
-sys32_timer_create(u32 clock, struct compat_sigevent __user *se32, timer_t __user *timer_id)
-{
-       struct sigevent __user *p = NULL;
-       if (se32) { 
-               struct sigevent se;
-               p = compat_alloc_user_space(sizeof(struct sigevent));
-               if (get_compat_sigevent(&se, se32) ||
-                   copy_to_user(p, &se, sizeof(se)))
-                       return -EFAULT;
-       } 
-       return sys_timer_create(clock, p, timer_id);
-} 
-
 long sys32_fadvise64_64(int fd, __u32 offset_low, __u32 offset_high, 
                        __u32 len_low, __u32 len_high, int advice)
 { 
index fe4cbd1c4b2fe2e894e22cb0855467a3e21b5c26..12bc54005e2faa59656ba68b272c1876e48b961f 100644 (file)
@@ -22,6 +22,7 @@ obj-$(CONFIG_X86_LOCAL_APIC)  += apic.o  nmi.o
 obj-$(CONFIG_X86_IO_APIC)      += io_apic.o mpparse.o \
                genapic.o genapic_cluster.o genapic_flat.o
 obj-$(CONFIG_KEXEC)            += machine_kexec.o relocate_kernel.o crash.o
+obj-$(CONFIG_CRASH_DUMP)       += crash_dump.o
 obj-$(CONFIG_PM)               += suspend.o
 obj-$(CONFIG_SOFTWARE_SUSPEND) += suspend_asm.o
 obj-$(CONFIG_CPU_FREQ)         += cpufreq/
index 535e04466079857a09d3f9b0c6649f15f36301e6..4e6c3b729e39793b39c0bcaed3a10e0e1832b0ec 100644 (file)
 #include <linux/types.h>
 #include <linux/kernel.h>
 #include <linux/smp.h>
+#include <linux/irq.h>
 #include <linux/reboot.h>
 #include <linux/kexec.h>
+#include <linux/delay.h>
+#include <linux/elf.h>
+#include <linux/elfcore.h>
 
 #include <asm/processor.h>
 #include <asm/hardirq.h>
 #include <asm/nmi.h>
 #include <asm/hw_irq.h>
+#include <asm/mach_apic.h>
 
-note_buf_t crash_notes[NR_CPUS];
+/* This keeps a track of which one is crashing cpu. */
+static int crashing_cpu;
+
+static u32 *append_elf_note(u32 *buf, char *name, unsigned type,
+                                               void *data, size_t data_len)
+{
+       struct elf_note note;
+
+       note.n_namesz = strlen(name) + 1;
+       note.n_descsz = data_len;
+       note.n_type   = type;
+       memcpy(buf, &note, sizeof(note));
+       buf += (sizeof(note) +3)/4;
+       memcpy(buf, name, note.n_namesz);
+       buf += (note.n_namesz + 3)/4;
+       memcpy(buf, data, note.n_descsz);
+       buf += (note.n_descsz + 3)/4;
+
+       return buf;
+}
+
+static void final_note(u32 *buf)
+{
+       struct elf_note note;
+
+       note.n_namesz = 0;
+       note.n_descsz = 0;
+       note.n_type   = 0;
+       memcpy(buf, &note, sizeof(note));
+}
+
+static void crash_save_this_cpu(struct pt_regs *regs, int cpu)
+{
+       struct elf_prstatus prstatus;
+       u32 *buf;
+
+       if ((cpu < 0) || (cpu >= NR_CPUS))
+               return;
+
+       /* Using ELF notes here is opportunistic.
+        * I need a well defined structure format
+        * for the data I pass, and I need tags
+        * on the data to indicate what information I have
+        * squirrelled away.  ELF notes happen to provide
+        * all of that that no need to invent something new.
+        */
+
+       buf = (u32*)per_cpu_ptr(crash_notes, cpu);
+
+       if (!buf)
+               return;
+
+       memset(&prstatus, 0, sizeof(prstatus));
+       prstatus.pr_pid = current->pid;
+       elf_core_copy_regs(&prstatus.pr_reg, regs);
+       buf = append_elf_note(buf, "CORE", NT_PRSTATUS, &prstatus,
+                                       sizeof(prstatus));
+       final_note(buf);
+}
+
+static void crash_save_self(struct pt_regs *regs)
+{
+       int cpu;
+
+       cpu = smp_processor_id();
+       crash_save_this_cpu(regs, cpu);
+}
+
+#ifdef CONFIG_SMP
+static atomic_t waiting_for_crash_ipi;
+
+static int crash_nmi_callback(struct pt_regs *regs, int cpu)
+{
+       /*
+        * Don't do anything if this handler is invoked on crashing cpu.
+        * Otherwise, system will completely hang. Crashing cpu can get
+        * an NMI if system was initially booted with nmi_watchdog parameter.
+        */
+       if (cpu == crashing_cpu)
+               return 1;
+       local_irq_disable();
+
+       crash_save_this_cpu(regs, cpu);
+       disable_local_APIC();
+       atomic_dec(&waiting_for_crash_ipi);
+       /* Assume hlt works */
+       for(;;)
+               asm("hlt");
+
+       return 1;
+}
+
+static void smp_send_nmi_allbutself(void)
+{
+       send_IPI_allbutself(APIC_DM_NMI);
+}
+
+/*
+ * This code is a best effort heuristic to get the
+ * other cpus to stop executing. So races with
+ * cpu hotplug shouldn't matter.
+ */
+
+static void nmi_shootdown_cpus(void)
+{
+       unsigned long msecs;
+
+       atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1);
+       set_nmi_callback(crash_nmi_callback);
+
+       /*
+        * Ensure the new callback function is set before sending
+        * out the NMI
+        */
+       wmb();
+
+       smp_send_nmi_allbutself();
+
+       msecs = 1000; /* Wait at most a second for the other cpus to stop */
+       while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) {
+               mdelay(1);
+               msecs--;
+       }
+       /* Leave the nmi callback set */
+       disable_local_APIC();
+}
+#else
+static void nmi_shootdown_cpus(void)
+{
+       /* There are no cpus to shootdown */
+}
+#endif
 
 void machine_crash_shutdown(struct pt_regs *regs)
 {
-       /* This function is only called after the system
+       /*
+        * This function is only called after the system
         * has paniced or is otherwise in a critical state.
         * The minimum amount of code to allow a kexec'd kernel
         * to run successfully needs to happen here.
@@ -31,4 +168,19 @@ void machine_crash_shutdown(struct pt_regs *regs)
         * In practice this means shooting down the other cpus in
         * an SMP system.
         */
+       /* The kernel is broken so disable interrupts */
+       local_irq_disable();
+
+       /* Make a note of crashing cpu. Will be used in NMI callback.*/
+       crashing_cpu = smp_processor_id();
+       nmi_shootdown_cpus();
+
+       if(cpu_has_apic)
+                disable_local_APIC();
+
+#if defined(CONFIG_X86_IO_APIC)
+       disable_IO_APIC();
+#endif
+
+       crash_save_self(regs);
 }
similarity index 60%
rename from kernel/crash_dump.c
rename to arch/x86_64/kernel/crash_dump.c
index fccb27dbc623b95405d2a6defaaf38696d2269d5..942deac4d43aa1e2b8eb0e3118933f9b4a140e58 100644 (file)
@@ -5,21 +5,12 @@
  *     Copyright (C) IBM Corporation, 2004. All rights reserved
  */
 
-#include <linux/smp_lock.h>
 #include <linux/errno.h>
-#include <linux/proc_fs.h>
-#include <linux/bootmem.h>
-#include <linux/highmem.h>
 #include <linux/crash_dump.h>
 
-#include <asm/io.h>
 #include <asm/uaccess.h>
-#include <asm/kexec.h>
-
-/* Stores the physical address of elf header of crash image. */
-unsigned long long elfcorehdr_addr = ELFCORE_ADDR_MAX;
+#include <asm/io.h>
 
-#ifndef HAVE_ARCH_COPY_OLDMEM_PAGE
 /**
  * copy_oldmem_page - copy one page from "oldmem"
  * @pfn: page frame number to be copied
@@ -34,31 +25,23 @@ unsigned long long elfcorehdr_addr = ELFCORE_ADDR_MAX;
  * in the current kernel. We stitch up a pte, similar to kmap_atomic.
  */
 ssize_t copy_oldmem_page(unsigned long pfn, char *buf,
-                               size_t csize, unsigned long offset, int userbuf)
+                               size_t csize, unsigned long offset, int userbuf)
 {
-       void *page, *vaddr;
+       void  *vaddr;
 
        if (!csize)
                return 0;
 
-       page = kmalloc(PAGE_SIZE, GFP_KERNEL);
-       if (!page)
-               return -ENOMEM;
-
-       vaddr = kmap_atomic_pfn(pfn, KM_PTE0);
-       copy_page(page, vaddr);
-       kunmap_atomic(vaddr, KM_PTE0);
+       vaddr = ioremap(pfn << PAGE_SHIFT, PAGE_SIZE);
 
        if (userbuf) {
-               if (copy_to_user(buf, (page + offset), csize)) {
-                       kfree(page);
+               if (copy_to_user(buf, (vaddr + offset), csize)) {
+                       iounmap(vaddr);
                        return -EFAULT;
                }
-       } else {
-               memcpy(buf, (page + offset), csize);
-       }
+       } else
+       memcpy(buf, (vaddr + offset), csize);
 
-       kfree(page);
+       iounmap(vaddr);
        return csize;
 }
-#endif
index 17579a1a174bda40da7f3291793ac746b9515cb0..293cd71a266aa221800c6e3246ee768cce5a71cd 100644 (file)
@@ -559,6 +559,27 @@ void __init parse_memopt(char *p, char **from)
        end_user_pfn >>= PAGE_SHIFT;    
 } 
 
+void __init parse_memmapopt(char *p, char **from)
+{
+       unsigned long long start_at, mem_size;
+
+       mem_size = memparse(p, from);
+       p = *from;
+       if (*p == '@') {
+               start_at = memparse(p+1, from);
+               add_memory_region(start_at, mem_size, E820_RAM);
+       } else if (*p == '#') {
+               start_at = memparse(p+1, from);
+               add_memory_region(start_at, mem_size, E820_ACPI);
+       } else if (*p == '$') {
+               start_at = memparse(p+1, from);
+               add_memory_region(start_at, mem_size, E820_RESERVED);
+       } else {
+               end_user_pfn = (mem_size >> PAGE_SHIFT);
+       }
+       p = *from;
+}
+
 unsigned long pci_mem_start = 0xaeedbabe;
 
 /*
index afe11f4fbd1d49d068e7bc3fb64f6d759c342ef1..b7dc1f816d13e616dacced97857994f42000ee47 100644 (file)
@@ -42,8 +42,8 @@
 #include <asm/pgtable.h>
 #include <asm/kdebug.h>
 
-static DECLARE_MUTEX(kprobe_mutex);
 void jprobe_return_end(void);
+static void __kprobes arch_copy_kprobe(struct kprobe *p);
 
 DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;
 DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
@@ -69,12 +69,11 @@ static inline int is_IF_modifier(kprobe_opcode_t *insn)
 int __kprobes arch_prepare_kprobe(struct kprobe *p)
 {
        /* insn: must be on special executable page on x86_64. */
-       down(&kprobe_mutex);
        p->ainsn.insn = get_insn_slot();
-       up(&kprobe_mutex);
        if (!p->ainsn.insn) {
                return -ENOMEM;
        }
+       arch_copy_kprobe(p);
        return 0;
 }
 
@@ -181,7 +180,7 @@ static inline s32 *is_riprel(u8 *insn)
        return NULL;
 }
 
-void __kprobes arch_copy_kprobe(struct kprobe *p)
+static void __kprobes arch_copy_kprobe(struct kprobe *p)
 {
        s32 *ripdisp;
        memcpy(p->ainsn.insn, p->addr, MAX_INSN_SIZE);
index 64c4534b930c74bc118cf1530a812401456f3d4e..a0e0c9ca8f10c2e2321e9aece952ad1a2602975a 100644 (file)
@@ -35,6 +35,7 @@
 #include <asm/processor.h>
 #include <linux/console.h>
 #include <linux/seq_file.h>
+#include <linux/crash_dump.h>
 #include <linux/root_dev.h>
 #include <linux/pci.h>
 #include <linux/acpi.h>
@@ -275,6 +276,7 @@ static __init void parse_cmdline_early (char ** cmdline_p)
 {
        char c = ' ', *to = command_line, *from = COMMAND_LINE;
        int len = 0;
+       int userdef = 0;
 
        /* Save unparsed command line copy for /proc/cmdline */
        memcpy(saved_command_line, COMMAND_LINE, COMMAND_LINE_SIZE);
@@ -357,6 +359,28 @@ static __init void parse_cmdline_early (char ** cmdline_p)
                if (!memcmp(from, "mem=", 4))
                        parse_memopt(from+4, &from); 
 
+               if (!memcmp(from, "memmap=", 7)) {
+                       /* exactmap option is for used defined memory */
+                       if (!memcmp(from+7, "exactmap", 8)) {
+#ifdef CONFIG_CRASH_DUMP
+                               /* If we are doing a crash dump, we
+                                * still need to know the real mem
+                                * size before original memory map is
+                                * reset.
+                                */
+                               saved_max_pfn = e820_end_of_ram();
+#endif
+                               from += 8+7;
+                               end_pfn_map = 0;
+                               e820.nr_map = 0;
+                               userdef = 1;
+                       }
+                       else {
+                               parse_memmapopt(from+7, &from);
+                               userdef = 1;
+                       }
+               }
+
 #ifdef CONFIG_NUMA
                if (!memcmp(from, "numa=", 5))
                        numa_setup(from+5); 
@@ -395,6 +419,14 @@ static __init void parse_cmdline_early (char ** cmdline_p)
                }
 #endif
 
+#ifdef CONFIG_PROC_VMCORE
+               /* elfcorehdr= specifies the location of elf core header
+                * stored by the crashed kernel. This option will be passed
+                * by kexec loader to the capture kernel.
+                */
+               else if(!memcmp(from, "elfcorehdr=", 11))
+                       elfcorehdr_addr = memparse(from+11, &from);
+#endif
        next_char:
                c = *(from++);
                if (!c)
@@ -403,6 +435,10 @@ static __init void parse_cmdline_early (char ** cmdline_p)
                        break;
                *(to++) = c;
        }
+       if (userdef) {
+               printk(KERN_INFO "user-defined physical RAM map:\n");
+               e820_print_map("user");
+       }
        *to = '\0';
        *cmdline_p = command_line;
 }
index 4a54221e10bc39a0371c35090fe4de72f472a70e..b7fd6681c629f24de029938715ae32fa9bbe1495 100644 (file)
@@ -13,7 +13,6 @@
 #include <linux/string.h>
 #include <linux/syscalls.h>
 #include <linux/tty.h>
-#include <linux/ioctl32.h>
 
 #include <asm/semaphore.h>
 #include <asm/processor.h>
index 7e841aa2a4aa1259ea9e7367d40f84fd617a5822..7ee4a14ec3b1949d38766b4247bf71d2f2f14159 100644 (file)
@@ -18,10 +18,6 @@ config XTENSA
          with reasonable minimum requirements.  The Xtensa Linux project has
          a home page at <http://xtensa.sourceforge.net/>.
 
-config UID16
-       bool
-       default n
-
 config RWSEM_XCHGADD_ALGORITHM
        bool
        default y
index fd8059920dbfde1a91a472d63480d0293b88236b..6b355bd7816d8fcffea570047396eb28323f6771 100644 (file)
@@ -161,8 +161,8 @@ static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
        return count;
 }
 
-/**
- *     device_subsys - structure to be registered with kobject core.
+/*
+ *     devices_subsys - structure to be registered with kobject core.
  */
 
 decl_subsys(devices, &ktype_device, &device_uevent_ops);
index 281d26784d251107bc6b158ba3ce5f5904a157fd..07a7f97e1de9d95a488f9fea90288052786f6e98 100644 (file)
@@ -83,6 +83,31 @@ static inline void register_cpu_control(struct cpu *cpu)
 }
 #endif /* CONFIG_HOTPLUG_CPU */
 
+#ifdef CONFIG_KEXEC
+#include <linux/kexec.h>
+
+static ssize_t show_crash_notes(struct sys_device *dev, char *buf)
+{
+       struct cpu *cpu = container_of(dev, struct cpu, sysdev);
+       ssize_t rc;
+       unsigned long long addr;
+       int cpunum;
+
+       cpunum = cpu->sysdev.id;
+
+       /*
+        * Might be reading other cpu's data based on which cpu read thread
+        * has been scheduled. But cpu data (memory) is allocated once during
+        * boot up and this data does not change there after. Hence this
+        * operation should be safe. No locking required.
+        */
+       addr = __pa(per_cpu_ptr(crash_notes, cpunum));
+       rc = sprintf(buf, "%Lx\n", addr);
+       return rc;
+}
+static SYSDEV_ATTR(crash_notes, 0400, show_crash_notes, NULL);
+#endif
+
 /*
  * register_cpu - Setup a driverfs device for a CPU.
  * @cpu - Callers can set the cpu->no_control field to 1, to indicate not to
@@ -108,6 +133,11 @@ int __devinit register_cpu(struct cpu *cpu, int num, struct node *root)
                register_cpu_control(cpu);
        if (!error)
                cpu_sys_devices[num] = &cpu->sysdev;
+
+#ifdef CONFIG_KEXEC
+       if (!error)
+               error = sysdev_create_file(&cpu->sysdev, &attr_crash_notes);
+#endif
        return error;
 }
 
index 573ff6c1be5f6080362407f17f0785729317025c..613673b12fa6711cb8b749c8aea03cc0fc1c7b01 100644 (file)
@@ -279,6 +279,7 @@ static int hci_uart_tty_open(struct tty_struct *tty)
 
        tty->disc_data = hu;
        hu->tty = tty;
+       tty->receive_room = 65536;
 
        spin_lock_init(&hu->rx_lock);
 
@@ -348,20 +349,6 @@ static void hci_uart_tty_wakeup(struct tty_struct *tty)
                hci_uart_tx_wakeup(hu);
 }
 
-/* hci_uart_tty_room()
- * 
- *    Callback function from tty driver. Return the amount of 
- *    space left in the receiver's buffer to decide if remote
- *    transmitter is to be throttled.
- *
- * Arguments:        tty    pointer to associated tty instance data
- * Return Value:    number of bytes left in receive buffer
- */
-static int hci_uart_tty_room (struct tty_struct *tty)
-{
-       return 65536;
-}
-
 /* hci_uart_tty_receive()
  * 
  *     Called by tty low level driver when receive data is
@@ -544,7 +531,6 @@ static int __init hci_uart_init(void)
        hci_uart_ldisc.write            = hci_uart_tty_write;
        hci_uart_ldisc.ioctl            = hci_uart_tty_ioctl;
        hci_uart_ldisc.poll             = hci_uart_tty_poll;
-       hci_uart_ldisc.receive_room     = hci_uart_tty_room;
        hci_uart_ldisc.receive_buf      = hci_uart_tty_receive;
        hci_uart_ldisc.write_wakeup     = hci_uart_tty_wakeup;
        hci_uart_ldisc.owner            = THIS_MODULE;
index dd7e6901c575b8d0d36dc22b17a820371ed95ec8..d6fcd0a36f9f2239ef025728e7c4ee9e67331af1 100644 (file)
@@ -80,7 +80,7 @@ config SERIAL_NONSTANDARD
 
 config COMPUTONE
        tristate "Computone IntelliPort Plus serial support"
-       depends on SERIAL_NONSTANDARD && BROKEN_ON_SMP
+       depends on SERIAL_NONSTANDARD
        ---help---
          This driver supports the entire family of Intelliport II/Plus
          controllers with the exception of the MicroChannel controllers and
@@ -153,7 +153,7 @@ config DIGIEPCA
 
 config ESPSERIAL
        tristate "Hayes ESP serial port support"
-       depends on SERIAL_NONSTANDARD && ISA && BROKEN_ON_SMP && ISA_DMA_API
+       depends on SERIAL_NONSTANDARD && ISA && ISA_DMA_API
        help
          This is a driver which supports Hayes ESP serial ports.  Both single
          port cards and multiport cards are supported.  Make sure to read
@@ -166,7 +166,7 @@ config ESPSERIAL
 
 config MOXA_INTELLIO
        tristate "Moxa Intellio support"
-       depends on SERIAL_NONSTANDARD && BROKEN_ON_SMP
+       depends on SERIAL_NONSTANDARD
        help
          Say Y here if you have a Moxa Intellio multiport serial card.
 
@@ -290,7 +290,7 @@ config SX
 
 config RIO
        tristate "Specialix RIO system support"
-       depends on SERIAL_NONSTANDARD && BROKEN_ON_SMP
+       depends on SERIAL_NONSTANDARD && BROKEN_ON_SMP && !64BIT
        help
          This is a driver for the Specialix RIO, a smart serial card which
          drives an outboard box that can support up to 128 ports.  Product
@@ -936,6 +936,15 @@ config SCx200_GPIO
 
          If compiled as a module, it will be called scx200_gpio.
 
+config CS5535_GPIO
+       tristate "AMD CS5535/CS5536 GPIO (Geode Companion Device)"
+       depends on X86_32
+       help
+         Give userspace access to the GPIO pins on the AMD CS5535 and
+         CS5536 Geode companion devices.
+
+         If compiled as a module, it will be called cs5535_gpio.
+
 config GPIO_VR41XX
        tristate "NEC VR4100 series General-purpose I/O Unit support"
        depends on CPU_VR41XX
index d973d14d8f7fc998ab88fee69365289f5264502e..503dd901d406bad8e432ce267642926ce325e9c3 100644 (file)
@@ -81,6 +81,7 @@ obj-$(CONFIG_PPDEV) += ppdev.o
 obj-$(CONFIG_NWBUTTON) += nwbutton.o
 obj-$(CONFIG_NWFLASH) += nwflash.o
 obj-$(CONFIG_SCx200_GPIO) += scx200_gpio.o
+obj-$(CONFIG_CS5535_GPIO) += cs5535_gpio.o
 obj-$(CONFIG_GPIO_VR41XX) += vr41xx_giu.o
 obj-$(CONFIG_TANBAC_TB0219) += tb0219.o
 obj-$(CONFIG_TELCLOCK) += tlclk.o
index a124f8c5d062dd65b29775881f9b9c55a0d95a14..869518e4035fab624464b646807980415afa5dc5 100644 (file)
@@ -116,7 +116,7 @@ static void rs_wait_until_sent(struct tty_struct *tty, int timeout);
 
 static struct serial_state rs_table[1];
 
-#define NR_PORTS       (sizeof(rs_table)/sizeof(struct serial_state))
+#define NR_PORTS ARRAY_SIZE(rs_table)
 
 /*
  * tmp_buf is used as a temporary buffer by serial_write.  We need to
@@ -265,8 +265,9 @@ static _INLINE_ void receive_chars(struct async_struct *info)
         int status;
        int serdatr;
        struct tty_struct *tty = info->tty;
-       unsigned char ch;
+       unsigned char ch, flag;
        struct  async_icount *icount;
+       int oe = 0;
 
        icount = &info->state->icount;
 
@@ -282,15 +283,12 @@ static _INLINE_ void receive_chars(struct async_struct *info)
            status |= UART_LSR_OE;
 
        ch = serdatr & 0xff;
-       if (tty->flip.count >= TTY_FLIPBUF_SIZE)
-         goto ignore_char;
-       *tty->flip.char_buf_ptr = ch;
        icount->rx++;
 
 #ifdef SERIAL_DEBUG_INTR
        printk("DR%02x:%02x...", ch, status);
 #endif
-       *tty->flip.flag_buf_ptr = 0;
+       flag = TTY_NORMAL;
 
        /*
         * We don't handle parity or frame errors - but I have left
@@ -319,7 +317,7 @@ static _INLINE_ void receive_chars(struct async_struct *info)
           * should be ignored.
           */
          if (status & info->ignore_status_mask)
-           goto ignore_char;
+           goto out;
 
          status &= info->read_status_mask;
 
@@ -327,33 +325,28 @@ static _INLINE_ void receive_chars(struct async_struct *info)
 #ifdef SERIAL_DEBUG_INTR
            printk("handling break....");
 #endif
-           *tty->flip.flag_buf_ptr = TTY_BREAK;
+           flag = TTY_BREAK;
            if (info->flags & ASYNC_SAK)
              do_SAK(tty);
          } else if (status & UART_LSR_PE)
-           *tty->flip.flag_buf_ptr = TTY_PARITY;
+           flag = TTY_PARITY;
          else if (status & UART_LSR_FE)
-           *tty->flip.flag_buf_ptr = TTY_FRAME;
+           flag = TTY_FRAME;
          if (status & UART_LSR_OE) {
            /*
             * Overrun is special, since it's
             * reported immediately, and doesn't
             * affect the current character
             */
-           if (tty->flip.count < TTY_FLIPBUF_SIZE) {
-             tty->flip.count++;
-             tty->flip.flag_buf_ptr++;
-             tty->flip.char_buf_ptr++;
-             *tty->flip.flag_buf_ptr = TTY_OVERRUN;
-           }
+            oe = 1;
          }
        }
-       tty->flip.flag_buf_ptr++;
-       tty->flip.char_buf_ptr++;
-       tty->flip.count++;
- ignore_char:
-
+       tty_insert_flip_char(tty, ch, flag);
+       if (oe == 1)
+               tty_insert_flip_char(tty, 0, TTY_OVERRUN);
        tty_flip_buffer_push(tty);
+out:
+       return;
 }
 
 static _INLINE_ void transmit_chars(struct async_struct *info)
diff --git a/drivers/char/cs5535_gpio.c b/drivers/char/cs5535_gpio.c
new file mode 100644 (file)
index 0000000..5d72f50
--- /dev/null
@@ -0,0 +1,250 @@
+/*
+ * AMD CS5535/CS5536 GPIO driver.
+ * Allows a user space process to play with the GPIO pins.
+ *
+ * Copyright (c) 2005 Ben Gardner <bgardner@wabtec.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the smems of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ */
+
+#include <linux/fs.h>
+#include <linux/module.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/cdev.h>
+#include <linux/ioport.h>
+#include <linux/pci.h>
+#include <asm/uaccess.h>
+#include <asm/io.h>
+
+
+#define NAME                   "cs5535_gpio"
+
+MODULE_AUTHOR("Ben Gardner <bgardner@wabtec.com>");
+MODULE_DESCRIPTION("AMD CS5535/CS5536 GPIO Pin Driver");
+MODULE_LICENSE("GPL");
+
+static int major;
+module_param(major, int, 0);
+MODULE_PARM_DESC(major, "Major device number");
+
+static ulong mask;
+module_param(mask, ulong, 0);
+MODULE_PARM_DESC(mask, "GPIO channel mask");
+
+#define MSR_LBAR_GPIO          0x5140000C
+
+static u32 gpio_base;
+
+static struct pci_device_id divil_pci[] = {
+       { PCI_DEVICE(PCI_VENDOR_ID_NS,  PCI_DEVICE_ID_NS_CS5535_ISA) },
+       { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA) },
+       { } /* NULL entry */
+};
+
+static struct cdev cs5535_gpio_cdev;
+
+/* reserve 32 entries even though some aren't usable */
+#define CS5535_GPIO_COUNT      32
+
+/* IO block size */
+#define CS5535_GPIO_SIZE       256
+
+struct gpio_regmap {
+       u32     rd_offset;
+       u32     wr_offset;
+       char    on;
+       char    off;
+};
+static struct gpio_regmap rm[] =
+{
+       { 0x30, 0x00, '1', '0' },       /* GPIOx_READ_BACK / GPIOx_OUT_VAL */
+       { 0x20, 0x20, 'I', 'i' },       /* GPIOx_IN_EN */
+       { 0x04, 0x04, 'O', 'o' },       /* GPIOx_OUT_EN */
+       { 0x08, 0x08, 't', 'T' },       /* GPIOx_OUT_OD_EN */
+       { 0x18, 0x18, 'P', 'p' },       /* GPIOx_OUT_PU_EN */
+       { 0x1c, 0x1c, 'D', 'd' },       /* GPIOx_OUT_PD_EN */
+};
+
+
+/**
+ * Gets the register offset for the GPIO bank.
+ * Low (0-15) starts at 0x00, high (16-31) starts at 0x80
+ */
+static inline u32 cs5535_lowhigh_base(int reg)
+{
+       return (reg & 0x10) << 3;
+}
+
+static ssize_t cs5535_gpio_write(struct file *file, const char __user *data,
+                                size_t len, loff_t *ppos)
+{
+       u32     m = iminor(file->f_dentry->d_inode);
+       int     i, j;
+       u32     base = gpio_base + cs5535_lowhigh_base(m);
+       u32     m0, m1;
+       char    c;
+
+       /**
+        * Creates the mask for atomic bit programming.
+        * The high 16 bits and the low 16 bits are used to set the mask.
+        * For example, GPIO 15 maps to 31,15: 0,1 => On; 1,0=> Off
+        */
+       m1 = 1 << (m & 0x0F);
+       m0 = m1 << 16;
+
+       for (i = 0; i < len; ++i) {
+               if (get_user(c, data+i))
+                       return -EFAULT;
+
+               for (j = 0; j < ARRAY_SIZE(rm); j++) {
+                       if (c == rm[j].on) {
+                               outl(m1, base + rm[j].wr_offset);
+                               break;
+                       } else if (c == rm[j].off) {
+                               outl(m0, base + rm[j].wr_offset);
+                               break;
+                       }
+               }
+       }
+       *ppos = 0;
+       return len;
+}
+
+static ssize_t cs5535_gpio_read(struct file *file, char __user *buf,
+                               size_t len, loff_t *ppos)
+{
+       u32     m = iminor(file->f_dentry->d_inode);
+       u32     base = gpio_base + cs5535_lowhigh_base(m);
+       int     rd_bit = 1 << (m & 0x0f);
+       int     i;
+       char    ch;
+       ssize_t count = 0;
+
+       if (*ppos >= ARRAY_SIZE(rm))
+               return 0;
+
+       for (i = *ppos; (i < (*ppos + len)) && (i < ARRAY_SIZE(rm)); i++) {
+               ch = (inl(base + rm[i].rd_offset) & rd_bit) ?
+                    rm[i].on : rm[i].off;
+
+               if (put_user(ch, buf+count))
+                       return -EFAULT;
+
+               count++;
+       }
+
+       /* add a line-feed if there is room */
+       if ((i == ARRAY_SIZE(rm)) && (count < len)) {
+               put_user('\n', buf + count);
+               count++;
+       }
+
+       *ppos += count;
+       return count;
+}
+
+static int cs5535_gpio_open(struct inode *inode, struct file *file)
+{
+       u32 m = iminor(inode);
+
+       /* the mask says which pins are usable by this driver */
+       if ((mask & (1 << m)) == 0)
+               return -EINVAL;
+
+       return nonseekable_open(inode, file);
+}
+
+static struct file_operations cs5535_gpio_fops = {
+       .owner  = THIS_MODULE,
+       .write  = cs5535_gpio_write,
+       .read   = cs5535_gpio_read,
+       .open   = cs5535_gpio_open
+};
+
+static int __init cs5535_gpio_init(void)
+{
+       dev_t   dev_id;
+       u32     low, hi;
+       int     retval;
+
+       if (pci_dev_present(divil_pci) == 0) {
+               printk(KERN_WARNING NAME ": DIVIL not found\n");
+               return -ENODEV;
+       }
+
+       /* Grab the GPIO I/O range */
+       rdmsr(MSR_LBAR_GPIO, low, hi);
+
+       /* Check the mask and whether GPIO is enabled (sanity check) */
+       if (hi != 0x0000f001) {
+               printk(KERN_WARNING NAME ": GPIO not enabled\n");
+               return -ENODEV;
+       }
+
+       /* Mask off the IO base address */
+       gpio_base = low & 0x0000ff00;
+
+       /**
+        * Some GPIO pins
+        *  31-29,23 : reserved (always mask out)
+        *  28       : Power Button
+        *  26       : PME#
+        *  22-16    : LPC
+        *  14,15    : SMBus
+        *  9,8      : UART1
+        *  7        : PCI INTB
+        *  3,4      : UART2/DDC
+        *  2        : IDE_IRQ0
+        *  0        : PCI INTA
+        *
+        * If a mask was not specified, be conservative and only allow:
+        *  1,2,5,6,10-13,24,25,27
+        */
+       if (mask != 0)
+               mask &= 0x1f7fffff;
+       else
+               mask = 0x0b003c66;
+
+       if (request_region(gpio_base, CS5535_GPIO_SIZE, NAME) == 0) {
+               printk(KERN_ERR NAME ": can't allocate I/O for GPIO\n");
+               return -ENODEV;
+       }
+
+       if (major) {
+               dev_id = MKDEV(major, 0);
+               retval = register_chrdev_region(dev_id, CS5535_GPIO_COUNT,
+                                               NAME);
+       } else {
+               retval = alloc_chrdev_region(&dev_id, 0, CS5535_GPIO_COUNT,
+                                            NAME);
+               major = MAJOR(dev_id);
+       }
+
+       if (retval) {
+               release_region(gpio_base, CS5535_GPIO_SIZE);
+               return -1;
+       }
+
+       printk(KERN_DEBUG NAME ": base=%#x mask=%#lx major=%d\n",
+              gpio_base, mask, major);
+
+       cdev_init(&cs5535_gpio_cdev, &cs5535_gpio_fops);
+       cdev_add(&cs5535_gpio_cdev, dev_id, CS5535_GPIO_COUNT);
+
+       return 0;
+}
+
+static void __exit cs5535_gpio_cleanup(void)
+{
+       dev_t dev_id = MKDEV(major, 0);
+       unregister_chrdev_region(dev_id, CS5535_GPIO_COUNT);
+       if (gpio_base != 0)
+               release_region(gpio_base, CS5535_GPIO_SIZE);
+}
+
+module_init(cs5535_gpio_init);
+module_exit(cs5535_gpio_cleanup);
index c7f818cd7b0214b321d9c6d5d7e3b5bf4c34ef03..39c61a71176e0f0eec82a7cb432dba91cd965fdb 100644 (file)
@@ -641,6 +641,7 @@ static char rcsid[] =
 #include <linux/timer.h>
 #include <linux/interrupt.h>
 #include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/serial.h>
 #include <linux/major.h>
 #include <linux/string.h>
@@ -723,7 +724,7 @@ static unsigned int cy_isa_addresses[] = {
         0xDE000,
         0,0,0,0,0,0,0,0
 };
-#define NR_ISA_ADDRS (sizeof(cy_isa_addresses)/sizeof(unsigned char*))
+#define NR_ISA_ADDRS ARRAY_SIZE(cy_isa_addresses)
 
 #ifdef MODULE
 static long maddr[NR_CARDS] = { 0, };
@@ -1086,7 +1087,7 @@ cyy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
   int had_work;
   int mdm_change;
   int mdm_status;
-
+  int len;
     if((cinfo = (struct cyclades_card *)dev_id) == 0){
 #ifdef CY_DEBUG_INTERRUPTS
        printk("cyy_interrupt: spurious interrupt %d\n\r", irq);
@@ -1163,63 +1164,43 @@ cyy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                                info->icount.rx++;
                                 continue;
                             }
-                            if (tty->flip.count < TTY_FLIPBUF_SIZE){
-                                tty->flip.count++;
+                            if (tty_buffer_request_room(tty, 1)) {
                                 if (data & info->read_status_mask){
                                     if(data & CyBREAK){
-                                        *tty->flip.flag_buf_ptr++ =
-                                                           TTY_BREAK;
-                                        *tty->flip.char_buf_ptr++ =
-                                         cy_readb(base_addr+(CyRDSR<<index));
+                                        tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_BREAK);
                                        info->icount.rx++;
                                         if (info->flags & ASYNC_SAK){
                                             do_SAK(tty);
                                         }
                                     }else if(data & CyFRAME){
-                                        *tty->flip.flag_buf_ptr++ =
-                                                           TTY_FRAME;
-                                        *tty->flip.char_buf_ptr++ =
-                                         cy_readb(base_addr+(CyRDSR<<index));
+                                        tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_FRAME);
                                        info->icount.rx++;
                                        info->idle_stats.frame_errs++;
                                     }else if(data & CyPARITY){
-                                        *tty->flip.flag_buf_ptr++ =
-                                                           TTY_PARITY;
-                                        *tty->flip.char_buf_ptr++ =
-                                         cy_readb(base_addr+(CyRDSR<<index));
+                                       /* Pieces of seven... */
+                                        tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_PARITY);
                                        info->icount.rx++;
                                        info->idle_stats.parity_errs++;
                                     }else if(data & CyOVERRUN){
-                                        *tty->flip.flag_buf_ptr++ =
-                                                           TTY_OVERRUN;
-                                        *tty->flip.char_buf_ptr++ = 0;
+                                        tty_insert_flip_char(tty, 0, TTY_OVERRUN);
                                        info->icount.rx++;
                                         /* If the flip buffer itself is
                                            overflowing, we still lose
                                            the next incoming character.
                                          */
-                                        if(tty->flip.count
-                                                  < TTY_FLIPBUF_SIZE){
-                                            tty->flip.count++;
-                                            *tty->flip.flag_buf_ptr++ =
-                                                            TTY_NORMAL;
-                                           *tty->flip.char_buf_ptr++ =
-                                           cy_readb(base_addr+(CyRDSR<<index));
-                                           info->icount.rx++;
-                                        }
+                                        tty_insert_flip_char(tty, cy_readb(base_addr+(CyRDSR<<index)), TTY_FRAME);
+                                       info->icount.rx++;
                                        info->idle_stats.overruns++;
                                     /* These two conditions may imply */
                                     /* a normal read should be done. */
                                     /* }else if(data & CyTIMEOUT){ */
                                     /* }else if(data & CySPECHAR){ */
-                                    }else{
-                                        *tty->flip.flag_buf_ptr++ = 0;
-                                        *tty->flip.char_buf_ptr++ = 0;
-                                       info->icount.rx++;
+               &