cpu_machdep.c (5455) | cpu_machdep.c (5603) |
---|---|
1/*- 2 * Copyright (c) 1992 Terrence R. Lambert. 3 * Copyright (c) 1982, 1987, 1990 The Regents of the University of California. 4 * All rights reserved. 5 * 6 * This code is derived from software contributed to Berkeley by 7 * William Jolitz. 8 * --- 21 unchanged lines hidden (view full) --- 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 * from: @(#)machdep.c 7.4 (Berkeley) 6/3/91 | 1/*- 2 * Copyright (c) 1992 Terrence R. Lambert. 3 * Copyright (c) 1982, 1987, 1990 The Regents of the University of California. 4 * All rights reserved. 5 * 6 * This code is derived from software contributed to Berkeley by 7 * William Jolitz. 8 * --- 21 unchanged lines hidden (view full) --- 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 * from: @(#)machdep.c 7.4 (Berkeley) 6/3/91 |
38 * $Id: machdep.c,v 1.99 1995/01/05 19:51:14 se Exp $ | 38 * $Id: machdep.c,v 1.100 1995/01/09 16:04:37 davidg Exp $ |
39 */ 40 41#include "npx.h" 42#include "isa.h" 43 44#include <sys/param.h> 45#include <sys/systm.h> 46#include <sys/signalvar.h> --- 407 unchanged lines hidden (view full) --- 454vmtime(otime, olbolt, oicr) 455 register int otime, olbolt, oicr; 456{ 457 458 return (((time.tv_sec-otime)*60 + lbolt-olbolt)*16667); 459} 460#endif 461 | 39 */ 40 41#include "npx.h" 42#include "isa.h" 43 44#include <sys/param.h> 45#include <sys/systm.h> 46#include <sys/signalvar.h> --- 407 unchanged lines hidden (view full) --- 454vmtime(otime, olbolt, oicr) 455 register int otime, olbolt, oicr; 456{ 457 458 return (((time.tv_sec-otime)*60 + lbolt-olbolt)*16667); 459} 460#endif 461 |
462extern int kstack[]; | 462extern char kstack[]; |
463 464/* 465 * Send an interrupt to process. 466 * 467 * Stack is set up to allow sigcode stored 468 * in u. to call routine, followed by kcall 469 * to sigreturn routine below. After sigreturn 470 * resets the signal mask, the stack, and the --- 131 unchanged lines hidden (view full) --- 602 */ 603 scp = uap->sigcntxp; 604 fp = (struct sigframe *) 605 ((caddr_t)scp - offsetof(struct sigframe, sf_sc)); 606 607 if (useracc((caddr_t)fp, sizeof (*fp), 0) == 0) 608 return(EINVAL); 609 | 463 464/* 465 * Send an interrupt to process. 466 * 467 * Stack is set up to allow sigcode stored 468 * in u. to call routine, followed by kcall 469 * to sigreturn routine below. After sigreturn 470 * resets the signal mask, the stack, and the --- 131 unchanged lines hidden (view full) --- 602 */ 603 scp = uap->sigcntxp; 604 fp = (struct sigframe *) 605 ((caddr_t)scp - offsetof(struct sigframe, sf_sc)); 606 607 if (useracc((caddr_t)fp, sizeof (*fp), 0) == 0) 608 return(EINVAL); 609 |
610 /* 611 * Don't allow users to change privileged or reserved flags. Let 612 * the hardware check for changing to excess I/O privilege. 613 */ 614#define EFLAGS_SECURE(ef, oef) ((((ef) ^ (oef)) & ~PSL_USERCHANGE) == 0) 615 |
|
610 eflags = scp->sc_ps; | 616 eflags = scp->sc_ps; |
611 if ((eflags & PSL_USERCLR) != 0 || 612 (eflags & PSL_USERSET) != PSL_USERSET || 613 (eflags & PSL_IOPL) < (regs[tEFLAGS] & PSL_IOPL)) { | 617 if (!EFLAGS_SECURE(eflags, regs[tEFLAGS])) { |
614#ifdef DEBUG | 618#ifdef DEBUG |
615 printf("sigreturn: eflags=0x%x\n", eflags); | 619 printf("sigreturn: eflags = 0x%x\n", eflags); |
616#endif 617 return(EINVAL); 618 } 619 620 /* | 620#endif 621 return(EINVAL); 622 } 623 624 /* |
621 * Sanity check the user's selectors and error if they 622 * are suspect. | 625 * Don't allow users to load a valid privileged %cs. Let the 626 * hardware check for invalid selectors, excess privilege in 627 * other selectors, invalid %eip's and invalid %esp's. |
623 */ | 628 */ |
624#define max_ldt_sel(pcb) \ 625 ((pcb)->pcb_ldt ? (pcb)->pcb_ldt_len : (sizeof(ldt) / sizeof(ldt[0]))) 626 627#define valid_ldt_sel(sel) \ 628 (ISLDT(sel) && ISPL(sel) == SEL_UPL && \ 629 IDXSEL(sel) < max_ldt_sel(&p->p_addr->u_pcb)) 630 631#define null_sel(sel) \ 632 (!ISLDT(sel) && IDXSEL(sel) == 0) 633 634 if (((scp->sc_cs&0xffff) != _ucodesel && !valid_ldt_sel(scp->sc_cs)) || 635 ((scp->sc_ss&0xffff) != _udatasel && !valid_ldt_sel(scp->sc_ss)) || 636 ((scp->sc_ds&0xffff) != _udatasel && !valid_ldt_sel(scp->sc_ds) && 637 !null_sel(scp->sc_ds)) || 638 ((scp->sc_es&0xffff) != _udatasel && !valid_ldt_sel(scp->sc_es) && 639 !null_sel(scp->sc_es))) { | 629#define CS_SECURE(cs) (ISPL(cs) == SEL_UPL) 630 if (!CS_SECURE(scp->sc_cs)) { |
640#ifdef DEBUG | 631#ifdef DEBUG |
641 printf("sigreturn: cs=0x%x ss=0x%x ds=0x%x es=0x%x\n", 642 scp->sc_cs, scp->sc_ss, scp->sc_ds, scp->sc_es); | 632 printf("sigreturn: cs = 0x%x\n", scp->sc_cs); |
643#endif 644 trapsignal(p, SIGBUS, T_PROTFLT); 645 return(EINVAL); 646 } 647 | 633#endif 634 trapsignal(p, SIGBUS, T_PROTFLT); 635 return(EINVAL); 636 } 637 |
648#undef max_ldt_sel 649#undef valid_ldt_sel 650#undef null_sel 651 | |
652 /* restore scratch registers */ 653 regs[tEAX] = scp->sc_eax; 654 regs[tEBX] = scp->sc_ebx; 655 regs[tECX] = scp->sc_ecx; 656 regs[tEDX] = scp->sc_edx; 657 regs[tESI] = scp->sc_esi; 658 regs[tEDI] = scp->sc_edi; 659 regs[tCS] = scp->sc_cs; --- 198 unchanged lines hidden (view full) --- 858 u_long entry; 859 u_long stack; 860{ 861 int *regs = p->p_md.md_regs; 862 863 bzero(regs, sizeof(struct trapframe)); 864 regs[tEIP] = entry; 865 regs[tESP] = stack; | 638 /* restore scratch registers */ 639 regs[tEAX] = scp->sc_eax; 640 regs[tEBX] = scp->sc_ebx; 641 regs[tECX] = scp->sc_ecx; 642 regs[tEDX] = scp->sc_edx; 643 regs[tESI] = scp->sc_esi; 644 regs[tEDI] = scp->sc_edi; 645 regs[tCS] = scp->sc_cs; --- 198 unchanged lines hidden (view full) --- 844 u_long entry; 845 u_long stack; 846{ 847 int *regs = p->p_md.md_regs; 848 849 bzero(regs, sizeof(struct trapframe)); 850 regs[tEIP] = entry; 851 regs[tESP] = stack; |
866 regs[tEFLAGS] = PSL_USERSET | (regs[tEFLAGS] & PSL_T); | 852 regs[tEFLAGS] = PSL_USER | (regs[tEFLAGS] & PSL_T); |
867 regs[tSS] = _udatasel; 868 regs[tDS] = _udatasel; 869 regs[tES] = _udatasel; 870 regs[tCS] = _ucodesel; 871 872 p->p_addr->u_pcb.pcb_flags = 0; /* no fp at all */ 873 load_cr0(rcr0() | CR0_TS); /* start emulating */ 874#if NNPX > 0 --- 226 unchanged lines hidden (view full) --- 1101} 1102 1103#define IDTVEC(name) __CONCAT(X,name) 1104 1105extern inthand_t 1106 IDTVEC(div), IDTVEC(dbg), IDTVEC(nmi), IDTVEC(bpt), IDTVEC(ofl), 1107 IDTVEC(bnd), IDTVEC(ill), IDTVEC(dna), IDTVEC(dble), IDTVEC(fpusegm), 1108 IDTVEC(tss), IDTVEC(missing), IDTVEC(stk), IDTVEC(prot), | 853 regs[tSS] = _udatasel; 854 regs[tDS] = _udatasel; 855 regs[tES] = _udatasel; 856 regs[tCS] = _ucodesel; 857 858 p->p_addr->u_pcb.pcb_flags = 0; /* no fp at all */ 859 load_cr0(rcr0() | CR0_TS); /* start emulating */ 860#if NNPX > 0 --- 226 unchanged lines hidden (view full) --- 1087} 1088 1089#define IDTVEC(name) __CONCAT(X,name) 1090 1091extern inthand_t 1092 IDTVEC(div), IDTVEC(dbg), IDTVEC(nmi), IDTVEC(bpt), IDTVEC(ofl), 1093 IDTVEC(bnd), IDTVEC(ill), IDTVEC(dna), IDTVEC(dble), IDTVEC(fpusegm), 1094 IDTVEC(tss), IDTVEC(missing), IDTVEC(stk), IDTVEC(prot), |
1109 IDTVEC(page), IDTVEC(rsvd), IDTVEC(fpu), IDTVEC(rsvd0), 1110 IDTVEC(rsvd1), IDTVEC(rsvd2), IDTVEC(rsvd3), IDTVEC(rsvd4), 1111 IDTVEC(rsvd5), IDTVEC(rsvd6), IDTVEC(rsvd7), IDTVEC(rsvd8), 1112 IDTVEC(rsvd9), IDTVEC(rsvd10), IDTVEC(rsvd11), IDTVEC(rsvd12), 1113 IDTVEC(rsvd13), IDTVEC(rsvd14), IDTVEC(syscall); | 1095 IDTVEC(page), IDTVEC(rsvd), IDTVEC(fpu), IDTVEC(align), 1096 IDTVEC(syscall); |
1114 1115void 1116sdtossd(sd, ssd) 1117 struct segment_descriptor *sd; 1118 struct soft_segment_descriptor *ssd; 1119{ 1120 ssd->ssd_base = (sd->sd_hibase << 24) | sd->sd_lobase; 1121 ssd->ssd_limit = (sd->sd_hilimit << 16) | sd->sd_lolimit; --- 64 unchanged lines hidden (view full) --- 1186#define VM_END_USER_R_ADDRESS (VM_END_USER_RW_ADDRESS + UPAGES * NBPG) 1187 ldt_segs[LUCODE_SEL].ssd_limit = i386_btop(VM_END_USER_R_ADDRESS) - 1; 1188 ldt_segs[LUDATA_SEL].ssd_limit = i386_btop(VM_END_USER_RW_ADDRESS) - 1; 1189 /* Note. eventually want private ldts per process */ 1190 for (x = 0; x < NLDT; x++) 1191 ssdtosd(&ldt_segs[x], &ldt[x].sd); 1192 1193 /* exceptions */ | 1097 1098void 1099sdtossd(sd, ssd) 1100 struct segment_descriptor *sd; 1101 struct soft_segment_descriptor *ssd; 1102{ 1103 ssd->ssd_base = (sd->sd_hibase << 24) | sd->sd_lobase; 1104 ssd->ssd_limit = (sd->sd_hilimit << 16) | sd->sd_lolimit; --- 64 unchanged lines hidden (view full) --- 1169#define VM_END_USER_R_ADDRESS (VM_END_USER_RW_ADDRESS + UPAGES * NBPG) 1170 ldt_segs[LUCODE_SEL].ssd_limit = i386_btop(VM_END_USER_R_ADDRESS) - 1; 1171 ldt_segs[LUDATA_SEL].ssd_limit = i386_btop(VM_END_USER_RW_ADDRESS) - 1; 1172 /* Note. eventually want private ldts per process */ 1173 for (x = 0; x < NLDT; x++) 1174 ssdtosd(&ldt_segs[x], &ldt[x].sd); 1175 1176 /* exceptions */ |
1177 for (x = 0; x < NIDT; x++) 1178 setidt(x, &IDTVEC(rsvd), SDT_SYS386TGT, SEL_KPL); |
|
1194 setidt(0, &IDTVEC(div), SDT_SYS386TGT, SEL_KPL); 1195 setidt(1, &IDTVEC(dbg), SDT_SYS386TGT, SEL_KPL); 1196 setidt(2, &IDTVEC(nmi), SDT_SYS386TGT, SEL_KPL); 1197 setidt(3, &IDTVEC(bpt), SDT_SYS386TGT, SEL_UPL); 1198 setidt(4, &IDTVEC(ofl), SDT_SYS386TGT, SEL_UPL); 1199 setidt(5, &IDTVEC(bnd), SDT_SYS386TGT, SEL_KPL); 1200 setidt(6, &IDTVEC(ill), SDT_SYS386TGT, SEL_KPL); 1201 setidt(7, &IDTVEC(dna), SDT_SYS386TGT, SEL_KPL); 1202 setidt(8, &IDTVEC(dble), SDT_SYS386TGT, SEL_KPL); 1203 setidt(9, &IDTVEC(fpusegm), SDT_SYS386TGT, SEL_KPL); 1204 setidt(10, &IDTVEC(tss), SDT_SYS386TGT, SEL_KPL); 1205 setidt(11, &IDTVEC(missing), SDT_SYS386TGT, SEL_KPL); 1206 setidt(12, &IDTVEC(stk), SDT_SYS386TGT, SEL_KPL); 1207 setidt(13, &IDTVEC(prot), SDT_SYS386TGT, SEL_KPL); 1208 setidt(14, &IDTVEC(page), SDT_SYS386TGT, SEL_KPL); 1209 setidt(15, &IDTVEC(rsvd), SDT_SYS386TGT, SEL_KPL); 1210 setidt(16, &IDTVEC(fpu), SDT_SYS386TGT, SEL_KPL); | 1179 setidt(0, &IDTVEC(div), SDT_SYS386TGT, SEL_KPL); 1180 setidt(1, &IDTVEC(dbg), SDT_SYS386TGT, SEL_KPL); 1181 setidt(2, &IDTVEC(nmi), SDT_SYS386TGT, SEL_KPL); 1182 setidt(3, &IDTVEC(bpt), SDT_SYS386TGT, SEL_UPL); 1183 setidt(4, &IDTVEC(ofl), SDT_SYS386TGT, SEL_UPL); 1184 setidt(5, &IDTVEC(bnd), SDT_SYS386TGT, SEL_KPL); 1185 setidt(6, &IDTVEC(ill), SDT_SYS386TGT, SEL_KPL); 1186 setidt(7, &IDTVEC(dna), SDT_SYS386TGT, SEL_KPL); 1187 setidt(8, &IDTVEC(dble), SDT_SYS386TGT, SEL_KPL); 1188 setidt(9, &IDTVEC(fpusegm), SDT_SYS386TGT, SEL_KPL); 1189 setidt(10, &IDTVEC(tss), SDT_SYS386TGT, SEL_KPL); 1190 setidt(11, &IDTVEC(missing), SDT_SYS386TGT, SEL_KPL); 1191 setidt(12, &IDTVEC(stk), SDT_SYS386TGT, SEL_KPL); 1192 setidt(13, &IDTVEC(prot), SDT_SYS386TGT, SEL_KPL); 1193 setidt(14, &IDTVEC(page), SDT_SYS386TGT, SEL_KPL); 1194 setidt(15, &IDTVEC(rsvd), SDT_SYS386TGT, SEL_KPL); 1195 setidt(16, &IDTVEC(fpu), SDT_SYS386TGT, SEL_KPL); |
1211 setidt(17, &IDTVEC(rsvd0), SDT_SYS386TGT, SEL_KPL); 1212 setidt(18, &IDTVEC(rsvd1), SDT_SYS386TGT, SEL_KPL); 1213 setidt(19, &IDTVEC(rsvd2), SDT_SYS386TGT, SEL_KPL); 1214 setidt(20, &IDTVEC(rsvd3), SDT_SYS386TGT, SEL_KPL); 1215 setidt(21, &IDTVEC(rsvd4), SDT_SYS386TGT, SEL_KPL); 1216 setidt(22, &IDTVEC(rsvd5), SDT_SYS386TGT, SEL_KPL); 1217 setidt(23, &IDTVEC(rsvd6), SDT_SYS386TGT, SEL_KPL); 1218 setidt(24, &IDTVEC(rsvd7), SDT_SYS386TGT, SEL_KPL); 1219 setidt(25, &IDTVEC(rsvd8), SDT_SYS386TGT, SEL_KPL); 1220 setidt(26, &IDTVEC(rsvd9), SDT_SYS386TGT, SEL_KPL); 1221 setidt(27, &IDTVEC(rsvd10), SDT_SYS386TGT, SEL_KPL); 1222 setidt(28, &IDTVEC(rsvd11), SDT_SYS386TGT, SEL_KPL); 1223 setidt(29, &IDTVEC(rsvd12), SDT_SYS386TGT, SEL_KPL); 1224 setidt(30, &IDTVEC(rsvd13), SDT_SYS386TGT, SEL_KPL); 1225 setidt(31, &IDTVEC(rsvd14), SDT_SYS386TGT, SEL_KPL); | 1196 setidt(17, &IDTVEC(align), SDT_SYS386TGT, SEL_KPL); |
1226 1227#include "isa.h" 1228#if NISA >0 1229 isa_defaultirq(); 1230#endif 1231 1232 r_gdt.rd_limit = sizeof(gdt) - 1; 1233 r_gdt.rd_base = (int) gdt; --- 206 unchanged lines hidden (view full) --- 1440 * The registers are in the frame; the frame is in the user area of 1441 * the process in question; when the process is active, the registers 1442 * are in "the kernel stack"; when it's not, they're still there, but 1443 * things get flipped around. So, since p->p_md.md_regs is the whole address 1444 * of the register set, take its offset from the kernel stack, and 1445 * index into the user block. Don't you just *love* virtual memory? 1446 * (I'm starting to think seymour is right...) 1447 */ | 1197 1198#include "isa.h" 1199#if NISA >0 1200 isa_defaultirq(); 1201#endif 1202 1203 r_gdt.rd_limit = sizeof(gdt) - 1; 1204 r_gdt.rd_base = (int) gdt; --- 206 unchanged lines hidden (view full) --- 1411 * The registers are in the frame; the frame is in the user area of 1412 * the process in question; when the process is active, the registers 1413 * are in "the kernel stack"; when it's not, they're still there, but 1414 * things get flipped around. So, since p->p_md.md_regs is the whole address 1415 * of the register set, take its offset from the kernel stack, and 1416 * index into the user block. Don't you just *love* virtual memory? 1417 * (I'm starting to think seymour is right...) 1418 */ |
1419#define TF_REGP(p) ((struct trapframe *) \ 1420 ((char *)(p)->p_addr \ 1421 + ((char *)(p)->p_md.md_regs - kstack))) |
|
1448 1449int | 1422 1423int |
1450ptrace_set_pc (struct proc *p, unsigned int addr) { 1451 void *regs = (char*)p->p_addr + 1452 ((char*) p->p_md.md_regs - (char*) kstack); 1453 1454 ((struct trapframe *)regs)->tf_eip = addr; 1455 return 0; | 1424ptrace_set_pc(p, addr) 1425 struct proc *p; 1426 unsigned int addr; 1427{ 1428 TF_REGP(p)->tf_eip = addr; 1429 return (0); |
1456} 1457 1458int | 1430} 1431 1432int |
1459ptrace_single_step (struct proc *p) { 1460 void *regs = (char*)p->p_addr + 1461 ((char*) p->p_md.md_regs - (char*) kstack); 1462 1463 ((struct trapframe *)regs)->tf_eflags |= PSL_T; 1464 return 0; | 1433ptrace_single_step(p) 1434 struct proc *p; 1435{ 1436 TF_REGP(p)->tf_eflags |= PSL_T; 1437 return (0); |
1465} 1466 | 1438} 1439 |
1467/* 1468 * Copy the registers to user-space. 1469 */ 1470 | |
1471int | 1440int |
1472ptrace_getregs (struct proc *p, unsigned int *addr) { | 1441ptrace_getregs(p, addr) 1442 struct proc *p; 1443 unsigned int *addr; 1444{ |
1473 int error; | 1445 int error; |
1474 struct reg regs = {0}; | 1446 struct reg regs; |
1475 | 1447 |
1476 error = fill_regs (p, ®s); | 1448 error = fill_regs(p, ®s); |
1477 if (error) | 1449 if (error) |
1478 return error; 1479 1480 return copyout (®s, addr, sizeof (regs)); | 1450 return (error); 1451 return (copyout(®s, addr, sizeof regs)); |
1481} 1482 1483int | 1452} 1453 1454int |
1484ptrace_setregs (struct proc *p, unsigned int *addr) { | 1455ptrace_setregs(p, addr) 1456 struct proc *p; 1457 unsigned int *addr; 1458{ |
1485 int error; | 1459 int error; |
1486 struct reg regs = {0}; | 1460 struct reg regs; |
1487 | 1461 |
1488 error = copyin (addr, ®s, sizeof(regs)); | 1462 error = copyin(addr, ®s, sizeof regs); |
1489 if (error) | 1463 if (error) |
1490 return error; | 1464 return (error); 1465 return (set_regs(p, ®s)); 1466} |
1491 | 1467 |
1492 return set_regs (p, ®s); | 1468int ptrace_write_u(p, off, data) 1469 struct proc *p; 1470 vm_offset_t off; 1471 int data; 1472{ 1473 struct trapframe frame_copy; 1474 vm_offset_t min; 1475 struct trapframe *tp; 1476 1477 /* 1478 * Privileged kernel state is scattered all over the user area. 1479 * Only allow write access to parts of regs and to fpregs. 1480 */ 1481 min = (char *)p->p_md.md_regs - kstack; 1482 if (off >= min && off <= min + sizeof(struct trapframe) - sizeof(int)) { 1483 tp = TF_REGP(p); 1484 frame_copy = *tp; 1485 *(int *)((char *)&frame_copy + (off - min)) = data; 1486 if (!EFLAGS_SECURE(frame_copy.tf_eflags, tp->tf_eflags) || 1487 !CS_SECURE(frame_copy.tf_cs)) 1488 return (EINVAL); 1489 *(int*)((char *)p->p_addr + off) = data; 1490 return (0); 1491 } 1492 min = offsetof(struct user, u_pcb) + offsetof(struct pcb, pcb_savefpu); 1493 if (off >= min && off <= min + sizeof(struct save87) - sizeof(int)) { 1494 *(int*)((char *)p->p_addr + off) = data; 1495 return (0); 1496 } 1497 return (EFAULT); |
1493} 1494 1495int | 1498} 1499 1500int |
1496fill_regs(struct proc *p, struct reg *regs) { | 1501fill_regs(p, regs) 1502 struct proc *p; 1503 struct reg *regs; 1504{ |
1497 struct trapframe *tp; | 1505 struct trapframe *tp; |
1498 void *ptr = (char*)p->p_addr + 1499 ((char*) p->p_md.md_regs - (char*) kstack); | |
1500 | 1506 |
1501 tp = ptr; | 1507 tp = TF_REGP(p); |
1502 regs->r_es = tp->tf_es; 1503 regs->r_ds = tp->tf_ds; 1504 regs->r_edi = tp->tf_edi; 1505 regs->r_esi = tp->tf_esi; 1506 regs->r_ebp = tp->tf_ebp; 1507 regs->r_ebx = tp->tf_ebx; 1508 regs->r_edx = tp->tf_edx; 1509 regs->r_ecx = tp->tf_ecx; 1510 regs->r_eax = tp->tf_eax; 1511 regs->r_eip = tp->tf_eip; 1512 regs->r_cs = tp->tf_cs; 1513 regs->r_eflags = tp->tf_eflags; 1514 regs->r_esp = tp->tf_esp; 1515 regs->r_ss = tp->tf_ss; | 1508 regs->r_es = tp->tf_es; 1509 regs->r_ds = tp->tf_ds; 1510 regs->r_edi = tp->tf_edi; 1511 regs->r_esi = tp->tf_esi; 1512 regs->r_ebp = tp->tf_ebp; 1513 regs->r_ebx = tp->tf_ebx; 1514 regs->r_edx = tp->tf_edx; 1515 regs->r_ecx = tp->tf_ecx; 1516 regs->r_eax = tp->tf_eax; 1517 regs->r_eip = tp->tf_eip; 1518 regs->r_cs = tp->tf_cs; 1519 regs->r_eflags = tp->tf_eflags; 1520 regs->r_esp = tp->tf_esp; 1521 regs->r_ss = tp->tf_ss; |
1516 return 0; | 1522 return (0); |
1517} 1518 1519int | 1523} 1524 1525int |
1520set_regs (struct proc *p, struct reg *regs) { | 1526set_regs(p, regs) 1527 struct proc *p; 1528 struct reg *regs; 1529{ |
1521 struct trapframe *tp; | 1530 struct trapframe *tp; |
1522 void *ptr = (char*)p->p_addr + 1523 ((char*) p->p_md.md_regs - (char*) kstack); | |
1524 | 1531 |
1525 tp = ptr; | 1532 tp = TF_REGP(p); 1533 if (!EFLAGS_SECURE(regs->r_eflags, tp->tf_eflags) || 1534 !CS_SECURE(regs->r_cs)) 1535 return (EINVAL); |
1526 tp->tf_es = regs->r_es; 1527 tp->tf_ds = regs->r_ds; 1528 tp->tf_edi = regs->r_edi; 1529 tp->tf_esi = regs->r_esi; 1530 tp->tf_ebp = regs->r_ebp; 1531 tp->tf_ebx = regs->r_ebx; 1532 tp->tf_edx = regs->r_edx; 1533 tp->tf_ecx = regs->r_ecx; 1534 tp->tf_eax = regs->r_eax; 1535 tp->tf_eip = regs->r_eip; 1536 tp->tf_cs = regs->r_cs; 1537 tp->tf_eflags = regs->r_eflags; 1538 tp->tf_esp = regs->r_esp; 1539 tp->tf_ss = regs->r_ss; | 1536 tp->tf_es = regs->r_es; 1537 tp->tf_ds = regs->r_ds; 1538 tp->tf_edi = regs->r_edi; 1539 tp->tf_esi = regs->r_esi; 1540 tp->tf_ebp = regs->r_ebp; 1541 tp->tf_ebx = regs->r_ebx; 1542 tp->tf_edx = regs->r_edx; 1543 tp->tf_ecx = regs->r_ecx; 1544 tp->tf_eax = regs->r_eax; 1545 tp->tf_eip = regs->r_eip; 1546 tp->tf_cs = regs->r_cs; 1547 tp->tf_eflags = regs->r_eflags; 1548 tp->tf_esp = regs->r_esp; 1549 tp->tf_ss = regs->r_ss; |
1540 return 0; | 1550 return (0); |
1541} 1542 1543#ifndef DDB 1544void 1545Debugger(const char *msg) 1546{ 1547 printf("Debugger(\"%s\") called.\n", msg); 1548} --- 73 unchanged lines hidden --- | 1551} 1552 1553#ifndef DDB 1554void 1555Debugger(const char *msg) 1556{ 1557 printf("Debugger(\"%s\") called.\n", msg); 1558} --- 73 unchanged lines hidden --- |