sys/amd64/amd64/ptrace_machdep.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2011 Konstantin Belousov <kib@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/lock.h>
  36 #include <sys/malloc.h>
  37 #include <sys/mutex.h>
  38 #include <sys/proc.h>
  39 #include <sys/ptrace.h>
  40 #include <sys/sysent.h>
  41 #include <vm/vm.h>
  42 #include <vm/pmap.h>
  43 #include <machine/md_var.h>
  44 #include <machine/pcb.h>
  45 #include <machine/frame.h>
  46 #include <machine/vmparam.h>
  47
  48 #ifdef COMPAT_FREEBSD32
  49 struct ptrace_xstate_info32 {
  50         uint32_t        xsave_mask1, xsave_mask2;
  51         uint32_t        xsave_len;
  52 };
  53 #endif
  54
  55 static int
  56 cpu_ptrace_xstate(struct thread *td, int req, void *addr, int data)
  57 {
  58         struct ptrace_xstate_info info;
  59 #ifdef COMPAT_FREEBSD32
  60         struct ptrace_xstate_info32 info32;
  61 #endif
  62         char *savefpu;
  63         int error;
  64
  65         if (!use_xsave)
  66                 return (EOPNOTSUPP);
  67
  68         switch (req) {
  69         case PT_GETXSTATE_OLD:
  70                 fpugetregs(td);
  71                 savefpu = (char *)(get_pcb_user_save_td(td) + 1);
  72                 error = copyout(savefpu, addr,
  73                     cpu_max_ext_state_size - sizeof(struct savefpu));
  74                 break;
  75
  76         case PT_SETXSTATE_OLD:
  77                 if (data > cpu_max_ext_state_size - sizeof(struct savefpu)) {
  78                         error = EINVAL;
  79                         break;
  80                 }
  81                 savefpu = malloc(data, M_TEMP, M_WAITOK);
  82                 error = copyin(addr, savefpu, data);
  83                 if (error == 0) {
  84                         fpugetregs(td);
  85                         error = fpusetxstate(td, savefpu, data);
  86                 }
  87                 free(savefpu, M_TEMP);
  88                 break;
  89
  90         case PT_GETXSTATE_INFO:
  91 #ifdef COMPAT_FREEBSD32
  92                 if (SV_CURPROC_FLAG(SV_ILP32)) {
  93                         if (data != sizeof(info32)) {
  94                                 error = EINVAL;
  95                         } else {
  96                                 info32.xsave_len = cpu_max_ext_state_size;
  97                                 info32.xsave_mask1 = xsave_mask;
  98                                 info32.xsave_mask2 = xsave_mask >> 32;
  99                                 error = copyout(&info32, addr, data);
 100                         }
 101                 } else
 102 #endif
 103                 {
 104                         if (data != sizeof(info)) {
 105                                 error  = EINVAL;
 106                         } else {
 107                                 bzero(&info, sizeof(info));
 108                                 info.xsave_len = cpu_max_ext_state_size;
 109                                 info.xsave_mask = xsave_mask;
 110                                 error = copyout(&info, addr, data);
 111                         }
 112                 }
 113                 break;
 114
 115         case PT_GETXSTATE:
 116                 fpugetregs(td);
 117                 savefpu = (char *)(get_pcb_user_save_td(td));
 118                 error = copyout(savefpu, addr, cpu_max_ext_state_size);
 119                 break;
 120
 121         case PT_SETXSTATE:
 122                 if (data < sizeof(struct savefpu) ||
 123                     data > cpu_max_ext_state_size) {
 124                         error = EINVAL;
 125                         break;
 126                 }
 127                 savefpu = malloc(data, M_TEMP, M_WAITOK);
 128                 error = copyin(addr, savefpu, data);
 129                 if (error == 0)
 130                         error = fpusetregs(td, (struct savefpu *)savefpu,
 131                             savefpu + sizeof(struct savefpu), data -
 132                             sizeof(struct savefpu));
 133                 free(savefpu, M_TEMP);
 134                 break;
 135
 136         default:
 137                 error = EINVAL;
 138                 break;
 139         }
 140
 141         return (error);
 142 }
 143
 144 static void
 145 cpu_ptrace_setbase(struct thread *td, int req, register_t r)
 146 {
 147         struct pcb *pcb;
 148
 149         pcb = td->td_pcb;
 150         set_pcb_flags(pcb, PCB_FULL_IRET);
 151         if (req == PT_SETFSBASE) {
 152                 pcb->pcb_fsbase = r;
 153                 td->td_frame->tf_fs = _ufssel;
 154         } else {
 155                 pcb->pcb_gsbase = r;
 156                 td->td_frame->tf_gs = _ugssel;
 157         }
 158 }
 159
 160 #ifdef COMPAT_FREEBSD32
 161 #define PT_I386_GETXMMREGS      (PT_FIRSTMACH + 0)
 162 #define PT_I386_SETXMMREGS      (PT_FIRSTMACH + 1)
 163
 164 static int
 165 cpu32_ptrace(struct thread *td, int req, void *addr, int data)
 166 {
 167         struct savefpu *fpstate;
 168         struct pcb *pcb;
 169         uint32_t r;
 170         int error;
 171
 172         switch (req) {
 173         case PT_I386_GETXMMREGS:
 174                 fpugetregs(td);
 175                 error = copyout(get_pcb_user_save_td(td), addr,
 176                     sizeof(*fpstate));
 177                 break;
 178
 179         case PT_I386_SETXMMREGS:
 180                 fpugetregs(td);
 181                 fpstate = get_pcb_user_save_td(td);
 182                 error = copyin(addr, fpstate, sizeof(*fpstate));
 183                 fpstate->sv_env.en_mxcsr &= cpu_mxcsr_mask;
 184                 break;
 185
 186         case PT_GETXSTATE_OLD:
 187         case PT_SETXSTATE_OLD:
 188         case PT_GETXSTATE_INFO:
 189         case PT_GETXSTATE:
 190         case PT_SETXSTATE:
 191                 error = cpu_ptrace_xstate(td, req, addr, data);
 192                 break;
 193
 194         case PT_GETFSBASE:
 195         case PT_GETGSBASE:
 196                 if (!SV_PROC_FLAG(td->td_proc, SV_ILP32)) {
 197                         error = EINVAL;
 198                         break;
 199                 }
 200                 pcb = td->td_pcb;
 201                 if (td == curthread)
 202                         update_pcb_bases(pcb);
 203                 r = req == PT_GETFSBASE ? pcb->pcb_fsbase : pcb->pcb_gsbase;
 204                 error = copyout(&r, addr, sizeof(r));
 205                 break;
 206
 207         case PT_SETFSBASE:
 208         case PT_SETGSBASE:
 209                 if (!SV_PROC_FLAG(td->td_proc, SV_ILP32)) {
 210                         error = EINVAL;
 211                         break;
 212                 }
 213                 error = copyin(addr, &r, sizeof(r));
 214                 if (error != 0)
 215                         break;
 216                 cpu_ptrace_setbase(td, req, r);
 217                 break;
 218
 219         default:
 220                 error = EINVAL;
 221                 break;
 222         }
 223
 224         return (error);
 225 }
 226 #endif
 227
 228 int
 229 cpu_ptrace(struct thread *td, int req, void *addr, int data)
 230 {
 231         register_t *r, rv;
 232         struct pcb *pcb;
 233         int error;
 234
 235 #ifdef COMPAT_FREEBSD32
 236         if (SV_CURPROC_FLAG(SV_ILP32))
 237                 return (cpu32_ptrace(td, req, addr, data));
 238 #endif
 239
 240         /* Support old values of PT_GETXSTATE_OLD and PT_SETXSTATE_OLD. */
 241         if (req == PT_FIRSTMACH + 0)
 242                 req = PT_GETXSTATE_OLD;
 243         if (req == PT_FIRSTMACH + 1)
 244                 req = PT_SETXSTATE_OLD;
 245
 246         switch (req) {
 247         case PT_GETXSTATE_OLD:
 248         case PT_SETXSTATE_OLD:
 249         case PT_GETXSTATE_INFO:
 250         case PT_GETXSTATE:
 251         case PT_SETXSTATE:
 252                 error = cpu_ptrace_xstate(td, req, addr, data);
 253                 break;
 254
 255         case PT_GETFSBASE:
 256         case PT_GETGSBASE:
 257                 pcb = td->td_pcb;
 258                 if (td == curthread)
 259                         update_pcb_bases(pcb);
 260                 r = req == PT_GETFSBASE ? &pcb->pcb_fsbase : &pcb->pcb_gsbase;
 261                 error = copyout(r, addr, sizeof(*r));
 262                 break;
 263
 264         case PT_SETFSBASE:
 265         case PT_SETGSBASE:
 266                 error = copyin(addr, &rv, sizeof(rv));
 267                 if (error != 0)
 268                         break;
 269                 if (rv >= td->td_proc->p_sysent->sv_maxuser) {
 270                         error = EINVAL;
 271                         break;
 272                 }
 273                 cpu_ptrace_setbase(td, req, rv);
 274                 break;
 275
 276         default:
 277                 error = EINVAL;
 278                 break;
 279         }
 280
 281         return (error);
 282 }
 283
 284 int
 285 ptrace_set_pc(struct thread *td, unsigned long addr)
 286 {
 287
 288         td->td_frame->tf_rip = addr;
 289         set_pcb_flags(td->td_pcb, PCB_FULL_IRET);
 290         return (0);
 291 }
 292
 293 int
 294 ptrace_single_step(struct thread *td)
 295 {
 296
 297         PROC_LOCK_ASSERT(td->td_proc, MA_OWNED);
 298         if ((td->td_frame->tf_rflags & PSL_T) == 0) {
 299                 td->td_frame->tf_rflags |= PSL_T;
 300                 td->td_dbgflags |= TDB_STEP;
 301         }
 302         return (0);
 303 }
 304
 305 int
 306 ptrace_clear_single_step(struct thread *td)
 307 {
 308
 309         PROC_LOCK_ASSERT(td->td_proc, MA_OWNED);
 310         td->td_frame->tf_rflags &= ~PSL_T;
 311         td->td_dbgflags &= ~TDB_STEP;
 312         return (0);
 313 }