void Main(struct Boot_Info *bootInfo) {
Init_BSS();
Init_Screen();
Init_Mem(bootInfo);
Init_CRC32();
Init_TSS();
lockKernel();
Init_Interrupts(0);
Init_SMP();
TODO_P(PROJECT_VIRTUAL_MEMORY_A,
"initialize virtual memory page tables.");
Init_Scheduler(0, (void *)KERN_STACK);
Init_Traps();
Init_Local_APIC(0);
Init_Timer();
Init_Keyboard();
Init_DMA();
/* Init_Floppy(); *//* floppy initialization hangs on virtualbox */
Init_IDE();
Init_PFAT();
Init_GFS2();
Init_GOSFS();
Init_CFS();
Init_Alarm();
Release_SMP();
/* Initialize Networking */
Init_Network_Devices();
Init_ARP_Protocol();
Init_IP();
Init_Routing();
Init_Sockets();
Init_RIP();
/* End networking subsystem init */
/* Initialize Sound */
Init_Sound_Devices();
/* End sound init */
Mount_Root_Filesystem();
TODO_P(PROJECT_VIRTUAL_MEMORY_A, "initialize page file.");
Set_Current_Attr(ATTRIB(BLACK, GREEN | BRIGHT));
Print("Welcome to GeekOS!\n");
Set_Current_Attr(ATTRIB(BLACK, GRAY));
TODO_P(PROJECT_SOUND, "play startup sound");
Spawn_Init_Process();
/* it's time to shutdown the system */
Hardware_Shutdown();
/* we should not get here */
}
static int GFS2_Disk_Properties(struct Mount_Point *mountPoint,
unsigned int *block_size,
unsigned int *blocks_in_disk) {
TODO_P(PROJECT_GFS2,
"GeekOS filesystem infomation operation; set variables.");
return EUNSUPPORTED;
}
int Eth_Dispatch(struct Net_Device *device, struct Net_Buf *nBuf) {
struct Ethernet_Header header;
int rc;
rc = Net_Buf_Extract(nBuf, 0x00, &header, sizeof(header));
if (rc != 0)
return rc;
DEBUG_ETH("Trying to remove the header... \n");
rc = Net_Buf_Remove(nBuf, 0x00, sizeof(header));
if (rc != 0) {
DEBUG_ETH("Failed to remove the header.\n");
return rc;
}
if (ntohs(header.type) <= 1500) {
/* treat as raw ethernet; this is the largest part of this assignment, approx ten lines. */
TODO_P(PROJECT_RAW_ETHERNET,
"awaken a thread waiting for this frame, if any");
return 0;
} else {
struct Ethernet_Dispatch_Entry *curr;
for (curr = Get_Front_Of_Ethernet_Dispatch_Table(&s_ethDispatchTable);
curr != NULL && curr->type != ntohs(header.type);
curr = Get_Next_In_Ethernet_Dispatch_Table(curr));
if (curr) {
DEBUG_ETH("Ethernet dispatching packet to %d protocol\n",
ntohs(header.type));
curr->dispatcher(device, nBuf);
return 0;
}
Print("Destroying netbuf in ethernet layer\n");
Net_Buf_Destroy(nBuf);
return -1;
}
}
int Eth_Transmit(struct Net_Device *device, struct Net_Buf *nBuf,
uchar_t * destAddr, ushort_t type) {
struct Ethernet_Header header;
int rc;
KASSERT(Interrupts_Enabled());
/* all you have to do in this function is fill in the header. */
TODO_P(PROJECT_RAW_ETHERNET,
"construct the ethernet header for the destination, this device's address, and the type.");
rc = Net_Buf_Prepend(nBuf, &header, sizeof(header), NET_BUF_ALLOC_COPY);
if (rc != 0)
return rc;
ulong_t size = MAX(NET_BUF_SIZE(nBuf), ETH_MIN_DATA); /* buffer size must be at least ETH_MIN_DATA,
even if we don't use it. */
KASSERT0(size >= ETH_MIN_DATA, "input to Eth_Transmit should be at least ETH_MIN_DATA long"); /* paranoia. */
void *buffer = Malloc(size);
if (buffer == 0)
return ENOMEM;
rc = Net_Buf_Extract_All(nBuf, buffer);
if (rc != 0) {
Free(buffer);
return rc;
}
Disable_Interrupts();
device->transmit(device, buffer, size);
Enable_Interrupts();
return 0;
}
/*
* Write data to current position in file.
*/
static int GFS2_Write(struct File *file, void *buf, ulong_t numBytes) {
TODO_P(PROJECT_GFS2, "GeekOS filesystem write operation");
return EUNSUPPORTED;
}
/*
* Open a file named by given path.
*/
static int GFS2_Open(struct Mount_Point *mountPoint, const char *path,
int mode, struct File **pFile) {
TODO_P(PROJECT_GFS2, "GeekOS filesystem open operation");
return EUNSUPPORTED;
}
void Init_Ethernet() {
TODO_P(PROJECT_ETHERNET, "initialization");
}
/*
* Get information about the running processes
* Params:
* state->ebx - pointer to user memory containing an array of
* Process_Info structs
* state->ecx - length of the passed in array in memory
* Returns: -1 on failure
* 0 if size of user memory too small
* N the number of entries in the table, on success
*/
static int Sys_PS(struct Interrupt_State *state) {
TODO_P(PROJECT_BACKGROUND_JOBS, "Sys_PS system call");
}
/*
* Get the time of day.
* Params:
* state - processor registers from user mode
*
* Returns: value of the g_numTicks global variable
*/
static int Sys_GetTimeOfDay(struct Interrupt_State *state) {
TODO_P(PROJECT_SCHEDULING, "GetTimeOfDay system call");
}
void Free(void *n) {
TODO_P(PROJECT_MALLOC, "free!");
}
void Init_RIP(void) {
TODO_P(PROJECT_RIP,
"start threads, setup state, set alarm to timeout routes");
}
/*
* Create a directory named by given path.
*/
static int GFS2_Create_Directory(struct Mount_Point *mountPoint,
const char *path) {
TODO_P(PROJECT_GFS2, "GeekOS filesystem create directory operation");
return EUNSUPPORTED;
}
/*
* Complete signal handling for this process.
* Params:
* none
*
* Returns: 0 on success or error code (< 0) on error
*/
static int Sys_ReturnSignal(struct Interrupt_State *state) {
TODO_P(PROJECT_SIGNALS, "Sys_ReturnSignal system call");
}
/*
* Get metadata for given file.
*/
static int GFS2_FStat(struct File *file, struct VFS_File_Stat *stat) {
TODO_P(PROJECT_GFS2, "GeekOS filesystem FStat operation");
return 0;
}
/*
* Open a directory named by given path.
*/
static int GFS2_Open_Directory(struct Mount_Point *mountPoint,
const char *path, struct File **pDir) {
TODO_P(PROJECT_GFS2, "GeekOS filesystem open directory operation");
return EUNSUPPORTED;
}
/*
* Synchronize the filesystem data with the disk
* (i.e., flush out all buffered filesystem data).
*/
static int GFS2_Sync(struct Mount_Point *mountPoint) {
TODO_P(PROJECT_GFS2, "GeekOS filesystem sync operation");
return EUNSUPPORTED;
}
/*
* Get metadata (size, permissions, etc.) of file named by given path.
*/
static int GFS2_Stat(struct Mount_Point *mountPoint, const char *path,
struct VFS_File_Stat *stat) {
TODO_P(PROJECT_GFS2, "GeekOS filesystem stat operation");
return EUNSUPPORTED;
}
/*
* Open a directory named by given path.
*/
static int GFS2_Delete(struct Mount_Point *mountPoint, const char *path) {
TODO_P(PROJECT_GFS2, "GeekOS filesystem delete operation");
return EUNSUPPORTED;
}
/*
* Register the Return_Signal trampoline for this process.
* Signals cannot be delivered until this is registered.
* Params:
* state->ebx - pointer to Return_Signal function
* state->ecx - pointer to the default handler
* state->edx - pointer to the ignore handler
*
* Returns: 0 on success or error code (< 0) on error
*/
static int Sys_RegDeliver(struct Interrupt_State *state) {
// TODO("Sys_RegDeliver system call");
TODO_P(PROJECT_SIGNALS, "Sys_RegDeliver system call");
return 0;
}
/*
* Seek to a position in file.
*/
static int GFS2_Seek(struct File *file, ulong_t pos) {
TODO_P(PROJECT_GFS2, "GeekOS filesystem seek operation");
return EUNSUPPORTED;
}
/*
* Reap a child process that has died
* Params:
* state->ebx - pointer to status of process reaped
* Returns: pid of reaped process on success, -1 on error.
*/
static int Sys_WaitNoPID(struct Interrupt_State *state) {
TODO_P(PROJECT_SIGNALS, "Sys_WaitNoPID system call");
}
/*
* Close a file.
*/
static int GFS2_Close(struct File *file) {
TODO_P(PROJECT_GFS2, "GeekOS filesystem close operation");
return EUNSUPPORTED;
}
void *Malloc(unsigned long n __attribute__ ((unused))) {
Print("Malloc not implemented in user mode\n");
return 0;
TODO_P(PROJECT_MALLOC, "Malloc");
}
/*
* Stat operation for an already open directory.
*/
static int GFS2_FStat_Directory(struct File *dir, struct VFS_File_Stat *stat) {
/* may be unused. */
TODO_P(PROJECT_GFS2, "GeekOS filesystem FStat directory operation");
return 0;
}
/*
* Directory Close operation.
*/
static int GFS2_Close_Directory(struct File *dir) {
TODO_P(PROJECT_GFS2, "GeekOS filesystem Close directory operation");
return EUNSUPPORTED;
}
void Main(struct Boot_Info *bootInfo) {
Init_BSS();
Init_Screen();
Init_Mem(bootInfo);
Init_CRC32();
TODO_P(PROJECT_PERCPU, "Initialize PERCPU");
Init_TSS();
/* by modifying begin_int_atomic to autolock if not locked when interrupts are disabled,
this lockKernel() became duplicative */
/* lockKernel(); */
Init_Interrupts(0);
Print("Init_SMP\n");
Init_SMP();
Print("/Init_SMP\n");
TODO_P(PROJECT_VIRTUAL_MEMORY_A,
"initialize virtual memory page tables.");
Init_Scheduler(0, (void *)KERN_STACK);
Init_Traps();
Init_Local_APIC(0);
Init_Timer();
Init_Keyboard();
Init_DMA();
/* Init_Floppy(); *//* floppy initialization hangs on virtualbox */
Init_IDE();
Init_PFAT();
if(Init_GFS2)
Init_GFS2();
if(Init_GFS3)
Init_GFS3();
Init_GOSFS();
Init_CFS();
Init_Alarm();
Init_Serial();
Print("the global lock is %sheld.\n",
Kernel_Is_Locked()? "" : "not ");
Release_SMP();
/* Initialize Networking */
/*
Init_Network_Devices();
Init_ARP_Protocol();
Init_IP();
Init_Routing();
Init_Sockets();
Init_RIP();
*/
/* End networking subsystem init */
/* Initialize Sound */
Init_Sound_Devices();
/* End sound init */
Mount_Root_Filesystem();
TODO_P(PROJECT_VIRTUAL_MEMORY_A, "initialize page file.");
Set_Current_Attr(ATTRIB(BLACK, GREEN | BRIGHT));
Print("Welcome to GeekOS!\n");
Set_Current_Attr(ATTRIB(BLACK, GRAY));
TODO_P(PROJECT_SOUND, "play startup sound");
TODO_P(PROJECT_SERIAL,
"Initialize the serial console and start the shell.");
Spawn_Init_Process();
/* it's time to shutdown the system because Init exited. */
Hardware_Shutdown();
/* we should not get here */
}
/*
* Set the scheduling policy.
* Params:
* state->ebx - policy,
* state->ecx - number of ticks in quantum
* Returns: 0 if successful, -1 otherwise
*/
static int Sys_SetSchedulingPolicy(struct Interrupt_State *state) {
TODO_P(PROJECT_SCHEDULING, "SetSchedulingPolicy system call");
}
/* called by the system call to read raw ethernet. not really needed except
as driver (testing) code. */
int Eth_Receive(struct Net_Device *device, /*@out@ */ struct Net_Buf **nBuf) {
/* This is the complementary part to the receive path. */
TODO_P(PROJECT_RAW_ETHERNET,
"sleep until a frame arrives, ensure that an nBuf is put in the second argument");
}
/*
* Limit system call.
*/
static int Sys_Limit(struct Interrupt_State *state) {
TODO_P(PROJECT_LIMIT_SYSCALLS_SYSCALL, "Need to Implement Sys_Limit");
}
/*
* Read a directory entry from an open directory.
*/
static int GFS2_Read_Entry(struct File *dir, struct VFS_Dir_Entry *entry) {
TODO_P(PROJECT_GFS2, "GeekOS filesystem Read_Entry operation");
return EUNSUPPORTED;
}
