Import 1.1.67

Makefile

 VERSION = 1
 PATCHLEVEL = 1
-SUBLEVEL = 66
+SUBLEVEL = 67
 
 ARCH = i386
 

arch/alpha/Makefile

+#
+# alpha/Makefile
+#
+# 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) 1994 by Linus Torvalds
+#
+
+AS      =as
+LD      =ld
+HOSTCC  =gcc -I$(TOPDIR)/include
+CC      =gcc -D__KERNEL__ -I$(TOPDIR)/include
+MAKE    =make
+CPP     =$(CC) -E
+AR      =ar
+STRIP   =strip
+
+zBoot/zSystem: zBoot/*.c zBoot/*.S tools/zSystem
+	$(MAKE) -C zBoot
+
+zImage: $(CONFIGURE) boot/bootsect boot/setup zBoot/zSystem tools/build
+	tools/build boot/bootsect boot/setup zBoot/zSystem $(ROOT_DEV) > zImage
+	sync
+
+zdisk: zImage
+	dd bs=8192 if=zImage of=/dev/fd0
+
+zlilo: $(CONFIGURE) zImage
+	if [ -f $(INSTALL_PATH)/vmlinuz ]; then mv $(INSTALL_PATH)/vmlinuz $(INSTALL_PATH)/vmlinuz.old; fi
+	if [ -f $(INSTALL_PATH)/zSystem.map ]; then mv $(INSTALL_PATH)/zSystem.map $(INSTALL_PATH)/zSystem.old; fi
+	cat zImage > $(INSTALL_PATH)/vmlinuz
+	cp zSystem.map $(INSTALL_PATH)/
+	if [ -x /sbin/lilo ]; then /sbin/lilo; else /etc/lilo/install; fi
+
+tools/system:	boot/head.o init/main.o tools/version.o linuxsubdirs
+	$(LD) $(LOWLDFLAGS) boot/head.o init/main.o tools/version.o \
+		$(ARCHIVES) \
+		$(FILESYSTEMS) \
+		$(DRIVERS) \
+		$(LIBS) \
+		-o tools/system
+		nm tools/zSystem | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)' | \
+		sort > System.map
+
+boot/setup.o: boot/setup.s
+	$(AS) -o $@ $<
+
+boot/setup.s: boot/setup.S $(CONFIGURE) include/linux/config.h Makefile
+	$(CPP) -traditional $(SVGA_MODE) $(RAMDISK) $< -o $@
+
+boot/bootsect.s: boot/bootsect.S $(CONFIGURE) include/linux/config.h Makefile
+	$(CPP) -traditional $(SVGA_MODE) $(RAMDISK) $< -o $@
+
+tools/zSystem:	boot/head.o init/main.o tools/version.o linuxsubdirs
+	$(LD) $(HIGHLDFLAGS) boot/head.o init/main.o tools/version.o \
+		$(ARCHIVES) \
+		$(FILESYSTEMS) \
+		$(DRIVERS) \
+		$(LIBS) \
+		-o tools/zSystem
+	nm tools/zSystem | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)' | \
+		sort > zSystem.map
+
+#
+# Leave these dummy entries for now to tell people that they are going away..
+#
+lilo:
+	@echo
+	@echo Uncompressed kernel images no longer supported. Use
+	@echo \"make zlilo\" instead.
+	@echo
+	@exit 1
+
+archclean:
+	rm -f boot/bootsect boot/setup

arch/alpha/boot/head.S

+/*
+ * alpha/head.S
+ *
+ * initial boot stuff..
+ */
+
+#include <asm/system.h>
+
+#define halt .long PAL_halt
+
+/*
+ * NOTE! The console bootstrap will load us at 0x20000000, but this image
+ * is linked to run at START_ADDR, so the first thing we do is to move
+ * ourself up to the right address.. We'd better be position-independent
+ * at that stage :-)
+ */
+	.set noreorder
+	.globl	__start
+	.ent	__start
+__start:
+	bis	$31,$31,$31
+	br	$1,$200
+	.long START_ADDR, START_ADDR >> 32	/* strange bug in the assembler.. duh */
+	.long START_SIZE, START_SIZE >> 32
+$200:	ldq	$30,0($1)		/* new stack - below this */
+	lda	$2,-8($1)		/* __start */
+	bis	$30,$30,$3		/* new address */
+	subq	$3,$2,$6		/* difference */
+	ldq	$4,8($1)		/* size */
+$201:	subq	$4,8,$4
+	ldq	$5,0($2)
+	addq	$2,8,$2
+	stq	$5,0($3)
+	addq	$3,8,$3
+	bne	$4,$201
+	br	$1,$202
+$202:	addq	$1,$6,$1
+	addq	$1,12,$1		/* $203 in the new address space */
+	jmp	$31,($1),$203
+$203:	br	$27,$100
+$100:	ldgp	$29,0($27)
+	lda	$27,start_kernel
+	jsr	$26,($27),start_kernel
+	halt
+	.end __start
+
+	.align 5
+	.globl	wrent
+	.ent	wrent
+wrent:
+	.long PAL_wrent
+	ret ($26)
+	.end wrent
+
+	.align 5
+	.globl	wrkgp
+	.ent	wrkgp
+wrkgp:
+	.long PAL_wrkgp
+	ret ($26)
+	.end wrkgp
+
+	.align 5
+	.globl	switch_to_osf_pal
+	.ent	switch_to_osf_pal
+switch_to_osf_pal:
+	subq	$30,128,$30
+	stq	$26,0($30)
+	stq	$1,8($30)
+	stq	$2,16($30)
+	stq	$3,24($30)
+	stq	$4,32($30)
+	stq	$5,40($30)
+	stq	$6,48($30)
+	stq	$7,56($30)
+	stq	$8,64($30)
+	stq	$9,72($30)
+	stq	$10,80($30)
+	stq	$11,88($30)
+	stq	$12,96($30)
+	stq	$13,104($30)
+	stq	$14,112($30)
+	stq	$15,120($30)
+
+	stq	$30,0($17)	/* save KSP in PCB */
+
+	bis	$30,$30,$20	/* a4 = KSP */
+	br	$17,__do_swppal
+
+	ldq	$26,0($30)
+	ldq	$1,8($30)
+	ldq	$2,16($30)
+	ldq	$3,24($30)
+	ldq	$4,32($30)
+	ldq	$5,40($30)
+	ldq	$6,48($30)
+	ldq	$7,56($30)
+	ldq	$8,64($30)
+	ldq	$9,72($30)
+	ldq	$10,80($30)
+	ldq	$11,88($30)
+	ldq	$12,96($30)
+	ldq	$13,104($30)
+	ldq	$14,112($30)
+	ldq	$15,120($30)
+	addq	$30,128,$30
+	ret ($26)
+
+__do_swppal:
+	.long	PAL_swppal
+	.end	switch_to_osf_pal

arch/alpha/config.in

