Project 4: Loading and Executing Modules
Due: April 22, 1998, in recitation
In this project we dynamically load application modules from disk. This involves a new system architecture, which is illustrated in the figure above. As can be seen, there is now onemain() module, containing the kernel and associated files, as well as many application modules. Each module is separately compiled into an individual executable file.
To enable this effort, we have provided the following new files:io412.c The standard IO functions from cmsc412.c. io412.h The header file for io412.c base412.c The memory management functions from cmscs412.c, and new file management functions. base412.h The header file for base412.c c0grh.obj The version of c0h to be linked in with the application modules.
io412, base412 and c0h are linked in with the main module; io412 and c0grh should be linked in with each application file.
When linking an application module, the order in which you specify the object files matters. Here is a generalized makefile rule that produces an application module from a .c file (the dollar signs indicate special built-in make variables):
bcc -v -mh -c $<
tlink /v c0grh $*.obj klib io412, $*.mod, $*, emu mathh ch
The link command for your kernel should have the form below, with c0h coming first and including both base412 and io412:
tlink /v c0h base412 io412 ..., myos, myos, emu mathh ch
Each application file must contain a special process (function) calledProc(), which is the module's sole public entry point.
Splitting Your Kernel
If you have not already done so, split your kernel into two groups of files. The first group (which we callklib.c) contains the system calls directly callable by application processes. These do not include System_service(), however. The second group (which we call kernel.c) contains System_service(), those functions which are only invoked by System_service() and all ISRs.
Put_char() should be implemented as a system call just like Proc_start(), etc. It should be in klib.c and it should generate an interrupt to System_service(). Otherwise, in each of the modules, the Cprintf() in io412.c would refer to a Put_char() which is not the one we have implemented (since the modules are linked separately).
The reason for this separation is that we want only one kernel, while the function interfaces for system calls (such as Proc_start()) must be linked in with every application module.
To verify that you have created the files properly, test out an old application (using only the main module). Make sure to link in io412.c and base412.c, and not the obsolete cmsc412.c.
In this project, application processes will now be allowed to dynamically allocate and free memory. You will write the following system calls (to be written inklib.c).
void *Kmalloc(int numBytes); /* Request numBytes of memory. */
void Kfree(void *ptr); /* Release segment at ptr. */
These functions simply generate interrupts to system service, which in turn directly callsSafe_malloc() and Safe_free(), respectively.
Loading and Executing Modules
The new kernel will now be able to open an application module's file, allocate memory for it, load it into memory, initialize the module, and finally, issue aProc_start() for the Proc() function in the module. Accomplishing these tasks requires adding new system calls, as well as modifying existing parts of the kernel.
The Open Module List (OML)
For the sake of bookkeeping, the kernel keeps a list of all modules currently residing in main memory. Each node in the open module list (OML) should contain at least the following fields:
Start address for module
End address for module
Address for "Proc" function
Reference Count (initially 0)
Address for "Module_init" function
The start address must be the pointer returned bySafe_malloc(), as that is the only one that can be freed by Safe_free(), which expects a tag above the pointer. The filename is the DOS name of the module, and the Proc() address is a pointer to its Proc() function. While there may be other local functions that can serve as code for process in the module, Proc() is the only process that will be visible to the outside world. The reference count denotes the number of processes executing code in the module.
One may still wish to have theInit() process (and other processes) reside in the main() module. If so, the module list should be initialized with a single node in it, which represents the main module. The filename in this node can be set to "_main". The start address should be a pointer to the first process lexically appearing in the main module, and the end address should point to the last process. The Proc() address should just be the start address of the Init() function.
A New PCB Field
The PCB structure should contain a field that contains the filename (called fn) of the PCB's process module.
Changes to System_service for Proc_Start
The PROC_START code must now use the process address argument to ensure that the referenced module is resident. First, the fn field of the running PCB is obtained. Then, the node corresponding to the fn is found in the OML. If the process address falls between the start address and end address for this module, we know that the process resides within the current module. Ergo, we know that the module is resident. In this case, the reference count in the node is incremented, and a copy (made withSafe_malloc) of the same fn is placed in the new PCB. When comparing pointers (e.g., p < q), you must convert them to 20-bit addresses and compare them as longs, not pointers. This is because of bugs in the compiler's handling of pointer comparisons. (You may wish to verify if this is still the case in Borland 4.5).
Otherwise, the new process must be in another module. Recall that the only entry point into each module is theProc() function, the address for which is stored in the module's OML node. This being the case, the OML is searched for a node with its Proc() field equal to the process argument. If one is found, the node's reference count is incremented, and the fn is placed in the new PCB. Make sure that you make a copy of the filename in the PCB of a new process during Proc_start, just as you did before for argv.
If neither of the above cases is true, we know that the module is nonresident (i.e., not loaded into memory). In this case an error should be returned byProc_start() (e.g., a pid of -1).
Changes to System_service for Proc_Term
Obtain the fn from the current PCB, and retrieve the corresponding OML node. Then, decrement the node's reference count. If it is now 0, perform aKwakeup on the address of the node (see below).
The "top" level of this process is initiated by the following new kernel call:
typedef (*Procptr) ( int, char ** ); /* Load module into memory and return its start address */ Procptr Load_module( char *pathname );
The argument "pathname" is the name of the file to be loaded, which should be in standard DOS format. The function generates an interrupt toSystem_service(), which loads the new module into memory. System_service() then passes back to Load_module() a pointer to the module's Proc() function. This pointer, in turn, is passed up to the caller of Load_module().
Recall that when a function's return value is a pointer, the segment is passed back in DX, while the offset is passed in the AX register.
Loading the Module
Since loading the module requires about 30 lines of C code, the code should not be within the body ofSystem_service(). Instead, System_service() should pass the module's pathname to an auxiliary function, Kload_module(), which should be local to the kernel:
Kload_module() will load the module and update various data structures as needed. It returns the address of Proc() back to System_service (which then returns it to the system call, Load_module()).
We provide three new functions to help do the disk IO, which can be found in base412.c.
int Open_exe(char *pathname, long *hsize);
/* Opens an .exe file with name pathname, puts the _header_ size into */
/* hsize and returns a file descriptor. Returns -1 on io error (file */
/* not found, etc.). If file is not an exe file, -2 is returned. */
int Read_exe(int fd, unsigned pos, unsigned len, void *buf);
/* Reads len bytes from .exe file, starting at position pos, into */
/* buffer. Returns the number of bytes read. On error, returns -1. */
int Close_exe(int fd);
/* Closes an open .exe file. On error, returns -1. */
Executable files are separated into two contiguous parts: the header, followed by the code. Note thatOpen_exe() returns the size of the file's header. The header itself contains the actual size of the entire file, including the header.
The loading/locating algorithm contains the following steps:
Opening the Exe File
First compare the requested filename against all of those already in the OML. If a node for it exists, simply return theProc() address field from the OML.
Otherwise, create a new OML node for the new module, put it on the OML list and initialize its fn field.
Then, callSafe_malloc() to get a buffer for the header. Since all of the header fields are 16 bits wide, it is a good idea to declare the buffer of type unsigned *. Then, using Read_exe(), read the header into the buffer.
A module's header has the following format (entries marked with* are used in this project).
00-01 File type
02-03 * Number of bytes in the last block of the file.
04-05 * File size in 512-byte blocks, including the header.
06-07 * Number of relocation table items.
08-09 Header size in 16-byte paragraphs.
0A-0B * Number of 16-byte paragraphs that must follow module in memory.
0C-0D High/Low loader switch.
0E-0F Stack segment.
10-11 Stack offset.
14-15 * Relative offset of init code (if start of code is at CS=0, IP=0).
16-17 * Relative segment of init code (if start of code is at CS=0, IP=0).
18-19 * Offset of relocation table with respect to start of header.
Allocate Memory and Read Module
First, we must calculate the amount of space needed, in bytes. The total is
<num of bytes is last block of file> (1)
+ (<num of blocks> - 1) * 512 (2)
+ <num of paragraphs at end> * 16 (3)
+ 15 (4)
- <size of header> (5)
<number bytes necessary>
Lines (1)-(2) are obvious. Line (3) is needed for uninitialized data following the code. Line (4) is due to a technicality: the start address of the code must be on a segment boundary. This means that its 20-bit address must have the lowest 4 bits equal to 0. Thus, regardless of the address returned bySafe_malloc(), we must have sufficient room to load the code starting on the first segment boundary.
IfSafe_malloc() returns a pointer p, the first segment boundary address is startseg:0, where
/* Make twenty-bit paragraph address, and then get segment part. */
startseg = (((long) FP_SEG(p) << 4) + FP_OFF(p) + 0x0F) >> 4
Thus,startseg:0 is the start location for the code to be read in via Read_exe(). After the code is read in, the file should be closed.
At this point, the start and end address fields can be filled in the OML node. (Make sure that the start address isp, and not startseg:0.)
Each relocation record is 32 bits wide, and gives the location of the segment part of some address in the code. To calculate the true location with respect to the code buffer, extract the offset and segment parts from the relocation record, and calculate the resulting 20-bit address (as shown below). This number gives the offset, with respect to the start of the code, of the address to be patched.
unsigned long x, seg, off;
seg = ((unsigned long) FP_SEG (addr)) << 4;
off = (unsigned long) FP_OFF (addr);
x = seg + off;
For example, assume that the instruction CALL 0012:292F is in the code. Then, there is some relocation record that gives the byte offset, with respect to the start of the code, of the0012 segment part. Since all addresses in the file are relative to 0000:0000, one must change 0012 to 0012 + startseg() (recall that the start offset is always 0).
To relocate all addresses, first use the relocation table offset to find the relocation table. Then, simply relocate every address listed in the table. Make sure to make all variables of type char unsigned. Shifting a signed character produces incorrect code.
Initializing the Module
There is an initialization function in each code module, which must be called to set up the data areas. This function has the added benefit of returning a pointer toProc() (in DX and AX), which is exactly what must be returned from Kload_module() itself.
Note that the init function's address is listed in the header (both its relative segment and offset parts). If a (unsigned) character pointercodeptr points to the start of the code (i.e., startseg:0), then the initialization function is at
Module_init = codeptr + (segment_part << 4) + offset_part
whereModule_init is defined as follows:
procptr (*Module_init)(unsigned int, void (*), void (*));
At this point the header buffer can be freed, since it is no longer used. Then the initialization function can be called as follows, and the return value should be put in theProc() field of the OML node.
result = Module_init(_psp, proc_term, proc_term)
Finally, the same result should be returned as the result ofKload_module().
_psp is the segment of the program segment prefix, a block of memory used by DOS (mainly for file handling). The second argument to Module_initis the function to use for _exit; the third is the function to use for abort.
Closing the Module
For our purposes, closing a module consists of freeing up the memory area that the module occupies. This is done by the following kernel call:
void Close_module(char *pathname); /* Close the module. */
Again, the function generates an interrupt toSystem_service(), which then calls an auxilary function
void Kclose_module(char *pathname);
First, the OML is searched, looking for a node with the correct filename. If the file is not in resident in memory, simply return.
Otherwise, retrieve the proper OML node. If the reference count is 0, the memory can be reclaimed. However, if the count is not 0, it means that some process is still using the module. In this case, callKsleep() on the OML node. When Proc_term() finally decrements the count to 0, a corresponding Kwakeup() will be called.
At that point, make sure that the OML node for that filename still exists, in case another process has closed it first. You can do so using a loop.
Reclaim the module's memory by simply callingSafe_free() on the OML node's start address. Then call the OML node's Module_init function with 0 for all three parameters to make it clean up. Finally, free up the memory of the OML node itself.
The Initial Module
You should loadinit.mod as your first module and Proc_start() the Proc() of this module. This module may Proc_start() other processes within itself or it might load another module and Proc_start() the Proc() of that module, etc. So, we can test your code by substituting our init.mod.