A tiny bit of clean up (e.g., move code searching cpu array from lapic.c into

mycpu() in proc.c.

A tiny bit of clean up (e.g., move code searching cpu array from lapic.c into
c9fa90f7 · Frans Kaashoek · 2e2d14c2 · c9fa90f7 · c9fa90f7 · c9fa90f7
--- a/console.c
+++ b/console.c
@@ -112,7 +112,7 @@ panic(char *s)
  cli();
  cons.locking = 0;
  // use lapiccpunum so that we can call panic from mycpu()
-  cprintf("cpu %d: panic: ", lapiccpunum());
+  cprintf("lapicid %d: panic: ", lapicid());
  cprintf(s);
  cprintf("\n");
  getcallerpcs(&s, pcs);

--- a/defs.h
+++ b/defs.h
@@ -74,7 +74,7 @@ void            kbdintr(void);
 // lapic.c
 void            cmostime(struct rtcdate *r);
-int             lapiccpunum(void);
+int             lapicid(void);
 extern volatile uint*    lapic;
 void            lapiceoi(void);
 void            lapicinit(void);

--- a/lapic.c
+++ b/lapic.c
@@ -9,7 +9,6 @@
 #include "traps.h"
 #include "mmu.h"
 #include "x86.h"
-#include "proc.h"  // ncpu
 // Local APIC registers, divided by 4 for use as uint[] indices.
 #define ID      (0x0020/4)   // ID
@@ -98,22 +97,12 @@ lapicinit(void)
  lapicw(TPR, 0);
 }
-// Should be called with interrupts disabled: the calling thread shouldn't be
-// rescheduled between reading lapic[ID] and checking against cpu array.
 int
-lapiccpunum(void)
+lapicid(void)
 {
-  int apicid, i;
  if (!lapic)
    return 0;
+  return lapic[ID] >> 24;
-  apicid = lapic[ID] >> 24;
-  for (i = 0; i < ncpu; ++i) {
-    if (cpus[i].apicid == apicid)
-      return i;
-  }
-  panic("unknown apicid\n");
 }
 // Acknowledge interrupt.

--- a/proc.c
+++ b/proc.c
@@ -32,13 +32,24 @@ cpuid() {
  return mycpu()-cpus;
 }
-// Must be called with interrupts disabled
+// Must be called with interrupts disabled to avoid the caller being rescheduled
+// between reading lapicid and running through the loop.
 struct cpu*
 mycpu(void)
 {
+  int apicid, i;
  if(readeflags()&FL_IF)
    panic("mycpu called with interrupts enabled\n");
-  return &cpus[lapiccpunum()];
+  apicid = lapicid();
+  // APIC IDs are not guaranteed to be contiguous. Maybe we should have
+  // a reverse map, or reserve a register to store &cpus[i].
+  for (i = 0; i < ncpu; ++i) {
+    if (cpus[i].apicid == apicid)
+      return &cpus[i];
+  }
+  panic("unknown apicid\n");
 }
 // Disable interrupts so that we are not rescheduled