The Limbo system modules are as follows:

bind, mount, unmount - change file name space

byte2char, char2byte - convert between bytes and characters

chdir - change working directory

dial, announce, export, listen - make network connections

dirread - read directory

dup - duplicate an open file descriptor

file2chan - create file connected to Limbo channel

millisec - millisecond timer

open, create - open/create a file for reading or writing

pctl - process control

print, fprint, sprint - print formatted output

read, write, stream - read, write, or stream file

remove - remove a file

seek - change file offset

sleep - delay execution

stat, fstat, fwstat, wstat - get and put file status

tokenize - split string into words

utfbytes - compute the Unicode length of a UTF byte sequence

Synopsis

include "sys.m";
sys:= load Sys Sys->PATH;

File Name Space

When a process presents a file name to Inferno, it is evaluated by the following algorithm:

1. Start with a directory that depends on the first character of the path: / means the root of the main hierarchy

   # means the separate root of a kernel device's file tree (see Section 3)

   anything else means the current working directory of the process.

2. For each path element, look up the element in the directory, advance to that directory, do a possible translation.
3. Repeat. The last step may yield a directory or regular file. The collection of files that can be reached from the root is called the name space of a process.

   A program can use bind or mount so that whenever a specified file is reached during an evaluation, that evaluation continues instead from some other specified file. These calls create union directories, which are concatenations of ordinary directories that are searched sequentially until the desired element is found.

   Using bind and mount to do name space adjustment affects only the current name space group.

Files are opened for input, output or input/output by open or create. These calls return reference to an abstract data type (adt) of type FD (file descriptor) that identifies the file to subsequent I/O calls, such as read and write.

Files are normally read or written in sequential order. The I/O position in the file is called the file offset and may be set arbitrarily using the seek system call.

File descriptors are garbage-collected as soon as they are no longer referenced. There is no close function.

Integer File Descriptor

By convention, the first three integer values are used by application programs as follows:

0	standard input,
1	standard output,
2	standard error output.

Since this is only a convention, it is possible to close file descriptor 0, or even to replace it by a file open only for writing. However, programs must agree upon convention.

File Descriptor Group

The set of processes that shares that table is called a file descriptor group. Files opened by one process in the group may be read from and written to other processes in the group. (See pctl - process control).

Directories and files

Directories may be opened and read much like regular files (see dirread - read directory). They contain an integral number of records, called directory entries. Each entry is a machine-independent representation of the information about an existing file in the directory including the name, ownership, permission, access dates, and similar information.

The entry corresponding to an arbitrary file can be retrieved by stat or fstat; wstat and fwstat write back entries, thus changing the properties of a file.

New files are made with create and deleted with remove (see open, create - open/create a file for reading or writing and remove - remove a file). As with regular files, attributes of directories can be manipulated by wstat, and fwstat. Directories may not be written directly.

Concurrent File Operations

Guaranteed synchronous writes are not available.

File locking from underlying file systems is not supported by Inferno. Processes can coordinate their file operations by other mechanisms.

Atomicity of I/O is guaranteed for I/O with byte counts smaller than the Styx message size; see read, write - transfer data from and to a file in Chapter 3.

Process execution and control

A newly spawned thread shares the same program name space as that of its creator thread. The set of global variables that is in scope to one thread is in scope to the other. Also, change made by one can be detected by the other. Since they are scheduled independently, a creator and a spawned thread should synchronize their actions to share data meaningfully.

Processes are also organized into process groups that represent the set of threads that a single kill request terminates (see prog - interface to running programs in Chapter 2).

A newly spawned thread inherits the following attributes:

• program name space

• file descriptor group membership

• file name space (this includes current directory)

• process group

  The pctl system call can be used by a thread to change its file name space, its file descriptor group, and its process group. A thread can change its program name space by transferring execution to another module.

When a pathname crosses from one server to another, the process identities are mapped by each server receiving a file request.

The uid and gid strings are assigned to the thread that is created when a user logs into Inferno and cannot be changed.