Linux System Programming note 4 —— Advanced File I/O

1. Scatter/Gather I/O(vectored I/O)

#include <sys/uio.h>

ssize_t readv (int fd,

                    const struct iovec *iov,

                    int count);

ssize_t writev (int fd,

                     const struct iovec *iov,

                     int count);

struct iovec {

     void *iov_base;

     size_t iov_len;

};

example:

#include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include <string.h>#include <sys/uio.h>int main(){     struct iovec iov[3];     ssize_t nr;     int fd, i;     char *buf[] = {          "The term buccaneer comes from the world boucan.\n",          "A boucan is a wooden frame used for cooking meat.\n",          "Buccaneer is the West Indies name for a pirate.\n"     };     fd = open("buccaner.txt", O_WRONLY | O_CREAT | O_TRUNC);     if (fd == -1){          perror("open");          return 1;     }     for (i = 0; i < 3; i++){          iov[i].iov_base = buf[i];          iov[i].iov_len = strlen(buf[i]) + 1;     }     nr = writev(fd, iov, 3);     if (nr == -1){          perror("writev");          return 1;     }     printf("wrote %d bytes\n", nr);     if (close(fd)){          perror("close");          return 1;     }     return 0;}

2. Creating a New Epoll Instance

#include <sys/epoll.h>

int epoll_create1(int flags); // Only EPOLL_CLOEXEC is a valid flag.

errno:

EINVAL: Invalid flags parameter

EMFILE: The user has reached limit on the total number of open files.

ENFILE: The system has reached its limit on the total number of open files.

ENOMEM: Insufficient memory was available to complete the operation.

3. Controlling Epoll

#include <sys/epoll.h>

int epoll_ctl(int epfd,

                 int op,

                 int fd,

                 struct epoll_event *event);

op: EPOLL_CTL_ADD, EPOLL_CTL_DEL, EPOLL_CTL_MOD

struct epoll_event{

     _u32 events;

     union {

          void *ptr;

          int fd;

          __u32 u32;

          __u64 u64;

     } data;

};

events:

EPOLLERR, EPOLLET, EPOLLHUP, EPOLLIN, EPOLLONESHOT, EPOLLOUT, EPOLLPRI

4. Waiting for Events with Epoll

#include <sys/epoll.h>

int epoll_wait(int epfd,

                    struct epoll_event *events,

                    int maxevents,

                    int timeout);

5. mmap()

#include <sys/mman.h>

void *mmap (void *addr,

                   size_t len,

                   int prot,

                   int flags,

                   int fd,

                   off_t offset);

prot: PROT_READ, PROT_WRITE, PROT_EXEC

flags:MAP_FIXED, MAP_PRIVATE, MAP_SHARED

6. The page size

#include <unistd.h>

long sysconf(int name); // best bet for portability and future compatility

long page_size = sysconf(_SC_PAGESIZE);

#include <unistd.h>

int getpagesize(void); // was dropped from the 1003.1-2001 revision of the POSIX standard.

#include <sys/usr.h>

int page_size = PAGE_SIZE;

SIGBUS 

This signal is generated when a process attempts to access a region of a mapping that is no longer valid--for example, because the file was truncated after it was mmaped.

SIGSEGV

This signal is generated when a process attempts to write to a region that is mapped read-only.

7. munmap()

#include <sys/mman.h>

int munmap (void *addr, size_t len);

Example: (of map)

#include <stdio.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include <unistd.h>#include <sys/mman.h>int main(int argc, char *argv[]){     struct stat sb;     off_t len;     char *p;     int fd;     if (argc < 2) {          fprintf(stderr, "usage: %s <file>\n", argv[0]);          return 1;     }     fd = open(argv[1], O_RDONLY);     if (fd == -1){          perror("open");          return 1;     }     if (fstat(fd, &sb) == -1){          perror("fstat");          return 1;     }     if (!S_ISREG (sb.st_mode)){          fprintf(stderr, "%s is not a file\n", argv[1]);          return 1;     }     p = mmap(0, sb.st_size, PROT_READ, MAP_SHARED, fd, 0);     if (p == MAP_FAILED){          perror ("mmap");          return 1;     }     if (close(fd) == -1){          perror("close");          return 1;     }     for (len = 0; len < sb.st_size; len++){          putchar (p[len]);     }     if (munmap (p, sb.st_size) == -1){          perror("munmap");          return 1;     }     return 0;}

8. Resizing a Mapping

#define  _GNU_SOURCE

#include <sys/mman.h>

void * mremap(void *addr, size_t old_size, size_t new_size, unsigned long flags);

flags: 0 or MREMAP_MAYMOVE

9. Changing the protection of a Mapping

#include <sys/mman.h>

int mprotect (const void *addr, size_t len, int prot);

10. Synchronizing File with a Mapping

#include <sys/mman.h>

int msync (void *addr, size_t len, int flags);

flags:

MS_SYNC:

     The sync() call will not return until all pages are written back to disk.

MS_ASYNC:

     The sync() call returns immediately without waiting for the writes to take place.

MS_INVALIDATE:

     Specifies that all other cached copies of the mapping be invalidated.

11. Giving Advice on a Mapping

#include <sys/mman.h>

int madvise (void *addr, size_t len, int advice);

advice:

MADV_NORMAL

MADV_RANDOM

MADV_SEQENTIAL

MADV_WILLNEED

MADV_DONTNEED

MADV_DONTFORK

MADV_DOFORK+

12. The posix_fadvise() System Call

#include <fcntl.h>

int posix_fadvise(int fd,

                        off_t offset,

                        off_t len,

                        int advice);

advice:

POSIX_FADV_NORMAL

POSIX_FADV_RANDOM

POSIX_FADV_SEQUENTIAL

POSIX_FADV_WILLNEED

POSIX_FADV_NOREUSE

POSIX_FADV_DONTNEED

13. The readhead() System Call

#define _GNU_SOURCE

#include <fcntl.h>

ssize_t readhead(int fd,

                         off64_t offset,

                         size_t count);

14. Asynchronous I/O

#include <aio.h>

/* asynchronous I/O control block */

struct aiocb {

     int aio_fildes;

     int aio_lio_opcode;

     int aio_reqprio;

     volatile void *aio_buf;

     size_t aio_nbytes;

     struct sigevent aio_sigevent;

     /* internal, private members follow... */

};

int aio_read(struct aiocb *aiocbp);

int aio_write(struct aiocb *aiocbp);

int aio_error(const struct aiocbp *aiocbp);

int aio_return(struct aiocb *aiocbp);

int aio_cancel(int fd, struct aiocb *aiocbp);

int aio_fsync(int op, struct aiocb *aiocbp);

int aio_suspend(const struct aiocb * const cblist[],

                       int n,

                       const struct timespec *timeout);