+#
+# For a description of the syntax of this configuration file,
+# see the Configure script.
+#
+
+comment 'General setup'
+
+bool 'Normal harddisk support' CONFIG_BLK_DEV_HD n
+bool 'XT harddisk support' CONFIG_BLK_DEV_XD n
+bool 'Networking support' CONFIG_NET y
+bool 'System V IPC' CONFIG_SYSVIPC y
+bool 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF y
+
+if [ "$CONFIG_NET" = "y" ]; then
+comment 'Networking options'
+bool 'TCP/IP networking' CONFIG_INET y
+if [ "$CONFIG_INET" "=" "y" ]; then
+bool 'IP forwarding/gatewaying' CONFIG_IP_FORWARD n
+comment '(it is safe to leave these untouched)'
+bool 'PC/TCP compatibility mode' CONFIG_INET_PCTCP n
+bool 'Reverse ARP' CONFIG_INET_RARP n
+bool 'Assume subnets are local' CONFIG_INET_SNARL y
+bool 'Disable NAGLE algorithm (normally enabled)' CONFIG_TCP_NAGLE_OFF n
+fi
+bool 'The IPX protocol' CONFIG_IPX n
+#bool 'Amateur Radio AX.25 Level 2' CONFIG_AX25 n
+fi
+
+comment 'SCSI support'
+
+bool 'SCSI support?' CONFIG_SCSI y
+
+if [ "$CONFIG_SCSI" = "n" ]; then
+
+comment 'Skipping SCSI configuration options...'
+
+else
+
+comment 'SCSI support type (disk, tape, CDrom)'
+
+bool 'Scsi disk support' CONFIG_BLK_DEV_SD y
+bool 'Scsi tape support' CONFIG_CHR_DEV_ST n
+bool 'Scsi CDROM support' CONFIG_BLK_DEV_SR n
+bool 'Scsi generic support' CONFIG_CHR_DEV_SG n
+
+comment 'SCSI low-level drivers'
+
+bool 'Adaptec AHA152X support' CONFIG_SCSI_AHA152X n
+bool 'Adaptec AHA1542 support' CONFIG_SCSI_AHA1542 n
+bool 'Adaptec AHA1740 support' CONFIG_SCSI_AHA1740 y
+bool 'Adaptec AHA274X/284X support' CONFIG_SCSI_AHA274X n
+bool 'BusLogic SCSI support' CONFIG_SCSI_BUSLOGIC n
+bool 'UltraStor 14F/34F support' CONFIG_SCSI_U14_34F n
+bool 'Future Domain 16xx SCSI support' CONFIG_SCSI_FUTURE_DOMAIN n
+bool 'Generic NCR5380 SCSI support' CONFIG_SCSI_GENERIC_NCR5380 n
+bool 'NCR53c7,8xx SCSI support'  CONFIG_SCSI_NCR53C7xx n
+bool 'Always IN2000 SCSI support' CONFIG_SCSI_IN2000 n
+bool 'PAS16 SCSI support' CONFIG_SCSI_PAS16 n
+bool 'QLOGIC SCSI support' CONFIG_SCSI_QLOGIC n
+bool 'Seagate ST-02 and Future Domain TMC-8xx SCSI support' CONFIG_SCSI_SEAGATE n
+bool 'Trantor T128/T128F/T228 SCSI support' CONFIG_SCSI_T128 n
+bool 'UltraStor SCSI support' CONFIG_SCSI_ULTRASTOR n
+bool '7000FASST SCSI support' CONFIG_SCSI_7000FASST n
+bool 'EISA EATA support' CONFIG_SCSI_EATA n
+#bool 'SCSI debugging host adapter' CONFIG_SCSI_DEBUG n
+fi
+
+
+if [ "$CONFIG_NET" = "y" ]; then
+
+comment 'Network device support'
+
+bool 'Network device support?' CONFIG_NETDEVICES y
+if [ "$CONFIG_NETDEVICES" = "n" ]; then
+
+comment 'Skipping network driver configuration options...'
+
+else
+bool 'Dummy net driver support' CONFIG_DUMMY n
+bool 'SLIP (serial line) support' CONFIG_SLIP n
+if [ "$CONFIG_SLIP" = "y" ]; then
+  bool ' CSLIP compressed headers' SL_COMPRESSED y
+#  bool ' SLIP debugging on' SL_DUMP y
+fi
+bool 'PPP (point-to-point) support' CONFIG_PPP n
+bool 'PLIP (parallel port) support' CONFIG_PLIP n
+bool 'Load balancing support (experimental)' CONFIG_SLAVE_BALANCING n
+bool 'Do you want to be offered ALPHA test drivers' CONFIG_NET_ALPHA n
+bool 'Western Digital/SMC cards' CONFIG_NET_VENDOR_SMC n
+if [ "$CONFIG_NET_VENDOR_SMC" = "y" ]; then
+	bool 'WD80*3 support' CONFIG_WD80x3 n
+	bool 'SMC Ultra support' CONFIG_ULTRA n
+fi
+bool '3COM cards' CONFIG_NET_VENDOR_3COM n
+if [ "$CONFIG_NET_VENDOR_3COM" = "y" ]; then
+	bool '3c501 support' CONFIG_EL1 n
+	bool '3c503 support' CONFIG_EL2 n
+	if [ "$CONFIG_NET_ALPHA" = "y" ]; then
+		bool '3c505 support' CONFIG_ELPLUS n
+		bool '3c507 support' CONFIG_EL16 n
+	fi
+	bool '3c509/3c579 support' CONFIG_EL3 y
+fi
+bool 'Other ISA cards' CONFIG_NET_ISA y
+if [ "$CONFIG_NET_ISA" = "y" ]; then
+	bool 'AT1500 and NE2100 (LANCE and PCnet-ISA) support' CONFIG_LANCE n
+	bool 'Cabletron E21xx support (not recommended)' CONFIG_E2100 n
+	bool 'DEPCA support' CONFIG_DEPCA y
+	bool 'EtherWorks 3 support' CONFIG_EWRK3 n
+	if [ "$CONFIG_NET_ALPHA" = "y" ]; then
+		bool 'EtherExpress support' CONFIG_EEXPRESS n
+		bool 'AT1700 support' CONFIG_AT1700 n
+		bool 'NI5210 support' CONFIG_NI52 n
+		bool 'NI6510 support' CONFIG_NI65 n
+	fi
+	bool 'HP PCLAN support' CONFIG_HPLAN n
+	bool 'HP PCLAN PLUS support' CONFIG_HPLAN_PLUS n
+	bool 'NE2000/NE1000 support' CONFIG_NE2000 n
+	bool 'SK_G16 support' CONFIG_SK_G16 n
+fi
+bool 'EISA and on board controllers' CONFIG_NET_EISA n
+	if [ "$CONFIG_NET_ALPHA" = "y" ]; then
+		bool 'Ansel Communications EISA 3200 support' CONFIG_AC3200 n
+	fi
+	bool 'Apricot Xen-II on board ethernet' CONFIG_APRICOT n
+bool 'Pocket and portable adaptors' CONFIG_NET_POCKET n
+if [ "$CONFIG_NET_POCKET" = "y" ]; then
+	bool 'D-Link DE600 pocket adaptor support' CONFIG_DE600 n
+	bool 'D-Link DE620 pocket adaptor support' CONFIG_DE620 n
+	bool 'AT-LAN-TEC/RealTek pocket adaptor support' CONFIG_ATP n
+	bool 'Zenith Z-Note support' CONFIG_ZNET n
+fi
+fi
+fi
+
+comment 'CD-ROM drivers'
+
+bool 'Sony CDU31A/CDU33A CDROM driver support' CONFIG_CDU31A n
+bool 'Mitsumi CDROM driver support' CONFIG_MCD n
+bool 'Matsushita/Panasonic CDROM driver support' CONFIG_SBPCD n
+if [ "$CONFIG_SBPCD" = "y" ]; then
+  bool 'Matsushita/Panasonic second CDROM controller support' CONFIG_SBPCD2 n
+  if [ "$CONFIG_SBPCD2" = "y" ]; then
+    bool 'Matsushita/Panasonic third CDROM controller support' CONFIG_SBPCD3 n
+    if [ "$CONFIG_SBPCD3" = "y" ]; then
+      bool 'Matsushita/Panasonic fourth CDROM controller support' CONFIG_SBPCD4 n
+    fi
+  fi
+fi
+
+comment 'Filesystems'
+
+bool 'Standard (minix) fs support' CONFIG_MINIX_FS y
+bool 'Extended fs support' CONFIG_EXT_FS n
+bool 'Second extended fs support' CONFIG_EXT2_FS y
+bool 'xiafs filesystem support' CONFIG_XIA_FS n
+bool 'msdos fs support' CONFIG_MSDOS_FS y
+if [ "$CONFIG_MSDOS_FS" = "y" ]; then
+bool 'umsdos: Unix like fs on top of std MSDOS FAT fs' CONFIG_UMSDOS_FS n
+fi
+bool '/proc filesystem support' CONFIG_PROC_FS y
+if [ "$CONFIG_INET" = "y" ]; then
+bool 'NFS filesystem support' CONFIG_NFS_FS y
+fi
+if [ "$CONFIG_BLK_DEV_SR" = "y" -o "$CONFIG_CDU31A" = "y" -o "$CONFIG_MCD" = "y" -o "$CONFIG_SBPCD" = "y" -o "$CONFIG_BLK_DEV_IDECD" = "y" ]; then
+	bool 'ISO9660 cdrom filesystem support' CONFIG_ISO9660_FS y
+else
+	bool 'ISO9660 cdrom filesystem support' CONFIG_ISO9660_FS n
+fi
+bool 'OS/2 HPFS filesystem support (read only)' CONFIG_HPFS_FS n
+bool 'System V and Coherent filesystem support' CONFIG_SYSV_FS n
+
+comment 'character devices'
+
+bool 'Parallel printer support' CONFIG_PRINTER n
+bool 'Logitech busmouse support' CONFIG_BUSMOUSE n
+bool 'PS/2 mouse (aka "auxiliary device") support' CONFIG_PSMOUSE y
+if [ "$CONFIG_PSMOUSE" = "y" ]; then
+bool 'C&T 82C710 mouse port support (as on TI Travelmate)' CONFIG_82C710_MOUSE y
+fi
+bool 'Microsoft busmouse support' CONFIG_MS_BUSMOUSE n
+bool 'ATIXL busmouse support' CONFIG_ATIXL_BUSMOUSE n
+bool 'Selection (cut and paste for virtual consoles)' CONFIG_SELECTION n
+
+bool 'QIC-02 tape support' CONFIG_QIC02_TAPE n
+if [ "$CONFIG_QIC02_TAPE" = "y" ]; then
+bool 'Do you want runtime configuration for QIC-02' CONFIG_QIC02_DYNCONF y
+if [ "$CONFIG_QIC02_DYNCONF" != "y" ]; then
+
+comment '>>> Edit configuration parameters in ./include/linux/tpqic02.h!'
+
+else
+
+comment '>>> Setting runtime QIC-02 configuration is done with qic02conf'
+comment '>>> Which is available from ftp://ftp.funet.fi/pub/OS/Linux/BETA/QIC-02/'
+
+fi
+fi
+
+bool 'QIC-117 tape support' CONFIG_FTAPE n
+if [ "$CONFIG_FTAPE" = "y" ]; then
+int ' number of ftape buffers' NR_FTAPE_BUFFERS 3
+fi
+
+comment 'Sound'
+
+bool 'Sound card support' CONFIG_SOUND n
+
+comment 'Kernel hacking'
+
+#bool 'Debug kmalloc/kfree' CONFIG_DEBUG_MALLOC n
+bool 'Kernel profiling support' CONFIG_PROFILE n
+if [ "$CONFIG_SCSI" = "y" ]; then
+bool 'Verbose scsi error reporting (kernel size +=12K)' CONFIG_SCSI_CONSTANTS y
+fi

arch/i386/boot/head.S

@@ -16,10 +16,10 @@
 .globl _empty_zero_page
 .globl _floppy_track_buffer
 
+#define __ASSEMBLY__
 #include <linux/tasks.h>
-#include <linux/segment.h>
-#define ASSEMBLER
 #include <linux/fd.h>
+#include <asm/segment.h>
 
 #define CL_MAGIC_ADDR	0x90020
 #define CL_MAGIC	0xA33F

arch/i386/boot/setup.S

@@ -19,8 +19,9 @@
 !
 
 ! NOTE! These had better be the same as in bootsect.s!
+#define __ASSEMBLY__
 #include <linux/config.h>
-#include <linux/segment.h>
+#include <asm/segment.h>
 
 #ifndef SVGA_MODE
 #define SVGA_MODE ASK_VGA

arch/i386/config.in

@@ -58,7 +58,7 @@ bool 'UltraStor 14F/34F support' CONFIG_SCSI_U14_34F n
 bool 'Future Domain 16xx SCSI support' CONFIG_SCSI_FUTURE_DOMAIN n
 bool 'Generic NCR5380 SCSI support' CONFIG_SCSI_GENERIC_NCR5380 n
 bool 'NCR53c7,8xx SCSI support'  CONFIG_SCSI_NCR53C7xx n
-bool 'Always IN2000 SCSI support' CONFIG_SCSI_IN2000 n
+bool 'Always IN2000 SCSI support (test release)' CONFIG_SCSI_IN2000 n
 bool 'PAS16 SCSI support' CONFIG_SCSI_PAS16 n
 bool 'QLOGIC SCSI support' CONFIG_SCSI_QLOGIC n
 bool 'Seagate ST-02 and Future Domain TMC-8xx SCSI support' CONFIG_SCSI_SEAGATE n

arch/i386/entry.S

@@ -40,8 +40,9 @@
  *	40(%esp) - %oldss
  */
 
-#include <linux/segment.h>
+#define __ASSEMBLY__
 #include <linux/sys.h>
+#include <asm/segment.h>
 
 EBX		= 0x00
 ECX		= 0x04

drivers/FPU-emu/fpu_entry.c

@@ -24,7 +24,8 @@
  +---------------------------------------------------------------------------*/
 
 #include <linux/signal.h>
-#include <linux/segment.h>
+
+#include <asm/segment.h>
 
 #include "fpu_system.h"
 #include "fpu_emu.h"
@@ -32,8 +33,6 @@
 #include "control_w.h"
 #include "status_w.h"
 
-#include <asm/segment.h>
-
 #define __BAD__ FPU_illegal   /* Illegal on an 80486, causes SIGILL */
 
 #ifndef NO_UNDOC_CODE    /* Un-documented FPU op-codes supported by default. */

drivers/char/console.c

@@ -27,7 +27,7 @@
  *     'void poke_blanked_console(void)'
  *     'void scrollback(int lines)'
  *     'void scrollfront(int lines)'
- *     'int do_screendump(int arg)'
+ *     'int do_screendump(int arg, int mode)'
  *
  *     'int con_get_font(char *)' 
  *     'int con_set_font(char *)' 
@@ -2122,10 +2122,18 @@ void update_screen(int new_console)
 	lock = 0;
 }
 
-int do_screendump(int arg)
+/*
+ * do_screendump is used for three tasks:
+ *   if (mode==0) is the old ioctl(TIOCLINUX,0)
+ *   if (mode==1) dumps wd,hg, cursor position, and all the char-attr pairs
+ *   if (mode==2) restores what mode1 got.
+ * the new modes are needed for a fast and complete dump-restore cycle,
+ * needed to implement root-window menus in text mode (A Rubini Nov 1994)
+ */
+int do_screendump(int arg, int mode)
 {
 	char *sptr, *buf = (char *)arg;
-	int currcons, l;
+	int currcons, l, chcount;
 
 	if (!suser())
 		return -EPERM;
@@ -2136,14 +2144,33 @@ int do_screendump(int arg)
 	currcons = (currcons ? currcons-1 : fg_console);
 	if (!vc_cons_allocated(currcons))
 		return -EIO;
-	l = verify_area(VERIFY_WRITE, buf, 2+video_num_columns*video_num_lines);
+	
+	/* mode 0 needs 2+wd*ht, modes 1 and 2 need 4+2*wd*ht */
+	chcount=video_num_columns*video_num_lines;
+	l = verify_area(mode==2 ? VERIFY_READ :VERIFY_WRITE,
+		buf, (2+chcount)*(1+mode!=0));
 	if (l)
 		return l;
+	if (mode<2) {
 	put_fs_byte((char)(video_num_lines),buf++);   
 	put_fs_byte((char)(video_num_columns),buf++);
+	    }
+	switch(mode) {
+	    case 0:
 	sptr = (char *) origin;
-	for (l=video_num_lines*video_num_columns; l>0 ; l--, sptr++)
+			for (l=chcount; l>0 ; l--, sptr++)
 		put_fs_byte(*sptr++,buf++);	
+			break;
+	    case 1:
+			put_fs_byte((char)x,buf++); put_fs_byte((char)y,buf++); 
+			memcpy_tofs(buf,(char *)origin,2*chcount);
+			break;
+	    case 2:
+			buf+=2; /* skip the the numnber 9 and console number */
+			x=get_fs_byte(buf++); y=get_fs_byte(buf++);
+			memcpy_fromfs((char *)origin,buf,2*chcount);
+			break;
+	    }
 	return(0);
 }
 

