Changeset 13799


Ignore:
Timestamp:
Jun 10, 2010, 4:14:38 AM (10 years ago)
Author:
gb
Message:

Reorganize a bit: return Boolean results from exception handlers,
check for valid callback pointers before trying to do callbacks.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/arm/lisp-kernel/arm-exceptions.c

    r13789 r13799  
    321321}
    322322
    323 OSStatus
     323Boolean
    324324handle_alloc_trap(ExceptionInformation *xp, TCR *tcr)
    325325{
     
    331331
    332332  cur_allocptr = xpGPR(xp,allocptr);
    333   program_counter = xpPC(xp);
    334   prev_instr = *(program_counter-1);
     333
    335334  allocptr_tag = fulltag_of(cur_allocptr);
    336335
     
    341340    break;
    342341
    343   case fulltag_even_fixnum:
    344   case fulltag_odd_fixnum:
    345     break;
    346 
    347342  case fulltag_misc:
    348343    disp = allocptr_displacement(xp);
     
    352347    /* else fall thru */
    353348  default:
    354     return -1;
    355   }
    356 
    357   if (bytes_needed) {
    358     update_bytes_allocated(tcr,((BytePtr)(cur_allocptr-disp)));
    359     if (allocate_object(xp, bytes_needed, disp, tcr)) {
    360 #if 0
    361       fprintf(dbgout, "alloc_trap in 0x%lx, new allocptr = 0x%lx\n",
    362               tcr, xpGPR(xp, allocptr));
    363 #endif
    364       adjust_exception_pc(xp,4);
    365       return 0;
    366     }
    367     lisp_allocation_failure(xp,tcr,bytes_needed);
    368     return -1;
    369   }
    370   return -1;
     349    return false;
     350  }
     351
     352  update_bytes_allocated(tcr,((BytePtr)(cur_allocptr-disp)));
     353  if (allocate_object(xp, bytes_needed, disp, tcr)) {
     354    adjust_exception_pc(xp,4);
     355    return true;
     356  }
     357  lisp_allocation_failure(xp,tcr,bytes_needed);
     358  return true;
    371359}
    372360
     
    379367}
    380368
    381 OSStatus
     369Boolean
    382370handle_gc_trap(ExceptionInformation *xp, TCR *tcr)
    383371{
     
    511499
    512500  adjust_exception_pc(xp,4);
    513   return 0;
     501  return true;
    514502}
    515503
     
    831819}
    832820
    833 OSStatus
     821Boolean
    834822handle_protection_violation(ExceptionInformation *xp, siginfo_t *info, TCR *tcr, int old_valence)
    835823{
     
    850838
    851839    xpGPR(xp,imm0) = 0;
    852     return 0;
     840    return true;
    853841  }
    854842
     
    856844    xpGPR(xp,imm0) = 0;
    857845    xpPC(xp) = (pc)touch_page_end;
    858     return 0;
     846    return true;
    859847  }
    860848
     
    870858        UnProtectMemory((LogicalAddress)(truncate_to_power_of_2(addr,log2_page_size)),
    871859                        page_size);
    872         return 0;
     860        return true;
    873861      }
    874862    }
    875863  }
    876864  if (old_valence == TCR_STATE_LISP) {
    877     callback_for_trap(nrs_CMAIN.vcell, xp, is_write_fault(xp,info)?SIGBUS:SIGSEGV, (natural)addr);
    878   }
    879   return -1;
     865    LispObj cmain = nrs_CMAIN.vcell;
     866   
     867    if ((fulltag_of(cmain) == fulltag_misc) &&
     868      (header_subtag(header_of(cmain)) == subtag_macptr)) {
     869     
     870      callback_for_trap(nrs_CMAIN.vcell, xp, is_write_fault(xp,info)?SIGBUS:SIGSEGV, (natural)addr);
     871    }
     872  }
     873  return false;
    880874}
    881875
     
    991985}
    992986
    993 OSStatus
    994 PMCL_exception_handler(int xnum,
    995                        ExceptionInformation *xp,
    996                        TCR *tcr,
    997                        siginfo_t *info,
    998                        int old_valence)
    999 {
    1000   OSStatus status = -1;
     987Boolean
     988handle_exception(int xnum,
     989                 ExceptionInformation *xp,
     990                 TCR *tcr,
     991                 siginfo_t *info,
     992                 int old_valence)
     993{
    1001994  pc program_counter;
    1002995  opcode instruction = 0;
     
    10101003
    10111004  if (IS_ALLOC_TRAP(instruction)) {
    1012     status = handle_alloc_trap(xp, tcr);
     1005    return handle_alloc_trap(xp, tcr);
    10131006  } else if ((xnum == SIGSEGV) ||
    10141007             (xnum == SIGBUS)) {
    1015     status = handle_protection_violation(xp, info, tcr, old_valence);
     1008    return handle_protection_violation(xp, info, tcr, old_valence);
    10161009  } else if (xnum == SIGFPE) {
    1017     status = handle_sigfpe(xp, tcr);
     1010    return handle_sigfpe(xp, tcr);
    10181011  } else if ((xnum == SIGILL)) {
    10191012    if (IS_GC_TRAP(instruction)) {
    1020       status = handle_gc_trap(xp, tcr);
     1013      return handle_gc_trap(xp, tcr);
    10211014    } else if (IS_UUO(instruction)) {
    1022       status = handle_uuo(xp, instruction);
     1015      return handle_uuo(xp, instruction);
    10231016    } else {
    1024       status = handle_unimplemented_instruction(xp,instruction,tcr);
     1017      return handle_unimplemented_instruction(xp,instruction,tcr);
    10251018    }
    10261019  } else if (xnum == SIGNAL_FOR_PROCESS_INTERRUPT) {
    10271020    tcr->interrupt_pending = 0;
    10281021    callback_for_trap(nrs_CMAIN.vcell, xp, xnum, 0);
    1029     status = 0;
    1030   }
    1031 
    1032   return status;
     1022    return true;
     1023  }
     1024
     1025  return false;
    10331026}
    10341027
     
    10531046}
    10541047
    1055 OSStatus
     1048Boolean
    10561049handle_uuo(ExceptionInformation *xp, opcode the_uuo)
    10571050{
    10581051  unsigned
    10591052    format = UUO_FORMAT(the_uuo);
    1060   OSStatus status = -1;
     1053  Boolean handled = false;
    10611054  int bump = 4;
    10621055  TCR *tcr = get_tcr(true);
     
    10681061      int service = UUO_UNARY_field(the_uuo);
    10691062
    1070       status = 0;
    10711063      switch (service) {
    10721064      case error_propagate_suspend:
     1065        handled = true;
    10731066        break;
    10741067      case error_interrupt:
    10751068        xpGPR(xp,imm0) = (LispObj) raise_thread_interrupt(target);
     1069        handled = true;
    10761070        break;
    10771071      case error_suspend:
    10781072        xpGPR(xp,imm0) = (LispObj) lisp_suspend_tcr(target);
     1073        handled = true;
    10791074        break;
    10801075      case error_suspend_all:
    10811076        lisp_suspend_other_threads();
     1077        handled = true;
    10821078        break;
    10831079      case error_resume:
    10841080        xpGPR(xp,imm0) = (LispObj) lisp_resume_tcr(target);
     1081        handled = true;
    10851082        break;
    10861083      case error_resume_all:
    10871084        lisp_resume_other_threads();
     1085        handled = true;
    10881086        break;
    10891087      case error_kill:
    10901088        xpGPR(xp,imm0) = (LispObj)kill_tcr(target);
     1089        handled = true;
    10911090        break;
    10921091      case error_allocate_list:
    10931092        allocate_list(xp,tcr);
     1093        handled = true;
    10941094        break;
    10951095      default:
    1096         status = -1;
     1096        handled = false;
    10971097        break;
    10981098      }
     
    11031103    case 3:
    11041104      if (extend_tcr_tlb(tcr,xp,UUOA_field(the_uuo))) {
    1105         status = 0;
     1105        handled = true;
    11061106        bump = 4;
    11071107        break;
     
    11091109      /* fall in */
    11101110    default:
    1111       status = -1;
     1111      handled = false;
    11121112      break;
    11131113
     
    11201120      tcr->interrupt_pending = 0;
    11211121      callback_for_trap(nrs_CMAIN.vcell, xp, SIGNAL_FOR_PROCESS_INTERRUPT, 0);
     1122      handled = true;
     1123      break;
     1124    default:
     1125      handled = false;
    11221126      break;
    11231127    }
     
    11291133  case uuo_format_unary_error:
    11301134  case uuo_format_binary_error:
    1131     bump = handle_error(xp,0,the_uuo);
    1132     if (bump >= 0) {
    1133       status = 0;
    1134     }
     1135    handled = handle_error(xp,0,the_uuo);
    11351136    break;
    11361137
    11371138  default:
    1138     status = -1;
     1139    handled = false;
    11391140    bump = 0;
    11401141  }
    11411142 
    1142   if ((!status) && bump) {
     1143  if (handled && bump) {
    11431144    adjust_exception_pc(xp, bump);
    11441145  }
    1145   return status;
     1146  return handled;
    11461147}
    11471148
     
    12491250}
    12501251
    1251 /* The main opcode.  */
    1252 
    1253 
    1254 int
     1252
     1253
     1254Boolean
    12551255handle_error(ExceptionInformation *xp, unsigned arg1, unsigned arg2)
    12561256{
     
    12631263    }
    12641264
    1265   return(-1);
     1265  return false;
    12661266}
    12671267               
     
    13581358 
    13591359  wait_for_exception_lock_in_handler(tcr, context, &xframe_link);
    1360   if ((noErr != PMCL_exception_handler(signum, context, tcr, info, old_valence))) {
     1360  if ((!handle_exception(signum, context, tcr, info, old_valence))) {
    13611361    char msg[512];
    13621362    snprintf(msg, sizeof(msg), "Unhandled exception %d at 0x%lx, context->regs at #x%lx", signum, xpPC(context), (natural)xpGPRvector(context));
     
    15741574          old_valence = prepare_to_wait_for_exception_lock(tcr, context);
    15751575          wait_for_exception_lock_in_handler(tcr, context, &xframe_link);
    1576           PMCL_exception_handler(signum, context, tcr, info, old_valence);
     1576          handle_exception(signum, context, tcr, info, old_valence);
    15771577          if (disp) {
    15781578            xpGPR(context,allocptr) -= disp;
Note: See TracChangeset for help on using the changeset viewer.