Author: marcus Date: Tue Feb 26 08:30:27 2008 GMT
Module: SOURCES Tag: HEAD
---- Log message:
- from
http://ace-host.stuart.id.au/russell/files/debian/sarge/kernel-patch-linuxabi/kernel-patch-linuxabi_20060404.tar.gz
for kernel 2.6.16
---- Files affected:
SOURCES:
linuxabi-2.6.16-0.patch (NONE -> 1.1) (NEW)
---- Diffs:
================================================================
Index: SOURCES/linuxabi-2.6.16-0.patch
diff -u /dev/null SOURCES/linuxabi-2.6.16-0.patch:1.1
--- /dev/null Tue Feb 26 09:30:27 2008
+++ SOURCES/linuxabi-2.6.16-0.patch Tue Feb 26 09:30:22 2008
@@ -0,0 +1,28575 @@
+diff -Nur kernel-source-2.6.16.orig/abi/cxenix/Makefile
kernel-source-2.6.16/abi/cxenix/Makefile
+--- kernel-source-2.6.16.orig/abi/cxenix/Makefile 1970-01-01
10:00:00.000000000 +1000
++++ kernel-source-2.6.16/abi/cxenix/Makefile 2006-04-27 18:50:24.000000000
+1000
+@@ -0,0 +1,7 @@
++
++abi-cxenix-objs := sysent.o misc.o stubs.o signal.o pathconf.o utsname.o
++
++obj-$(CONFIG_ABI_SCO) += abi-cxenix.o
++
++abi-cxenix.o: $(abi-cxenix-objs)
++ $(LD) -r -o $@ $(abi-cxenix-objs)
+diff -Nur kernel-source-2.6.16.orig/abi/cxenix/misc.c
kernel-source-2.6.16/abi/cxenix/misc.c
+--- kernel-source-2.6.16.orig/abi/cxenix/misc.c 1970-01-01
10:00:00.000000000 +1000
++++ kernel-source-2.6.16/abi/cxenix/misc.c 2006-04-27 18:50:24.000000000
+1000
+@@ -0,0 +1,294 @@
++/*
++ * misc.c - misc cxenix() subcalls
++ *
++ * Copyright (c) 1993,1994 Drew Sullivan
++ * Copyright (c) 1994-1996 Mike Jagdis
++ */
++
++#ident "%W% %G%"
++
++#include <linux/types.h>
++#include <linux/module.h>
++#include <linux/errno.h>
++#include <linux/kernel.h>
++#include <linux/unistd.h>
++#include <linux/ptrace.h>
++#include <linux/fcntl.h>
++#include <linux/time.h>
++#include <linux/signal.h>
++#include <linux/syscalls.h>
++#include <linux/termios.h>
++#include <asm/uaccess.h>
++
++#include <abi/util/trace.h>
++#include <abi/util/sysent.h>
++#include <abi/svr4/sigaction.h>
++
++
++struct timeb {
++ time_t time;
++ u_short millitm;
++ short timezone;
++ short dstflag;
++};
++
++enum {
++ XF_UNLCK = 0,
++ XF_WRLCK = 1,
++ XF_RDLCK = 3,
++};
++
++struct ibcs_flock {
++ short l_type;
++ short l_whence;
++ off_t l_start;
++ off_t l_len;
++ short l_sysid;
++ short l_pid;
++};
++
++
++/*
++ * locking() requires mandatory locking. Processes that attempt to
++ * read or write a region locked with locking() are required to block.
++ * You need to build a kernel with mandatory locking support and set
++ * the permissions on the required file to setgid, no group execute.
++ */
++int
++xnx_locking(int fd, int mode, unsigned long size)
++{
++ struct flock fl;
++ mm_segment_t old_fs;
++ int error;
++
++ if ((mode < 0 || mode > 7) && mode != 20) {
++#if defined(CONFIG_ABI_TRACE)
++ abi_trace(ABI_TRACE_API,
++ "unsupported locking() mode=0x%x\n", mode);
++#endif
++ return -EINVAL;
++ }
++
++ /*
++ * Modes 5, 6 & 7 are very like the fcntl mechanism but
++ * we can't just punt to that because the type values are
++ * different.
++ */
++ if (mode > 4 && mode < 8) {
++ struct ibcs_flock *ifl = (struct ibcs_flock *)size;
++ short t;
++
++ if (!access_ok(VERIFY_READ, ifl, sizeof(*ifl)))
++ return -EFAULT;
++
++ get_user(t, &ifl->l_type);
++ switch (t) {
++ case XF_UNLCK: t = F_UNLCK; break;
++ case XF_WRLCK: t = F_WRLCK; break;
++ case XF_RDLCK: t = F_RDLCK; break;
++ default: return -EINVAL;
++ }
++ put_user(t, &ifl->l_type);
++
++ error = sys_fcntl(fd, mode, (u_long)ifl);
++
++ get_user(t, &ifl->l_type);
++ switch (t) {
++ case F_UNLCK: t = XF_UNLCK; break;
++ case F_WRLCK: t = XF_WRLCK; break;
++ case F_RDLCK: t = XF_RDLCK; break;
++ }
++ put_user(t, &ifl->l_type);
++
++ get_user(t, &ifl->l_sysid);
++ put_user(t, &ifl->l_pid);
++ put_user(0, &ifl->l_sysid);
++ return error;
++ }
++
++ fl.l_type = (mode == 0 ? F_UNLCK
++ : ((mode <= 2 || mode == 20) ? F_WRLCK
++ : F_RDLCK));
++ fl.l_whence = 1;
++ fl.l_start = 0;
++ fl.l_len = size;
++
++ old_fs = get_fs();
++ set_fs (get_ds());
++ error = sys_fcntl(fd, (mode == 5) ? F_GETLK
++ : (!(mode % 2) ? F_SETLK : F_SETLKW), (u_long)&fl);
++ set_fs(old_fs);
++ return error;
++}
++
++
++/* Check if input is available */
++int
++xnx_rdchk(int fd)
++{
++ int error, nbytes;
++ mm_segment_t old_fs;
++
++ old_fs = get_fs();
++ set_fs (get_ds());
++ error = sys_ioctl(fd, FIONREAD, (long)&nbytes);
++ set_fs(old_fs);
++
++ if (error < 0) return error;
++ return nbytes ? 1 : 0;
++}
++
++/*
++ * Linux has a stub sys_ftime. Perhaps this should be there? On the other
++ * hand it's an old call that probably shouldn't be used by most modern
++ * applications so perhaps it's better here where it needn't bloat the
++ * base kernel.
++ */
++int
++xnx_ftime(struct timeb *tp)
++{
++ struct timeval tv;
++ struct timezone tz;
++ int error;
++ mm_segment_t old_fs;
++
++ if (!access_ok(VERIFY_WRITE, tp, sizeof(struct timeb)))
++ return -EFAULT;
++
++ old_fs = get_fs();
++ set_fs (get_ds());
++ error = sys_gettimeofday(&tv, &tz);
++ set_fs(old_fs);
++ if (error)
++ return error;
++
++ put_user(tv.tv_sec, &tp->time);
++ put_user((unsigned short)(tv.tv_usec/1000), &tp->millitm);
++ put_user((short)tz.tz_minuteswest, &tp->timezone);
++ put_user((short)tz.tz_dsttime, &tp->dstflag);
++
++ return 0;
++}
++
++#define USE_NEW_NAP_CODE
++
++#ifndef USE_NEW_NAP_CODE
++static __inline __sighandler_t
++sigaction(int sig, __sighandler_t handler)
++{
++ struct k_sigaction *k = ¤t->sighand->action[sig-1];
++ __sighandler_t old_handler;
++
++ spin_lock(¤t->sighand->siglock);
++ old_handler = k->sa.sa_handler;
++ k->sa.sa_handler = handler;
++ spin_unlock(¤t->sighand->siglock);
++
++ return old_handler;
++}
++#endif
++
++/* go to sleep for period milliseconds */
++/* - returns either an EINTR error or returns the elapsed time */
++/* Note:
++ for SCO OpenServer 5.0.6 the original nap was fixed so that it
++ no longer waits a minimum of 2 tick (20ms)
++ but fewer time with a 10 ms granularity */
++long
++xnx_nap(long period)
++{
++#ifdef USE_NEW_NAP_CODE
++ // Hz means the number of jiffies per second.
++ // the below code needs HZ to be 1 <= HZ <= 1000
++ // in order to work correctly in any case.
++#if HZ > 1000
++#error this code only works with HZ <= 1000
++#endif
++ struct timeval tv1, tv2;
++ struct timezone tz;
++ mm_segment_t oldfs;
++ long period_s; // seconds part
++ long period_ms_hz; // milli seconds part, scaled to a base of HZ
++ long period_j; // jiffies
++
++ if (!period)
++ return 0; // zereo request, zero reply
++
++ oldfs = get_fs();
++ set_fs(get_ds());
++ sys_gettimeofday(&tv1, &tz);
++
++ period_s = period / 1000;
++ period_ms_hz = (period - period_s * 1000) * HZ;
++ period_j = period_s * HZ + period_ms_hz / 1000;
++ // take care of rounding errors, round up
++ if (period > period_j * (1000 / HZ)) period_j++;
++
++ set_current_state(TASK_INTERRUPTIBLE);
++ schedule_timeout (period_j);
++
++ sys_gettimeofday(&tv2, &tz);
++ set_fs(oldfs);
++
++ if (signal_pending(current))
++ return -EINTR; // interrupted
++ return (tv2.tv_sec - tv1.tv_sec) * 1000
++ + (tv2.tv_usec - tv1.tv_usec + 500) / 1000;
++#else
++ __sighandler_t old_handler;
++ struct itimerval it;
++ struct timeval tv1, tv2;
++ struct timezone tz;
++ mm_segment_t oldfs;
++
++ if (!period)
++ return 0;
++
++ it.it_interval.tv_sec = 0;
++ it.it_interval.tv_usec = 0;
++ it.it_value.tv_sec = 0;
++ it.it_value.tv_usec = period * 1000;
++
++ oldfs = get_fs();
++ set_fs(get_ds());
++
++ sys_gettimeofday(&tv1, &tz);
++ old_handler = sigaction(SIGALRM, SIG_DFL); // SIG_DFL -> terminate
++ sys_setitimer(ITIMER_REAL, &it, NULL);
++ sys_pause();
++ sigaction(SIGALRM, old_handler);
++ sys_gettimeofday(&tv2, &tz);
++ set_fs(oldfs);
++
++ deactivate_signal(current, SIGALRM);
++
++ if (signal_pending(current))
++ return -EINTR;
++ return ((tv2.tv_sec - tv1.tv_sec) * 1000000
++ + (tv2.tv_usec - tv1.tv_usec)) / 1000;
++#endif
++}
++
++/*
++ * eaccess() checks access to the given path using the effective
++ * uid/gid rather than the real uid/gid.
++ */
++int
++xnx_eaccess(char *path, int mode)
++{
++ uid_t ouid;
++ gid_t ogid;
++ int err;
++
++ ouid = current->uid;
++ ogid = current->gid;
++ current->uid = current->euid;
++ current->gid = current->egid;
++
++ err = sys_access(path, mode);
++
++ current->uid = ouid;
++ current->gid = ogid;
++
++ return err;
++}
+diff -Nur kernel-source-2.6.16.orig/abi/cxenix/pathconf.c
kernel-source-2.6.16/abi/cxenix/pathconf.c
+--- kernel-source-2.6.16.orig/abi/cxenix/pathconf.c 1970-01-01
10:00:00.000000000 +1000
++++ kernel-source-2.6.16/abi/cxenix/pathconf.c 2006-04-27 18:50:24.000000000
+1000
+@@ -0,0 +1,140 @@
++/*
++ * pathconf.c - support for xenix pathconf
++ *
++ * Copyright (c) 1993,1994 Drew Sullivan
++ * Copyright (c) 1994-1996 Mike Jagdis
++ */
++
++#ident "%W% %G%"
++
++#include <linux/errno.h>
++#include <linux/fs.h>
++#include <linux/slab.h>
++#include <linux/sched.h>
++#include <linux/unistd.h>
++#include <linux/syscalls.h>
++#include <linux/statfs.h>
++#include <asm/uaccess.h>
++
++
++enum {
++ _PC_LINK_MAX = 0,
++ _PC_MAX_CANON = 1,
++ _PC_MAX_INPUT = 2,
++ _PC_NAME_MAX = 3,
++ _PC_PATH_MAX = 4,
++ _PC_PIPE_BUF = 5,
++ _PC_CHOWN_RESTRICTED = 6,
++ _PC_NO_TRUNC = 7,
++ _PC_VDISABLE = 8,
++};
++
++static int
++xnx_name_max(char *path)
++{
++ struct statfs stf;
++ mm_segment_t fs;
++ char *p;
++ int error;
++
++ p = getname(path);
++ if (IS_ERR(p))
++ return PTR_ERR(p);
++
++ fs = get_fs();
++ set_fs(get_ds());
++ error = sys_statfs(p, &stf);
++ set_fs(fs);
++
++ putname(p);
++ if (error)
++ return (error);
++ return (stf.f_namelen);
++}
++
++int
++xnx_pathconf(char *path, int name)
++{
++ switch (name) {
++ case _PC_LINK_MAX:
++ /*
++ * Although Linux headers define values on a per
++ * filesystem basis there is no way to access
++ * these without hard coding fs information here
++ * so for now we use a bogus value.
++ */
++ return LINK_MAX;
++ case _PC_MAX_CANON:
++ return MAX_CANON;
++ case _PC_MAX_INPUT:
++ return MAX_INPUT;
++ case _PC_PATH_MAX:
++ return PATH_MAX;
++ case _PC_PIPE_BUF:
++ return PIPE_BUF;
++ case _PC_CHOWN_RESTRICTED:
++ /*
++ * We should really think about this and tell
++ * the truth.
++ */
++ return 0;
++ case _PC_NO_TRUNC:
++ /* Not sure... It could be fs dependent? */
++ return 1;
++ case _PC_VDISABLE:
++ return 1;
++ case _PC_NAME_MAX:
++ return xnx_name_max(path);
++ }
++ return -EINVAL;
++}
++
++int
++xnx_fpathconf(int fildes, int name)
++{
++ switch (name) {
++ case _PC_LINK_MAX:
++ /*
++ * Although Linux headers define values on a per
++ * filesystem basis there is no way to access
++ * these without hard coding fs information here
++ * so for now we use a bogus value.
++ */
++ return LINK_MAX;
++ case _PC_MAX_CANON:
++ return MAX_CANON;
++ case _PC_MAX_INPUT:
++ return MAX_INPUT;
++ case _PC_PATH_MAX:
++ return PATH_MAX;
++ case _PC_PIPE_BUF:
++ return PIPE_BUF;
++ case _PC_CHOWN_RESTRICTED:
++ /*
++ * We should really think about this and tell
++ * the truth.
++ */
++ return 0;
++ case _PC_NO_TRUNC:
++ /* Not sure... It could be fs dependent? */
++ return 1;
++ case _PC_VDISABLE:
++ return 1;
++ case _PC_NAME_MAX:
++ {
++ struct statfs buf;
++ int error;
++ mm_segment_t old_fs;
++
++ old_fs = get_fs();
++ set_fs (get_ds());
++ error = sys_fstatfs(fildes, &buf);
++ set_fs(old_fs);
++ if (!error)
++ return buf.f_namelen;
++ return error;
++ }
++ }
++
++ return -EINVAL;
++}
+diff -Nur kernel-source-2.6.16.orig/abi/cxenix/signal.c
kernel-source-2.6.16/abi/cxenix/signal.c
+--- kernel-source-2.6.16.orig/abi/cxenix/signal.c 1970-01-01
10:00:00.000000000 +1000
++++ kernel-source-2.6.16/abi/cxenix/signal.c 2006-04-27 18:50:24.000000000
+1000
+@@ -0,0 +1,88 @@
++#ident "%W% %G%"
++
++#include <linux/module.h>
++#include <linux/kernel.h>
++#include <linux/personality.h>
++#include <linux/sched.h>
++#define __KERNEL_SYSCALLS__
++#include <linux/unistd.h>
++#include <asm/uaccess.h>
++
++#include <abi/cxenix/signal.h>
++#include <abi/signal.h>
++
++#include <abi/util/map.h>
++#include <abi/util/sysent.h>
++
++
++int
++xnx_sigaction(int sco_signum, const struct sco_sigaction *action,
++ struct sco_sigaction *oldaction)
++{
++ struct sco_sigaction new_sa, old_sa;
++ struct sigaction nsa, osa;
++ mm_segment_t fs;
++ int error, signo;
++
++ if (sco_signum >= NSIGNALS)
++ return -EINVAL;
++ signo = current_thread_info()->exec_domain->signal_map[sco_signum];
++
++ if (oldaction) {
++ if (!access_ok(VERIFY_WRITE, oldaction,
++ sizeof(struct sco_sigaction)))
++ return -EFAULT;
++ }
++
++ if (action) {
++ error = copy_from_user(&new_sa, action,
++ sizeof(struct sco_sigaction));
++ if (error)
++ return -EFAULT;
++ nsa.sa_restorer = NULL;
++ nsa.sa_handler = new_sa.sa_handler;
++ nsa.sa_mask = map_sigvec_to_kernel(new_sa.sa_mask,
++ current_thread_info()->exec_domain->signal_map);
++ nsa.sa_flags = SA_NOMASK;
++ if (new_sa.sa_flags & SCO_SA_NOCLDSTOP)
++ nsa.sa_flags |= SA_NOCLDSTOP;
++ }
++
++ fs = get_fs();
++ set_fs(get_ds());
++ error = sys_rt_sigaction(signo, action ? &nsa : NULL,
++ oldaction ? &osa : NULL, sizeof(sigset_t));
++ set_fs(fs);
++
++ if (error || !oldaction)
++ return (error);
++
++ old_sa.sa_handler = osa.sa_handler;
++ old_sa.sa_mask = map_sigvec_from_kernel(osa.sa_mask,
++ current_thread_info()->exec_domain->signal_invmap);
++ old_sa.sa_flags = 0;
++ if (osa.sa_flags & SA_NOCLDSTOP)
++ old_sa.sa_flags |= SCO_SA_NOCLDSTOP;
++
++ if (copy_to_user(oldaction, &old_sa, sizeof(struct sco_sigaction)))
++ return -EFAULT;
++ return 0;
++}
++
++int
++xnx_sigpending(u_long *setp)
++{
++ sigset_t lxpending;
++ u_long pending;
++
++ spin_lock_irq(¤t->sighand->siglock);
++ sigandsets(&lxpending, ¤t->blocked, ¤t->pending.signal);
++ spin_unlock_irq(¤t->sighand->siglock);
++
++ pending = map_sigvec_from_kernel(lxpending,
++ current_thread_info()->exec_domain->signal_invmap);
++
++ if (copy_to_user(setp, &pending, sizeof(u_long)))
++ return -EFAULT;
++ return 0;
++}
+diff -Nur kernel-source-2.6.16.orig/abi/cxenix/stubs.c
kernel-source-2.6.16/abi/cxenix/stubs.c
+--- kernel-source-2.6.16.orig/abi/cxenix/stubs.c 1970-01-01
10:00:00.000000000 +1000
++++ kernel-source-2.6.16/abi/cxenix/stubs.c 2006-04-27 18:50:24.000000000
+1000
+@@ -0,0 +1,123 @@
++/*
++ * stubs.c - stubs for unimplemented cxenix subcalls
++ *
++ * Copyright (c) 1993,1994 Drew Sullivan.
++ * Copyright (c) 1994-1996 Mike Jagdis.
++ */
++
++#ident "%W% %G%"
++
++#include <linux/errno.h>
++#include <linux/types.h>
++#include <linux/ptrace.h>
++
++#include <abi/cxenix/sysent.h>
++
++
++int
++xnx_creatsem(char *sem_name, int mode)
++{
++ return -EPERM;
++}
++
++int
++xnx_opensem(char *sem_name)
++{
++ return -EPERM;
++}
++
++int
++xnx_sigsem(int sem_num)
++{
++ return -EPERM;
++}
++
++int
++xnx_waitsem(int sem_num)
++{
++ return -EPERM;
++}
++
++int
++xnx_nbwaitsem(int sem_num)
<<Diff was trimmed, longer than 597 lines>>
_______________________________________________
pld-cvs-commit mailing list
[email protected]
http://lists.pld-linux.org/mailman/listinfo/pld-cvs-commit