drivers/char/lp.c

@@ -456,6 +456,8 @@ long lp_init(long kmem_start)
 	}
 	/* take on all known port values */
 	for (offset = 0; offset < LP_NO; offset++) {
+		if (check_region(LP_B(offset), 3))
+			continue;
 		/* write to port & read back to check */
 		outb_p( LP_DUMMY, LP_B(offset));
 		for (testvalue = 0 ; testvalue < LP_DELAY ; testvalue++)
@@ -465,6 +467,7 @@ long lp_init(long kmem_start)
 			LP_F(offset) |= LP_EXIST;
 			lp_reset(offset);
 			printk("lp_init: lp%d exists, ", offset);
+			snarf_region(LP_B(offset), 3);
 			if (LP_IRQ(offset))
 				printk("using IRQ%d\n", LP_IRQ(offset));
 			else

drivers/char/tty_io.c

@@ -72,7 +72,7 @@ extern int sel_loadlut(const int arg);
 extern int mouse_reporting(void);
 extern int shift_state;
 #endif /* CONFIG_SELECTION */
-extern int do_screendump(int arg);
+extern int do_screendump(int arg, int mode);
 
 struct termios tty_std_termios;		/* for the benefit of tty drivers  */
 struct tty_driver *tty_drivers = NULL;	/* linked list of tty drivers */
@@ -1400,10 +1400,10 @@ static int tty_ioctl(struct inode * inode, struct file * file,
 			retval = verify_area(VERIFY_READ, (void *) arg, 1);
 			if (retval)
 				return retval;
-			switch (get_fs_byte((char *)arg))
+			switch (retval = get_fs_byte((char *)arg))
 			{
 				case 0: 
-					return do_screendump(arg);
+					return do_screendump(arg,0);
 				case 1:
 					printk("Deprecated TIOCLINUX (1) ioctl\n");
 					return do_get_ps_info(arg);
@@ -1420,16 +1420,21 @@ static int tty_ioctl(struct inode * inode, struct file * file,
 				case 5:
 					return sel_loadlut(arg);
 				case 6:
-			/* Make it possible to react to Shift+Mousebutton */
-			/* Note that shift_state is an undocumented
-			   kernel-internal variable; programs not closely
-			   related to the kernel should not use this. */
+			/*
+			 * Make it possible to react to Shift+Mousebutton.
+			 * Note that 'shift_state' is an undocumented
+			 * kernel-internal variable; programs not closely
+			 * related to the kernel should not use this.
+			 */
 					put_fs_byte(shift_state,arg);
 					return 0;
 				case 7:
 					put_fs_byte(mouse_reporting(),arg);
 					return 0;
 #endif /* CONFIG_SELECTION */
+				case 8: /* second arg is 1 or 2 */
+				case 9: /* both are explained in console.c */
+					return do_screendump(arg,retval-7);
 				default: 
 					return -EINVAL;
 			}
@@ -1598,7 +1603,7 @@ int tty_unregister_driver(struct tty_driver *driver)
 	int	found = 0;
 	int	major_inuse = 0;
 	
-	if (driver->refcount)
+	if (*driver->refcount)
 		return -EBUSY;
 
 	for (p = tty_drivers; p; p = p->next) {

drivers/net/3c501.c

@@ -34,9 +34,10 @@ static char *version =
 #include <linux/malloc.h>
 #include <linux/string.h>
 #include <linux/ioport.h>
+#include <linux/errno.h>
+
 #include <asm/bitops.h>
 #include <asm/io.h>
-#include <errno.h>
 
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>

drivers/net/8390.c

@@ -41,7 +41,7 @@ static char *version =
 #include <asm/segment.h>
 #include <asm/bitops.h>
 #include <asm/io.h>
-#include <errno.h>
+#include <linux/errno.h>
 #include <linux/fcntl.h>
 #include <linux/in.h>
 #include <linux/interrupt.h>

drivers/net/apricot.c

@@ -671,13 +671,13 @@ unsigned long apricot_init(unsigned long mem_start, unsigned long mem_end)
 
 
     for(i = 0; i < 6 ; i++)
-    	eth_addr[i] = inb(ioaddr +8 +i));
+    	eth_addr[i] = inb(ioaddr +8 +i);
     
     /* Some other boards trip the checksum.. but then appear as ether
        address 0. Trap these - AC */
        
     if(memcmp(eth_addr,"\x00\x00\x00\x00\x00\x00",6)==0)
-    	return mem_addr;
+    	return mem_start;
 
     dev = init_etherdev(0, (sizeof (struct i596_private) + 0xf), &mem_start);
     printk("%s: Apricot 82596 at %#3x,", dev->name, ioaddr);

drivers/net/at1700.c

@@ -47,7 +47,7 @@ static char *version =
 #include <asm/bitops.h>
 #include <asm/io.h>
 #include <asm/dma.h>
-#include <errno.h>
+#include <linux/errno.h>
 
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>

drivers/net/atp.c

@@ -89,7 +89,7 @@ static char *version =
 #include <asm/bitops.h>
 #include <asm/io.h>
 #include <asm/dma.h>
-#include <errno.h>
+#include <linux/errno.h>
 
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>

drivers/net/de600.c

@@ -98,10 +98,10 @@ unsigned int de600_debug = DE600_DEBUG;
 #include <linux/string.h>
 #include <linux/interrupt.h>
 #include <asm/io.h>
-#include <netinet/in.h>
+#include <linux/in.h>
 #include <linux/ptrace.h>
 #include <asm/system.h>
-#include <errno.h>
+#include <linux/errno.h>
 
 #include <linux/inet.h>
 #include <linux/netdevice.h>

drivers/net/de620.c

@@ -109,10 +109,10 @@ static char *version =
 #include <linux/string.h>
 #include <linux/interrupt.h>
 #include <asm/io.h>
-#include <netinet/in.h>
+#include <linux/in.h>
 #include <linux/ptrace.h>
 #include <asm/system.h>
-#include <errno.h>
+#include <linux/errno.h>
 
 #include <linux/inet.h>
 #include <linux/netdevice.h>

drivers/net/dummy.c

@@ -46,7 +46,7 @@
 #include <asm/bitops.h>
 #include <asm/io.h>
 #include <asm/dma.h>
-#include <errno.h>
+#include <linux/errno.h>
 
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>

drivers/net/ne.c

+#define rw_bugfix
 /* ne.c: A general non-shared-memory NS8390 ethernet driver for linux. */
 /*
     Written 1992-94 by Donald Becker.

drivers/net/sk_g16.c

@@ -69,7 +69,7 @@ static char *rcsid = "$Id: sk_g16.c,v 1.1 1994/06/30 16:25:15 root Exp $";
 #include <asm/system.h>
 #include <asm/io.h>
 #include <asm/bitops.h> 
-#include <errno.h>
+#include <linux/errno.h>
 
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>

drivers/net/skeleton.c

@@ -57,7 +57,7 @@ static char *version =
 #include <asm/bitops.h>
 #include <asm/io.h>
 #include <asm/dma.h>
-#include <errno.h>
+#include <linux/errno.h>
 
 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>

drivers/scsi/README.qlogic

@@ -14,7 +14,7 @@ you will have to load your socket and card services, and QL41DOS.SYS and
 QL40ENBL.SYS.  These are a minimum, but loading the rest of the modules
 won't interfere with the operation.  The next thing to do is load the kernel
 without resetting the hardware, which can be a simple ctrl-alt-delete with
-a boot floppy, or by using loadlin with the kernel image accessable from
+a boot floppy, or by using loadlin with the kernel image accessible from
 DOS.  If you are using the Linux PCMCIA driver, you will have to adjust
 it or otherwise stop it from configuring the card.
 
@@ -37,7 +37,7 @@ hardware and connections it may be more useful to not reset things.
 
 SOME TROUBLESHOOTING TIPS
 
-Make sure it works properly under DOS.  You should also do an inital FDISK
+Make sure it works properly under DOS.  You should also do an initial FDISK
 on a new drive if you want partitions.
 
 Don't enable all the speedups first.  If anything is wrong, they will make

drivers/scsi/in2000.c

 /*
  *  This file is in2000.c, written and
  *  Copyright (C) 1993  Brad McLean
- *	Last edit 07/19/94 WDE
+ *	Last edit 08/25/94 WDE
  * Disclaimer:
  * Note:  This is ugly.  I know it, I wrote it, but my whole
  * focus was on getting the damn thing up and out quickly.
@@ -44,6 +44,9 @@
  */
 /* Changes for 1.1.28 kernel made 7/19/94, code not affected. (WDE)
  */
+/* Changes for 1.1.43+ kernels made 8/25/94, code added to check for
+ * new BIOS version, derived by jshiffle@netcom.com. (WDE)
+ */
 
 #include <linux/kernel.h>
 #include <linux/head.h>
@@ -124,13 +127,14 @@ static int in2000_test_port(int index)
     tmp = inb(INFLED);
 	/* First, see if the DIP switch values are valid */
 	/* The test of B7 may fail on some early boards, mine works. */
-    if (((~tmp & 0x3) != index ) || (tmp & 0x80) || !(tmp & 0x4) )
+    if ( ((~tmp & 0x3) != index ) || (tmp & 0x80) || !(tmp & 0x4) )
     	return 0;
     printk("IN-2000 probe got dip setting of %02X\n", tmp);
     tmp = inb(INVERS);
 /* Add some extra sanity checks here */
     for(i=0; i < 3; i++)
-	if(*(bios_tab[i]+0x04) == 0x41564f4e) {
+	if(*(bios_tab[i]+0x04) == 0x41564f4e ||
+		*(bios_tab[i]+0xc) == 0x61776c41) {
 	  printk("IN-2000 probe found hdw. vers. %02x, BIOS at %06x\n",
 		tmp, (unsigned int)bios_tab[i]);
 		return 1;
@@ -141,7 +145,7 @@ static int in2000_test_port(int index)
 
 
 /*
- * retreive the current transaction counter from the WD
+ * retrieve the current transaction counter from the WD
  */
 
 static unsigned in2000_txcnt(void)
@@ -173,7 +177,7 @@ static void in2000_fifo_out(void)	/* uses FIFOCNTR */
     do {
 	txcnt = in2000_txcnt();
 /*DEB(printk("FIw:%d %02x %d\n", in2000_datalen, infcnt, txcnt));*/
-	count = (infcnt << 3) - 32;	/* dont fill completely */
+	count = (infcnt << 3) - 32;	/* don't fill completely */
 	if ( count > in2000_datalen )
 	    count = in2000_datalen;	/* limit to actual data on hand */
 	count >>= 1;		/* Words, not bytes */

drivers/scsi/in2000.h

 #ifndef _IN2000_H
 
-/* $Id: in2000.h,v 1.1 1994/03/14 06:27:38 root Exp root $
+/* $Id: in2000.h,v 1.2 1994/08/25 06:27:38 root Exp root $
  *
  * Header file for the Always IN 2000 driver for Linux
  *
@@ -26,6 +26,7 @@
 
 /* WD33C93 defines */
 #define	OWNID	0
+#undef	CONTROL
 #define	CONTROL	1
 #define	TIMEOUT	2
 #define	TOTSECT	3
@@ -69,22 +70,17 @@
 /* Select timeout const, 1 count = 8ms */
 #define IN2000_TMOUT 0x1f
 
-#if 0
-/* This is used with scatter-gather */
-struct in2000_chain {
-  ulong  dataptr;		/* Location of data */
-  ulong  datalen;		/* Size of this part of chain */
-};
-#endif
-
 /* These belong in scsi.h also */
+#undef any2scsi
 #define any2scsi(up, p)				\
 (up)[0] = (((unsigned long)(p)) >> 16);		\
 (up)[1] = (((unsigned long)(p)) >> 8);		\
 (up)[2] = ((unsigned long)(p));
 
+#undef scsi2int
 #define scsi2int(up) ( ((((long)*(up))&0x1f) << 16) + (((long)(up)[1]) << 8) + ((long)(up)[2]) )
 
+#undef xany2scsi
 #define xany2scsi(up, p)	\
 (up)[0] = ((long)(p)) >> 24;	\
 (up)[1] = ((long)(p)) >> 16;	\

drivers/scsi/qlogic.c

@@ -212,7 +212,7 @@ int	i,k;
 }
 
 /*----------------------------------------------------------------*/
-/* initate scsi command - queueing handler */
+/* initiate scsi command - queueing handler */
 static void	ql_icmd(Scsi_Cmnd * cmd)
 {
 unsigned int	    i;
@@ -524,7 +524,7 @@ struct	Scsi_Host	*hreg;	/* registered host structure */
 /* return bios parameters */
 int	qlogic_biosparam(Disk * disk, int dev, int ip[])
 {
-/* This should mimmic the DOS Qlogic driver's behavior exactly */
+/* This should mimic the DOS Qlogic driver's behavior exactly */
 	ip[0] = 0x40;
 	ip[1] = 0x20;
 	ip[2] = disk->capacity / (ip[0] * ip[1]);

drivers/scsi/scsi.c

@@ -347,11 +347,11 @@ static void scan_scsis (struct Scsi_Host * shpnt)
 			scsi_result[1] |= 0x80;  /* removable */
 		}
 
-	      SDpnt->manufactor = SCSI_MAN_UNKNOWN;
+	      SDpnt->manufacturer = SCSI_MAN_UNKNOWN;
 	      if (!strncmp(scsi_result+8,"NEC",3))
-		SDpnt->manufactor = SCSI_MAN_NEC;
+		SDpnt->manufacturer = SCSI_MAN_NEC;
 	      if (!strncmp(scsi_result+8,"TOSHIBA",7))
-		SDpnt->manufactor = SCSI_MAN_TOSHIBA;
+		SDpnt->manufacturer = SCSI_MAN_TOSHIBA;
 
 	      SDpnt->removable = (0x80 & 
 				  scsi_result[1]) >> 7;

drivers/scsi/scsi.h

@@ -260,7 +260,7 @@ extern const unsigned char scsi_command_size[8];
 */
 
 /*
-        Manufactors list
+        Manufacturers list
 */
 
 #define SCSI_MAN_UNKNOWN     0
@@ -275,7 +275,7 @@ extern const unsigned char scsi_command_size[8];
 typedef struct scsi_device {
         struct scsi_device * next; /* Used for linked list */
 	unsigned char id, lun;
-	unsigned int manufactor; /* Manufactor of device, for using vendor-specific cmd's */
+	unsigned int manufacturer; /* Manufacturer of device, for using vendor-specific cmd's */
 	int attached;          /* # of high level drivers attached to this */
 	int access_count;	/* Count of open channels/mounts */
 	struct wait_queue * device_wait;  /* Used to wait if device is busy */

drivers/scsi/sr.c

@@ -19,6 +19,7 @@
 #include <linux/sched.h>
 #include <linux/string.h>
 #include <linux/errno.h>
+#include <linux/cdrom.h>
 #include <asm/system.h>
 
 #define MAJOR_NR SCSI_CDROM_MAJOR
@@ -279,7 +280,7 @@ static void rw_intr (Scsi_Cmnd * SCpnt)
  *
  * Actually works: (should work ;-)
  *   - NEC:     Detection and support of multisession CD's. Special handling
- *              for XA-disks is not nessesary.
+ *              for XA-disks is not necessary.
  *     
  *   - TOSHIBA: setting density is done here now, mounting PhotoCD's should
  *              work now without running the program "set_density"
@@ -302,7 +303,7 @@ static void sr_photocd(struct inode *inode)
   unsigned char   *buffer;
   int             rc;
 
-  switch(scsi_CDs[MINOR(inode->i_rdev)].device->manufactor) {
+  switch(scsi_CDs[MINOR(inode->i_rdev)].device->manufacturer) {
 
   case SCSI_MAN_NEC:
     printk("sr_photocd: use NEC code\n");
@@ -324,6 +325,7 @@ static void sr_photocd(struct inode *inode)
       sec   = (unsigned long)buffer[16]/16*10 + (unsigned long)buffer[16]%16;
       frame = (unsigned long)buffer[17]/16*10 + (unsigned long)buffer[17]%16;
       sector = min*60*75 + sec*75 + frame;
+      sector-=CD_BLOCK_OFFSET;
       if (sector) {
 	printk("sr_photocd: multisession PhotoCD detected\n"); }}
     scsi_free(buffer,512);
@@ -372,6 +374,7 @@ static void sr_photocd(struct inode *inode)
       sec   = (unsigned long)buffer[2]/16*10 + (unsigned long)buffer[2]%16;
       frame = (unsigned long)buffer[3]/16*10 + (unsigned long)buffer[3]%16;
       sector = min*60*75 + sec*75 + frame;
+      sector-=CD_BLOCK_OFFSET;
       if (sector) {
         printk("sr_photocd: multisession PhotoCD detected: %lu\n",sector); }}
     scsi_free(buffer,512);
@@ -408,7 +411,9 @@ static int sr_open(struct inode * inode, struct file * filp)
 	if(scsi_CDs[MINOR(inode->i_rdev)].needs_sector_size)
 	  get_sectorsize(MINOR(inode->i_rdev));
 
+#if 0	/* don't use for now - it doesn't seem to work for everybody */
 	sr_photocd(inode);
+#endif
 
 	return 0;
 }

fs/exec.c

@@ -36,16 +36,12 @@
 #include <linux/fcntl.h>
 #include <linux/ptrace.h>
 #include <linux/user.h>
-#include <linux/segment.h>
 #include <linux/malloc.h>
-
-#include <asm/system.h>
-
 #include <linux/binfmts.h>
 #include <linux/personality.h>
 
-#include <asm/segment.h>
 #include <asm/system.h>
+#include <asm/segment.h>
 
 asmlinkage int sys_exit(int exit_code);
 asmlinkage int sys_brk(unsigned long);

fs/isofs/dir.c

@@ -90,7 +90,7 @@ static int isofs_readdir(struct inode * inode, struct file * filp,
 
 	while (filp->f_pos < inode->i_size) {
 #ifdef DEBUG
-		printk("Block, offset: %x %x %x\n",
+		printk("Block, offset, f_pos: %x %x %x\n",
 		       block, offset, filp->f_pos);
 #endif
 		de = (struct iso_directory_record *) (bh->b_data + offset);
@@ -122,7 +122,7 @@ static int isofs_readdir(struct inode * inode, struct file * filp,
 		offset += *((unsigned char *) de);
 		filp->f_pos += *((unsigned char *) de);
 
-		if (offset >=  bufsize) {
+		if (offset > bufsize) {
 		        unsigned int frag1;
 			frag1 = bufsize - old_offset;
 			cpnt = kmalloc(*((unsigned char *) de),GFP_KERNEL);

fs/isofs/file.c

@@ -156,14 +156,15 @@ static int isofs_file_read(struct inode * inode, struct file * filp, char * buf,
 
 	/*
 	 * this is for stopping read ahead at EOF. It's  important for
-	 * reading PhotoCD's, becauce they have many small data tracks instead
+	 * reading PhotoCD's, because they have many small data tracks instead
 	 * of one big. And between two data-tracks are some unreadable sectors.
 	 * A read ahead after a EOF may try to read such an unreadable sector.
 	 *    kraxel@cs.tu-berlin.de (Gerd Knorr)
 	 */
-	total_blocks = inode->i_size >> ISOFS_BUFFER_BITS(inode);
-	if (inode->i_size & (ISOFS_BUFFER_BITS(inode)-1)) total_blocks++;
-	while (block + blocks > total_blocks) blocks--;
+	total_blocks = (inode->i_size + (1 << ISOFS_BUFFER_BITS(inode)) - 1)
+	   >> ISOFS_BUFFER_BITS(inode);
+	if (block + blocks > total_blocks)
+		blocks = total_blocks - block;
 
 	max_block = (inode->i_size + BLOCK_SIZE - 1)/BLOCK_SIZE;
 	nextblock = -1;

fs/locks.c

@@ -11,11 +11,17 @@
  *	- mandatory locks (requires lots of changes elsewhere)
  *
  *  Edited by Kai Petzke, wpp@marie.physik.tu-berlin.de
+ *
+ *  Converted file_lock_table to a linked list from an array, which eliminates
+ *  the limits on how many active file locks are open - Chad Page
+ *  (pageone@netcom.com), November 27, 1994 
  */
+
 #define DEADLOCK_DETECTION
 
 #include <asm/segment.h>
 
+#include <linux/malloc.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
@@ -36,25 +42,8 @@ static void free_lock(struct file_lock **fl);
 int locks_deadlocked(int my_pid,int blocked_pid);
 #endif
 
-static struct file_lock file_lock_table[NR_FILE_LOCKS];
-static struct file_lock *file_lock_free_list;
-
-/*
- * Called at boot time to initialize the lock table ...
- */
-
-void fcntl_init_locks(void)
-{
-	struct file_lock *fl;
-
-	for (fl = &file_lock_table[0]; fl < file_lock_table + NR_FILE_LOCKS - 1; fl++) {
-		fl->fl_next = fl + 1;
-		fl->fl_owner = NULL;
-	}
-	file_lock_table[NR_FILE_LOCKS - 1].fl_next = NULL;
-	file_lock_table[NR_FILE_LOCKS - 1].fl_owner = NULL;
-	file_lock_free_list = &file_lock_table[0];
-}
+static struct file_lock *file_lock_table = NULL;
+static struct file_lock *file_lock_free_list = NULL;
 
 int fcntl_getlk(unsigned int fd, struct flock *l)
 {
@@ -185,7 +174,7 @@ int locks_deadlocked(int my_pid,int blocked_pid)
 	int ret_val;
 	struct wait_queue *dlock_wait;
 	struct file_lock *fl;
-	for (fl = &file_lock_table[0]; fl < file_lock_table + NR_FILE_LOCKS - 1; fl++) {
+	for (fl = file_lock_table; fl != NULL; fl = fl->fl_nextlink) {
 		if (fl->fl_owner == NULL) continue;	/* not a used lock */
 		if (fl->fl_owner->pid != my_pid) continue;
 		if (fl->fl_wait == NULL) continue;	/* no queues */
@@ -453,6 +442,9 @@ static int lock_it(struct file *filp, struct file_lock *caller, unsigned int fd)
 
 /*
  * File_lock() inserts a lock at the position pos of the linked list.
+ *
+ *  Modified to create a new node if no free entries available - Chad Page
+ *
  */
 
 static struct file_lock *alloc_lock(struct file_lock **pos,
@@ -462,14 +454,25 @@ static struct file_lock *alloc_lock(struct file_lock **pos,
 	struct file_lock *tmp;
 
 	tmp = file_lock_free_list;
+
 	if (tmp == NULL)
-		return NULL;			/* no available entry */
+	{
+		/* Okay, let's make a new file_lock structure... */
+		tmp = (struct file_lock *)kmalloc(sizeof(struct file_lock), GFP_KERNEL);
+		tmp -> fl_owner = NULL;
+		tmp -> fl_next = file_lock_free_list;
+		tmp -> fl_nextlink = file_lock_table;
+		file_lock_table = tmp;
+	}
+	else
+	{
+		/* remove from free list */
+		file_lock_free_list = tmp->fl_next;
+	}
+
 	if (tmp->fl_owner != NULL)
 		panic("alloc_lock: broken free list\n");
 
-	/* remove from free list */
-	file_lock_free_list = tmp->fl_next;
-
 	*tmp = *fl;
 
 	tmp->fl_next = *pos;	/* insert into file's list */

fs/proc/mem.c

@@ -9,8 +9,8 @@
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
-#include <linux/page.h>
 
+#include <asm/page.h>
 #include <asm/segment.h>
 #include <asm/io.h>
 

fs/super.c

@@ -26,7 +26,6 @@ extern struct file_operations * get_blkfops(unsigned int);
 extern struct file_operations * get_chrfops(unsigned int);
 
 extern void wait_for_keypress(void);
-extern void fcntl_init_locks(void);
 
 extern int root_mountflags;
 
@@ -442,14 +441,18 @@ static int do_mount(dev_t dev, const char * dir, char * type, int flags, void *
 	}
 	if (!S_ISDIR(dir_i->i_mode)) {
 		iput(dir_i);
-		return -EPERM;
+		return -ENOTDIR;
 	}
 	if (!fs_may_mount(dev)) {
 		iput(dir_i);
 		return -EBUSY;
 	}
 	sb = read_super(dev,type,flags,data,0);
-	if (!sb || sb->s_covered) {
+	if (!sb) {
+		iput(dir_i);
+		return -EINVAL;
+	}
+	if (sb->s_covered) {
 		iput(dir_i);
 		return -EBUSY;
 	}
@@ -640,7 +643,6 @@ void mount_root(void)
 	int retval;
 
 	memset(super_blocks, 0, sizeof(super_blocks));
-	fcntl_init_locks();
 #ifdef CONFIG_BLK_DEV_FD
 	if (MAJOR(ROOT_DEV) == FLOPPY_MAJOR) {
 		printk(KERN_NOTICE "VFS: Insert root floppy and press ENTER\n");

fs/umsdos/inode.c

@@ -6,7 +6,6 @@
  *
  */
 
-#include <stdlib.h>
 #include <linux/fs.h>
 #include <linux/msdos_fs.h>
 #include <linux/kernel.h>

ibcs/Makefile

@@ -26,7 +26,6 @@ ibcs.o: $(OBJS)
 
 dep:
 	$(CPP) -M *.c > .depend
-	set -e; for i in $(SUBDIRS); do $(MAKE) -C $$i dep; done
 
 dummy:
 

include/asm-alpha/dma.h

+/*
+ * include/asm-alpha/dma.h
+ *
+ * This is essentially the same as the i386 DMA stuff, as
+ * the AlphaPC uses normal EISA dma (but the DMA controller
+ * is not on the EISA bus, but on the local VL82c106 bus).
+ *
+ * These DMA-functions don't know about EISA DMA yet..
+ */
+
+/* $Id: dma.h,v 1.7 1992/12/14 00:29:34 root Exp root $
+ * linux/include/asm/dma.h: Defines for using and allocating dma channels.
+ * Written by Hennus Bergman, 1992.
+ * High DMA channel support & info by Hannu Savolainen
+ * and John Boyd, Nov. 1992.
+ */
+
+#ifndef _ASM_DMA_H
+#define _ASM_DMA_H
+
+#include <asm/io.h>		/* need byte IO */
+
+#define dma_outb	outb_local
+#define dma_inb		inb_local
+
+/*
+ * NOTES about DMA transfers:
+ *
+ *  controller 1: channels 0-3, byte operations, ports 00-1F
+ *  controller 2: channels 4-7, word operations, ports C0-DF
+ *
+ *  - ALL registers are 8 bits only, regardless of transfer size
+ *  - channel 4 is not used - cascades 1 into 2.
+ *  - channels 0-3 are byte - addresses/counts are for physical bytes
+ *  - channels 5-7 are word - addresses/counts are for physical words
+ *  - transfers must not cross physical 64K (0-3) or 128K (5-7) boundaries
+ *  - transfer count loaded to registers is 1 less than actual count
+ *  - controller 2 offsets are all even (2x offsets for controller 1)
+ *  - page registers for 5-7 don't use data bit 0, represent 128K pages
+ *  - page registers for 0-3 use bit 0, represent 64K pages
+ *
+ * DMA transfers are limited to the lower 16MB of _physical_ memory.  
+ * Note that addresses loaded into registers must be _physical_ addresses,
+ * not logical addresses (which may differ if paging is active).
+ *
+ *  Address mapping for channels 0-3:
+ *
+ *   A23 ... A16 A15 ... A8  A7 ... A0    (Physical addresses)
+ *    |  ...  |   |  ... |   |  ... |
+ *    |  ...  |   |  ... |   |  ... |
+ *    |  ...  |   |  ... |   |  ... |
+ *   P7  ...  P0  A7 ... A0  A7 ... A0   
+ * |    Page    | Addr MSB | Addr LSB |   (DMA registers)
+ *
+ *  Address mapping for channels 5-7:
+ *
+ *   A23 ... A17 A16 A15 ... A9 A8 A7 ... A1 A0    (Physical addresses)
+ *    |  ...  |   \   \   ... \  \  \  ... \  \
+ *    |  ...  |    \   \   ... \  \  \  ... \  (not used)
+ *    |  ...  |     \   \   ... \  \  \  ... \
+ *   P7  ...  P1 (0) A7 A6  ... A0 A7 A6 ... A0   
+ * |      Page      |  Addr MSB   |  Addr LSB  |   (DMA registers)
+ *
+ * Again, channels 5-7 transfer _physical_ words (16 bits), so addresses
+ * and counts _must_ be word-aligned (the lowest address bit is _ignored_ at
+ * the hardware level, so odd-byte transfers aren't possible).
+ *
+ * Transfer count (_not # bytes_) is limited to 64K, represented as actual
+ * count - 1 : 64K => 0xFFFF, 1 => 0x0000.  Thus, count is always 1 or more,
+ * and up to 128K bytes may be transferred on channels 5-7 in one operation. 
+ *
+ */
+
+#define MAX_DMA_CHANNELS	8
+
+/* 8237 DMA controllers */
+#define IO_DMA1_BASE	0x00	/* 8 bit slave DMA, channels 0..3 */
+#define IO_DMA2_BASE	0xC0	/* 16 bit master DMA, ch 4(=slave input)..7 */
+
+/* DMA controller registers */
+#define DMA1_CMD_REG		0x08	/* command register (w) */
+#define DMA1_STAT_REG		0x08	/* status register (r) */
+#define DMA1_REQ_REG            0x09    /* request register (w) */
+#define DMA1_MASK_REG		0x0A	/* single-channel mask (w) */
+#define DMA1_MODE_REG		0x0B	/* mode register (w) */
+#define DMA1_CLEAR_FF_REG	0x0C	/* clear pointer flip-flop (w) */
+#define DMA1_TEMP_REG           0x0D    /* Temporary Register (r) */
+#define DMA1_RESET_REG		0x0D	/* Master Clear (w) */
+#define DMA1_CLR_MASK_REG       0x0E    /* Clear Mask */
+#define DMA1_MASK_ALL_REG       0x0F    /* all-channels mask (w) */
+
+#define DMA2_CMD_REG		0xD0	/* command register (w) */
+#define DMA2_STAT_REG		0xD0	/* status register (r) */
+#define DMA2_REQ_REG            0xD2    /* request register (w) */
+#define DMA2_MASK_REG		0xD4	/* single-channel mask (w) */
+#define DMA2_MODE_REG		0xD6	/* mode register (w) */
+#define DMA2_CLEAR_FF_REG	0xD8	/* clear pointer flip-flop (w) */
+#define DMA2_TEMP_REG           0xDA    /* Temporary Register (r) */
+#define DMA2_RESET_REG		0xDA	/* Master Clear (w) */
+#define DMA2_CLR_MASK_REG       0xDC    /* Clear Mask */
+#define DMA2_MASK_ALL_REG       0xDE    /* all-channels mask (w) */
+
+#define DMA_ADDR_0              0x00    /* DMA address registers */
+#define DMA_ADDR_1              0x02
+#define DMA_ADDR_2              0x04
+#define DMA_ADDR_3              0x06
+#define DMA_ADDR_4              0xC0
+#define DMA_ADDR_5              0xC4
+#define DMA_ADDR_6              0xC8
+#define DMA_ADDR_7              0xCC
+
+#define DMA_CNT_0               0x01    /* DMA count registers */
+#define DMA_CNT_1               0x03
+#define DMA_CNT_2               0x05
+#define DMA_CNT_3               0x07
+#define DMA_CNT_4               0xC2
+#define DMA_CNT_5               0xC6
+#define DMA_CNT_6               0xCA
+#define DMA_CNT_7               0xCE
+
+#define DMA_PAGE_0              0x87    /* DMA page registers */
+#define DMA_PAGE_1              0x83
+#define DMA_PAGE_2              0x81
+#define DMA_PAGE_3              0x82
+#define DMA_PAGE_5              0x8B
+#define DMA_PAGE_6              0x89
+#define DMA_PAGE_7              0x8A
+
+#define DMA_MODE_READ	0x44	/* I/O to memory, no autoinit, increment, single mode */
+#define DMA_MODE_WRITE	0x48	/* memory to I/O, no autoinit, increment, single mode */
+#define DMA_MODE_CASCADE 0xC0   /* pass thru DREQ->HRQ, DACK<-HLDA only */
+
+/* enable/disable a specific DMA channel */
+static __inline__ void enable_dma(unsigned int dmanr)
+{
+	if (dmanr<=3)
+		dma_outb(dmanr,  DMA1_MASK_REG);
+	else
+		dma_outb(dmanr & 3,  DMA2_MASK_REG);
+}
+
+static __inline__ void disable_dma(unsigned int dmanr)
+{
+	if (dmanr<=3)
+		dma_outb(dmanr | 4,  DMA1_MASK_REG);
+	else
+		dma_outb((dmanr & 3) | 4,  DMA2_MASK_REG);
+}
+
+/* Clear the 'DMA Pointer Flip Flop'.
+ * Write 0 for LSB/MSB, 1 for MSB/LSB access.
+ * Use this once to initialize the FF to a known state.
+ * After that, keep track of it. :-)
+ * --- In order to do that, the DMA routines below should ---
+ * --- only be used while interrupts are disabled! ---
+ */
+static __inline__ void clear_dma_ff(unsigned int dmanr)
+{
+	if (dmanr<=3)
+		dma_outb(0,  DMA1_CLEAR_FF_REG);
+	else
+		dma_outb(0,  DMA2_CLEAR_FF_REG);
+}
+
+/* set mode (above) for a specific DMA channel */
+static __inline__ void set_dma_mode(unsigned int dmanr, char mode)
+{
+	if (dmanr<=3)
+		dma_outb(mode | dmanr,  DMA1_MODE_REG);
+	else
+		dma_outb(mode | (dmanr&3),  DMA2_MODE_REG);
+}
+
+/* Set only the page register bits of the transfer address.
+ * This is used for successive transfers when we know the contents of
+ * the lower 16 bits of the DMA current address register, but a 64k boundary
+ * may have been crossed.
+ */
+static __inline__ void set_dma_page(unsigned int dmanr, char pagenr)
+{
+	switch(dmanr) {
+		case 0:
+			dma_outb(pagenr, DMA_PAGE_0);
+			break;
+		case 1:
+			dma_outb(pagenr, DMA_PAGE_1);
+			break;
+		case 2:
+			dma_outb(pagenr, DMA_PAGE_2);
+			break;
+		case 3:
+			dma_outb(pagenr, DMA_PAGE_3);
+			break;
+		case 5:
+			dma_outb(pagenr & 0xfe, DMA_PAGE_5);
+			break;
+		case 6:
+			dma_outb(pagenr & 0xfe, DMA_PAGE_6);
+			break;
+		case 7:
+			dma_outb(pagenr & 0xfe, DMA_PAGE_7);
+			break;
+	}
+}
+
+
+/* Set transfer address & page bits for specific DMA channel.
+ * Assumes dma flipflop is clear.
+ */
+static __inline__ void set_dma_addr(unsigned int dmanr, unsigned int a)
+{
+	set_dma_page(dmanr, a>>16);
+	if (dmanr <= 3)  {
+	    dma_outb( a & 0xff, ((dmanr&3)<<1) + IO_DMA1_BASE );
+            dma_outb( (a>>8) & 0xff, ((dmanr&3)<<1) + IO_DMA1_BASE );
+	}  else  {
+	    dma_outb( (a>>1) & 0xff, ((dmanr&3)<<2) + IO_DMA2_BASE );
+	    dma_outb( (a>>9) & 0xff, ((dmanr&3)<<2) + IO_DMA2_BASE );
+	}
+}
+
+
+/* Set transfer size (max 64k for DMA1..3, 128k for DMA5..7) for
+ * a specific DMA channel.
+ * You must ensure the parameters are valid.
+ * NOTE: from a manual: "the number of transfers is one more
+ * than the initial word count"! This is taken into account.
+ * Assumes dma flip-flop is clear.
+ * NOTE 2: "count" represents _bytes_ and must be even for channels 5-7.
+ */
+static __inline__ void set_dma_count(unsigned int dmanr, unsigned int count)
+{
+        count--;
+	if (dmanr <= 3)  {
+	    dma_outb( count & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
+	    dma_outb( (count>>8) & 0xff, ((dmanr&3)<<1) + 1 + IO_DMA1_BASE );
+        } else {
+	    dma_outb( (count>>1) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
+	    dma_outb( (count>>9) & 0xff, ((dmanr&3)<<2) + 2 + IO_DMA2_BASE );
+        }
+}
+
+
+/* Get DMA residue count. After a DMA transfer, this
+ * should return zero. Reading this while a DMA transfer is
+ * still in progress will return unpredictable results.
+ * If called before the channel has been used, it may return 1.
+ * Otherwise, it returns the number of _bytes_ left to transfer.
+ *
+ * Assumes DMA flip-flop is clear.
+ */
+static __inline__ int get_dma_residue(unsigned int dmanr)
+{
+	unsigned int io_port = (dmanr<=3)? ((dmanr&3)<<1) + 1 + IO_DMA1_BASE
+					 : ((dmanr&3)<<2) + 2 + IO_DMA2_BASE;
+
+	/* using short to get 16-bit wrap around */
+	unsigned short count;
+
+	count = 1 + dma_inb(io_port);
+	count += dma_inb(io_port) << 8;
+	
+	return (dmanr<=3)? count : (count<<1);
+}
+
+
+/* These are in kernel/dma.c: */
+extern int request_dma(unsigned int dmanr, char * deviceID);	/* reserve a DMA channel */
+extern void free_dma(unsigned int dmanr);	/* release it again */
+
+
+#endif /* _ASM_DMA_H */

include/asm-alpha/irq.h

+#ifndef _ALPHA_IRQ_H
+#define _ALPHA_IRQ_H
+
+/*
+ *	linux/include/alpha/irq.h
+ *
+ *	(C) 1994 Linus Torvalds
+ */
+
+#include <linux/linkage.h>
+
+extern void disable_irq(unsigned int);
+extern void enable_irq(unsigned int);
+
+#define __STR(x) #x
+#define STR(x) __STR(x)
+ 
+#define SAVE_ALL "xx"
+
+/*
+ * SAVE_MOST/RESTORE_MOST is used for the faster version of IRQ handlers,
+ * installed by using the SA_INTERRUPT flag. These kinds of IRQ's don't
+ * call the routines that do signal handling etc on return, and can have
+ * more relaxed register-saving etc. They are also atomic, and are thus
+ * suited for small, fast interrupts like the serial lines or the harddisk
+ * drivers, which don't actually need signal handling etc.
+ *
+ * Also note that we actually save only those registers that are used in
+ * C subroutines, so if you do something weird, you're on your own. 
+ */
+#define SAVE_MOST "yy"
+
+#define RESTORE_MOST "zz"
+
+#define ACK_FIRST(mask) "aa"
+
+#define ACK_SECOND(mask) "dummy"
+
+#define UNBLK_FIRST(mask) "dummy"
+
+#define UNBLK_SECOND(mask) "dummy"
+
+#define IRQ_NAME2(nr) nr##_interrupt(void)
+#define IRQ_NAME(nr) IRQ_NAME2(IRQ##nr)
+#define FAST_IRQ_NAME(nr) IRQ_NAME2(fast_IRQ##nr)
+#define BAD_IRQ_NAME(nr) IRQ_NAME2(bad_IRQ##nr)
+	
+#define BUILD_IRQ(chip,nr,mask) \
+asmlinkage void IRQ_NAME(nr); \
+asmlinkage void FAST_IRQ_NAME(nr); \
+asmlinkage void BAD_IRQ_NAME(nr); \
+asm code comes here
+
+#endif

include/asm-alpha/page.h

+#ifndef _ALPHA_PAGE_H
+#define _ALPHA_PAGE_H
+
+#define invalidate_all() \
+__asm__ __volatile__( \
+	"lda $16,-2($31)\n\t" \
+	".long 51" \
+	: : :"$1", "$16", "$17", "$22","$23","$24","$25")
+
+#define invalidate() \
+__asm__ __volatile__( \
+	"lda $16,-1($31)\n\t" \
+	".long 51" \
+	: : :"$1", "$16", "$17", "$22","$23","$24","$25")
+
+			/* PAGE_SHIFT determines the page size */
+#define PAGE_SHIFT			13
+#define PGDIR_SHIFT			23
+#define PAGE_SIZE			(1UL << PAGE_SHIFT)
+#define PGDIR_SIZE			(1UL << PGDIR_SHIFT)
+
+#ifdef __KERNEL__
+
+			/* number of bits that fit into a memory pointer */
+#define BITS_PER_PTR			(8*sizeof(unsigned long))
+			/* to mask away the intra-page address bits */
+#define PAGE_MASK			(~(PAGE_SIZE-1))
+			/* to mask away the intra-page address bits */
+#define PGDIR_MASK			(~(PGDIR_SIZE-1))
+			/* to align the pointer to the (next) page boundary */
+#define PAGE_ALIGN(addr)		(((addr)+PAGE_SIZE-1)&PAGE_MASK)
+			/* to align the pointer to a pointer address */
+#define PTR_MASK			(~(sizeof(void*)-1))
+
+					/* sizeof(void*)==1<<SIZEOF_PTR_LOG2 */
+					/* 64-bit machines, beware!  SRB. */
+#define SIZEOF_PTR_LOG2			4
+
+			/* to find an entry in a page-table-directory */
+#define PAGE_DIR_OFFSET(base,address)	((unsigned long*)((base)+\
+  ((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)*2&PTR_MASK&~PAGE_MASK)))
+			/* to find an entry in a page-table */
+#define PAGE_PTR(address)		\
+  ((unsigned long)(address)>>(PAGE_SHIFT-SIZEOF_PTR_LOG2)&PTR_MASK&~PAGE_MASK)
+			/* the no. of pointers that fit on a page */
+#define PTRS_PER_PAGE			(PAGE_SIZE/sizeof(void*))
+
+#endif /* __KERNEL__ */
+
+#endif /* _ALPHA_PAGE_H */

include/asm-alpha/segment.h

+#ifndef _ASM_SEGMENT_H
+#define _ASM_SEGMENT_H
+
+#include <linux/string.h>
+
+static inline unsigned char get_user_byte(const char * addr)
+{
+	return *addr;
+}
+
+#define get_fs_byte(addr) get_user_byte((char *)(addr))
+
+static inline unsigned short get_user_word(const short *addr)
+{
+	return *addr;
+}
+
+#define get_fs_word(addr) get_user_word((short *)(addr))
+
+static inline unsigned long get_user_long(const int *addr)
+{
+	return *addr;
+}
+
+#define get_fs_long(addr) get_user_long((int *)(addr))
+
+static inline unsigned long get_user_quad(const long *addr)
+{
+	return *addr;
+}
+
+#define get_fs_quad(addr) get_user_quad((long *)(addr))
+
+static inline void put_user_byte(char val,char *addr)
+{
+	*addr = val;
+}
+
+#define put_fs_byte(x,addr) put_user_byte((x),(char *)(addr))
+
+static inline void put_user_word(short val,short * addr)
+{
+	*addr = val;
+}
+
+#define put_fs_word(x,addr) put_user_word((x),(short *)(addr))
+
+static inline void put_user_long(unsigned long val,int * addr)
+{
+	*addr = val;
+}
+
+#define put_fs_long(x,addr) put_user_long((x),(int *)(addr))
+
+static inline void put_user_quad(unsigned long val,long * addr)
+{
+	*addr = val;
+}
+
+#define put_fs_quad(x,addr) put_user_quad((x),(long *)(addr))
+
+#define memcpy_fromfs(to, from, n) memcpy((to),(from),(n))
+
+#define memcpy_tofs(to, from, n) memcpy((to),(from),(n))
+
+static inline unsigned long get_fs(void)
+{
+	return 0;
+}
+
+static inline unsigned long get_ds(void)
+{
+	return 0;
+}
+
+static inline void set_fs(unsigned long val)
+{
+}
+
+#endif /* _ASM_SEGMENT_H */

include/asm-alpha/system.h

@@ -15,7 +15,7 @@
 #define INIT_PCB	0xfffffc0000300000
 #define INIT_STACK	0xfffffc0000302000
 #define START_ADDR	0xfffffc0000304000
-#define SIZE		(32*1024)
+#define START_SIZE	(32*1024)
 
 /*
  * Common PAL-code
@@ -66,18 +66,6 @@
 #define mb() __asm__ __volatile__("mb": : :"memory")
 #endif
 
-#define invalidate_all() \
-__asm__ __volatile__( \
-	"lda $16,-2($31)\n\t" \
-	".long 51" \
-	: : :"$1", "$16", "$17", "$22","$23","$24","$25")
-
-#define invalidate() \
-__asm__ __volatile__( \
-	"lda $16,-1($31)\n\t" \
-	".long 51" \
-	: : :"$1", "$16", "$17", "$22","$23","$24","$25")
-
 #define swpipl(__new_ipl) \
 ({ unsigned long __old_ipl; \
 __asm__ __volatile__( \

include/asm-alpha/types.h

+#ifndef _ALPHA_TYPES_H
+#define _ALPHA_TYPES_H
+
+/*
+ * These aren't exported outside the kernel to avoid name space clashes
+ */
+#ifdef __KERNEL__
+
+typedef signed char s8;
+typedef unsigned char u8;
+
+typedef signed short s16;
+typedef unsigned short u16;
+
+typedef signed int s32;
+typedef unsigned int u32;
+
+/*
+ * There are 32-bit compilers for the alpha out there..
+ */
+#if ((~0UL) == 0xffffffff)
+
+typedef signed long long s64;
+typedef unsigned long long u64;
+
+#else
+
+typedef signed long s64;
+typedef unsigned long u64;
+
+#endif
+
+#endif /* __KERNEL__ */
+
+#endif

include/asm-alpha/unistd.h

+#ifndef _ALPHA_UNISTD_H
+#define _ALPHA_UNISTD_H
+
+/*
+ * ".long 131" is "PAL_callsys"..
+ *
+ * Duh, the alpha gcc compiler doesn't allow us to specify regs
+ * yet. I'll have to see about this later..
+ */
+
+/* XXX - _foo needs to be __foo, while __NR_bar could be _NR_bar. */
+#define _syscall0(type,name) \
+type name(void) \
+{ \
+long __res; \
+__asm__ __volatile__ (".long 131" \
+	: "=a" (__res) \
+	: "0" (__NR_##name)); \
+if (__res >= 0) \
+	return (type) __res; \
+errno = -__res; \
+return -1; \
+}
+
+#define _syscall1(type,name,type1,arg1) \
+type name(type1 arg1) \
+{ \
+long __res; \
+__asm__ __volatile__ (".long 131" \
+	: "=a" (__res) \
+	: "0" (__NR_##name),"b" ((long)(arg1))); \
+if (__res >= 0) \
+	return (type) __res; \
+errno = -__res; \
+return -1; \
+}
+
+#define _syscall2(type,name,type1,arg1,type2,arg2) \
+type name(type1 arg1,type2 arg2) \
+{ \
+long __res; \
+__asm__ __volatile__ (".long 131" \
+	: "=a" (__res) \
+	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2))); \
+if (__res >= 0) \
+	return (type) __res; \
+errno = -__res; \
+return -1; \
+}
+
+#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
+type name(type1 arg1,type2 arg2,type3 arg3) \
+{ \
+long __res; \
+__asm__ __volatile__ (".long 131" \
+	: "=a" (__res) \
+	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
+		  "d" ((long)(arg3))); \
+if (__res>=0) \
+	return (type) __res; \
+errno=-__res; \
+return -1; \
+}
+
+#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
+type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
+{ \
+long __res; \
+__asm__ __volatile__ (".long 131" \
+	: "=a" (__res) \
+	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
+	  "d" ((long)(arg3)),"S" ((long)(arg4))); \
+if (__res>=0) \
+	return (type) __res; \
+errno=-__res; \
+return -1; \
+} 
+
+#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
+	  type5,arg5) \
+type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
+{ \
+long __res; \
+__asm__ __volatile__ (".long 131" \
+	: "=a" (__res) \
+	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2)), \
+	  "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5))); \
+if (__res>=0) \
+	return (type) __res; \
+errno=-__res; \
+return -1; \
+}
+
+#endif /* _ALPHA_UNISTD_H */

include/asm-i386/dma.h

@@ -17,6 +17,8 @@
 #define dma_outb	outb
 #endif
 
+#define dma_inb		inb
+
 /*
  * NOTES about DMA transfers:
  *
@@ -251,8 +253,8 @@ static __inline__ int get_dma_residue(unsigned int dmanr)
 	/* using short to get 16-bit wrap around */
 	unsigned short count;
 
-	count = 1 + inb(io_port);
-	count += inb(io_port) << 8;
+	count = 1 + dma_inb(io_port);
+	count += dma_inb(io_port) << 8;
 	
 	return (dmanr<=3)? count : (count<<1);
 }

include/asm-i386/irq.h

@@ -7,8 +7,8 @@
  *	(C) 1992, 1993 Linus Torvalds
  */
 
-#include <linux/segment.h>
 #include <linux/linkage.h>
+#include <asm/segment.h>
 
 extern void disable_irq(unsigned int);
 extern void enable_irq(unsigned int);

include/linux/page.h → include/asm-i386/page.h

-#ifndef _LINUX_PAGE_H
-#define _LINUX_PAGE_H
+#ifndef _I386_PAGE_H
+#define _I386_PAGE_H
+
+#define invalidate() \
+__asm__ __volatile__("movl %%cr3,%%eax\n\tmovl %%eax,%%cr3": : :"ax")
 
 			/* PAGE_SHIFT determines the page size */
 #define PAGE_SHIFT			12
@@ -35,4 +38,4 @@
 
 #endif /* __KERNEL__ */
 
-#endif /* _LINUX_PAGE_H */
+#endif /* _I386_PAGE_H */

include/asm-i386/segment.h

 #ifndef _ASM_SEGMENT_H
 #define _ASM_SEGMENT_H
 
+#define KERNEL_CS	0x10
+#define KERNEL_DS	0x18
+
+#define USER_CS		0x23
+#define USER_DS		0x2B
+
+#ifndef __ASSEMBLY__
+
 static inline unsigned char get_user_byte(const char * addr)
 {
 	register unsigned char _v;
@@ -216,4 +224,6 @@ static inline void set_fs(unsigned long val)
 	__asm__ __volatile__("mov %w0,%%fs": /* no output */ :"r" (val));
 }
 
+#endif /* __ASSEMBLY__ */
+
 #endif /* _ASM_SEGMENT_H */

include/asm-i386/system.h

 #ifndef __ASM_SYSTEM_H
 #define __ASM_SYSTEM_H
 
-#include <linux/segment.h>
+#include <asm/segment.h>
 
 #define move_to_user_mode() \
 __asm__ __volatile__ ("movl %%esp,%%eax\n\t" \

include/asm-i386/types.h

+#ifndef _I386_TYPES_H
+#define _I386_TYPES_H
+
+/*
+ * These aren't exported outside the kernel to avoid name space clashes
+ */
+#ifdef __KERNEL__
+
+typedef signed char s8;
+typedef unsigned char u8;
+
+typedef signed short s16;
+typedef unsigned short u16;
+
+typedef signed long s32;
+typedef unsigned long u32;
+
+typedef signed long long s64;
+typedef unsigned long long u64;
+
+#endif /* __KERNEL__ */
+
+#endif

include/asm-mips/segment.h

@@ -12,8 +12,6 @@
 #ifndef _ASM_MIPS_SEGMENT_H_
 #define _ASM_MIPS_SEGMENT_H_
 
-#include <linux/segment.h>
-
 static inline unsigned char get_user_byte(const char * addr)
 {
 	register unsigned char _v;

include/asm-mips/system.h

@@ -11,7 +11,7 @@
 #ifndef _ASM_MIPS_SYSTEM_H_
 #define _ASM_MIPS_SYSTEM_H_
 
-#include <linux/segment.h>
+#include <asm/segment.h>
 #include <mips/mipsregs.h>
 
 /*

include/linux/a.out.h

@@ -136,7 +136,7 @@ enum machine_type {
 #endif
 
 #ifdef linux
-#include <linux/page.h>
+#include <asm/page.h>
 #define SEGMENT_SIZE	1024
 #endif
 

include/linux/fd.h

@@ -54,7 +54,7 @@
 			     512 : 128 << FD_SIZECODE(floppy) )
 #define FD_PERP 0x40
 
-#ifndef ASSEMBLER
+#ifndef __ASSEMBLY__
 /* the following structure is used by FDSETPRM, FDDEFPRM and FDGETPRM */
 struct floppy_struct {
 	unsigned int	size,		/* nr of sectors total */

include/linux/fs.h

@@ -29,7 +29,6 @@
 #define NR_FILE 1024	/* this can well be larger on a larger system */
 #define NR_SUPER 32
 #define NR_IHASH 131
-#define NR_FILE_LOCKS 64
 #define BLOCK_SIZE 1024
 #define BLOCK_SIZE_BITS 10
 
@@ -267,6 +266,7 @@ struct file {
 
 struct file_lock {
 	struct file_lock *fl_next;	/* singly linked list */
+	struct file_lock *fl_nextlink;
 	struct task_struct *fl_owner;	/* NULL if on free list, for sanity checks */
         unsigned int fl_fd;             /* File descriptor for this lock */
 	struct wait_queue *fl_wait;

include/linux/ip.h

@@ -29,23 +29,24 @@
 
 
 struct timestamp {
-  unsigned char	len;
-  unsigned char ptr;
-  union {
+	u8	len;
+	u8	ptr;
+	union {
 #if defined(__i386__)  
-	unsigned char	flags:4,
+		u8	flags:4,
 			overflow:4;
-#else
-#if defined(__mc680x0__)
-	unsigned char	overflow:4,
+#elif defined(__mc680x0__)
+		u8	overflow:4,
 			flags:4;
+#elif defined(__alpha__)
+		u8	flags:4,
+			overflow:4;
 #else
 #error	"Adjust this structure to match your CPU"
-#endif
 #endif						
-	unsigned char	full_char;
-  } x;
-  unsigned long	data[9];
+		u8	full_char;
+	} x;
+	u32	data[9];
 };
 
 
@@ -73,26 +74,27 @@ struct options {
 
 struct iphdr {
 #if defined(__i386__)
-  unsigned char		ihl:4,
-			version:4;
-#else
-#if defined (__mc680x0__)
-  unsigned char		version:4,
-  			ihl:4;
+	u8	ihl:4,
+		version:4;
+#elif defined (__mc680x0__)
+	u8	version:4,
+  		ihl:4;
+#elif defined (__alpha__)
+	u8	ihl:4,
+		version:4;
 #else
 #error "Adjust this structure to match your CPU"
-#endif			
 #endif
-  unsigned char		tos;
-  unsigned short	tot_len;
-  unsigned short	id;
-  unsigned short	frag_off;
-  unsigned char		ttl;
-  unsigned char		protocol;
-  unsigned short	check;
-  unsigned long		saddr;
-  unsigned long		daddr;
-  /*The options start here. */
+	u8	tos;
+	u16	tot_len;
+	u16	id;
+	u16	frag_off;
+	u8	ttl;
+	u8	protocol;
+	u16	check;
+	u32	saddr;
+	u32	daddr;
+	/*The options start here. */
 };
 
 

include/linux/mm.h

 #ifndef _LINUX_MM_H
 #define _LINUX_MM_H
 
-#include <linux/page.h>
+#include <asm/page.h>
+
 #include <linux/sched.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
@@ -204,9 +205,6 @@ extern unsigned long get_unmapped_area(unsigned long);
 #define write_swap_page(nr,buf) \
 	rw_swap_page(WRITE,(nr),(buf))
 
-#define invalidate() \
-__asm__ __volatile__("movl %%cr3,%%eax\n\tmovl %%eax,%%cr3": : :"ax")
-
 extern unsigned long high_memory;
 
 #define MAP_NR(addr) ((addr) >> PAGE_SHIFT)

include/linux/segment.h

-#ifndef _LINUX_SEGMENT_H
-#define _LINUX_SEGMENT_H
-
-#define KERNEL_CS	0x10
-#define KERNEL_DS	0x18
-
-#define USER_CS		0x23
-#define USER_DS		0x2B
-
-#endif

include/linux/soundcard.h

@@ -40,7 +40,7 @@
 #define SOUND_VERSION	300
 #define VOXWARE
 
-#include <sys/ioctl.h>
+#include <linux/ioctl.h>
 
 /*
  *	Supported card ID numbers (Should be somewhere else?)

include/linux/tcp.h

@@ -17,43 +17,52 @@
 #ifndef _LINUX_TCP_H
 #define _LINUX_TCP_H
 
+#include <asm/types.h>
 
 #define HEADER_SIZE	64		/* maximum header size		*/
 
 
 struct tcphdr {
-  unsigned short	source;
-  unsigned short	dest;
-  unsigned long		seq;
-  unsigned long		ack_seq;
+	u16	source;
+	u16	dest;
+	u32	seq;
+	u32	ack_seq;
 #if defined(__i386__)
-  unsigned short	res1:4,
-			doff:4,
-			fin:1,
-			syn:1,
-			rst:1,
-			psh:1,
-			ack:1,
-			urg:1,
-			res2:2;
-#else
-#if defined(__mc680x0__)
-  unsigned short	res2:2,
-  			urg:1,
-  			ack:1,
-  			psh:1,
-  			rst:1,
-  			syn:1,
-  			fin:1,
-  			doff:4,
-  			res1:4;
+	u16	res1:4,
+		doff:4,
+		fin:1,
+		syn:1,
+		rst:1,
+		psh:1,
+		ack:1,
+		urg:1,
+		res2:2;
+#elif defined(__mc680x0__)
+	u16	res2:2,
+		urg:1,
+		ack:1,
+		psh:1,
+		rst:1,
+		syn:1,
+		fin:1,
+		doff:4,
+		res1:4;
+#elif defined(__alpha__)
+	u16	res1:4,
+		doff:4,
+		fin:1,
+		syn:1,
+		rst:1,
+		psh:1,
+		ack:1,
+		urg:1,
+		res2:2;
 #else
 #error	"Adjust this structure for your cpu alignment rules"
-#endif  		
 #endif	
-  unsigned short	window;
-  unsigned short	check;
-  unsigned short	urg_ptr;
+	u16	window;
+	u16	check;
+	u16	urg_ptr;
 };
 
 

include/linux/types.h

 #ifndef _LINUX_TYPES_H
 #define _LINUX_TYPES_H
 
+#include <asm/types.h>
+
 #ifndef _SIZE_T
 #define _SIZE_T
 typedef unsigned int size_t;
@@ -34,11 +36,7 @@ typedef int pid_t;
 typedef unsigned short uid_t;
 typedef unsigned short gid_t;
 typedef unsigned short dev_t;
-#ifdef OLD_LINUX
-typedef unsigned short ino_t;
-#else
 typedef unsigned long ino_t;
-#endif
 typedef unsigned short mode_t;
 typedef unsigned short umode_t;
 typedef unsigned short nlink_t;

include/linux/umsdos_fs.h

@@ -79,14 +79,12 @@ struct umsdos_info{
 #define UMSDOS_INIT_EMD		1242	/* Create the EMD file if not there */
 #define UMSDOS_DOS_SETUP	1243	/* Set the defaults of the MsDOS driver */
 
-#ifndef _SYS_STAT_H
-#include <sys/stat.h>
-#endif
+#include <linux/stat.h>
 
 struct umsdos_ioctl{
 	struct dirent dos_dirent;
 	struct umsdos_dirent umsdos_dirent;
-	struct stat stat;
+	struct new_stat stat;
 	char version,release;
 };
 

kernel/bios32.c

@@ -36,10 +36,11 @@
 
 #include <linux/config.h>
 #include <linux/kernel.h>
-#include <linux/segment.h>
 #include <linux/bios32.h>
 #include <linux/pci.h>
 
+#include <asm/segment.h>
+
 /*
  * It would seem some PCI bioses are buggy, so we don't actually use these
  * routines unless we need to..

kernel/fork.c

@@ -17,7 +17,6 @@
 #include <linux/mm.h>
 #include <linux/stddef.h>
 #include <linux/unistd.h>
-#include <linux/segment.h>
 #include <linux/ptrace.h>
 #include <linux/malloc.h>
 #include <linux/ldt.h>

kernel/ksyms.c

@@ -128,6 +128,8 @@ struct symbol_table symbol_table = { 0, 0, 0, /* for stacked module support */
 	X(blk_dev),
 	X(is_read_only),
 	X(set_device_ro),
+	X(bmap),
+	X(sync_dev),
 	
 	/* Module creation of serial units */
 	X(register_serial),

kernel/module.c

@@ -7,6 +7,10 @@
 #include <linux/sched.h>
 #include <linux/malloc.h>
 /*
+ * Originally by Anonymous (as far as I know...)
+ * Linux version by Bas Laarhoven <bas@vimec.nl>
+ * 0.99.14 version by Jon Tombs <jon@gtex02.us.es>,
+ *
  * Heavily modified by Bjorn Ekwall <bj0rn@blox.se> May 1994 (C)
  * This source is covered by the GNU GPL, the same as all kernel sources.
  *
@@ -213,6 +217,7 @@ sys_init_module(char *module_name, char *code, unsigned codesize,
 		struct module_ref *ref;
 		int size;
 		int i;
+		int legal_start;
 
 		if ((error = verify_area(VERIFY_READ, symtab, sizeof(int))))
 			return error;
@@ -222,13 +227,33 @@ sys_init_module(char *module_name, char *code, unsigned codesize,
 			return -ENOMEM;
 		}
 
-		if ((error = verify_area(VERIFY_READ, symtab, size)))
+		if ((error = verify_area(VERIFY_READ, symtab, size))) {
+			kfree_s(newtab, size);
 			return error;
+		}
 		memcpy_fromfs((char *)(newtab), symtab, size);
 
+		/* sanity check */
+		legal_start = sizeof(struct symbol_table) +
+			newtab->n_symbols * sizeof(struct internal_symbol) +
+			newtab->n_refs * sizeof(struct module_ref);
+
+		if ((newtab->n_symbols < 0) || (newtab->n_refs < 0) ||
+			(legal_start > size)) {
+			printk("Illegal symbol table! Rejected!\n");
+			kfree_s(newtab, size);
+			return -EINVAL;
+		}
+
 		/* relocate name pointers, index referred from start of table */
 		for (sym = &(newtab->symbol[0]), i = 0;
 			i < newtab->n_symbols; ++sym, ++i) {
+			if ((int)sym->name < legal_start || size <= (int)sym->name) {
+				printk("Illegal symbol table! Rejected!\n");
+				kfree_s(newtab, size);
+				return -EINVAL;
+			}
+			/* else */
 			sym->name += (long)newtab;
 		}
 		mp->symtab = newtab;
@@ -236,10 +261,24 @@ sys_init_module(char *module_name, char *code, unsigned codesize,
 		/* Update module references.
 		 * On entry, from "insmod", ref->module points to
 		 * the referenced module!
+		 * Now it will point to the current module instead!
+		 * The ref structure becomes the first link in the linked
+		 * list of references to the referenced module.
 		 * Also, "sym" from above, points to the first ref entry!!!
 		 */
 		for (ref = (struct module_ref *)sym, i = 0;
 			i < newtab->n_refs; ++ref, ++i) {
+
+			/* Check for valid reference */
+			struct module *link = module_list;
+			while (link && (ref->module != link))
+				link = link->next;
+
+			if (link == (struct module *)0) {
+				printk("Non-module reference! Rejected!\n");
+				return -EINVAL;
+			}
+
 			ref->next = ref->module->ref;
 			ref->module->ref = ref;
 			ref->module = mp;

kernel/sched.c

@@ -21,7 +21,6 @@
 #include <linux/errno.h>
 #include <linux/time.h>
 #include <linux/ptrace.h>
-#include <linux/segment.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/tqueue.h>

kernel/traps.c

@@ -15,7 +15,6 @@
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
-#include <linux/segment.h>
 #include <linux/ptrace.h>
 
 #include <asm/system.h>

mm/memory.c

@@ -33,9 +33,7 @@
  * 		Idea by Alex Bligh (alex@cconcepts.co.uk)
  */
 
-#include <asm/system.h>
 #include <linux/config.h>
-
 #include <linux/signal.h>
 #include <linux/sched.h>
 #include <linux/head.h>
@@ -45,7 +43,8 @@
 #include <linux/types.h>
 #include <linux/ptrace.h>
 #include <linux/mman.h>
-#include <linux/segment.h>
+
+#include <asm/system.h>
 #include <asm/segment.h>
 
 /*

net/inet/af_inet.c

@@ -1307,12 +1307,6 @@ struct sock *get_sock(struct proto *prot, unsigned short num,
 				continue;
 			score++;
 		}
-		/*
-		 * strange but true: udp sockets don't care that much
-		 * about the remote address.
-		 */
-		if (prot == &udp_prot)
-			return s;
 		/* remote address matches? */
 		if (s->daddr) {
 			if (s->daddr != raddr)

net/inet/sock.c

@@ -504,7 +504,7 @@ void release_sock(struct sock *sk)
 	/*
 	 *	Make the backlog atomic. If we don't do this there is a tiny
 	 *	window where a packet may arrive between the sk->blog being 
-	 *	tested and then set with sk->inuse stil 0 causing an extra 
+	 *	tested and then set with sk->inuse still 0 causing an extra 
 	 *	unwanted re-entry into release_sock().
 	 */
 

net/inet/tcp.c

@@ -3100,8 +3100,8 @@ static int tcp_data(struct sk_buff *skb, struct sock *sk,
 		 *	the naive implementation:
 		 *		after(new_seq,sk->acked_seq+1)
 		 *	will cause bogus resets IFF a resend of a frame that has
-		 *	been queued but not yet read after a shutdown has been done
-		 *	occured.What we do now is a bit more complex but works as
+		 *	been queued but not yet read after a shutdown has been done.
+		 *	What we do now is a bit more complex but works as
 		 *	follows. If the queue is empty copied_seq+1 is right (+1 for FIN)
 		 *	if the queue has data the shutdown occurs at the right edge of
 		 *	the last packet queued +1
@@ -4160,7 +4160,7 @@ tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
 			if (!th->rst) {
 				if (!th->ack)
 					th->ack_seq = 0;
-				if(sk->debug) printk("Reset on closed socket %s.\n",sk->blog);
+				if(sk->debug) printk("Reset on closed socket %d.\n",sk->blog);
 				tcp_reset(daddr, saddr, th, sk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
 			}
 			kfree_skb(skb, FREE_READ);
@@ -4174,7 +4174,7 @@ tcp_rcv(struct sk_buff *skb, struct device *dev, struct options *opt,
 				return(0);
 			}
 			if (th->ack) {
-				printk("Reset on listening socket %d.\n",sk->blog);
+				if(sk->debug) printk("Reset on listening socket %d.\n",sk->blog);
 				tcp_reset(daddr, saddr, th, sk->prot, opt,dev,sk->ip_tos,sk->ip_ttl);
 				kfree_skb(skb, FREE_READ);
 				release_sock(sk);

zBoot/head.S

@@ -18,7 +18,8 @@
  */
 .text
 
-#include <linux/segment.h>
+#define __ASSEMBLY__
+#include <asm/segment.h>
 
 startup_32:
 	cld

zBoot/misc.c

@@ -11,7 +11,7 @@
 #include "gzip.h"
 #include "lzw.h"
 
-#include <linux/segment.h>
+#include <asm/segment.h>
 
 /*
  * These are set up by the setup-routine at boot-time: