Post on 15-Jan-2016
description
transcript
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