Daemon Processes

Long lived utility processes Often started at system boot and

ended when system shuts down Run in the background with no

controlling terminal

Daemon Processes

Coding rules (see page 425) Call umask and set the file mode

creation mask to 0 Call fork and let the parent die Call setsid Change current working directory to

root directory Close unneeded file descriptors

Advanced I/O

Nonblocking I/O I/O Multiplexing

The poll() function call The select() function call

File record locking Memory mapped I/O

“Slow” I/O Reads of certain file types that can

block forever if data is not ready (pipes, terminal devices, network devices)

Writes on those same file types where data can’t be accepted immediately (pipe full, network flow control, etc)

Opens of certain file types that block until some condition becomes true (terminal device that waits on a modem, open of a FIFO for writing only when no other process has it open for reading)

“Slow” I/O

Reads and writes of files with mandatory record locking enabled

Some ioctl operations Some IPC functions

Nonblocking I/O

We can specify nonblocking I/O when we open a file by providing the O_NONBLOCK flagopen(file,O_RDONLY | O_NONBLOCK);

If the file is already open, we can use fcntl to set the O_NONBLOCK flag

Nonblocking I/O

flags = fcntl(fd, F_GETFL, 0);flags = flags | O_NONBLOCK;fcntl(fd, F_SETFL, flags);

F_GETFL – get flags F_SETFL – set flags

Check if file has nonblocking I/O enabledif(flags & O_NONBLOCK)

Turn off nonblocking I/Oflags = flags & ~O_NONBLOCK;fcntl(fd, F_SETFL, flags);

I/O Multiplexing

Avoids the busy waiting loop common with simple nonblocking I/O

Using multiplexing we can block on multiple file descriptors simultaneously

poll functionint poll(struct pollfd *fds, nfds_t nfds, int timeout);struct pollfd { int fd; /* file descriptor */ short events; /* requested events */ short revents; /* returned events */}; fds is an array of pollfd elements nfds is the number of elements in the array timeout specifies how long the function should

block timeout = 0 – don’t block timeout = -1 - wait forever timeout > 0 - wait timeout miliseconds

select functionint select(int nfds, fd_set *readfds, fd_set *writefds, fd_set

*exceptfds, struct timeval *timeout);struct timeval { long tv_sec; /* seconds */ long tv_usec; /* microseconds */}; timeout specifies how long to block

NULL – wait forever, or until a signal is caught

tv_sec = 0 and tv_usec = 0 – don’t block tv_sec != 0 or tv_usec != 0 – block until a

descriptor is ready or the timeout is reached. Can also be interrupted by a signal

select function readfds, writefds, exceptfds are pointers to descriptor

sets telling the system which file descriptors we are interested in for reading, writing and exceptions

The type for descriptor sets is fd_set. This type can not be directly manipulated

Use the following functions with fd_set void FD_CLR(int fd, fd_set *set); int FD_ISSET(int fd, fd_set *set); void FD_SET(int fd, fd_set *set); void FD_ZERO(fd_set *set);

nfds is the number of file descriptors (usually the highest number plus one)

Scatter Read and Gather Write

ssize_t readv(int fd, const struct iovec *vector, int count);ssize_t writev(int fd, const struct iovec *vector, int count);struct iovec { void *iov_base; /* Starting address */ size_t iov_len; /* Number of bytes */}; readv and writev allows us to read or write to

multiple non contiguous buffers at the same time fd is the file descriptor to read from or write to vector is a pointer to an array of iovec structures count is the number of elements in the array

Memory Mapped I/O

Reading/Writing a memory address actually causes I/O to another device

Functions are provided to memory map an open file

Memory Mapped I/O

void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);

Maps an open file to an area of memory

start lets us request a given starting point in memory.

length is the number of bytes to read from the file

Memory Mapped I/O offset is the location within the file to begin fd is the file descriptor to be mapped prot specifies the protection of the mapped

region PROT_READ - region can be read PROT_WRITE – region can be written PROT_EXEC – region can be executed PROT_NONE – region cannot be accessed

flags – sets attributes of the mapped region. See page 488 for values and descriptions

Memory Mapped I/O

int munmap(void *start, size_t length); A mapped region is automatically

unmapped when the process terminates munmap can be used to unmap a

region earlier start – beginning address of mapped region length – number of bytes in region

Note: closing the file descriptors does not unmap a region.

File (Record) Locking Allows a process to lock a portion of a file

to prevent access by another process Advisory Locking

A convention that all processes accessing the file must follow

Mandatory Locking Enforced by the Kernel. Other processes

suspended if they try to read/write the locked section

Mandatory Locking enabled by turning on the Set Group ID bit and turning off the group execute bit

File (Record) Locking

Locking Functions lockf - System V flock – BSD fcntl - POSIX

fcntl Record Locking

int fcntl(int fd, int cmd, struct flock *lock);struct flock { short l_type; short l_whence; off_t l_start; off_t l_len; pid_t l_pid; };

fd an open file descriptor

fcntl Record Locking lock – a pointer to a flock struct

l_type – F_RDLCK, F_WRLCK or F_UNLCK l_start – starting byte offset of locked

region l_whence – same as for lseek:

SEEK_SET, SEEK_CUR, SEEK_END l_len – length in bytes to lock. 0 means

lock until EOF l_pid – used to return a pid with

F_GETLK

fcntl Record Locking

cmd F_GETLK – checks to see if we can acquire

the requested lock. If another process has a conflicting lock the information about that lock is passed back through lock

F_SETLK – set a lock F_SETLKW – set a lock, but wait if there is

a conflict. May be interrupted by a signal

fcntl Record Locking

Lock type must be consistent with the opened mode of the file F_RDLCK for O_RDONLY or O_RDWR F_WRLCK for O_WRONLY or O_RDWR

Lock Compatibility Any number of processes may have

shared read locks on a region of a file Only one processes at a time can

have an exclusive write lock on a region

We can not obtain a write lock on a region that already has a read lock

We can not obtain a read lock on a region that already has a write lock

Lock Combining If a process attempts to acquire a lock

on a region it already has a lock on the old lock is replaced by the new lock

The system will split and combine locks automatically Lock acquired from byte 100 to 200 Lock released for bytes 125 to 150 We now have 2 locks for bytes 100 to 125

and 150 to 200

Implied Inheritance and Release of Locks

Locks are associated with a process and a file

If the process terminates, its locks are released

When a file is closed, any locks on it for that process are released

Locks are not inherited across a fork Locks are inherited across an exec

unless the close-on-exec flag is set