1The Tempo Operating SystemPart 5System Calls -- OverviewLast update: 2/16/2009System Call DocumentationSystem calls for Tempo are documented in the file doc/tempo32.txt (but beware – it is continually under modification!)For each call, the file contains a prototype declaration indicating each of the parameters, a textual description of the effect of the system call, and indication of the values that might be returned (indicating success or failure).2Return ValuesSystem calls return:NOERROR (0) indicating that the call was successfully completedA negative value indicating an exceptional condition (e.g. –1001 to indicate that an operation was attempted on a non-existent message queue)A positive value conveying a result (e.g. read and write return the number of bytes processed).Error codes are symbolically defined in the file “h/syserrs.h”System Call CategoriesSystem calls can be grouped into several categories:Process functions (e.g. newproca, kill)Time functions (e.g. sleep and time)Memory management functions (in infancy)Semaphore functions (e.g. up and down)Interprocess communication functions (e.g. send, receive)Low-level I/O functions (console, keyboard, disk)Filesystem and higher-level I/O functions (open, read)Information functions (getsysparm)3Additional CategoriesOther operating systems may provide system calls in additional categories. Most notable among these are:Network and protocol-related functionsGraphic and window-related functions, including font managementEvent management (e.g. in Windows)Asynchronous signals (as in UNIX)Process ManagementMost modern systems have facilities for process management; many also support threads (kernel and/or user threads). Examples:Windows: CreateProcess, CreateThread, WaitForSingleObjectUNIX/Linux: fork, pthread_create, clone, wait/waitpidAlthough these calls vary from system to system, the concept of a “process” is consistently present.4Process SchedulingProcess scheduling is a “rich” topic, and there are numerous variations.The most popular scheduling techniques include:priority-based scheduling: higher priority tasks run before lower priority tasksrun-to-completion scheduling: a process runs until it blocks, terminates, or voluntarily yields the processorround-robin scheduling: each process runs for at most a ‘quantum’ of time before being forced to yield to another ready process at the same priorityProcess CreationCurrently, the primary system call used in Tempo to create processes is ‘newproca’. The function ‘newproc’ is a shorthand version that calls newproca with some default parameters.pid_t newproc (int (*root)(void), int prio, unsigned stksize)root is the name of the function with which execution will beginprio is the initial priority for the new processstksize is the number of pages for the stack (0 means 1)5Tempo: newprocaroot, prio, stksize as for newprocnargs is the number of “command line” arguments for the new processargs points to an array of nargs null-terminated character strings, each of which contains one command-line argument.pid_t newproca (int (*root)(int,char **), int prio,unsigned stksize, unsigned nargs, unsigned char **args)Tempo: getpid, exit, getpstateReturns the process ID of the calling process.pid_t getpid ()Terminates the calling process, and provides that status be returned to any processes waiting for this process to terminate.void exit (int status)Returns the current status of the process with pid proc. The status of the calling process is 2 (meaning it’s running); other values defined in file “h/sysparm.h”int getpstate (pid_t proc)6Tempo: kill, waitpidTerminates process proc and returns any resources it owns. A process may terminate itself. Note that this is notthe same as the UNIX killsystem call.int kill (pid_t proc)Waits for process with pid proc to terminate.Then returns that process’ exit status to exitstatus.timeout indicates how long waitpid should wait:INFINITE (-1) means wait forever0 means never wait (inappropriate with waitpid)> 0 means a wait for that many clock ticksint waitpid (pid_t proc, int *exitstatus, int timeout)Tempo: quit, getprio, setprioShuts down the system and display the string pointed to by msg if it is not NULL. This should not normally be used by user processes.void quit (char *msg)Returns the priority of the currently-running process.int getprio (void)Sets the priority of the currently-running process.int setprio (int newprio)7Tempo: yield, setquantumYields the CPU to the process at the head of the ready queue with the same priority as the current process.int yield (void)Sets the quantum size (in clock ticks) to nquantum. If this is 0, the system uses “run to completion” scheduling. Otherwise each process is allowed to run for at most nquantumclock ticks before being preempted by another ready process at the same priority.int setquantum (unsigned int nquantum)Tempo: getquantumReturns the current quantum size setting for the system.unsigned int getquantum (void)8Time FunctionsMany systems have calls that deal with time in one way or another. The fundamental calls deal with several “types” of time:the current “wall clock” timeCPU time used by a process (either in user mode or in kernel mode)Windows ExamplesGetTickCount(void)returns the number of milliseconds that have elapsed since the system was startedGetSystemTime(…)returns the current system date and timeGetSystemTimes(…)returns total processor idle time, time spent executing kernel code, and time spent executing user-mode codeSleep(n)causes a process to sleep for at least n milliseconds9UNIX/Linux Exampletime()returns time of day as seconds past 1/1/1970 at midnight UTC.times(…)returns kernel and user-mode time for the current process and all terminated (waited-for) child processesnanosleep(…)causes a process to sleep for at least a give time (specified inseconds and nanoseconds)Tempo: time, sleepReturns number of milliseconds since the system was started.[In earlier versions of the system, the time between clock ticks – that is, interrupts – could be adjusted. The clock tick interval has now been standardized at one millisecond.]unsigned int time (void)Causes the current process to sleep (block) for at least nticksmilliseconds. int sleep (unsigned int nticks)10Tempo: setxlimit, getxlimitPrimarily for debugging purposes, set the maximum execution time for the entire system to nticksmilliseconds. If this is 0 (as it is by default), no limit is