a01b03714ac87e65752ff007b11ce539725eb4bd
[dragonfly.git] / sys / i386 / i386 / procfs_machdep.c
1 /*
2  * Copyright (c) 1993
3  *      The Regents of the University of California.  All rights reserved.
4  * Copyright (c) 1993 Jan-Simon Pendry
5  *
6  * This code is derived from software contributed to Berkeley by
7  * Jan-Simon Pendry.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgement:
19  *      This product includes software developed by the University of
20  *      California, Berkeley and its contributors.
21  * 4. Neither the name of the University nor the names of its contributors
22  *    may be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  *
37  *      @(#)procfs_machdep.c    8.3 (Berkeley) 1/27/94
38  *
39  * From:
40  * $FreeBSD: src/sys/i386/i386/procfs_machdep.c,v 1.14 1999/10/11 14:50:03 peter Exp $
41  * $DragonFly: src/sys/i386/i386/Attic/procfs_machdep.c,v 1.4 2005/10/27 03:15:47 sephe Exp $
42  */
43
44 /*
45  * Functions to be implemented here are:
46  *
47  * procfs_read_regs(proc, regs)
48  *      Get the current user-visible register set from the process
49  *      and copy it into the regs structure (<machine/reg.h>).
50  *      The process is stopped at the time read_regs is called.
51  *
52  * procfs_write_regs(proc, regs)
53  *      Update the current register set from the passed in regs
54  *      structure.  Take care to avoid clobbering special CPU
55  *      registers or privileged bits in the PSL.
56  *      Depending on the architecture this may have fix-up work to do,
57  *      especially if the IAR or PCW are modified.
58  *      The process is stopped at the time write_regs is called.
59  *
60  * procfs_read_fpregs, procfs_write_fpregs
61  *      deal with the floating point register set, otherwise as above.
62  *
63  * procfs_read_dbregs, procfs_write_dbregs
64  *      deal with the processor debug register set, otherwise as above.
65  *
66  * procfs_sstep(proc)
67  *      Arrange for the process to trap after executing a single instruction.
68  *
69  */
70
71 #include <sys/param.h>
72 #include <sys/proc.h>
73 #include <sys/ptrace.h>
74 #include <sys/vnode.h>
75 #include <machine/reg.h>
76 #include <machine/md_var.h>
77 #include <vfs/procfs/procfs.h>
78
79 #include <vm/vm.h>
80 #include <sys/lock.h>
81 #include <vm/pmap.h>
82 #include <vm/vm_map.h>
83
84 int
85 procfs_read_regs(p, regs)
86         struct proc *p;
87         struct reg *regs;
88 {
89         if ((p->p_flag & P_INMEM) == 0)
90                 return (EIO);
91         return (fill_regs(&p->p_lwp, regs));
92 }
93
94 int
95 procfs_write_regs(p, regs)
96         struct proc *p;
97         struct reg *regs;
98 {
99         if ((p->p_flag & P_INMEM) == 0)
100                 return (EIO);
101         return (set_regs(&p->p_lwp, regs));
102 }
103
104 int
105 procfs_read_dbregs(p, dbregs)
106         struct proc *p;
107         struct dbreg *dbregs;
108 {
109         if ((p->p_flag & P_INMEM) == 0)
110                 return (EIO);
111         return (fill_dbregs(&p->p_lwp, dbregs));
112 }
113
114 int
115 procfs_write_dbregs(p, dbregs)
116         struct proc *p;
117         struct dbreg *dbregs;
118 {
119         if ((p->p_flag & P_INMEM) == 0)
120                 return (EIO);
121         return (set_dbregs(&p->p_lwp, dbregs));
122 }
123
124 /*
125  * Ptrace doesn't support fpregs at all, and there are no security holes
126  * or translations for fpregs, so we can just copy them.
127  */
128
129 int
130 procfs_read_fpregs(p, fpregs)
131         struct proc *p;
132         struct fpreg *fpregs;
133 {
134         if ((p->p_flag & P_INMEM) == 0)
135                 return (EIO);
136         return (fill_fpregs(&p->p_lwp, fpregs));
137 }
138
139 int
140 procfs_write_fpregs(p, fpregs)
141         struct proc *p;
142         struct fpreg *fpregs;
143 {
144         if ((p->p_flag & P_INMEM) == 0)
145                 return (EIO);
146         return (set_fpregs(&p->p_lwp, fpregs));
147 }
148
149 int
150 procfs_sstep(p)
151         struct proc *p;
152 {
153         if ((p->p_flag & P_INMEM) == 0)
154                 return (EIO);
155         return (ptrace_single_step(&p->p_lwp));
156 }