fs-poll.c File Reference

#include "uv.h"
#include "uv-common.h"
#include "unix/internal.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>

Go to the source code of this file.

Classes
struct	poll_ctx

Functions
static int	statbuf_eq (const uv_stat_t *a, const uv_stat_t *b)
static void	poll_cb (uv_fs_t *req)
static void	timer_cb (uv_timer_t *timer)
static void	timer_close_cb (uv_handle_t *handle)
int	uv_fs_poll_init (uv_loop_t *loop, uv_fs_poll_t *handle)
int	uv_fs_poll_start (uv_fs_poll_t *handle, uv_fs_poll_cb cb, const char *path, unsigned int interval)
int	uv_fs_poll_stop (uv_fs_poll_t *handle)
int	uv_fs_poll_getpath (uv_fs_poll_t *handle, char *buffer, size_t *size)
void	uv__fs_poll_close (uv_fs_poll_t *handle)

Variables
static uv_stat_t	zero_statbuf

Function Documentation

poll_cb()

static void poll_cb ( uv_fs_t *  req )

static

Definition at line 185 of file fs-poll.c.

                                  {
  uv_stat_t* statbuf;
  struct poll_ctx* ctx;
  uint64_t interval;
  uv_fs_poll_t* handle;
 
  ctx = container_of(req, struct poll_ctx, fs_req);
  handle = ctx->parent_handle;
 
  if (!uv_is_active((uv_handle_t*)handle) || uv__is_closing(handle))
    goto out;
 
  if (req->result != 0) {
    if (ctx->busy_polling != req->result) {
      ctx->poll_cb(ctx->parent_handle,
                   req->result,
                   &ctx->statbuf,
                   &zero_statbuf);
      ctx->busy_polling = req->result;
    }
    goto out;
  }
 
  statbuf = &req->statbuf;
 
  if (ctx->busy_polling != 0)
    if (ctx->busy_polling < 0 || !statbuf_eq(&ctx->statbuf, statbuf))
      ctx->poll_cb(ctx->parent_handle, 0, &ctx->statbuf, statbuf);
 
  ctx->statbuf = *statbuf;
  ctx->busy_polling = 1;
 
out:
  uv_fs_req_cleanup(req);
 
  if (!uv_is_active((uv_handle_t*)handle) || uv__is_closing(handle)) {
    uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);
    return;
  }
 
  /* Reschedule timer, subtract the delay from doing the stat(). */
  interval = ctx->interval;
  interval -= (uv_now(ctx->loop) - ctx->start_time) % interval;
 
  if (uv_timer_start(&ctx->timer_handle, timer_cb, interval, 0))
    abort();
}

References container_of, poll_ctx::fs_req, handle, poll_ctx::interval, out, req, poll_ctx::statbuf, statbuf_eq(), timer_cb(), timer_close_cb(), uv__is_closing, uv_close(), uv_fs_req_cleanup(), uv_is_active(), uv_now(), uv_timer_start(), and zero_statbuf.

Referenced by timer_cb(), uv_fs_poll_start(), and uv_poll_start().

statbuf_eq()

static int statbuf_eq ( const uv_stat_t *  a, const uv_stat_t *  b  )

static

Definition at line 258 of file fs-poll.c.

                                                              {
  return a->st_ctim.tv_nsec == b->st_ctim.tv_nsec
      && a->st_mtim.tv_nsec == b->st_mtim.tv_nsec
      && a->st_birthtim.tv_nsec == b->st_birthtim.tv_nsec
      && a->st_ctim.tv_sec == b->st_ctim.tv_sec
      && a->st_mtim.tv_sec == b->st_mtim.tv_sec
      && a->st_birthtim.tv_sec == b->st_birthtim.tv_sec
      && a->st_size == b->st_size
      && a->st_mode == b->st_mode
      && a->st_uid == b->st_uid
      && a->st_gid == b->st_gid
      && a->st_ino == b->st_ino
      && a->st_dev == b->st_dev
      && a->st_flags == b->st_flags
      && a->st_gen == b->st_gen;
}

References a, and b.

Referenced by poll_cb().

timer_cb()

static void timer_cb ( uv_timer_t *  timer )

static

Definition at line 172 of file fs-poll.c.

                                        {
  struct poll_ctx* ctx;
 
  ctx = container_of(timer, struct poll_ctx, timer_handle);
  assert(ctx->parent_handle != NULL);
  assert(ctx->parent_handle->poll_ctx == ctx);
  ctx->start_time = uv_now(ctx->loop);
 
  if (uv_fs_stat(ctx->loop, &ctx->fs_req, ctx->path, poll_cb))
    abort();
}

References assert(), container_of, NULL, poll_cb(), poll_ctx::timer_handle, uv_fs_stat(), and uv_now().

Referenced by poll_cb().

timer_close_cb()

static void timer_close_cb ( uv_handle_t *  handle )

static

