Date: Sat, 29 Dec 2001 11:21:30 -0500 (EST) From: "Alexander N. Kabaev" <ak03@gte.com> To: FreeBSD-gnats-submit@freebsd.org Subject: i386/33299: -CURRENT ptrace(2) implementation for linux emulator on i386 Message-ID: <200112291621.fBTGLUW50719@h132-197-179-27.gte.com>
next in thread | raw e-mail | index | archive | help
>Number: 33299
>Category: i386
>Synopsis: -CURRENT ptrace(2) implementation for linux emulator on i386
>Confidential: no
>Severity: non-critical
>Priority: low
>Responsible: freebsd-bugs
>State: open
>Quarter:
>Keywords:
>Date-Required:
>Class: change-request
>Submitter-Id: current-users
>Arrival-Date: Sat Dec 29 08:30:00 PST 2001
>Closed-Date:
>Last-Modified:
>Originator: Alexander N. Kabaev
>Release: FreeBSD 5.0-CURRENT i386
>Organization:
Verizon Data Services
>Environment:
System: FreeBSD kanpc.gte.com 5.0-CURRENT FreeBSD 5.0-CURRENT #13: Mon Dec 24 11:36:50 EST 2001 root@kanpc.gte.com:/usr/src/sys/i386/compile/KANPC i386
>Description:
The patch below implements Linux ptrace syscall for linuxulator.
With this patch applied, it is possible to use /compat/linux/usr/bin/gdb
to debug Linux binaries. At the very least it provides much more
meaningful backtraces. All gdb features I tried seem to be working
correctly so far.
The patch also fixes long-standing bug with FreeBSD native ptrace
in kern/sys_process.c, where prace would not allow process using
signal number > NSIG to be continued from gdb. The check for
signal validity should use _SIG_MAXSIG instead of obsoleted
NSIG.
>How-To-Repeat:
Apply the patch in /usr/src/sys. Do not forget to regenerate
files from i386/linux/syscalls.master to get an undated
linux_ptrace syscall signature.
>Fix:
Index: conf/files.i386
===================================================================
RCS file: /home/ncvs/src/sys/conf/files.i386,v
retrieving revision 1.386
diff -u -r1.386 files.i386
--- conf/files.i386 22 Dec 2001 09:25:17 -0000 1.386
+++ conf/files.i386 29 Dec 2001 15:23:55 -0000
@@ -288,6 +288,7 @@
i386/linux/linux_locore.s optional compat_linux \
dependency "linux_assym.h"
i386/linux/linux_machdep.c optional compat_linux
+i386/linux/linux_ptrace.c optional compat_linux
i386/linux/linux_sysent.c optional compat_linux
i386/linux/linux_sysvec.c optional compat_linux
i386/pci/pci_cfgreg.c optional pci
Index: kern/sys_process.c
===================================================================
RCS file: /home/ncvs/src/sys/kern/sys_process.c,v
retrieving revision 1.76
diff -u -r1.76 sys_process.c
--- kern/sys_process.c 21 Oct 2001 23:57:15 -0000 1.76
+++ kern/sys_process.c 26 Dec 2001 20:02:05 -0000
@@ -419,7 +419,7 @@
case PT_STEP:
case PT_CONTINUE:
case PT_DETACH:
- if ((uap->req != PT_STEP) && ((unsigned)uap->data >= NSIG))
+ if ((uap->req != PT_STEP) && ((unsigned)uap->data > _SIG_MAXSIG))
return (EINVAL);
PHOLD(p);
Index: i386/linux/linux_ptrace.c
===================================================================
RCS file: i386/linux/linux_ptrace.c
diff -N i386/linux/linux_ptrace.c
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ i386/linux/linux_ptrace.c 26 Dec 2001 20:08:45 -0000
@@ -0,0 +1,499 @@
+/*
+ * Copyright (c) 2001 Alexander Kabaev
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer
+ * in this position and unchanged.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD:$
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/proc.h>
+#include <sys/ptrace.h>
+#include <sys/sysproto.h>
+#include <sys/user.h>
+
+#include <machine/md_var.h>
+#include <machine/npx.h>
+#include <machine/reg.h>
+
+#include <i386/linux/linux.h>
+#include <i386/linux/linux_proto.h>
+#include <compat/linux/linux_util.h>
+
+/*
+ * Linux ptrace requests numbers. Mostly identical to FreeBSD,
+ * except for MD ones and PT_ATTACH/PT_DETACH.
+ */
+#define PTRACE_TRACEME 0
+#define PTRACE_PEEKTEXT 1
+#define PTRACE_PEEKDATA 2
+#define PTRACE_PEEKUSR 3
+#define PTRACE_POKETEXT 4
+#define PTRACE_POKEDATA 5
+#define PTRACE_POKEUSR 6
+#define PTRACE_CONT 7
+#define PTRACE_KILL 8
+#define PTRACE_SINGLESTEP 9
+
+#define PTRACE_ATTACH 16
+#define PTRACE_DETACH 17
+
+#define PTRACE_SYSCALL 24
+
+#define PTRACE_GETREGS 12
+#define PTRACE_SETREGS 13
+#define PTRACE_GETFPREGS 14
+#define PTRACE_SETFPREGS 15
+#define PTRACE_GETFPXREGS 18
+#define PTRACE_SETFPXREGS 19
+
+#define PTRACE_SETOPTIONS 21
+
+/*
+ * Linux keeps debug registers at the following
+ * offset in the user struct
+ */
+#define LINUX_DBREG_OFFSET 252
+#define LINUX_DBREG_SIZE 8*sizeof(l_int)
+
+static __inline__ int
+map_signum(int signum)
+{
+#ifndef __alpha__
+ if (signum > 0 && signum <= LINUX_SIGTBLSZ)
+ signum = linux_to_bsd_signal[_SIG_IDX(signum)];
+#endif
+ return ((signum == SIGSTOP)? 0 : signum);
+}
+
+struct linux_pt_reg {
+ l_long ebx;
+ l_long ecx;
+ l_long edx;
+ l_long esi;
+ l_long edi;
+ l_long ebp;
+ l_long eax;
+ l_int xds;
+ l_int xes;
+ l_int xfs;
+ l_int xgs;
+ l_long orig_eax;
+ l_long eip;
+ l_int xcs;
+ l_long eflags;
+ l_long esp;
+ l_int xss;
+};
+
+
+/*
+ * Translate i386 ptrace registers between Linux and FreeBSD formats.
+ * The translation is pretty straighforward, for all registers, but
+ * orig_eax in Linux side and r_trapno and r_err in FreeBSD
+ */
+static int
+map_regs_to_linux(struct reg *bsd_r, struct linux_pt_reg *linux_r)
+{
+ linux_r->ebx = bsd_r->r_ebx;
+ linux_r->ecx = bsd_r->r_ecx;
+ linux_r->edx = bsd_r->r_edx;
+ linux_r->esi = bsd_r->r_esi;
+ linux_r->edi = bsd_r->r_edi;
+ linux_r->ebp = bsd_r->r_ebp;
+ linux_r->eax = bsd_r->r_eax;
+ linux_r->xds = bsd_r->r_ds;
+ linux_r->xes = bsd_r->r_es;
+ linux_r->xfs = bsd_r->r_fs;
+ linux_r->xgs = bsd_r->r_gs;
+ linux_r->orig_eax = bsd_r->r_eax;
+ linux_r->eip = bsd_r->r_eip;
+ linux_r->xcs = bsd_r->r_cs;
+ linux_r->eflags = bsd_r->r_eflags;
+ linux_r->esp = bsd_r->r_esp;
+ linux_r->xss = bsd_r->r_ss;
+ return (0);
+}
+
+static int
+map_regs_from_linux(struct reg *bsd_r, struct linux_pt_reg *linux_r)
+{
+ bsd_r->r_ebx = linux_r->ebx;
+ bsd_r->r_ecx = linux_r->ecx;
+ bsd_r->r_edx = linux_r->edx;
+ bsd_r->r_esi = linux_r->esi;
+ bsd_r->r_edi = linux_r->edi;
+ bsd_r->r_ebp = linux_r->ebp;
+ bsd_r->r_eax = linux_r->eax;
+ bsd_r->r_ds = linux_r->xds;
+ bsd_r->r_es = linux_r->xes;
+ bsd_r->r_fs = linux_r->xfs;
+ bsd_r->r_gs = linux_r->xgs;
+ bsd_r->r_eip = linux_r->eip;
+ bsd_r->r_cs = linux_r->xcs;
+ bsd_r->r_eflags = linux_r->eflags;
+ bsd_r->r_esp = linux_r->esp;
+ bsd_r->r_ss = linux_r->xss;
+ return (0);
+}
+
+struct linux_pt_fpreg {
+ l_long cwd;
+ l_long swd;
+ l_long twd;
+ l_long fip;
+ l_long fcs;
+ l_long foo;
+ l_long fos;
+ l_long st_space[2*10];
+};
+
+static int
+map_fpregs_to_linux(struct fpreg *bsd_r, struct linux_pt_fpreg *linux_r)
+{
+ linux_r->cwd = bsd_r->fpr_env[0];
+ linux_r->swd = bsd_r->fpr_env[1];
+ linux_r->twd = bsd_r->fpr_env[2];
+ linux_r->fip = bsd_r->fpr_env[3];
+ linux_r->fcs = bsd_r->fpr_env[4];
+ linux_r->foo = bsd_r->fpr_env[5];
+ linux_r->fos = bsd_r->fpr_env[6];
+ bcopy(bsd_r->fpr_acc, linux_r->st_space, sizeof(linux_r->st_space));
+ return (0);
+}
+
+static int
+map_fpregs_from_linux(struct fpreg *bsd_r, struct linux_pt_fpreg *linux_r)
+{
+ bsd_r->fpr_env[0] = linux_r->cwd;
+ bsd_r->fpr_env[1] = linux_r->swd;
+ bsd_r->fpr_env[2] = linux_r->twd;
+ bsd_r->fpr_env[3] = linux_r->fip;
+ bsd_r->fpr_env[4] = linux_r->fcs;
+ bsd_r->fpr_env[5] = linux_r->foo;
+ bsd_r->fpr_env[6] = linux_r->fos;
+ bcopy(bsd_r->fpr_acc, linux_r->st_space, sizeof(bsd_r->fpr_acc));
+ return (0);
+}
+
+struct linux_pt_fpxreg {
+ l_ushort cwd;
+ l_ushort swd;
+ l_ushort twd;
+ l_ushort fop;
+ l_long fip;
+ l_long fcs;
+ l_long foo;
+ l_long fos;
+ l_long mxcsr;
+ l_long reserved;
+ l_long st_space[32];
+ l_long xmm_space[32];
+ l_long padding[56];
+};
+
+static int
+linux_proc_read_fpxregs(struct thread *td, struct linux_pt_fpxreg *fpxregs)
+{
+#ifdef CPU_ENABLE_SSE
+ if (sizeof(*fpxregs) != sizeof(td->td_pcb->pcb_save.sv_xmm)) {
+ printf("linux: savexmm != linux_pt_fpxreg\n");
+ return (EIO);
+ }
+ if (cpu_fxsr == 0)
+#endif
+ return (EIO);
+ bcopy(&td->td_pcb->pcb_save.sv_xmm, fpxregs, sizeof *fpxregs);
+ return (0);
+}
+
+static int
+linux_proc_write_fpxregs(struct thread *td, struct linux_pt_fpxreg *fpxregs)
+{
+#ifdef CPU_ENABLE_SSE
+ if (sizeof(*fpxregs) != sizeof(td->td_pcb->pcb_save.sv_xmm)) {
+ printf("linux: savexmm != linux_pt_fpxreg\n");
+ return (EIO);
+ }
+ if (cpu_fxsr == 0)
+#endif
+ return (EIO);
+ bcopy(fpxregs, &td->td_pcb->pcb_save.sv_xmm, sizeof *fpxregs);
+ return (0);
+}
+
+
+int
+linux_ptrace(struct thread *td, struct linux_ptrace_args *uap)
+{
+ struct ptrace_args bsd_args;
+ int error;
+ caddr_t sg;
+ union {
+ struct linux_pt_reg reg;
+ struct linux_pt_fpreg fpreg;
+ struct linux_pt_fpxreg fpxreg;
+ } r;
+
+ sg = stackgap_init();
+
+ error = 0;
+
+ /* by default, just copy data intact */
+ bsd_args.req = uap->req;
+ bsd_args.pid = (pid_t)uap->pid;
+ bsd_args.addr = (caddr_t)uap->addr;
+ bsd_args.data = uap->data;
+
+ switch (uap->req) {
+ case PTRACE_TRACEME:
+ case PTRACE_POKETEXT:
+ case PTRACE_POKEDATA:
+ case PTRACE_KILL:
+ error = ptrace(td, &bsd_args);
+ break;
+ case PTRACE_PEEKTEXT:
+ case PTRACE_PEEKDATA: {
+ /* need to preserve return value */
+ int rval = td->td_retval[0];
+ bsd_args.data = 0;
+ error = ptrace(td, &bsd_args);
+ if (error == 0)
+ error = copyout(td->td_retval,
+ (caddr_t)uap->data, sizeof(l_int));
+ td->td_retval[0] = rval;
+ break;
+ }
+ case PTRACE_DETACH:
+ bsd_args.req = PT_DETACH;
+ /* fall through */
+ case PTRACE_SINGLESTEP:
+ case PTRACE_CONT:
+ bsd_args.data = map_signum(uap->data);
+ bsd_args.addr = (caddr_t)1;
+ error = ptrace(td, &bsd_args);
+ break;
+ case PTRACE_ATTACH:
+ bsd_args.req = PT_ATTACH;
+ error = ptrace(td, &bsd_args);
+ break;
+ case PTRACE_GETREGS: {
+ struct reg *bsd_r = (struct reg*)stackgap_alloc(&sg,
+ sizeof(*bsd_r));
+ /* Linux is using data where FreeBSD is using addr */
+ bsd_args.req = PT_GETREGS;
+ bsd_args.addr = (caddr_t)bsd_r;
+ bsd_args.data = 0;
+ error = ptrace(td, &bsd_args);
+ if (error == 0)
+ error = map_regs_to_linux(bsd_r, &r.reg);
+ if (error == 0)
+ error = copyout(&r.reg, (caddr_t)uap->data, sizeof r.reg);
+ break;
+ }
+ case PTRACE_SETREGS: {
+ struct reg *bsd_r = (struct reg*)stackgap_alloc(&sg,
+ sizeof(*bsd_r));
+ /* Linux is using data where FreeBSD is using addr */
+ bsd_args.req = PT_SETREGS;
+ bsd_args.addr = (caddr_t)bsd_r;
+ bsd_args.data = 0;
+ error = copyin((caddr_t)uap->data, &r.reg, sizeof r.reg);
+ if (error == 0)
+ error = map_regs_from_linux(bsd_r, &r.reg);
+ if (error == 0)
+ error = ptrace(td, &bsd_args);
+ break;
+ }
+ case PTRACE_GETFPREGS: {
+ struct fpreg *bsd_r = (struct fpreg*)stackgap_alloc(&sg,
+ sizeof(*bsd_r));
+ /* Linux is using data where FreeBSD is using addr */
+ bsd_args.req = PT_GETFPREGS;
+ bsd_args.addr = (caddr_t)bsd_r;
+ bsd_args.data = 0;
+ error = ptrace(td, &bsd_args);
+ if (error == 0)
+ error = map_fpregs_to_linux(bsd_r, &r.fpreg);
+ if (error == 0)
+ error = copyout(&r.fpreg, (caddr_t)uap->data, sizeof r.fpreg);
+ break;
+ }
+ case PTRACE_SETFPREGS: {
+ struct fpreg *bsd_r = (struct fpreg*)stackgap_alloc(&sg,
+ sizeof(*bsd_r));
+ /* Linux is using data where FreeBSD is using addr */
+ bsd_args.req = PT_SETFPREGS;
+ bsd_args.addr = (caddr_t)bsd_r;
+ bsd_args.data = 0;
+ error = copyin((caddr_t)uap->data, &r.fpreg, sizeof r.fpreg);
+ if (error == 0)
+ error = map_fpregs_from_linux(bsd_r, &r.fpreg);
+ if (error == 0)
+ error = ptrace(td, &bsd_args);
+ break;
+ }
+ case PTRACE_SETFPXREGS:
+ case PTRACE_GETFPXREGS: {
+ struct proc *p;
+ struct fpreg *bsd_r;
+
+ /*
+ * Use FreeBSD PT_GETFPREGS for permisson testing.
+ */
+ bsd_r = (struct fpreg*)stackgap_alloc(&sg,
+ sizeof(*bsd_r));
+ bsd_args.req = PT_GETFPREGS;
+ bsd_args.addr = (caddr_t)bsd_r;
+ bsd_args.data = 0;
+ error = ptrace(td, &bsd_args);
+ /*
+ * If this fails, PTRACE_GETFPXREGS should fail
+ * for exactly the same reason.
+ */
+ if (error != 0)
+ break;
+
+ if ((p = pfind(uap->pid)) == NULL) {
+ error = ESRCH;
+ break;
+ }
+ if (uap->req == PTRACE_GETFPXREGS) {
+ PHOLD(p);
+ error = linux_proc_read_fpxregs(
+ &p->p_thread, &r.fpxreg);
+ PRELE(p);
+ if (error == 0)
+ error = copyout(&r.fpxreg,
+ (caddr_t)uap->data, sizeof r.fpxreg);
+ } else {
+ error = copyin((caddr_t)uap->data,
+ &r.fpxreg, sizeof r.fpxreg);
+ if (error == 0) {
+ /* clear dangerous bits exactly as Linux does*/
+ r.fpxreg.mxcsr &= 0xffbf;
+ PHOLD(p);
+ error = linux_proc_write_fpxregs(
+ &p->p_thread, &r.fpxreg);
+ PRELE(p);
+ }
+ }
+ break;
+ }
+ case PTRACE_PEEKUSR:
+ case PTRACE_POKEUSR: {
+ error = EIO;
+
+ /* check addr for alignment */
+ if (uap->addr < 0 || uap->addr & (sizeof(l_int) - 1))
+ break;
+ /*
+ * Allow linux programs to access register values in
+ * user struct. We simulate this through PT_GET/SETREGS
+ * as necessary.
+ */
+ if (uap->addr < sizeof(struct linux_pt_reg)) {
+ struct reg *bsd_r;
+
+ bsd_r = (struct reg*)stackgap_alloc(&sg,
+ sizeof(*bsd_r));
+ bsd_args.req = PT_GETREGS;
+ bsd_args.addr = (caddr_t)bsd_r;
+ bsd_args.data = 0;
+
+ error = ptrace(td, &bsd_args);
+ if (error != 0)
+ break;
+
+ error = map_regs_to_linux(bsd_r, &r.reg);
+ if (error != 0)
+ break;
+
+ if (uap->req == PTRACE_PEEKUSR) {
+ error = copyout((char *)&r.reg + uap->addr,
+ (caddr_t)uap->data, sizeof(l_int));
+ break;
+ }
+
+ *(l_int *)((char *)&r.reg + uap->addr) = (l_int)uap->data;
+
+ error = map_regs_from_linux(bsd_r, &r.reg);
+ if (error != 0)
+ break;
+
+ bsd_args.req = PT_SETREGS;
+ bsd_args.addr = (caddr_t)bsd_r;
+ bsd_args.data = 0;
+ error = ptrace(td, &bsd_args);
+ }
+
+ /*
+ * Simulate debug registers access
+ */
+ if (uap->addr >= LINUX_DBREG_OFFSET &&
+ uap->addr <= LINUX_DBREG_OFFSET + LINUX_DBREG_SIZE) {
+ struct dbreg *bsd_r;
+
+ bsd_r = (struct dbreg*)stackgap_alloc(&sg,
+ sizeof(*bsd_r));
+ bsd_args.req = PT_GETDBREGS;
+ bsd_args.addr = (caddr_t)bsd_r;
+ bsd_args.data = 0;
+ error = ptrace(td, &bsd_args);
+ if (error != 0)
+ break;
+
+ uap->addr -= LINUX_DBREG_OFFSET;
+ if (uap->req == PTRACE_PEEKUSR) {
+ error = copyout((char *)bsd_r + uap->addr,
+ (caddr_t)uap->data, sizeof(l_int));
+ break;
+ }
+
+ *(l_int *)((char *)bsd_r + uap->addr) = uap->data;
+ bsd_args.req = PT_SETDBREGS;
+ bsd_args.addr = (caddr_t)bsd_r;
+ bsd_args.data = 0;
+ error = ptrace(td, &bsd_args);
+ }
+
+ break;
+ }
+ case PTRACE_SYSCALL:
+ /* fall through */
+ default:
+ error = EINVAL;
+ goto noimpl;
+ }
+ return (error);
+
+ noimpl:
+ printf("linux: ptrace(%u, ...) not implemented\n",
+ (u_int32_t)uap->req);
+ return (error);
+}
Index: i386/linux/linux_dummy.c
===================================================================
RCS file: /home/ncvs/src/sys/i386/linux/linux_dummy.c,v
retrieving revision 1.32
diff -u -r1.32 linux_dummy.c
--- i386/linux/linux_dummy.c 16 Oct 2001 06:15:36 -0000 1.32
+++ i386/linux/linux_dummy.c 24 Dec 2001 22:02:11 -0000
@@ -38,7 +38,6 @@
DUMMY(stat);
DUMMY(stime);
-DUMMY(ptrace);
DUMMY(fstat);
DUMMY(olduname);
DUMMY(syslog);
Index: i386/linux/syscalls.master
===================================================================
RCS file: /home/ncvs/src/sys/i386/linux/syscalls.master,v
retrieving revision 1.45
diff -u -r1.45 syscalls.master
--- i386/linux/syscalls.master 16 Oct 2001 06:11:11 -0000 1.45
+++ i386/linux/syscalls.master 24 Dec 2001 22:02:11 -0000
@@ -65,7 +65,8 @@
23 STD LINUX { int linux_setuid16(l_uid16_t uid); }
24 STD LINUX { int linux_getuid16(void); }
25 STD LINUX { int linux_stime(void); }
-26 STD LINUX { int linux_ptrace(void); }
+26 STD LINUX { int linux_ptrace(l_long req, l_long pid, l_long addr, \
+ l_long data); }
27 STD LINUX { int linux_alarm(l_uint secs); }
28 STD LINUX { int linux_fstat(l_uint fd, struct ostat *up); }
29 STD LINUX { int linux_pause(void); }
Index: modules/linux/Makefile
===================================================================
RCS file: /home/ncvs/src/sys/modules/linux/Makefile,v
retrieving revision 1.54
diff -u -r1.54 Makefile
--- modules/linux/Makefile 18 Nov 2001 05:45:27 -0000 1.54
+++ modules/linux/Makefile 24 Dec 2001 22:03:37 -0000
@@ -8,7 +8,9 @@
SRCS= linux_dummy.c linux_file.c linux_getcwd.c linux_ioctl.c linux_ipc.c \
linux_machdep.c linux_mib.c linux_misc.c linux_signal.c linux_socket.c \
linux_stats.c linux_sysctl.c linux_sysent.c linux_sysvec.c \
- linux_util.c opt_compat.h opt_linux.h opt_vmpage.h vnode_if.h
+ linux_util.c linux_ptrace.c opt_compat.h opt_linux.h opt_vmpage.h \
+ vnode_if.h
+
OBJS= linux_locore.o
.if ${MACHINE_ARCH} == "i386"
>Release-Note:
>Audit-Trail:
>Unformatted:
To Unsubscribe: send mail to majordomo@FreeBSD.org
with "unsubscribe freebsd-bugs" in the body of the message
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200112291621.fBTGLUW50719>