reftable/system.c

   1 #include "system.h"
   2 #include "basics.h"
   3 #include "reftable-error.h"
   4 #include "../lockfile.h"
   5 #include "../tempfile.h"
   6
   7 int tmpfile_from_pattern(struct reftable_tmpfile *out, const char *pattern)
   8 {
   9         struct tempfile *tempfile;
  10
  11         tempfile = mks_tempfile(pattern);
  12         if (!tempfile)
  13                 return REFTABLE_IO_ERROR;
  14
  15         out->path = tempfile->filename.buf;
  16         out->fd = tempfile->fd;
  17         out->priv = tempfile;
  18
  19         return 0;
  20 }
  21
  22 int tmpfile_close(struct reftable_tmpfile *t)
  23 {
  24         struct tempfile *tempfile = t->priv;
  25         int ret = close_tempfile_gently(tempfile);
  26         t->fd = -1;
  27         if (ret < 0)
  28                 return REFTABLE_IO_ERROR;
  29         return 0;
  30 }
  31
  32 int tmpfile_delete(struct reftable_tmpfile *t)
  33 {
  34         struct tempfile *tempfile = t->priv;
  35         int ret = delete_tempfile(&tempfile);
  36         *t = REFTABLE_TMPFILE_INIT;
  37         if (ret < 0)
  38                 return REFTABLE_IO_ERROR;
  39         return 0;
  40 }
  41
  42 int tmpfile_rename(struct reftable_tmpfile *t, const char *path)
  43 {
  44         struct tempfile *tempfile = t->priv;
  45         int ret = rename_tempfile(&tempfile, path);
  46         *t = REFTABLE_TMPFILE_INIT;
  47         if (ret < 0)
  48                 return REFTABLE_IO_ERROR;
  49         return 0;
  50 }
  51
  52 int flock_acquire(struct reftable_flock *l, const char *target_path,
  53                   long timeout_ms)
  54 {
  55         struct lock_file *lockfile;
  56         int err;
  57
  58         lockfile = reftable_malloc(sizeof(*lockfile));
  59         if (!lockfile)
  60                 return REFTABLE_OUT_OF_MEMORY_ERROR;
  61
  62         err = hold_lock_file_for_update_timeout(lockfile, target_path, LOCK_NO_DEREF,
  63                                                 timeout_ms);
  64         if (err < 0) {
  65                 reftable_free(lockfile);
  66                 if (errno == EEXIST)
  67                         return REFTABLE_LOCK_ERROR;
  68                 return -1;
  69         }
  70
  71         l->fd = get_lock_file_fd(lockfile);
  72         l->path = get_lock_file_path(lockfile);
  73         l->priv = lockfile;
  74
  75         return 0;
  76 }
  77
  78 int flock_close(struct reftable_flock *l)
  79 {
  80         struct lock_file *lockfile = l->priv;
  81         int ret;
  82
  83         if (!lockfile)
  84                 return REFTABLE_API_ERROR;
  85
  86         ret = close_lock_file_gently(lockfile);
  87         l->fd = -1;
  88         if (ret < 0)
  89                 return REFTABLE_IO_ERROR;
  90
  91         return 0;
  92 }
  93
  94 int flock_release(struct reftable_flock *l)
  95 {
  96         struct lock_file *lockfile = l->priv;
  97         int ret;
  98
  99         if (!lockfile)
 100                 return 0;
 101
 102         ret = rollback_lock_file(lockfile);
 103         reftable_free(lockfile);
 104         *l = REFTABLE_FLOCK_INIT;
 105         if (ret < 0)
 106                 return REFTABLE_IO_ERROR;
 107
 108         return 0;
 109 }
 110
 111 int flock_commit(struct reftable_flock *l)
 112 {
 113         struct lock_file *lockfile = l->priv;
 114         int ret;
 115
 116         if (!lockfile)
 117                 return REFTABLE_API_ERROR;
 118
 119         ret = commit_lock_file(lockfile);
 120         reftable_free(lockfile);
 121         *l = REFTABLE_FLOCK_INIT;
 122         if (ret < 0)
 123                 return REFTABLE_IO_ERROR;
 124
 125         return 0;
 126 }