Definition at line 234 of file fs-poll.c.

                                               {
  struct poll_ctx* ctx;
  struct poll_ctx* it;
  struct poll_ctx* last;
  uv_fs_poll_t* handle;
 
  ctx = container_of(timer, struct poll_ctx, timer_handle);
  handle = ctx->parent_handle;
  if (ctx == handle->poll_ctx) {
    handle->poll_ctx = ctx->previous;
    if (handle->poll_ctx == NULL && uv__is_closing(handle))
      uv__make_close_pending((uv_handle_t*)handle);
  } else {
    for (last = handle->poll_ctx, it = last->previous;
         it != ctx;
         last = it, it = it->previous) {
      assert(last->previous != NULL);
    }
    last->previous = ctx->previous;
  }
  uv__free(ctx);
}

References assert(), container_of, handle, NULL, poll_ctx::previous, poll_ctx::timer_handle, uv__free(), uv__is_closing, and uv__make_close_pending().

Referenced by poll_cb(), and uv_fs_poll_stop().

uv__fs_poll_close()

void uv__fs_poll_close

(

uv_fs_poll_t *

handle

)

Definition at line 164 of file fs-poll.c.

                                             {
  uv_fs_poll_stop(handle);
 
  if (handle->poll_ctx == NULL)
    uv__make_close_pending((uv_handle_t*)handle);
}

References handle, NULL, uv__make_close_pending(), and uv_fs_poll_stop().

Referenced by uv_close().

uv_fs_poll_getpath()

int uv_fs_poll_getpath	(	uv_fs_poll_t *	handle,
		char *	buffer,
		size_t *	size
	)

Definition at line 138 of file fs-poll.c.

                                                                         {
  struct poll_ctx* ctx;
  size_t required_len;
 
  if (!uv_is_active((uv_handle_t*)handle)) {
    *size = 0;
    return UV_EINVAL;
  }
 
  ctx = handle->poll_ctx;
  assert(ctx != NULL);
 
  required_len = strlen(ctx->path);
  if (required_len >= *size) {
    *size = required_len + 1;
    return UV_ENOBUFS;
  }
 
  memcpy(buffer, ctx->path, required_len);
  *size = required_len;
  buffer[required_len] = '\0';
 
  return 0;
}

References assert(), handle, memcpy(), NULL, and uv_is_active().

uv_fs_poll_init()

int uv_fs_poll_init	(	uv_loop_t *	loop,
		uv_fs_poll_t *	handle
	)

Definition at line 59 of file fs-poll.c.

                                                           {
  uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_POLL);
  handle->poll_ctx = NULL;
  return 0;
}

References handle, loop, NULL, and uv__handle_init.

uv_fs_poll_start()

int uv_fs_poll_start	(	uv_fs_poll_t *	handle,
		uv_fs_poll_cb	cb,
		const char *	path,
		unsigned int	interval
	)

Definition at line 66 of file fs-poll.c.

                                            {
  struct poll_ctx* ctx;
  uv_loop_t* loop;
  size_t len;
  int err;
 
  if (uv_is_active((uv_handle_t*)handle))
    return 0;
 
  loop = handle->loop;
  len = strlen(path);
  ctx = uv__calloc(1, sizeof(*ctx) + len);
 
  if (ctx == NULL)
    return UV_ENOMEM;
 
  ctx->loop = loop;
  ctx->poll_cb = cb;
  ctx->interval = interval ? interval : 1;
  ctx->start_time = uv_now(loop);
  ctx->parent_handle = handle;
  memcpy(ctx->path, path, len + 1);
 
  err = uv_timer_init(loop, &ctx->timer_handle);
  if (err < 0)
    goto error;
 
  ctx->timer_handle.flags |= UV_HANDLE_INTERNAL;
  uv__handle_unref(&ctx->timer_handle);
 
  err = uv_fs_stat(loop, &ctx->fs_req, ctx->path, poll_cb);
  if (err < 0)
    goto error;
 
  if (handle->poll_ctx != NULL)
    ctx->previous = handle->poll_ctx;
  handle->poll_ctx = ctx;
  uv__handle_start(handle);
 
  return 0;
 
error:
  uv__free(ctx);
  return err;
}

References cb, err, error(), handle, poll_ctx::interval, len, loop, memcpy(), NULL, path, poll_cb(), uv__calloc(), uv__free(), uv__handle_start, uv__handle_unref, uv_fs_stat(), UV_HANDLE_INTERNAL, uv_is_active(), uv_now(), and uv_timer_init().

uv_fs_poll_stop()

int uv_fs_poll_stop

(

uv_fs_poll_t *

handle

)

Definition at line 116 of file fs-poll.c.

                                          {
  struct poll_ctx* ctx;
 
  if (!uv_is_active((uv_handle_t*)handle))
    return 0;
 
  ctx = handle->poll_ctx;
  assert(ctx != NULL);
  assert(ctx->parent_handle == handle);
 
  /* Close the timer if it's active. If it's inactive, there's a stat request
   * in progress and poll_cb will take care of the cleanup.
   */
  if (uv_is_active((uv_handle_t*)&ctx->timer_handle))
    uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);
 
  uv__handle_stop(handle);
 
  return 0;
}

References assert(), handle, NULL, timer_close_cb(), uv__handle_stop, uv_close(), and uv_is_active().

Referenced by uv__fs_poll_close().

Variable Documentation

zero_statbuf

uv_stat_t zero_statbuf

static

Definition at line 56 of file fs-poll.c.

Referenced by poll_cb().