library/locks.c

   1 /*
   2  * 2011+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #include <sys/stat.h>
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <unistd.h>
  21 #include <fcntl.h>
  22 #include <signal.h>
  23
  24 #include "elliptics.h"
  25
  26 void dnet_locks_destroy(struct dnet_node *n)
  27 {
  28         int i;
  29
  30         if (n->locks) {
  31                 for (i = 0; i < n->locks->num; ++i) {
  32                         pthread_mutex_destroy(&n->locks->lock[i]);
  33                 }
  34
  35                 free(n->locks);
  36                 n->locks = NULL;
  37         }
  38 }
  39
  40 int dnet_locks_init(struct dnet_node *n, int num)
  41 {
  42         int err, i;
  43
  44         n->locks = malloc(sizeof(struct dnet_locks) + num * sizeof(pthread_mutex_t));
  45         if (!n->locks) {
  46                 err = -ENOMEM;
  47                 goto err_out_exit;
  48         }
  49
  50         n->locks->num = num;
  51
  52         for (i = 0; i < num; ++i) {
  53                 err = pthread_mutex_init(&n->locks->lock[i], NULL);
  54                 if (err) {
  55                         err = -err;
  56                         dnet_log(n, DNET_LOG_ERROR, "Could not create lock %d/%d: %s [%d]\n", i, num, strerror(-err), err);
  57
  58                         n->locks->num = i;
  59                         goto err_out_destroy;
  60                 }
  61         }
  62
  63         return 0;
  64
  65 err_out_destroy:
  66         dnet_locks_destroy(n);
  67 err_out_exit:
  68         return err;
  69 }
  70
  71 static unsigned int dnet_ophash_index(struct dnet_node *n, struct dnet_id *key)
  72 {
  73         unsigned int *ptr = (unsigned int *)key->id;
  74         unsigned int h = 0;
  75         unsigned int i;
  76
  77         for (i = 0; i < sizeof(key->id) / sizeof(unsigned int); ++i) {
  78                 h ^= ptr[i];
  79         }
  80
  81         return h % n->locks->num;
  82 }
  83
  84 void dnet_oplock(struct dnet_node *n, struct dnet_id *key)
  85 {
  86         unsigned int idx = dnet_ophash_index(n, key);
  87
  88         pthread_mutex_lock(&n->locks->lock[idx]);
  89 }
  90
  91 void dnet_opunlock(struct dnet_node *n, struct dnet_id *key)
  92 {
  93         unsigned int idx = dnet_ophash_index(n, key);
  94
  95         pthread_mutex_unlock(&n->locks->lock[idx]);
  96 }
  97
  98 int dnet_optrylock(struct dnet_node *n, struct dnet_id *key)
  99 {
 100         unsigned int idx = dnet_ophash_index(n, key);
 101         int err;
 102
 103         err = pthread_mutex_trylock(&n->locks->lock[idx]);
 104         return err;
 105 }
 106