One Level Up Top Level

src/os/unix/ngx_files.c - nginx source code

Global variables defined

Data types defined

Functions 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_THREADS)
  13. #include <ngx_thread_pool.h>
  14. static void ngx_thread_read_handler(void *data, ngx_log_t *log);
  15. static void ngx_thread_write_chain_to_file_handler(void *data, ngx_log_t *log);
  16. #endif

  18. static ngx_chain_t *ngx_chain_to_iovec(ngx_iovec_t *vec, ngx_chain_t *cl);
  19. static ssize_t ngx_writev_file(ngx_file_t *file, ngx_iovec_t *vec,
  20.     off_t offset);


  23. #if (NGX_HAVE_FILE_AIO)

  25. ‌ngx_uint_t  ngx_file_aio = 1;

  27. #endif


  30. ssize_t
  31. ‌ngx_read_file(ngx_file_t *file, u_char *buf, size_t size, off_t offset)
  32. {
  33.     ssize_t  n;

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

  38. #if (NGX_HAVE_PREAD)

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

  42.     if (n == -1) {
  43.         ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  44.                       "pread() \"%s\" failed", file->name.data);
  45.         return NGX_ERROR;
  46.     }

  48. #else

  50.     if (file->sys_offset != offset) {
  51.         if (lseek(file->fd, offset, SEEK_SET) == -1) {
  52.             ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  53.                           "lseek() \"%s\" failed", file->name.data);
  54.             return NGX_ERROR;
  55.         }

  57.         file->sys_offset = offset;
  58.     }

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

  62.     if (n == -1) {
  63.         ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  64.                       "read() \"%s\" failed", file->name.data);
  65.         return NGX_ERROR;
  66.     }

  68.     file->sys_offset += n;

  70. #endif

  72.     file->offset += n;

  74.     return n;
  75. }


  78. #if (NGX_THREADS)

  80. ‌typedef struct {
  81.     ngx_fd_t       fd;
  82.     ngx_uint_t     write;   /* unsigned  write:1; */

  84.     u_char        *buf;
  85.     size_t         size;
  86.     ngx_chain_t   *chain;
  87.     off_t          offset;

  89.     size_t         nbytes;
  90.     ngx_err_t      err;
  91. ‌} ngx_thread_file_ctx_t;


  94. ssize_t
  95. ‌ngx_thread_read(ngx_file_t *file, u_char *buf, size_t size, off_t offset,
  96.     ngx_pool_t *pool)
  97. {
  98.     ngx_thread_task_t      *task;
  99.     ngx_thread_file_ctx_t  *ctx;

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

  105.     task = file->thread_task;

  107.     if (task == NULL) {
  108.         task = ngx_thread_task_alloc(pool, sizeof(ngx_thread_file_ctx_t));
  109.         if (task == NULL) {
  110.             return NGX_ERROR;
  111.         }

  113.         task->event.log = file->log;

  115.         file->thread_task = task;
  116.     }

  118.     ctx = task->ctx;

  120.     if (task->event.complete) {
  121.         task->event.complete = 0;

  123.         if (ctx->write) {
  124.             ngx_log_error(NGX_LOG_ALERT, file->log, 0,
  125.                           "invalid thread call, read instead of write");
  126.             return NGX_ERROR;
  127.         }

  129.         if (ctx->err) {
  130.             ngx_log_error(NGX_LOG_CRIT, file->log, ctx->err,
  131.                           "pread() \"%s\" failed", file->name.data);
  132.             return NGX_ERROR;
  133.         }

  135.         return ctx->nbytes;
  136.     }

  138.     task->handler = ngx_thread_read_handler;

  140.     ctx->write = 0;

  142.     ctx->fd = file->fd;
  143.     ctx->buf = buf;
  144.     ctx->size = size;
  145.     ctx->offset = offset;

  147.     if (file->thread_handler(task, file) != NGX_OK) {
  148.         return NGX_ERROR;
  149.     }

  151.     return NGX_AGAIN;
  152. }


  155. #if (NGX_HAVE_PREAD)

  157. static void
  158. ‌ngx_thread_read_handler(void *data, ngx_log_t *log)
  159. {
  160.     ngx_thread_file_ctx_t *ctx = data;

  162.     ssize_t  n;

  164.     ngx_log_debug0(NGX_LOG_DEBUG_CORE, log, 0, "thread read handler");

  166.     n = pread(ctx->fd, ctx->buf, ctx->size, ctx->offset);

  168.     if (n == -1) {
  169.         ctx->err = ngx_errno;

  171.     } else {
  172.         ctx->nbytes = n;
  173.         ctx->err = 0;
  174.     }

  176. #if 0
  177.     ngx_time_update();
  178. #endif

  180.     ngx_log_debug4(NGX_LOG_DEBUG_CORE, log, 0,
  181.                    "pread: %z (err: %d) of %uz @%O",
  182.                    n, ctx->err, ctx->size, ctx->offset);
  183. }

  185. #else

  187. #error pread() is required!

  189. #endif

  191. #endif /* NGX_THREADS */


  194. ssize_t
  195. ‌ngx_write_file(ngx_file_t *file, u_char *buf, size_t size, off_t offset)
  196. {
  197.     ssize_t    n, written;
  198.     ngx_err_t  err;

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

  203.     written = 0;

  205. #if (NGX_HAVE_PWRITE)

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

  210.         if (n == -1) {
  211.             err = ngx_errno;

  213.             if (err == NGX_EINTR) {
  214.                 ngx_log_debug0(NGX_LOG_DEBUG_CORE, file->log, err,
  215.                                "pwrite() was interrupted");
  216.                 continue;
  217.             }

  219.             ngx_log_error(NGX_LOG_CRIT, file->log, err,
  220.                           "pwrite() \"%s\" failed", file->name.data);
  221.             return NGX_ERROR;
  222.         }

  224.         file->offset += n;
  225.         written += n;

  227.         if ((size_t) n == size) {
  228.             return written;
  229.         }

  231.         offset += n;
  232.         size -= n;
  233.     }

  235. #else

  237.     if (file->sys_offset != offset) {
  238.         if (lseek(file->fd, offset, SEEK_SET) == -1) {
  239.             ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  240.                           "lseek() \"%s\" failed", file->name.data);
  241.             return NGX_ERROR;
  242.         }

  244.         file->sys_offset = offset;
  245.     }

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

  250.         if (n == -1) {
  251.             err = ngx_errno;

  253.             if (err == NGX_EINTR) {
  254.                 ngx_log_debug0(NGX_LOG_DEBUG_CORE, file->log, err,
  255.                                "write() was interrupted");
  256.                 continue;
  257.             }

  259.             ngx_log_error(NGX_LOG_CRIT, file->log, err,
  260.                           "write() \"%s\" failed", file->name.data);
  261.             return NGX_ERROR;
  262.         }

  264.         file->sys_offset += n;
  265.         file->offset += n;
  266.         written += n;

  268.         if ((size_t) n == size) {
  269.             return written;
  270.         }

  272.         size -= n;
  273.     }
  274. #endif
  275. }


  278. ngx_fd_t
  279. ‌ngx_open_tempfile(u_char *name, ngx_uint_t persistent, ngx_uint_t access)
  280. {
  281.     ngx_fd_t  fd;

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

  286.     if (fd != -1 && !persistent) {
  287.         (void) unlink((const char *) name);
  288.     }

  290.     return fd;
  291. }


  294. ssize_t
  295. ‌ngx_write_chain_to_file(ngx_file_t *file, ngx_chain_t *cl, off_t offset,
  296.     ngx_pool_t *pool)
  297. {
  298.     ssize_t        total, n;
  299.     ngx_iovec_t    vec;
  300.     struct iovec   iovs[NGX_IOVS_PREALLOCATE];

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

  304.     if (cl->next == NULL) {
  305.         return ngx_write_file(file, cl->buf->pos,
  306.                               (size_t) (cl->buf->last - cl->buf->pos),
  307.                               offset);
  308.     }

  310.     total = 0;

  312.     vec.iovs = iovs;
  313.     vec.nalloc = NGX_IOVS_PREALLOCATE;

  315.     do {
  316.         /* create the iovec and coalesce the neighbouring bufs */
  317.         cl = ngx_chain_to_iovec(&vec, cl);

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

  321.         if (vec.count == 1) {
  322.             n = ngx_write_file(file, (u_char *) iovs[0].iov_base,
  323.                                iovs[0].iov_len, offset);

  325.             if (n == NGX_ERROR) {
  326.                 return n;
  327.             }

  329.             return total + n;
  330.         }

  332.         n = ngx_writev_file(file, &vec, offset);

  334.         if (n == NGX_ERROR) {
  335.             return n;
  336.         }

  338.         offset += n;
  339.         total += n;

  341.     } while (cl);

  343.     return total;
  344. }


  347. static ngx_chain_t *
  348. ‌ngx_chain_to_iovec(ngx_iovec_t *vec, ngx_chain_t *cl)
  349. {
  350.     size_t         total, size;
  351.     u_char        *prev;
  352.     ngx_uint_t     n;
  353.     struct iovec  *iov;

  355.     iov = NULL;
  356.     prev = NULL;
  357.     total = 0;
  358.     n = 0;

  360.     for ( /* void */ ; cl; cl = cl->next) {

  362.         if (ngx_buf_special(cl->buf)) {
  363.             continue;
  364.         }

  366.         size = cl->buf->last - cl->buf->pos;

  368.         if (prev == cl->buf->pos) {
  369.             iov->iov_len += size;

  371.         } else {
  372.             if (n == vec->nalloc) {
  373.                 break;
  374.             }

  376.             iov = &vec->iovs[n++];

  378.             iov->iov_base = (void *) cl->buf->pos;
  379.             iov->iov_len = size;
  380.         }

  382.         prev = cl->buf->pos + size;
  383.         total += size;
  384.     }

  386.     vec->count = n;
  387.     vec->size = total;

  389.     return cl;
  390. }


  393. static ssize_t
  394. ‌ngx_writev_file(ngx_file_t *file, ngx_iovec_t *vec, off_t offset)
  395. {
  396.     ssize_t    n;
  397.     ngx_err_t  err;

  399.     ngx_log_debug3(NGX_LOG_DEBUG_CORE, file->log, 0,
  400.                    "writev: %d, %uz, %O", file->fd, vec->size, offset);

  402. #if (NGX_HAVE_PWRITEV)

  404. eintr:

  406.     n = pwritev(file->fd, vec->iovs, vec->count, offset);

  408.     if (n == -1) {
  409.         err = ngx_errno;

  411.         if (err == NGX_EINTR) {
  412.             ngx_log_debug0(NGX_LOG_DEBUG_CORE, file->log, err,
  413.                            "pwritev() was interrupted");
  414.             goto eintr;
  415.         }

  417.         ngx_log_error(NGX_LOG_CRIT, file->log, err,
  418.                       "pwritev() \"%s\" failed", file->name.data);
  419.         return NGX_ERROR;
  420.     }

  422.     if ((size_t) n != vec->size) {
  423.         ngx_log_error(NGX_LOG_CRIT, file->log, 0,
  424.                       "pwritev() \"%s\" has written only %z of %uz",
  425.                       file->name.data, n, vec->size);
  426.         return NGX_ERROR;
  427.     }

  429. #else

  431.     if (file->sys_offset != offset) {
  432.         if (lseek(file->fd, offset, SEEK_SET) == -1) {
  433.             ngx_log_error(NGX_LOG_CRIT, file->log, ngx_errno,
  434.                           "lseek() \"%s\" failed", file->name.data);
  435.             return NGX_ERROR;
  436.         }

  438.         file->sys_offset = offset;
  439.     }

  441. eintr:

  443.     n = writev(file->fd, vec->iovs, vec->count);

  445.     if (n == -1) {
  446.         err = ngx_errno;

  448.         if (err == NGX_EINTR) {
  449.             ngx_log_debug0(NGX_LOG_DEBUG_CORE, file->log, err,
  450.                            "writev() was interrupted");
  451.             goto eintr;
  452.         }

  454.         ngx_log_error(NGX_LOG_CRIT, file->log, err,
  455.                       "writev() \"%s\" failed", file->name.data);
  456.         return NGX_ERROR;
  457.     }

  459.     if ((size_t) n != vec->size) {
  460.         ngx_log_error(NGX_LOG_CRIT, file->log, 0,
  461.                       "writev() \"%s\" has written only %z of %uz",
  462.                       file->name.data, n, vec->size);
  463.         return NGX_ERROR;
  464.     }

  466.     file->sys_offset += n;

  468. #endif

  470.     file->offset += n;

  472.     return n;
  473. }


  476. #if (NGX_THREADS)

  478. ssize_t
  479. ‌ngx_thread_write_chain_to_file(ngx_file_t *file, ngx_chain_t *cl, off_t offset,
  480.     ngx_pool_t *pool)
  481. {
  482.     ngx_thread_task_t      *task;
  483.     ngx_thread_file_ctx_t  *ctx;

  485.     ngx_log_debug3(NGX_LOG_DEBUG_CORE, file->log, 0,
  486.                    "thread write chain: %d, %p, %O",
  487.                    file->fd, cl, offset);

  489.     task = file->thread_task;

  491.     if (task == NULL) {
  492.         task = ngx_thread_task_alloc(pool,
  493.                                      sizeof(ngx_thread_file_ctx_t));
  494.         if (task == NULL) {
  495.             return NGX_ERROR;
  496.         }

  498.         task->event.log = file->log;

  500.         file->thread_task = task;
  501.     }

  503.     ctx = task->ctx;

  505.     if (task->event.complete) {
  506.         task->event.complete = 0;

  508.         if (!ctx->write) {
  509.             ngx_log_error(NGX_LOG_ALERT, file->log, 0,
  510.                           "invalid thread call, write instead of read");
  511.             return NGX_ERROR;
  512.         }

  514.         if (ctx->err || ctx->nbytes == 0) {
  515.             ngx_log_error(NGX_LOG_CRIT, file->log, ctx->err,
  516.                           "pwritev() \"%s\" failed", file->name.data);
  517.             return NGX_ERROR;
  518.         }

  520.         file->offset += ctx->nbytes;
  521.         return ctx->nbytes;
  522.     }

  524.     task->handler = ngx_thread_write_chain_to_file_handler;

  526.     ctx->write = 1;

  528.     ctx->fd = file->fd;
  529.     ctx->chain = cl;
  530.     ctx->offset = offset;

  532.     if (file->thread_handler(task, file) != NGX_OK) {
  533.         return NGX_ERROR;
  534.     }

  536.     return NGX_AGAIN;
  537. }


  540. static void
  541. ‌ngx_thread_write_chain_to_file_handler(void *data, ngx_log_t *log)
  542. {
  543.     ngx_thread_file_ctx_t *ctx = data;

  545. #if (NGX_HAVE_PWRITEV)

  547.     off_t          offset;
  548.     ssize_t        n;
  549.     ngx_err_t      err;
  550.     ngx_chain_t   *cl;
  551.     ngx_iovec_t    vec;
  552.     struct iovec   iovs[NGX_IOVS_PREALLOCATE];

  554.     vec.iovs = iovs;
  555.     vec.nalloc = NGX_IOVS_PREALLOCATE;

  557.     cl = ctx->chain;
  558.     offset = ctx->offset;

  560.     ctx->nbytes = 0;
  561.     ctx->err = 0;

  563.     do {
  564.         /* create the iovec and coalesce the neighbouring bufs */
  565.         cl = ngx_chain_to_iovec(&vec, cl);

  567. eintr:

  569.         n = pwritev(ctx->fd, iovs, vec.count, offset);

  571.         if (n == -1) {
  572.             err = ngx_errno;

  574.             if (err == NGX_EINTR) {
  575.                 ngx_log_debug0(NGX_LOG_DEBUG_CORE, log, err,
  576.                                "pwritev() was interrupted");
  577.                 goto eintr;
  578.             }

  580.             ctx->err = err;
  581.             return;
  582.         }

  584.         if ((size_t) n != vec.size) {
  585.             ctx->nbytes = 0;
  586.             return;
  587.         }

  589.         ctx->nbytes += n;
  590.         offset += n;
  591.     } while (cl);

  593. #else

  595.     ctx->err = NGX_ENOSYS;
  596.     return;

  598. #endif
  599. }

  601. #endif /* NGX_THREADS */


  604. ngx_int_t
  605. ‌ngx_set_file_time(u_char *name, ngx_fd_t fd, time_t s)
  606. {
  607.     struct timeval  tv[2];

  609.     tv[0].tv_sec = ngx_time();
  610.     tv[0].tv_usec = 0;
  611.     tv[1].tv_sec = s;
  612.     tv[1].tv_usec = 0;

  614.     if (utimes((char *) name, tv) != -1) {
  615.         return NGX_OK;
  616.     }

  618.     return NGX_ERROR;
  619. }


  622. ngx_int_t
  623. ‌ngx_create_file_mapping(ngx_file_mapping_t *fm)
  624. {
  625.     fm->fd = ngx_open_file(fm->name, NGX_FILE_RDWR, NGX_FILE_TRUNCATE,
  626.                            NGX_FILE_DEFAULT_ACCESS);

  628.     if (fm->fd == NGX_INVALID_FILE) {
  629.         ngx_log_error(NGX_LOG_CRIT, fm->log, ngx_errno,
  630.                       ngx_open_file_n " \"%s\" failed", fm->name);
  631.         return NGX_ERROR;
  632.     }

  634.     if (ftruncate(fm->fd, fm->size) == -1) {
  635.         ngx_log_error(NGX_LOG_CRIT, fm->log, ngx_errno,
  636.                       "ftruncate() \"%s\" failed", fm->name);
  637.         goto failed;
  638.     }

  640.     fm->addr = mmap(NULL, fm->size, PROT_READ|PROT_WRITE, MAP_SHARED,
  641.                     fm->fd, 0);
  642.     if (fm->addr != MAP_FAILED) {
  643.         return NGX_OK;
  644.     }

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

  649. failed:

  651.     if (ngx_close_file(fm->fd) == NGX_FILE_ERROR) {
  652.         ngx_log_error(NGX_LOG_ALERT, fm->log, ngx_errno,
  653.                       ngx_close_file_n " \"%s\" failed", fm->name);
  654.     }

  656.     return NGX_ERROR;
  657. }


  660. void
  661. ‌ngx_close_file_mapping(ngx_file_mapping_t *fm)
  662. {
  663.     if (munmap(fm->addr, fm->size) == -1) {
  664.         ngx_log_error(NGX_LOG_CRIT, fm->log, ngx_errno,
  665.                       "munmap(%uz) \"%s\" failed", fm->size, fm->name);
  666.     }

  668.     if (ngx_close_file(fm->fd) == NGX_FILE_ERROR) {
  669.         ngx_log_error(NGX_LOG_ALERT, fm->log, ngx_errno,
  670.                       ngx_close_file_n " \"%s\" failed", fm->name);
  671.     }
  672. }


  675. ngx_int_t
  676. ‌ngx_open_dir(ngx_str_t *name, ngx_dir_t *dir)
  677. {
  678.     dir->dir = opendir((const char *) name->data);

  680.     if (dir->dir == NULL) {
  681.         return NGX_ERROR;
  682.     }

  684.     dir->valid_info = 0;

  686.     return NGX_OK;
  687. }


  690. ngx_int_t
  691. ‌ngx_read_dir(ngx_dir_t *dir)
  692. {
  693.     dir->de = readdir(dir->dir);

  695.     if (dir->de) {
  696. #if (NGX_HAVE_D_TYPE)
  697.         dir->type = dir->de->d_type;
  698. #else
  699.         dir->type = 0;
  700. #endif
  701.         return NGX_OK;
  702.     }

  704.     return NGX_ERROR;
  705. }


  708. ngx_int_t
  709. ‌ngx_open_glob(ngx_glob_t *gl)
  710. {
  711.     int  n;

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

  715.     if (n == 0) {
  716.         return NGX_OK;
  717.     }

  719. #ifdef GLOB_NOMATCH

  721.     if (n == GLOB_NOMATCH && gl->test) {
  722.         return NGX_OK;
  723.     }

  725. #endif

  727.     return NGX_ERROR;
  728. }


  731. ngx_int_t
  732. ‌ngx_read_glob(ngx_glob_t *gl, ngx_str_t *name)
  733. {
  734.     size_t  count;

  736. #ifdef GLOB_NOMATCH
  737.     count = (size_t) gl->pglob.gl_pathc;
  738. #else
  739.     count = (size_t) gl->pglob.gl_matchc;
  740. #endif

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

  744.         name->len = (size_t) ngx_strlen(gl->pglob.gl_pathv[gl->n]);
  745.         name->data = (u_char *) gl->pglob.gl_pathv[gl->n];
  746.         gl->n++;

  748.         return NGX_OK;
  749.     }

  751.     return NGX_DONE;
  752. }


  755. void
  756. ‌ngx_close_glob(ngx_glob_t *gl)
  757. {
  758.     globfree(&gl->pglob);
  759. }


  762. ngx_err_t
  763. ‌ngx_trylock_fd(ngx_fd_t fd)
  764. {
  765.     struct flock  fl;

  767.     ngx_memzero(&fl, sizeof(struct flock));
  768.     fl.l_type = F_WRLCK;
  769.     fl.l_whence = SEEK_SET;

  771.     if (fcntl(fd, F_SETLK, &fl) == -1) {
  772.         return ngx_errno;
  773.     }

  775.     return 0;
  776. }


  779. ngx_err_t
  780. ‌ngx_lock_fd(ngx_fd_t fd)
  781. {
  782.     struct flock  fl;

  784.     ngx_memzero(&fl, sizeof(struct flock));
  785.     fl.l_type = F_WRLCK;
  786.     fl.l_whence = SEEK_SET;

  788.     if (fcntl(fd, F_SETLKW, &fl) == -1) {
  789.         return ngx_errno;
  790.     }

  792.     return 0;
  793. }


  796. ngx_err_t
  797. ‌ngx_unlock_fd(ngx_fd_t fd)
  798. {
  799.     struct flock  fl;

  801.     ngx_memzero(&fl, sizeof(struct flock));
  802.     fl.l_type = F_UNLCK;
  803.     fl.l_whence = SEEK_SET;

  805.     if (fcntl(fd, F_SETLK, &fl) == -1) {
  806.         return  ngx_errno;
  807.     }

  809.     return 0;
  810. }


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

  815. ngx_int_t
  816. ‌ngx_read_ahead(ngx_fd_t fd, size_t n)
  817. {
  818.     int  err;

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

  822.     if (err == 0) {
  823.         return 0;
  824.     }

  826.     ngx_set_errno(err);
  827.     return NGX_FILE_ERROR;
  828. }

  830. #endif


  833. #if (NGX_HAVE_O_DIRECT)

  835. ngx_int_t
  836. ‌ngx_directio_on(ngx_fd_t fd)
  837. {
  838.     int  flags;

  840.     flags = fcntl(fd, F_GETFL);

  842.     if (flags == -1) {
  843.         return NGX_FILE_ERROR;
  844.     }

  846.     return fcntl(fd, F_SETFL, flags | O_DIRECT);
  847. }


  850. ngx_int_t
  851. ‌ngx_directio_off(ngx_fd_t fd)
  852. {
  853.     int  flags;

  855.     flags = fcntl(fd, F_GETFL);

  857.     if (flags == -1) {
  858.         return NGX_FILE_ERROR;
  859.     }

  861.     return fcntl(fd, F_SETFL, flags & ~O_DIRECT);
  862. }

  864. #endif


  867. #if (NGX_HAVE_STATFS)

  869. size_t
  870. ‌ngx_fs_bsize(u_char *name)
  871. {
  872.     struct statfs  fs;

  874.     if (statfs((char *) name, &fs) == -1) {
  875.         return 512;
  876.     }

  878.     if ((fs.f_bsize % 512) != 0) {
  879.         return 512;
  880.     }

  882. #if (NGX_LINUX)
  883.     if ((size_t) fs.f_bsize > ngx_pagesize) {
  884.         return 512;
  885.     }
  886. #endif

  888.     return (size_t) fs.f_bsize;
  889. }


  892. off_t
  893. ‌ngx_fs_available(u_char *name)
  894. {
  895.     struct statfs  fs;

  897.     if (statfs((char *) name, &fs) == -1) {
  898.         return NGX_MAX_OFF_T_VALUE;
  899.     }

  901.     return (off_t) fs.f_bavail * fs.f_bsize;
  902. }

  904. #elif (NGX_HAVE_STATVFS)

  906. size_t
  907. ‌ngx_fs_bsize(u_char *name)
  908. {
  909.     struct statvfs  fs;

  911.     if (statvfs((char *) name, &fs) == -1) {
  912.         return 512;
  913.     }

  915.     if ((fs.f_frsize % 512) != 0) {
  916.         return 512;
  917.     }

  919. #if (NGX_LINUX)
  920.     if ((size_t) fs.f_frsize > ngx_pagesize) {
  921.         return 512;
  922.     }
  923. #endif

  925.     return (size_t) fs.f_frsize;
  926. }


  929. off_t
  930. ‌ngx_fs_available(u_char *name)
  931. {
  932.     struct statvfs  fs;

  934.     if (statvfs((char *) name, &fs) == -1) {
  935.         return NGX_MAX_OFF_T_VALUE;
  936.     }

  938.     return (off_t) fs.f_bavail * fs.f_frsize;
  939. }

  941. #else

  943. size_t
  944. ‌ngx_fs_bsize(u_char *name)
  945. {
  946.     return 512;
  947. }


  950. off_t
  951. ‌ngx_fs_available(u_char *name)
  952. {
  953.     return NGX_MAX_OFF_T_VALUE;
  954. }

  956. #endif

One Level Up Top Level