base_gdt:

§ 15.7.1

base_idt:

§ 15.7.4

base_tss_load:

§ 15.7.8

boot_info:

§ 15.14.7

phys_mem_va:

§ 15.6.2

lmm_alloc_page:

§ 25.6.8

malloc_lmm:

§ 14.5.1

panic:

§ 14.8.3

printf:

§ 14.6

base_critical_enter:

§ 15.2.5

base_critical_leave:

§ 15.2.5

#include <oskit/smp.h>

int smp_init(void);

This function does the initial setup for the SMP support. It should be called before any other SMP library routines are used. It identifies the processors and gets them ready and waiting in a busy-loop for a “go” from the boot processor.

Note that success does not necessarily mean the system has multiple processors. Rather, failure indicates that the machine does not support multiple processors. smp_get_num_cpus should be used to determine the number of CPUs present.

Don’t call this more than once. . . yet.

It returns 0 on success (SMP-capable system is found). E_SMP_NO_CONFIG is returned on non-IMPS-compliant x86 machines.

#include <oskit/smp.h>

int smp_find_cur_cpu(void);

This function returns a unique (per-processor) integer representing the current processor. Note that the numbers are not guaranteed to be sequential or starting from 0, although that may be a common case.

On the x86, these numbers correspond to the processor’s APIC ID, which is set by the hardware. However, these are to be treated as logical processor numbers since the smp library may do a transformation in the future.

The processor’s ID.

#include <oskit/smp.h>

int smp_find_cpu(int first);

Given a number first, it returns the first processor ID such that the ID is greater than or equal to that number.

In order to be assured of finding all the CPUs, the initial call should be made with an argument of 0 and subsequent calls should be made with one more than the previously returned value.

This is designed to be used as an iterator function for the client OS to determine which processor numbers are present.

first:

The processor number at which to start searching.

Returns E_SMP_NO_PROC if there are no more processors, otherwise the ID of the next processor.

#include <oskit/smp.h>

void smp_start_cpu(int processor_id, void (*func)(void *data), void *data, void *stack_ptr);

This releases the specified processor to start running a function with the specified stack.

Results are undefined if:

1. the processor indicated does not exist,
2. a processor attempts to start itself,
3. any processor is started more than once, or
4. any of the parameters is invalid.

smp_find_cur_cpu can be used to prevent calling smp_start_cpu on yourself. This function must be called for each processor started up by smp_init; if the processor is not used, then func should execute the halt instruction immediately.

It is up to the user to verify that the processor is started up correctly.

processor_id:

The ID of a processor found by the startup code.

func:

A function pointer to be called by the processor after it has set up its stack.

data:

A pointer to some structure that is placed on that stack before func is called.

stack_ptr:

The stack pointer to be used by the processor. This should point to the top of the stack to be used by the processor, and should be large enough for func’s requirements.

#include <oskit/smp.h>

int smp_get_num_cpus(void);

This returns the number of processors that exist.

The number of processors that have been found. In a non-SMP-capable system, this will always return one.

#include <oskit/smp.h>

oskit_addr_t smp_map_range(oskit_addr_t start, oskit_size_t size);

This function is a hook provided by the host OS to allow the SMP library to request physical memory be mapped into its virtual address space. This is called by smp_init_paging.

Note that this could be implemented using osenv_mem_map_phys.

The virtual address where the physical pages are mapped. Returns zero if unable to map the memory.

#include <oskit/smp.h>

int smp_init_paging(void);

This routine is called by the OS when it is ready to turn on paging. This call causes the SMP library to make call-backs to the OS to map the regions that are SMP-specific. On Intel x86 processors, this means the APICS.

Zero on success, non-zero on failure.

#include <oskit/smp.h>

void smp_message_pass(int cpunum);

This causes the target processor to run its interrupt handler for the IPI vector, if the appropriate entry of smp_message_pass_enable has been set to non-zero by that processor. A processor should only modify its own smp_message_pass_enable entry after it is ready to start receiving IPIs.

This call offers very limited functionality. The expectation is that the OS writer will implement the desired functionality on top of this primitive.

smp_message_pass_enable[CPUID]

This array contains an entry for each processor. If a processor is ready to start receiving inter-processor interrupts, it should set smp_message_pass_enable[smp_find_cur_cpu()] to non-zero. This is used internally by the SMP library to prevent interrupts from being delivered before the processor has set up enough state to receive them.

#include <oskit/x86/smp.h>

void smp_apic_ack(void);

This routine ACKs the local APIC. The APIC must be ACKed before returning from the IPI handler. Due to limitations in the APIC design, IPIs can be lost if sent too closely together, as the APIC only handles two outstanding requests.