locks.c

   1 /*
   2  * Copyright (c) 2017-2020, 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
  46 setup_locks(const struct configuration *conf)
  47 {
  48         int ret = -1;
  49         char *path = 0;
  50         size_t len = 0;
  51
  52         if (lock_table) {
  53                 return 0;
  54         }
  55
  56         if (!(lock_table = calloc(conf->boards_num, sizeof *lock_table))) {
  57                 PERROR_MESSAGE("malloc");
  58                 ERROR_MESSAGE("Cannot set up locks");
  59                 goto done;
  60         }
  61
  62         for (size_t j = 0; j < conf->boards_num; ++j) {
  63                 lock_table[j] = -1;
  64         }
  65
  66         /* Locks for each board */
  67         for (size_t j = 0; j < conf->boards_num; ++j) {
  68                 len = snprintf(0, 0, "%s/lock_board_%s", conf->work_path,
  69                                conf->boards[j].name);
  70
  71                 if (len + 1 < len) {
  72                         ERROR_MESSAGE("overflow");
  73                         goto done;
  74                 }
  75
  76                 if (!(path = malloc(len + 1))) {
  77                         PERROR_MESSAGE("malloc");
  78                         goto done;
  79                 }
  80
  81                 sprintf(path, "%s/lock_board_%s", conf->work_path,
  82                         conf->boards[j].name);
  83
  84                 if (!(lock_table[j] = open(path, O_RDWR | O_CREAT, 0700))) {
  85                         PERROR_MESSAGE("open");
  86                         ERROR_MESSAGE("Cannot open or create lock file %s",
  87                                       path);
  88                         goto done;
  89                 }
  90
  91                 free(path);
  92                 path = 0;
  93         }
  94
  95         lock_table_len = conf->boards_num;
  96
  97         /* Lock for the recent page */
  98         len = snprintf(0, 0, "%s/lock_recent", conf->work_path);
  99
 100         if (len + 1 < len) {
 101                 ERROR_MESSAGE("overflow");
 102                 goto done;
 103         }
 104
 105         if (!(path = malloc(len + 1))) {
 106                 PERROR_MESSAGE("malloc");
 107                 goto done;
 108         }
 109
 110         sprintf(path, "%s/lock_recent", conf->work_path);
 111
 112         if (!(lock_recent = open(path, O_RDWR | O_CREAT, 0700))) {
 113                 PERROR_MESSAGE("open");
 114                 ERROR_MESSAGE("Cannot open or create lock file %s", path);
 115                 goto done;
 116         }
 117
 118         free(path);
 119         path = 0;
 120
 121         /* Now we've got all the locks */
 122         ret = 0;
 123 done:
 124         free(path);
 125
 126         return ret;
 127 }
 128
 129 /*
 130  * Get a lock for a board
 131  *
 132  * Preconditions:
 133  *
 134  *  - board_idx represents a board.
 135  *
 136  *  - The lock for board_idx is not held in this program.
 137  *
 138  * Postconditions (success):
 139  *
 140  *  - The lock for board_idx is now held by this program.
 141  */
 142 int
 143 lock_acquire(size_t board_idx)
 144 {
 145         int ret = -1;
 146
 147         if (!lock_table ||
 148             lock_table[board_idx] < 0) {
 149                 ERROR_MESSAGE("lock_table isn't set up yet");
 150                 goto done;
 151         }
 152
 153         if (lockf(lock_table[board_idx], F_LOCK, 0) < 0) {
 154                 PERROR_MESSAGE("lockf");
 155                 ERROR_MESSAGE("Cannot lock board %zu", board_idx);
 156                 goto done;
 157         }
 158
 159         ret = 0;
 160 done:
 161
 162         return ret;
 163 }
 164
 165 /*
 166  * Get a lock for the recent page
 167  *
 168  * Preconditions:
 169  *
 170  *  - The lock for the recent page is not held in this program.
 171  *
 172  * Postconditions (success):
 173  *
 174  *  - The lock for the recent page is now held by this program.
 175  */
 176 int
 177 lock_acquire_recent(void)
 178 {
 179         int ret = -1;
 180
 181         if (lock_recent < 0) {
 182                 ERROR_MESSAGE("lock_recent isn't set up yet");
 183                 goto done;
 184         }
 185
 186         if (lockf(lock_recent, F_LOCK, 0) < 0) {
 187                 PERROR_MESSAGE("lockf");
 188                 ERROR_MESSAGE("Cannot lock recent page");
 189                 goto done;
 190         }
 191
 192         ret = 0;
 193 done:
 194
 195         return ret;
 196 }
 197
 198 /*
 199  * Release a lock for a board
 200  *
 201  * Preconditions:
 202  *
 203  *  - board_idx represents a board.
 204  *
 205  *  - The lock for board_idx is held in this program.
 206  *
 207  * Postconditions (success):
 208  *
 209  *  - The lock for board_idx is now not held by this program.
 210  */
 211 int
 212 lock_release(size_t board_idx)
 213 {
 214         if (!lock_table ||
 215             lock_table[board_idx] < 0) {
 216                 return 0;
 217         }
 218
 219         if (lockf(lock_table[board_idx], F_ULOCK, 0) < 0) {
 220                 PERROR_MESSAGE("lockf");
 221                 ERROR_MESSAGE("Cannot release lock for board %zu", board_idx);
 222
 223                 return -1;
 224         }
 225
 226         return 0;
 227 }
 228
 229 /*
 230  * Release a lock for a board
 231  *
 232  * Preconditions:
 233  *
 234  *  - The lock for the recent page is held in this program.
 235  *
 236  * Postconditions (success):
 237  *
 238  *  - The lock for the recent page is now not held by this program.
 239  */
 240 int
 241 lock_release_recent(void)
 242 {
 243         if (lock_recent < 0) {
 244                 return 0;
 245         }
 246
 247         if (lockf(lock_recent, F_ULOCK, 0) < 0) {
 248                 PERROR_MESSAGE("lockf");
 249                 ERROR_MESSAGE("Cannot release lock for recent page");
 250
 251                 return -1;
 252         }
 253
 254         return 0;
 255 }
 256
 257 /*
 258  * Clean up any memory from this file
 259  *
 260  * Postconditions (success):
 261  *
 262  *  - Valgrind won't report any memory leaks from this file.
 263  *
 264  *  - setup_locks() can be safely called again.
 265  */
 266 int
 267 clean_locks(void)
 268 {
 269         if (!lock_table) {
 270                 return 0;
 271         }
 272
 273         for (size_t j = 0; j < lock_table_len; ++j) {
 274                 lock_release(j);
 275                 close(lock_table[j]);
 276         }
 277
 278         free(lock_table);
 279         lock_table = 0;
 280         lock_release_recent();
 281         close(lock_recent);
 282
 283         return 0;
 284 }