One Level Up Top Level

src/os/unix/ngx_files.c - nginx-1.7.10

Global variables defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>


  12. #if (NGX_HAVE_FILE_AIO)

  14. ‌ngx_uint_t  ngx_file_aio = 1;

  16. #endif


  19. ssize_t
  20. ‌ngx_read_file(ngx_file_t *file, u_char *buf, size_t size, off_t offset)
  21. {
  22.     ssize_t  n;

  24.     ngx_log_debug4(NGX_LOG_DEBUG_CORE, file->log, 0,
  25.                    "read: %d, %p, %uz, %O", file->fd, buf, size, offset);

  27. #if (NGX_HAVE_PREAD)

  29.     n = pread(file->fd, buf, size, offset);

  31.     if (n == -1) {
  32.         ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  33.                       "pread() \"%s\" failed", file->name.data);
  34.         return NGX_ERROR;
  35.     }

  37. #else

  39.     if (file->sys_offset != offset) {
  40.         if (lseek(file->fd, offset, SEEK_SET) == -1) {
  41.             ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  42.                           "lseek() \"%s\" failed", file->name.data);
  43.             return NGX_ERROR;
  44.         }

  46.         file->sys_offset = offset;
  47.     }

  49.     n = read(file->fd, buf, size);

  51.     if (n == -1) {
  52.         ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  53.                       "read() \"%s\" failed", file->name.data);
  54.         return NGX_ERROR;
  55.     }

  57.     file->sys_offset += n;

  59. #endif

  61.     file->offset += n;

  63.     return n;
  64. }


  67. ssize_t
  68. ‌ngx_write_file(ngx_file_t *file, u_char *buf, size_t size, off_t offset)
  69. {
  70.     ssize_t  n, written;

  72.     ngx_log_debug4(NGX_LOG_DEBUG_CORE, file->log, 0,
  73.                    "write: %d, %p, %uz, %O", file->fd, buf, size, offset);

  75.     written = 0;

  77. #if (NGX_HAVE_PWRITE)

  79.     for ( ;; ) {
  80.         n = pwrite(file->fd, buf + written, size, offset);

  82.         if (n == -1) {
  83.             ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  84.                           "pwrite() \"%s\" failed", file->name.data);
  85.             return NGX_ERROR;
  86.         }

  88.         file->offset += n;
  89.         written += n;

  91.         if ((size_t) n == size) {
  92.             return written;
  93.         }

  95.         offset += n;
  96.         size -= n;
  97.     }

  99. #else

  101.     if (file->sys_offset != offset) {
  102.         if (lseek(file->fd, offset, SEEK_SET) == -1) {
  103.             ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  104.                           "lseek() \"%s\" failed", file->name.data);
  105.             return NGX_ERROR;
  106.         }

  108.         file->sys_offset = offset;
  109.     }

  111.     for ( ;; ) {
  112.         n = write(file->fd, buf + written, size);

  114.         if (n == -1) {
  115.             ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  116.                           "write() \"%s\" failed", file->name.data);
  117.             return NGX_ERROR;
  118.         }

  120.         file->offset += n;
  121.         written += n;

  123.         if ((size_t) n == size) {
  124.             return written;
  125.         }

  127.         size -= n;
  128.     }
  129. #endif
  130. }


  133. ngx_fd_t
  134. ‌ngx_open_tempfile(u_char *name, ngx_uint_t persistent, ngx_uint_t access)
  135. {
  136.     ngx_fd_t  fd;

  138.     fd = open((const char *) name, O_CREAT|O_EXCL|O_RDWR,
  139.               access ? access : 0600);

  141.     if (fd != -1 && !persistent) {
  142.         (void) unlink((const char *) name);
  143.     }

  145.     return fd;
  146. }


  149. ‌#define NGX_IOVS  8

  151. ssize_t
  152. ‌ngx_write_chain_to_file(ngx_file_t *file, ngx_chain_t *cl, off_t offset,
  153.     ngx_pool_t *pool)
  154. {
  155.     u_char        *prev;
  156.     size_t         size;
  157.     ssize_t        total, n;
  158.     ngx_array_t    vec;
  159.     struct iovec  *iov, iovs[NGX_IOVS];

  161.     /* use pwrite() if there is the only buf in a chain */

  163.     if (cl->next == NULL) {
  164.         return ngx_write_file(file, cl->buf->pos,
  165.                               (size_t) (cl->buf->last - cl->buf->pos),
  166.                               offset);
  167.     }

  169.     total = 0;

  171.     vec.elts = iovs;
  172.     vec.size = sizeof(struct iovec);
  173.     vec.nalloc = NGX_IOVS;
  174.     vec.pool = pool;

  176.     do {
  177.         prev = NULL;
  178.         iov = NULL;
  179.         size = 0;

  181.         vec.nelts = 0;

  183.         /* create the iovec and coalesce the neighbouring bufs */

  185.         while (cl && vec.nelts < IOV_MAX) {
  186.             if (prev == cl->buf->pos) {
  187.                 iov->iov_len += cl->buf->last - cl->buf->pos;

  189.             } else {
  190.                 iov = ngx_array_push(&vec);
  191.                 if (iov == NULL) {
  192.                     return NGX_ERROR;
  193.                 }

  195.                 iov->iov_base = (void *) cl->buf->pos;
  196.                 iov->iov_len = cl->buf->last - cl->buf->pos;
  197.             }

  199.             size += cl->buf->last - cl->buf->pos;
  200.             prev = cl->buf->last;
  201.             cl = cl->next;
  202.         }

  204.         /* use pwrite() if there is the only iovec buffer */

  206.         if (vec.nelts == 1) {
  207.             iov = vec.elts;

  209.             n = ngx_write_file(file, (u_char *) iov[0].iov_base,
  210.                                iov[0].iov_len, offset);

  212.             if (n == NGX_ERROR) {
  213.                 return n;
  214.             }

  216.             return total + n;
  217.         }

  219.         if (file->sys_offset != offset) {
  220.             if (lseek(file->fd, offset, SEEK_SET) == -1) {
  221.                 ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  222.                               "lseek() \"%s\" failed", file->name.data);
  223.                 return NGX_ERROR;
  224.             }

  226.             file->sys_offset = offset;
  227.         }

  229.         n = writev(file->fd, vec.elts, vec.nelts);

  231.         if (n == -1) {
  232.             ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  233.                           "writev() \"%s\" failed", file->name.data);
  234.             return NGX_ERROR;
  235.         }

  237.         if ((size_t) n != size) {
  238.             ngx_log_error(NGX_LOG_CRIT, file->log, 0,
  239.                           "writev() \"%s\" has written only %z of %uz",
  240.                           file->name.data, n, size);
  241.             return NGX_ERROR;
  242.         }

  244.         ngx_log_debug2(NGX_LOG_DEBUG_CORE, file->log, 0,
  245.                        "writev: %d, %z", file->fd, n);

  247.         file->sys_offset += n;
  248.         file->offset += n;
  249.         offset += n;
  250.         total += n;

  252.     } while (cl);

  254.     return total;
  255. }


  258. ngx_int_t
  259. ‌ngx_set_file_time(u_char *name, ngx_fd_t fd, time_t s)
  260. {
  261.     struct timeval  tv[2];

  263.     tv[0].tv_sec = ngx_time();
  264.     tv[0].tv_usec = 0;
  265.     tv[1].tv_sec = s;
  266.     tv[1].tv_usec = 0;

  268.     if (utimes((char *) name, tv) != -1) {
  269.         return NGX_OK;
  270.     }

  272.     return NGX_ERROR;
  273. }


  276. ngx_int_t
  277. ‌ngx_create_file_mapping(ngx_file_mapping_t *fm)
  278. {
  279.     fm->fd = ngx_open_file(fm->name, NGX_FILE_RDWR, NGX_FILE_TRUNCATE,
  280.                            NGX_FILE_DEFAULT_ACCESS);
  281.     if (fm->fd == NGX_INVALID_FILE) {
  282.         ngx_log_error(NGX_LOG_CRIT, fm->log, ngx_errno,
  283.                       ngx_open_file_n " \"%s\" failed", fm->name);
  284.         return NGX_ERROR;
  285.     }

  287.     if (ftruncate(fm->fd, fm->size) == -1) {
  288.         ngx_log_error(NGX_LOG_CRIT, fm->log, ngx_errno,
  289.                       "ftruncate() \"%s\" failed", fm->name);
  290.         goto failed;
  291.     }

  293.     fm->addr = mmap(NULL, fm->size, PROT_READ|PROT_WRITE, MAP_SHARED,
  294.                     fm->fd, 0);
  295.     if (fm->addr != MAP_FAILED) {
  296.         return NGX_OK;
  297.     }

  299.     ngx_log_error(NGX_LOG_CRIT, fm->log, ngx_errno,
  300.                   "mmap(%uz) \"%s\" failed", fm->size, fm->name);

  302. failed:

  304.     if (ngx_close_file(fm->fd) == NGX_FILE_ERROR) {
  305.         ngx_log_error(NGX_LOG_ALERT, fm->log, ngx_errno,
  306.                       ngx_close_file_n " \"%s\" failed", fm->name);
  307.     }

  309.     return NGX_ERROR;
  310. }


  313. void
  314. ‌ngx_close_file_mapping(ngx_file_mapping_t *fm)
  315. {
  316.     if (munmap(fm->addr, fm->size) == -1) {
  317.         ngx_log_error(NGX_LOG_CRIT, fm->log, ngx_errno,
  318.                       "munmap(%uz) \"%s\" failed", fm->size, fm->name);
  319.     }

  321.     if (ngx_close_file(fm->fd) == NGX_FILE_ERROR) {
  322.         ngx_log_error(NGX_LOG_ALERT, fm->log, ngx_errno,
  323.                       ngx_close_file_n " \"%s\" failed", fm->name);
  324.     }
  325. }


  328. ngx_int_t
  329. ‌ngx_open_dir(ngx_str_t *name, ngx_dir_t *dir)
  330. {
  331.     dir->dir = opendir((const char *) name->data);

  333.     if (dir->dir == NULL) {
  334.         return NGX_ERROR;
  335.     }

  337.     dir->valid_info = 0;

  339.     return NGX_OK;
  340. }


  343. ngx_int_t
  344. ‌ngx_read_dir(ngx_dir_t *dir)
  345. {
  346.     dir->de = readdir(dir->dir);

  348.     if (dir->de) {
  349. #if (NGX_HAVE_D_TYPE)
  350.         dir->type = dir->de->d_type;
  351. #else
  352.         dir->type = 0;
  353. #endif
  354.         return NGX_OK;
  355.     }

  357.     return NGX_ERROR;
  358. }


  361. ngx_int_t
  362. ‌ngx_open_glob(ngx_glob_t *gl)
  363. {
  364.     int  n;

  366.     n = glob((char *) gl->pattern, 0, NULL, &gl->pglob);

  368.     if (n == 0) {
  369.         return NGX_OK;
  370.     }

  372. #ifdef GLOB_NOMATCH

  374.     if (n == GLOB_NOMATCH && gl->test) {
  375.         return NGX_OK;
  376.     }

  378. #endif

  380.     return NGX_ERROR;
  381. }


  384. ngx_int_t
  385. ‌ngx_read_glob(ngx_glob_t *gl, ngx_str_t *name)
  386. {
  387.     size_t  count;

  389. #ifdef GLOB_NOMATCH
  390.     count = (size_t) gl->pglob.gl_pathc;
  391. #else
  392.     count = (size_t) gl->pglob.gl_matchc;
  393. #endif

  395.     if (gl->n < count) {

  397.         name->len = (size_t) ngx_strlen(gl->pglob.gl_pathv[gl->n]);
  398.         name->data = (u_char *) gl->pglob.gl_pathv[gl->n];
  399.         gl->n++;

  401.         return NGX_OK;
  402.     }

  404.     return NGX_DONE;
  405. }


  408. void
  409. ‌ngx_close_glob(ngx_glob_t *gl)
  410. {
  411.     globfree(&gl->pglob);
  412. }


  415. ngx_err_t
  416. ‌ngx_trylock_fd(ngx_fd_t fd)
  417. {
  418.     struct flock  fl;

  420.     ngx_memzero(&fl, sizeof(struct flock));
  421.     fl.l_type = F_WRLCK;
  422.     fl.l_whence = SEEK_SET;

  424.     if (fcntl(fd, F_SETLK, &fl) == -1) {
  425.         return ngx_errno;
  426.     }

  428.     return 0;
  429. }


  432. ngx_err_t
  433. ‌ngx_lock_fd(ngx_fd_t fd)
  434. {
  435.     struct flock  fl;

  437.     ngx_memzero(&fl, sizeof(struct flock));
  438.     fl.l_type = F_WRLCK;
  439.     fl.l_whence = SEEK_SET;

  441.     if (fcntl(fd, F_SETLKW, &fl) == -1) {
  442.         return ngx_errno;
  443.     }

  445.     return 0;
  446. }


  449. ngx_err_t
  450. ‌ngx_unlock_fd(ngx_fd_t fd)
  451. {
  452.     struct flock  fl;

  454.     ngx_memzero(&fl, sizeof(struct flock));
  455.     fl.l_type = F_UNLCK;
  456.     fl.l_whence = SEEK_SET;

  458.     if (fcntl(fd, F_SETLK, &fl) == -1) {
  459.         return  ngx_errno;
  460.     }

  462.     return 0;
  463. }


  466. #if (NGX_HAVE_POSIX_FADVISE) && !(NGX_HAVE_F_READAHEAD)

  468. ngx_int_t
  469. ‌ngx_read_ahead(ngx_fd_t fd, size_t n)
  470. {
  471.     int  err;

  473.     err = posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);

  475.     if (err == 0) {
  476.         return 0;
  477.     }

  479.     ngx_set_errno(err);
  480.     return NGX_FILE_ERROR;
  481. }

  483. #endif


  486. #if (NGX_HAVE_O_DIRECT)

  488. ngx_int_t
  489. ‌ngx_directio_on(ngx_fd_t fd)
  490. {
  491.     int  flags;

  493.     flags = fcntl(fd, F_GETFL);

  495.     if (flags == -1) {
  496.         return NGX_FILE_ERROR;
  497.     }

  499.     return fcntl(fd, F_SETFL, flags | O_DIRECT);
  500. }


  503. ngx_int_t
  504. ‌ngx_directio_off(ngx_fd_t fd)
  505. {
  506.     int  flags;

  508.     flags = fcntl(fd, F_GETFL);

  510.     if (flags == -1) {
  511.         return NGX_FILE_ERROR;
  512.     }

  514.     return fcntl(fd, F_SETFL, flags & ~O_DIRECT);
  515. }

  517. #endif


  520. #if (NGX_HAVE_STATFS)

  522. size_t
  523. ‌ngx_fs_bsize(u_char *name)
  524. {
  525.     struct statfs  fs;

  527.     if (statfs((char *) name, &fs) == -1) {
  528.         return 512;
  529.     }

  531.     if ((fs.f_bsize % 512) != 0) {
  532.         return 512;
  533.     }

  535.     return (size_t) fs.f_bsize;
  536. }

  538. #elif (NGX_HAVE_STATVFS)

  540. size_t
  541. ‌ngx_fs_bsize(u_char *name)
  542. {
  543.     struct statvfs  fs;

  545.     if (statvfs((char *) name, &fs) == -1) {
  546.         return 512;
  547.     }

  549.     if ((fs.f_frsize % 512) != 0) {
  550.         return 512;
  551.     }

  553.     return (size_t) fs.f_frsize;
  554. }

  556. #else

  558. size_t
  559. ‌ngx_fs_bsize(u_char *name)
  560. {
  561.     return 512;
  562. }

  564. #endif

One Level Up Top Level