r923 - trunk/linux

jim at linuxfromscratch.org jim at linuxfromscratch.org
Sun Apr 24 13:04:15 PDT 2005


Author: jim
Date: 2005-04-24 14:04:14 -0600 (Sun, 24 Apr 2005)
New Revision: 923

Added:
   trunk/linux/linux-2.4.30-pseudo_random-1.patch
   trunk/linux/linux-2.4.30-unistd_x86_PIC-1.patch
Log:
Added: linux-2.4.30-pseudo_random-1.patch linux-2.4.30-unistd_x86_PIC-1.patch

Added: trunk/linux/linux-2.4.30-pseudo_random-1.patch
===================================================================
--- trunk/linux/linux-2.4.30-pseudo_random-1.patch	2005-04-15 16:14:53 UTC (rev 922)
+++ trunk/linux/linux-2.4.30-pseudo_random-1.patch	2005-04-24 20:04:14 UTC (rev 923)
@@ -0,0 +1,631 @@
+Submitted By: Robert Connolly <robert at linuxfromscratch dot org> (ashes)
+Date: 2005-04-17
+Initial Package Version: 2.4.30
+Upstream Status: Not submitted
+Origin: http://frandom.sourceforge.net/
+Description: This patch adds the he frandom, and erandom devices, and a
+sysctl interface for urandom.
+
+mknod /dev/frandom c 235 11
+mknod /dev/erandom c 235 12
+
+Also see:
+http://www.linuxfromscratch.org/hlfs/
+http://www.linuxfromscratch.org/hints/downloads/files/entropy.txt
+
+diff -Naur linux-2.4.30.orig/Documentation/Configure.help linux-2.4.30/Documentation/Configure.help
+--- linux-2.4.30.orig/Documentation/Configure.help	2005-04-04 01:42:19.000000000 +0000
++++ linux-2.4.30/Documentation/Configure.help	2005-04-17 03:51:25.000000000 +0000
+@@ -4642,6 +4642,13 @@
+   building a kernel for install/rescue disks or your system is very
+   limited in memory.
+ 
++Sysctl_Urandom support
++CONFIG_SYSCTL_URANDOM
++ If you say Y here, hooks will be enabled to access get_random_bytes()
++ from sysctl kernel.random.urandom. This is a non-blocking interface.
++ The main advantage to this is to be able to access urandom through
++ a chroot.
++
+ # Choice: kcore
+ Kernel core (/proc/kcore) format
+ CONFIG_KCORE_ELF
+@@ -18491,6 +18498,17 @@
+   input/output character sets. Say Y here for the UTF-8 encoding of
+   the Unicode/ISO9646 universal character set.
+ 
++Fast random data generator suite (/dev/frandom and /dev/erandom)
++CONFIG_FRANDOM
++  Fast random data/number generator support in kernel. This random
++  generator is 10-50 times faster than /dev/urandom, and saves kernel
++  entropy.
++
++  If unsure, say Y unless you're tight on kernel size. This module is
++  small and harmless otherwise.
++
++  If you choose M, the sysctl interface will be disabled.
++
+ Virtual terminal
+ CONFIG_VT
+   If you say Y here, you will get support for terminal devices with
+diff -Naur linux-2.4.30.orig/arch/i386/config.in linux-2.4.30/arch/i386/config.in
+--- linux-2.4.30.orig/arch/i386/config.in	2004-11-17 11:54:21.000000000 +0000
++++ linux-2.4.30/arch/i386/config.in	2005-04-17 03:57:58.000000000 +0000
+@@ -320,6 +320,9 @@
+ bool 'System V IPC' CONFIG_SYSVIPC
+ bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
+ bool 'Sysctl support' CONFIG_SYSCTL
++if [ "$CONFIG_SYSCTL" = "y" ]; then
++   bool 'Sysctl Urandom support' CONFIG_SYSCTL_URANDOM
++fi
+ if [ "$CONFIG_PROC_FS" = "y" ]; then
+    choice 'Kernel core (/proc/kcore) format' \
+ 	"ELF		CONFIG_KCORE_ELF	\
+diff -Naur linux-2.4.30.orig/arch/i386/defconfig linux-2.4.30/arch/i386/defconfig
+--- linux-2.4.30.orig/arch/i386/defconfig	2005-01-19 14:09:25.000000000 +0000
++++ linux-2.4.30/arch/i386/defconfig	2005-04-17 03:52:21.000000000 +0000
+@@ -113,6 +113,7 @@
+ CONFIG_SYSVIPC=y
+ # CONFIG_BSD_PROCESS_ACCT is not set
+ CONFIG_SYSCTL=y
++CONFIG_SYSCTL_URANDOM=y
+ CONFIG_KCORE_ELF=y
+ # CONFIG_KCORE_AOUT is not set
+ CONFIG_BINFMT_AOUT=y
+@@ -580,6 +581,7 @@
+ #
+ CONFIG_VT=y
+ CONFIG_VT_CONSOLE=y
++CONFIG_FRANDOM=y
+ CONFIG_SERIAL=y
+ # CONFIG_SERIAL_CONSOLE is not set
+ # CONFIG_SERIAL_EXTENDED is not set
+diff -Naur linux-2.4.30.orig/drivers/char/Config.in linux-2.4.30/drivers/char/Config.in
+--- linux-2.4.30.orig/drivers/char/Config.in	2004-08-07 23:26:04.000000000 +0000
++++ linux-2.4.30/drivers/char/Config.in	2005-04-17 03:44:32.000000000 +0000
+@@ -25,6 +25,7 @@
+       tristate '   Dual serial port support' CONFIG_DUALSP_SERIAL
+    fi
+ fi
++tristate 'Fast random data generator suite (/dev/frandom and /dev/erandom)' CONFIG_FRANDOM
+ dep_mbool 'Extended dumb serial driver options' CONFIG_SERIAL_EXTENDED $CONFIG_SERIAL
+ if [ "$CONFIG_SERIAL_EXTENDED" = "y" ]; then
+    bool '  Support more than 4 serial ports' CONFIG_SERIAL_MANY_PORTS
+diff -Naur linux-2.4.30.orig/drivers/char/Makefile linux-2.4.30/drivers/char/Makefile
+--- linux-2.4.30.orig/drivers/char/Makefile	2004-08-07 23:26:04.000000000 +0000
++++ linux-2.4.30/drivers/char/Makefile	2005-04-17 03:44:32.000000000 +0000
+@@ -25,7 +25,7 @@
+ 			misc.o pty.o random.o selection.o serial.o \
+ 			sonypi.o tty_io.o tty_ioctl.o generic_serial.o \
+ 			au1000_gpio.o vac-serial.o hp_psaux.o nvram.o \
+-			scx200.o fetchop.o
++			scx200.o fetchop.o frandom.o
+ 
+ mod-subdirs	:=	joystick ftape drm drm-4.0 pcmcia
+ 
+@@ -334,6 +334,8 @@
+   obj-y += ipmi/ipmi.o
+ endif
+ 
++obj-$(CONFIG_FRANDOM) += frandom.o
++
+ include $(TOPDIR)/Rules.make
+ 
+ fastdep:
+diff -Naur linux-2.4.30.orig/drivers/char/frandom.c linux-2.4.30/drivers/char/frandom.c
+--- linux-2.4.30.orig/drivers/char/frandom.c	1970-01-01 00:00:00.000000000 +0000
++++ linux-2.4.30/drivers/char/frandom.c	2005-04-17 03:44:33.000000000 +0000
+@@ -0,0 +1,362 @@
++/*
++** frandom.c
++**      Fast pseudo-random generator 
++**
++**      (c) Copyright 2003 Eli Billauer
++**      http://www.billauer.co.il
++**
++** 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.
++**
++** Usage: mknod /dev/frandom c 235 11
++**        mknod /dev/erandom c 235 12
++**        insmod frandom
++**
++** This code is highly based upon the examples given in the book "Linux
++** Device Drivers" by Alessandro Rubini and Jonathan Corbet, published
++** by O'Reilly & Associates.
++** O'Reilly's release of this book on the web for free is highly
++** appreciated.
++**
++*/
++
++#include <linux/version.h>
++#include <linux/config.h>
++#include <linux/module.h>
++
++#include <linux/kernel.h>
++#include <linux/init.h>
++#include <linux/slab.h> 
++#include <linux/fs.h> 
++#include <linux/errno.h>
++#include <linux/types.h> 
++#include <linux/random.h>
++
++#include <asm/uaccess.h>
++
++#if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,0))
++#include <linux/moduleparam.h>
++#endif
++
++#define INTERNAL_SEED 0
++#define EXTERNAL_SEED 1
++
++#define FRANDOM_MAJOR 235
++#define FRANDOM_MINOR 11 
++#define ERANDOM_MINOR 12 
++
++static struct file_operations frandom_fops; /* Values assigned below */
++
++static int erandom_seeded = 0; /* Internal flag */
++
++static int frandom_major = FRANDOM_MAJOR;
++static int frandom_minor = FRANDOM_MINOR;
++static int erandom_minor = ERANDOM_MINOR;
++static int frandom_bufsize = 256;
++static int frandom_chunklimit = 0; /* =0 means unlimited */
++
++MODULE_DESCRIPTION("Fast pseudo-random number generator");
++MODULE_LICENSE("GPL");
++MODULE_AUTHOR("Eli Billauer");
++MODULE_PARM(frandom_major,"i");
++MODULE_PARM_DESC(frandom_major,"Major number of /dev/frandom and /dev/erandom");
++MODULE_PARM(frandom_minor,"i");
++MODULE_PARM_DESC(frandom_minor,"Minor number of /dev/frandom");
++MODULE_PARM(erandom_minor,"i");
++MODULE_PARM_DESC(erandom_minor,"Minor number of /dev/erandom");
++MODULE_PARM(frandom_bufsize,"i");
++MODULE_PARM_DESC(frandom_bufsize,"Internal buffer size in bytes. Default is 256. Must be >= 256");
++MODULE_PARM(frandom_chunklimit,"i");
++MODULE_PARM_DESC(frandom_chunklimit,"Limit for read() blocks size. 0 (default) is unlimited, otherwise must be >= 256");
++
++struct frandom_state
++{
++	struct semaphore sem; /* Semaphore on the state structure */
++
++	u8 S[256]; /* The state array */
++	u8 i;        
++	u8 j;
++
++	char *buf;
++};
++
++static struct frandom_state *erandom_state;
++
++static inline void swap_byte(u8 *a, u8 *b)
++{
++	u8 swapByte; 
++  
++	swapByte = *a; 
++	*a = *b;      
++	*b = swapByte;
++}
++
++static void init_rand_state(struct frandom_state *state, int seedflag);
++
++void erandom_get_random_bytes(char *buf, size_t count)
++{
++	struct frandom_state *state = erandom_state;
++	int k;
++
++	unsigned int i;
++	unsigned int j;
++	u8 *S;
++  
++	/* If we fail to get the semaphore, we revert to external random data.
++	   Since semaphore blocking is expected to be very rare, and interrupts
++	   during these rare and very short periods of time even less frequent,
++	   we take the better-safe-than-sorry approach, and fill the buffer
++	   some expensive random data, in case the caller wasn't aware of this
++	   possibility, and expects random data anyhow.
++	*/
++
++	if (down_interruptible(&state->sem)) {
++		get_random_bytes(buf, count);
++		return;
++	}
++
++	/* We seed erandom as late as possible, hoping that the kernel's main
++	   RNG is already restored in the boot sequence (not critical, but
++	   better.
++	*/
++	
++	if (!erandom_seeded) {
++		erandom_seeded = 1;
++		init_rand_state(state, EXTERNAL_SEED);
++		printk(KERN_INFO "frandom: Seeded global generator now (used by erandom)\n");
++	}
++
++	i = state->i;     
++	j = state->j;
++	S = state->S;  
++
++	for (k=0; k<count; k++) {
++		i = (i + 1) & 0xff;
++		j = (j + S[i]) & 0xff;
++		swap_byte(&S[i], &S[j]);
++		*buf++ = S[(S[i] + S[j]) & 0xff];
++	}
++ 
++	state->i = i;     
++	state->j = j;
++
++	up(&state->sem);
++}
++
++static void init_rand_state(struct frandom_state *state, int seedflag)
++{
++	unsigned int i, j, k;
++	u8 *S;
++	u8 *seed = state->buf;
++
++	if (seedflag == INTERNAL_SEED)
++		erandom_get_random_bytes(seed, 256);
++	else
++		get_random_bytes(seed, 256);
++
++	S = state->S;
++	for (i=0; i<256; i++)
++		*S++=i;
++
++	j=0;
++	S = state->S;
++
++	for (i=0; i<256; i++) {
++		j = (j + S[i] + *seed++) & 0xff;
++		swap_byte(&S[i], &S[j]);
++	}
++
++	/* It's considered good practice to discard the first 256 bytes
++	   generated. So we do it:
++	*/
++
++	i=0; j=0;
++	for (k=0; k<256; k++) {
++		i = (i + 1) & 0xff;
++		j = (j + S[i]) & 0xff;
++		swap_byte(&S[i], &S[j]);
++	}
++
++	state->i = i; /* Save state */
++	state->j = j;
++}
++
++static int frandom_open(struct inode *inode, struct file *filp)
++{
++  
++	struct frandom_state *state;
++
++	int num =MINOR(inode->i_rdev);
++	if ((num != frandom_minor) && (num != erandom_minor)) return -ENODEV;
++  
++	state = kmalloc(sizeof(struct frandom_state), GFP_KERNEL);
++	if (!state)
++		return -ENOMEM;
++
++	state->buf = kmalloc(frandom_bufsize, GFP_KERNEL);
++	if (!state->buf) {
++		kfree(state);
++		return -ENOMEM;
++	}
++
++	sema_init(&state->sem, 1); /* Init semaphore as a mutex */
++
++	if (num == frandom_minor)
++		init_rand_state(state, EXTERNAL_SEED);
++	else
++		init_rand_state(state, INTERNAL_SEED);
++
++	filp->private_data = state;
++
++#if (LINUX_VERSION_CODE<KERNEL_VERSION(2,4,0))
++	MOD_INC_USE_COUNT; 
++#endif
++  
++	return 0; /* Success */
++}
++
++static int frandom_release(struct inode *inode, struct file *filp)
++{
++
++	struct frandom_state *state = filp->private_data;
++
++	kfree(state->buf);
++	kfree(state);
++  
++#if (LINUX_VERSION_CODE<KERNEL_VERSION(2,4,0))
++	MOD_DEC_USE_COUNT;
++#endif
++
++	return 0;
++}
++
++static ssize_t frandom_read(struct file *filp, char *buf, size_t count,
++			    loff_t *f_pos)
++{
++	struct frandom_state *state = filp->private_data;
++	ssize_t ret;
++	int dobytes, k;
++	char *localbuf;
++
++	unsigned int i;
++	unsigned int j;
++	u8 *S;
++  
++	if (down_interruptible(&state->sem))
++		return -ERESTARTSYS;
++  
++	if ((frandom_chunklimit > 0) && (count > frandom_chunklimit))
++		count = frandom_chunklimit;
++
++	ret = count; /* It's either everything or an error... */
++  
++	i = state->i;     
++	j = state->j;
++	S = state->S;  
++
++	while (count) {
++		if (count > frandom_bufsize)
++			dobytes = frandom_bufsize;
++		else
++			dobytes = count;
++
++		localbuf = state->buf;
++
++		for (k=0; k<dobytes; k++) {
++			i = (i + 1) & 0xff;
++			j = (j + S[i]) & 0xff;
++			swap_byte(&S[i], &S[j]);
++			*localbuf++ = S[(S[i] + S[j]) & 0xff];
++		}
++ 
++		if (copy_to_user(buf, state->buf, dobytes)) {
++			ret = -EFAULT;
++			goto out;
++		}
++
++		buf += dobytes;
++		count -= dobytes;
++	}
++
++ out:
++	state->i = i;     
++	state->j = j;
++
++	up(&state->sem);
++	return ret;
++}
++
++static struct file_operations frandom_fops = {
++	read:       frandom_read,
++	open:       frandom_open,
++	release:    frandom_release,
++};
++
++static void frandom_cleanup_module(void) {
++	kfree(erandom_state->buf);
++	kfree(erandom_state);
++ 
++	unregister_chrdev(frandom_major, "frandom");
++}
++
++
++static int frandom_init_module(void)
++{
++	int result;
++
++	/* The buffer size MUST be at least 256 bytes, because we assume that
++	   minimal length in init_rand_state().
++	*/       
++	if (frandom_bufsize < 256) {
++		printk(KERN_ERR "frandom: Refused to load because frandom_bufsize=%d < 256\n",frandom_bufsize);
++		return -EINVAL;
++	}
++	if ((frandom_chunklimit != 0) && (frandom_chunklimit < 256)) {
++		printk(KERN_ERR "frandom: Refused to load because frandom_chunklimit=%d < 256 and != 0\n",frandom_chunklimit);
++		return -EINVAL;
++	}
++
++	erandom_state = kmalloc(sizeof(struct frandom_state), GFP_KERNEL);
++	if (!erandom_state)
++		return -ENOMEM;
++
++	/* This specific buffer is only used for seeding, so we need
++	   256 bytes exactly */
++	erandom_state->buf = kmalloc(256, GFP_KERNEL);
++	if (!erandom_state->buf) {
++		kfree(erandom_state);
++		return -ENOMEM;
++	}
++
++	sema_init(&erandom_state->sem, 1); /* Init semaphore as a mutex */
++
++	erandom_seeded = 0;
++
++#ifdef SET_MODULE_OWNER
++	SET_MODULE_OWNER(&frandom_fops);
++#endif
++	/*
++	 * Register your major, and accept a dynamic number. This is the
++	 * first thing to do, in order to avoid releasing other module's
++	 * fops in frandom_cleanup_module()
++	 */
++	result = register_chrdev(frandom_major, "frandom", &frandom_fops);
++	if (result < 0) {
++		printk(KERN_WARNING "frandom: can't get major %d\n",frandom_major);
++
++		kfree(erandom_state->buf);
++		kfree(erandom_state);
++	
++		return result;
++	}
++	if (frandom_major == 0) frandom_major = result; /* dynamic */
++    
++	return 0; /* succeed */
++}
++
++module_init(frandom_init_module);
++module_exit(frandom_cleanup_module);
++
++EXPORT_SYMBOL(erandom_get_random_bytes);
+diff -Naur linux-2.4.30.orig/drivers/char/random.c linux-2.4.30/drivers/char/random.c
+--- linux-2.4.30.orig/drivers/char/random.c	2005-01-19 14:09:48.000000000 +0000
++++ linux-2.4.30/drivers/char/random.c	2005-04-17 04:17:37.000000000 +0000
+@@ -1875,6 +1875,107 @@
+ 	return 1;
+ }
+ 
++#ifdef CONFIG_SYSCTL_URANDOM
++static int proc_do_urandom(ctl_table *table, int write, struct file *filp,
++			void *buffer, size_t *lenp)
++{
++	ctl_table	fake_table;
++	unsigned char	buf[64], random[16], *p;
++	int i;
++
++	get_random_bytes(random, 16);
++
++	p=buf;
++
++	for (i=0; i<16; i++) {
++		sprintf(p, "%02x", random[i]);
++		p+=2;
++	}
++
++	fake_table.data = buf;
++	fake_table.maxlen = sizeof(buf);
++
++	return proc_dostring(&fake_table, write, filp, buffer, lenp);
++}
++
++static int urandom_strategy(ctl_table *table, int *name, int nlen,
++			void *oldval, size_t *oldlenp,
++			void *newval, size_t newlen, void **context)
++{
++	unsigned char   random[16];
++	unsigned int    len;
++
++	if (!oldval || !oldlenp)
++		return 1;
++
++	get_random_bytes(random, 16);
++
++	if (get_user(len, oldlenp))
++		return -EFAULT;
++	if (len) {
++		if (len > 16)
++			len = 16;
++		if (copy_to_user(oldval, random, len) ||
++		put_user(len, oldlenp))
++			return -EFAULT;
++	}
++	return 1;
++}
++#endif
++
++#ifdef CONFIG_FRANDOM
++/* We don't really want to create a header file for frandom
++   at this stage, so here's the prototype: */
++
++void erandom_get_random_bytes(char *buf, size_t count);
++
++static int proc_do_erandom(ctl_table *table, int write, struct file *filp,
++			void *buffer, size_t *lenp)
++{
++	ctl_table	fake_table;
++	unsigned char	buf[64], random[16], *p;
++	int i;
++	
++	erandom_get_random_bytes(random, 16);
++	
++	p=buf;
++	
++	for (i=0; i<16; i++) {
++     		sprintf(p, "%02x", random[i]);
++		p+=2;
++	}
++
++	fake_table.data = buf;
++	fake_table.maxlen = sizeof(buf);
++
++	return proc_dostring(&fake_table, write, filp, buffer, lenp);
++}
++
++static int erandom_strategy(ctl_table *table, int *name, int nlen,
++			 void *oldval, size_t *oldlenp,
++			 void *newval, size_t newlen, void **context)
++{
++	unsigned char	random[16];
++	unsigned int	len;
++
++	if (!oldval || !oldlenp)
++		return 1;
++
++	erandom_get_random_bytes(random, 16);
++
++	if (get_user(len, oldlenp))
++		return -EFAULT;
++	if (len) {
++		if (len > 16)
++			len = 16;
++		if (copy_to_user(oldval, random, len) ||
++		    put_user(len, oldlenp))
++			return -EFAULT;
++	}
++	return 1;
++}
++#endif
++
+ ctl_table random_table[] = {
+ 	{RANDOM_POOLSIZE, "poolsize",
+ 	 &sysctl_poolsize, sizeof(int), 0644, NULL,
+@@ -1893,6 +1994,16 @@
+ 	{RANDOM_BOOT_ID, "boot_id",
+ 	 &sysctl_bootid, 16, 0444, NULL,
+ 	 &proc_do_uuid, &uuid_strategy},
++#ifdef CONFIG_SYSCTL_URANDOM
++	{RANDOM_URANDOM, "urandom",
++	 NULL, 16, 0444, NULL,
++	 &proc_do_urandom, &urandom_strategy},
++#endif
++#ifdef CONFIG_FRANDOM
++	{RANDOM_ERANDOM, "erandom",
++	 NULL, 16, 0444, NULL,
++	 &proc_do_erandom, &erandom_strategy},
++#endif
+ 	{RANDOM_UUID, "uuid",
+ 	 NULL, 16, 0444, NULL,
+ 	 &proc_do_uuid, &uuid_strategy},
+diff -Naur linux-2.4.30.orig/include/linux/sysctl.h linux-2.4.30/include/linux/sysctl.h
+--- linux-2.4.30.orig/include/linux/sysctl.h	2005-04-04 01:42:20.000000000 +0000
++++ linux-2.4.30/include/linux/sysctl.h	2005-04-17 04:14:48.000000000 +0000
+@@ -185,6 +185,8 @@
+ };
+ 
+ /* /proc/sys/kernel/random */
++#define SYSCTL_URANDOM
++#define SYSCTL_ERANDOM
+ enum
+ {
+ 	RANDOM_POOLSIZE=1,
+@@ -192,7 +194,9 @@
+ 	RANDOM_READ_THRESH=3,
+ 	RANDOM_WRITE_THRESH=4,
+ 	RANDOM_BOOT_ID=5,
+-	RANDOM_UUID=6
++	RANDOM_UUID=6,
++	RANDOM_URANDOM=7,
++	RANDOM_ERANDOM=8
+ };
+ 
+ /* /proc/sys/bus/isa */

Added: trunk/linux/linux-2.4.30-unistd_x86_PIC-1.patch
===================================================================
--- trunk/linux/linux-2.4.30-unistd_x86_PIC-1.patch	2005-04-15 16:14:53 UTC (rev 922)
+++ trunk/linux/linux-2.4.30-unistd_x86_PIC-1.patch	2005-04-24 20:04:14 UTC (rev 923)
@@ -0,0 +1,175 @@
+Submitted By: Robert Connolly <robert at linuxfromscratch dot org> (ashes)
+Date: 2005-04-19
+Initial Package Version: 2.4.30
+Upstream Status: Not submitted
+Origin: Gentoo - unistd.h-i386-pic.patch
+Description: This patch adds position independent assembly for syscalls.
+This fixes problems with llseek(), util-linux, vsftpd, proftpd, and more.
+
+Also see:
+http://www.linuxfromscratch.org/hlfs/
+
+diff -Naur linux-2.4.30.orig/include/asm-i386/unistd.h linux-2.4.30/include/asm-i386/unistd.h
+--- linux-2.4.30.orig/include/asm-i386/unistd.h	2004-11-17 11:54:22.000000000 +0000
++++ linux-2.4.30/include/asm-i386/unistd.h	2005-04-19 19:35:39.000000000 +0000
+@@ -280,6 +280,21 @@
+ __syscall_return(type,__res); \
+ }
+ 
++#ifdef __PIC__
++#define _syscall1(type,name,type1,arg1) \
++type name(type1 arg1) \
++{ \
++long __res; \
++__asm__ volatile (\
++	"pushl %%ebx\n\t" \
++	"movl %2,%%ebx\n\t" \
++	"int $0x80\n\t" \
++	"popl %%ebx\n\t" \
++	: "=a" (__res) \
++	: "0" (__NR_##name),"r" ((long)(arg1))); \
++__syscall_return(type,__res); \
++}
++#else
+ #define _syscall1(type,name,type1,arg1) \
+ type name(type1 arg1) \
+ { \
+@@ -289,7 +304,23 @@
+ 	: "0" (__NR_##name),"b" ((long)(arg1))); \
+ __syscall_return(type,__res); \
+ }
++#endif
+ 
++#ifdef __PIC__
++#define _syscall2(type,name,type1,arg1,type2,arg2) \
++type name(type1 arg1,type2 arg2) \
++{ \
++long __res; \
++__asm__ volatile (\
++	"pushl %%ebx\n\t" \
++	"movl %2,%%ebx\n\t" \
++	"int $0x80\n\t" \
++	"popl %%ebx\n\t" \
++	: "=a" (__res) \
++	: "0" (__NR_##name),"r" ((long)(arg1)),"c" ((long)(arg2))); \
++__syscall_return(type,__res); \
++}
++#else
+ #define _syscall2(type,name,type1,arg1,type2,arg2) \
+ type name(type1 arg1,type2 arg2) \
+ { \
+@@ -299,7 +330,24 @@
+ 	: "0" (__NR_##name),"b" ((long)(arg1)),"c" ((long)(arg2))); \
+ __syscall_return(type,__res); \
+ }
++#endif
+ 
++#ifdef __PIC__
++#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
++type name(type1 arg1,type2 arg2,type3 arg3) \
++{ \
++long __res; \
++__asm__ volatile (\
++	"pushl %%ebx\n\t" \
++	"movl %2,%%ebx\n\t" \
++	"int $0x80\n\t" \
++	"popl %%ebx\n\t" \
++	: "=a" (__res) \
++	: "0" (__NR_##name),"r" ((long)(arg1)),"c" ((long)(arg2)), \
++		  "d" ((long)(arg3))); \
++__syscall_return(type,__res); \
++}
++#else
+ #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
+ type name(type1 arg1,type2 arg2,type3 arg3) \
+ { \
+@@ -310,7 +358,24 @@
+ 		  "d" ((long)(arg3))); \
+ __syscall_return(type,__res); \
+ }
++#endif
+ 
++#ifdef __PIC__
++#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 (\
++	"pushl %%ebx\n\t" \
++	"movl %2,%%ebx\n\t" \
++	"int $0x80\n\t" \
++	"popl %%ebx\n\t" \
++	: "=a" (__res) \
++	: "0" (__NR_##name),"r" ((long)(arg1)),"c" ((long)(arg2)), \
++	  "d" ((long)(arg3)),"S" ((long)(arg4))); \
++__syscall_return(type,__res); \
++} 
++#else
+ #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
+ type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
+ { \
+@@ -321,7 +386,25 @@
+ 	  "d" ((long)(arg3)),"S" ((long)(arg4))); \
+ __syscall_return(type,__res); \
+ } 
++#endif
+ 
++#ifdef __PIC__
++#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 (\
++	"pushl %%ebx\n\t" \
++	"movl %2,%%ebx\n\t" \
++	"int $0x80\n\t" \
++	"popl %%ebx\n\t" \
++	: "=a" (__res) \
++	: "0" (__NR_##name),"m" ((long)(arg1)),"c" ((long)(arg2)), \
++	  "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5))); \
++__syscall_return(type,__res); \
++}
++#else
+ #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) \
+@@ -333,7 +416,30 @@
+ 	  "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5))); \
+ __syscall_return(type,__res); \
+ }
++#endif
+ 
++#ifdef __PIC__
++#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
++	  type5,arg5,type6,arg6) \
++type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,type6 arg6) \
++{ \
++long __res; \
++__asm__ volatile (\
++	"pushl %%ebp\n\t" \
++	"movl %%eax,%%ebp\n\t" \
++	"movl %1,%%eax\n\t" \
++	"pushl %%ebx\n\t" \
++	"movl %2,%%ebx\n\t" \
++	"int $0x80\n\t" \
++	"popl %%ebx\n\t" \
++	"popl %%ebp\n\t" \
++	: "=a" (__res) \
++	: "i" (__NR_##name),"m" ((long)(arg1)),"c" ((long)(arg2)), \
++	  "d" ((long)(arg3)),"S" ((long)(arg4)),"D" ((long)(arg5)), \
++	  "0" ((long)(arg6))); \
++__syscall_return(type,__res); \
++}
++#else
+ #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
+ 	  type5,arg5,type6,arg6) \
+ type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,type6 arg6) \
+@@ -346,6 +452,7 @@
+ 	  "0" ((long)(arg6))); \
+ __syscall_return(type,__res); \
+ }
++#endif
+ 
+ #ifdef __KERNEL_SYSCALLS__
+ 




More information about the patches mailing list