locks.c

   1 /*
   2  * Copyright (c) 2017-2018, De Rais <derais@cock.li>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for
   5  * any purpose with or without fee is hereby granted, provided that the
   6  * above copyright notice and this permission notice appear in all
   7  * copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10  * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11  * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12  * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  13  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  14  * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  15  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16  * PERFORMANCE OF THIS SOFTWARE.
  17  */
  18 #include <errno.h>
  19 #include <fcntl.h>
  20 #include <stdint.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <sys/stat.h>
  24 #include <time.h>
  25 #include <unistd.h>
  26
  27 #include "macros.h"
  28 #include "rb79.h"
  29
  30 static int *lock_table = 0;
  31 static size_t lock_table_len = 0;
  32 static int lock_recent;
  33
  34 /*
  35  * Set up the lock files and make sure we can connect to them.
  36  *
  37  * Preconditions:
  38  *
  39  *  - setup_locks() was not invoked more recently than clean_locks().
  40  *
  41  * Postconditions (success):
  42  *
  43  *  - Any other function in this file may be safely called.
  44  */
  45 int setup_locks(const struct configuration *conf)
  46 {
  47         int ret = -1;
  48         char *path = 0;
  49         size_t len = 0;
  50
  51         if (lock_table) {
  52                 return 0;
  53         }
  54
  55         if (!(lock_table = calloc(conf->boards_num, sizeof *lock_table))) {
  56                 PERROR_MESSAGE("malloc");
  57                 ERROR_MESSAGE("Cannot set up locks");
  58                 goto done;
  59         }
  60
  61         for (size_t j = 0; j < conf->boards_num; ++j) {
  62                 lock_table[j] = -1;
  63         }
  64
  65         /* Locks for each board */
  66         for (size_t j = 0; j < conf->boards_num; ++j) {
  67                 len = snprintf(0, 0, "%s/lock_board_%s", conf->work_path,
  68                                conf->boards[j].name);
  69
  70                 if (len + 1 < len) {
  71                         ERROR_MESSAGE("overflow");
  72                         goto done;
  73                 }
  74
  75                 if (!(path = malloc(len + 1))) {
  76                         PERROR_MESSAGE("malloc");
  77                         goto done;
  78                 }
  79
  80                 sprintf(path, "%s/lock_board_%s", conf->work_path,
  81                         conf->boards[j].name);
  82
  83                 if (!(lock_table[j] = open(path, O_RDWR | O_CREAT, 0700))) {
  84                         PERROR_MESSAGE("open");
  85                         ERROR_MESSAGE("Cannot open or create lock file %s",
  86                                       path);
  87                         goto done;
  88                 }
  89
  90                 free(path);
  91                 path = 0;
  92         }
  93
  94         lock_table_len = conf->boards_num;
  95
  96         /* Lock for the recent page */
  97         len = snprintf(0, 0, "%s/lock_recent", conf->work_path);
  98
  99         if (len + 1 < len) {
 100                 ERROR_MESSAGE("overflow");
 101                 goto done;
 102         }
 103
 104         if (!(path = malloc(len + 1))) {
 105                 PERROR_MESSAGE("malloc");
 106                 goto done;
 107         }
 108
 109         sprintf(path, "%s/lock_recent", conf->work_path);
 110
 111         if (!(lock_recent = open(path, O_RDWR | O_CREAT, 0700))) {
 112                 PERROR_MESSAGE("open");
 113                 ERROR_MESSAGE("Cannot open or create lock file %s", path);
 114                 goto done;
 115         }
 116
 117         free(path);
 118         path = 0;
 119
 120         /* Now we've got all the locks */
 121         ret = 0;
 122 done:
 123         free(path);
 124
 125         return ret;
 126 }
 127
 128 /*
 129  * Get a lock for a board
 130  *
 131  * Preconditions:
 132  *
 133  *  - board_idx represents a board.
 134  *
 135  *  - The lock for board_idx is not held in this program.
 136  *
 137  * Postconditions (success):
 138  *
 139  *  - The lock for board_idx is now held by this program.
 140  */
 141 int lock_acquire(size_t board_idx)
 142 {
 143         int ret = -1;
 144
 145         if (!lock_table ||
 146             lock_table[board_idx] < 0) {
 147                 ERROR_MESSAGE("lock_table isn't set up yet");
 148                 goto done;
 149         }
 150
 151         if (lockf(lock_table[board_idx], F_LOCK, 0) < 0) {
 152                 PERROR_MESSAGE("lockf");
 153                 ERROR_MESSAGE("Cannot lock board %zu", board_idx);
 154                 goto done;
 155         }
 156
 157         ret = 0;
 158 done:
 159
 160         return ret;
 161 }
 162
 163 /*
 164  * Get a lock for the recent page
 165  *
 166  * Preconditions:
 167  *
 168  *  - The lock for the recent page is not held in this program.
 169  *
 170  * Postconditions (success):
 171  *
 172  *  - The lock for the recent page is now held by this program.
 173  */
 174 int lock_acquire_recent(void)
 175 {
 176         int ret = -1;
 177
 178         if (lock_recent < 0) {
 179                 ERROR_MESSAGE("lock_recent isn't set up yet");
 180                 goto done;
 181         }
 182
 183         if (lockf(lock_recent, F_LOCK, 0) < 0) {
 184                 PERROR_MESSAGE("lockf");
 185                 ERROR_MESSAGE("Cannot lock recent page");
 186                 goto done;
 187         }
 188
 189         ret = 0;
 190 done:
 191
 192         return ret;
 193 }
 194
 195 /*
 196  * Release a lock for a board
 197  *
 198  * Preconditions:
 199  *
 200  *  - board_idx represents a board.
 201  *
 202  *  - The lock for board_idx is held in this program.
 203  *
 204  * Postconditions (success):
 205  *
 206  *  - The lock for board_idx is now not held by this program.
 207  */
 208 int lock_release(size_t board_idx)
 209 {
 210         if (!lock_table ||
 211             lock_table[board_idx] < 0) {
 212                 return 0;
 213         }
 214
 215         if (lockf(lock_table[board_idx], F_ULOCK, 0) < 0) {
 216                 PERROR_MESSAGE("lockf");
 217                 ERROR_MESSAGE("Cannot release lock for board %zu", board_idx);
 218
 219                 return -1;
 220         }
 221
 222         return 0;
 223 }
 224
 225 /*
 226  * Release a lock for a board
 227  *
 228  * Preconditions:
 229  *
 230  *  - The lock for the recent page is held in this program.
 231  *
 232  * Postconditions (success):
 233  *
 234  *  - The lock for the recent page is now not held by this program.
 235  */
 236 int lock_release_recent(void)
 237 {
 238         if (lock_recent < 0) {
 239                 return 0;
 240         }
 241
 242         if (lockf(lock_recent, F_ULOCK, 0) < 0) {
 243                 PERROR_MESSAGE("lockf");
 244                 ERROR_MESSAGE("Cannot release lock for recent page");
 245
 246                 return -1;
 247         }
 248
 249         return 0;
 250 }
 251
 252 /*
 253  * Clean up any memory from this file
 254  *
 255  * Postconditions (success):
 256  *
 257  *  - Valgrind won't report any memory leaks from this file.
 258  *
 259  *  - setup_locks() can be safely called again.
 260  */
 261 int clean_locks(void)
 262 {
 263         if (!lock_table) {
 264                 return 0;
 265         }
 266
 267         for (size_t j = 0; j < lock_table_len; ++j) {
 268                 lock_release(j);
 269                 close(lock_table[j]);
 270         }
 271
 272         free(lock_table);
 273         lock_table = 0;
 274         lock_release_recent();
 275         close(lock_recent);
 276
 277         return 0;
 278 }