bhyve/block_if: allow DIOCGMEDIASIZE ioctl

[rew]

Summary

This is needed to get mediasize of the device after a resize event.

Fixes: ae9ea22e14bf ("bhyve: get mediasize for character devices when ...")

usr.sbin/bhyve/block_if.c

 #endif
 
 extern register_t fsu_intr_fault;
 
 /* Called from exception.S */
 void do_el1h_sync(struct trapframe *);
 void do_el0_sync(struct trapframe *);
 void do_el0_error(struct trapframe *);
+static void print_registers(struct trapframe *frame);
 
 int (*dtrace_invop_jump_addr)(struct trapframe *);
 
 static __inline void
 call_trapsignal(struct thread *td, int sig, int code, void *addr)
 {
         ksiginfo_t ksi;
 
svc_handler(struct trapframe *frame)
         td = curthread;
         td->td_frame = frame;
 
         error = syscallenter(td, &sa);
         syscallret(td, error, &sa);
 }
 
 static void
-data_abort(struct trapframe *frame, uint64_t esr, int lower)
+data_abort(struct trapframe *frame, uint64_t esr, uint64_t far, int lower)
 {
         struct vm_map *map;
         struct thread *td;
         struct proc *p;
         struct pcb *pcb;
         vm_prot_t ftype;
         vm_offset_t va;
-        uint64_t far;
         int error, sig, ucode;
 
         /*
          * According to the ARMv8-A rev. A.g, B2.10.5 "Load-Exclusive
          * and Store-Exclusive instruction usage restrictions", state
          * of the exclusive monitors after data abort exception is unknown.
          */
         clrex();
#endif
          * Special case for fuswintr and suswintr. These can't sleep so
          * handle them early on in the trap handler.
          */
         if (__predict_false(pcb->pcb_onfault == (vm_offset_t)&fsu_intr_fault)) {
                 frame->tf_elr = pcb->pcb_onfault;
                 return;
         }
 
-        far = READ_SPECIALREG(far_el1);
-        p = td->td_proc;
+        KASSERT(td->td_md.md_spinlock_count == 0,
+            ("data abort with spinlock held"));
+        if (td->td_critnest != 0 || WITNESS_CHECK(WARN_SLEEPOK |
+            WARN_GIANTOK, NULL, "Kernel page fault") != 0) {
+                print_registers(frame);
+                panic("data abort in critical section or under mutex");
+        }
 
+        p = td->td_proc;
         if (lower)
-                map = &td->td_proc->p_vmspace->vm_map;
+                map = &p->p_vmspace->vm_map;
         else {
                 /* The top bit tells us which range to use */
                 if ((far >> 63) == 1)
                         map = kernel_map;
                 else
-                        map = &td->td_proc->p_vmspace->vm_map;
+                        map = &p->p_vmspace->vm_map;
         }
 
         va = trunc_page(far);
         ftype = ((esr >> 6) & 1) ? VM_PROT_READ | VM_PROT_WRITE : VM_PROT_READ;
 
         /* Fault in the page. */
         error = vm_fault(map, va, ftype, VM_FAULT_NORMAL);
         if (error != KERN_SUCCESS) {
print_registers(struct trapframe *frame)
         printf(" elr: %16lx\n", frame->tf_elr);
         printf("spsr: %16lx\n", frame->tf_spsr);
 }
 
 void
 do_el1h_sync(struct trapframe *frame)
 {
         uint32_t exception;
-        uint64_t esr;
+        uint64_t esr, far;
 
         /* Read the esr register to get the exception details */
         esr = READ_SPECIALREG(esr_el1);
         exception = ESR_ELx_EXCEPTION(esr);
 
 #ifdef KDTRACE_HOOKS
         if (dtrace_trap_func != NULL && (*dtrace_trap_func)(frame, exception))
                 return;
CTR4(KTR_TRAP,
             curthread, esr, frame->tf_elr, frame);
 
         switch(exception) {
         case EXCP_FP_SIMD:
         case EXCP_TRAP_FP:
                 print_registers(frame);
                 panic("VFP exception in the kernel");
         case EXCP_DATA_ABORT:
-                data_abort(frame, esr, 0);
+                far = READ_SPECIALREG(far_el1);
+                intr_enable();
+                data_abort(frame, esr, far, 0);
                 break;
         case EXCP_BRK:
 #ifdef KDTRACE_HOOKS
                 if ((esr & ESR_ELx_ISS_MASK) == 0x40d && \
                     dtrace_invop_jump_addr != 0) {
                         dtrace_invop_jump_addr(frame);
                         break;
                 }
el0_excp_unknown(struct trapframe *frame)
         userret(td, frame);
 }
 
 void
 do_el0_sync(struct trapframe *frame)
 {
         struct thread *td;
         uint32_t exception;
-        uint64_t esr;
+        uint64_t esr, far;
 
         /* Check we have a sane environment when entering from userland */
         KASSERT((uintptr_t)get_pcpu() >= VM_MIN_KERNEL_ADDRESS,
             ("Invalid pcpu address from userland: %p (tpidr %lx)",
              get_pcpu(), READ_SPECIALREG(tpidr_el1)));
 
         esr = READ_SPECIALREG(esr_el1);
         exception = ESR_ELx_EXCEPTION(esr);
+        switch (exception) {
+        case EXCP_INSN_ABORT_L:
+        case EXCP_DATA_ABORT_L:
+        case EXCP_DATA_ABORT:
+                far = READ_SPECIALREG(far_el1);
+        }
+        intr_enable();
 
         CTR4(KTR_TRAP,
             "do_el0_sync: curthread: %p, esr %lx, elr: %lx, frame: %p",
             curthread, esr, frame->tf_elr, frame);
 
         switch(exception) {
         case EXCP_FP_SIMD:
         case EXCP_TRAP_FP:
 #ifdef VFP
                 vfp_restore_state();
 #else
                 panic("VFP exception in userland");
 #endif
                 break;
         case EXCP_SVC:
-                /*
-                 * Ensure the svc_handler is being run with interrupts enabled.
-                 * They will be automatically restored when returning from
-                 * exception handler.
-                 */
-                intr_enable();
                 svc_handler(frame);
                 break;
         case EXCP_INSN_ABORT_L:
         case EXCP_DATA_ABORT_L:
         case EXCP_DATA_ABORT:
-                data_abort(frame, esr, 1);
+                data_abort(frame, esr, far, 1);
                 break;
         case EXCP_UNKNOWN:
                 el0_excp_unknown(frame);
                 break;
         case EXCP_BRK:
                 td = curthread;
                 call_trapsignal(td, SIGTRAP, TRAP_BRKPT, (void *)frame->tf_elr);
                 userret(td, frame);