source/lib/tdb/common/lock.c

   1  /*
   2    Unix SMB/CIFS implementation.
   3
   4    trivial database library
   5
   6    Copyright (C) Andrew Tridgell              1999-2005
   7    Copyright (C) Paul `Rusty' Russell              2000
   8    Copyright (C) Jeremy Allison                    2000-2003
   9
  10      ** NOTE! The following LGPL license applies to the tdb
  11      ** library. This does NOT imply that all of Samba is released
  12      ** under the LGPL
  13
  14    This library is free software; you can redistribute it and/or
  15    modify it under the terms of the GNU Lesser General Public
  16    License as published by the Free Software Foundation; either
  17    version 2 of the License, or (at your option) any later version.
  18
  19    This library is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22    Lesser General Public License for more details.
  23
  24    You should have received a copy of the GNU Lesser General Public
  25    License along with this library; if not, write to the Free Software
  26    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  27 */
  28
  29 #include "tdb_private.h"
  30
  31 /* a byte range locking function - return 0 on success
  32    this functions locks/unlocks 1 byte at the specified offset.
  33
  34    On error, errno is also set so that errors are passed back properly
  35    through tdb_open().
  36
  37    note that a len of zero means lock to end of file
  38 */
  39 int tdb_brlock_len(struct tdb_context *tdb, tdb_off_t offset,
  40                    int rw_type, int lck_type, int probe, size_t len)
  41 {
  42         struct flock fl;
  43         int ret;
  44
  45         if (tdb->flags & TDB_NOLOCK) {
  46                 return 0;
  47         }
  48
  49         if ((rw_type == F_WRLCK) && (tdb->read_only)) {
  50                 tdb->ecode = TDB_ERR_RDONLY;
  51                 return -1;
  52         }
  53
  54         fl.l_type = rw_type;
  55         fl.l_whence = SEEK_SET;
  56         fl.l_start = offset;
  57         fl.l_len = len;
  58         fl.l_pid = 0;
  59
  60         do {
  61                 ret = fcntl(tdb->fd,lck_type,&fl);
  62         } while (ret == -1 && errno == EINTR);
  63
  64         if (ret == -1) {
  65                 /* Generic lock error. errno set by fcntl.
  66                  * EAGAIN is an expected return from non-blocking
  67                  * locks. */
  68                 if (errno != EAGAIN) {
  69                         TDB_LOG((tdb, 5, "tdb_brlock failed (fd=%d) at offset %d rw_type=%d lck_type=%d len=%d: %s\n",
  70                                  tdb->fd, offset, rw_type, lck_type, len,
  71                                  strerror(errno)));
  72                 } else if (!probe && lck_type != F_SETLK) {
  73                         /* Ensure error code is set for log fun to examine. */
  74                         tdb->ecode = TDB_ERR_LOCK;
  75                         TDB_LOG((tdb, 5,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d lck_type=%d\n",
  76                                  tdb->fd, offset, rw_type, lck_type));
  77                 }
  78                 return TDB_ERRCODE(TDB_ERR_LOCK, -1);
  79         }
  80         return 0;
  81 }
  82
  83
  84 /* a byte range locking function - return 0 on success
  85    this functions locks/unlocks 1 byte at the specified offset.
  86
  87    On error, errno is also set so that errors are passed back properly
  88    through tdb_open(). */
  89 int tdb_brlock(struct tdb_context *tdb, tdb_off_t offset,
  90                int rw_type, int lck_type, int probe)
  91 {
  92         return tdb_brlock_len(tdb, offset, rw_type, lck_type, probe, 1);
  93 }
  94
  95 /* lock a list in the database. list -1 is the alloc list */
  96 int tdb_lock(struct tdb_context *tdb, int list, int ltype)
  97 {
  98         if (list < -1 || list >= (int)tdb->header.hash_size) {
  99                 TDB_LOG((tdb, 0,"tdb_lock: invalid list %d for ltype=%d\n",
 100                            list, ltype));
 101                 return -1;
 102         }
 103         if (tdb->flags & TDB_NOLOCK)
 104                 return 0;
 105
 106         /* Since fcntl locks don't nest, we do a lock for the first one,
 107            and simply bump the count for future ones */
 108         if (tdb->locked[list+1].count == 0) {
 109                 if (tdb->methods->tdb_brlock(tdb,FREELIST_TOP+4*list,ltype,F_SETLKW, 0)) {
 110                         TDB_LOG((tdb, 0,"tdb_lock failed on list %d ltype=%d (%s)\n",
 111                                  list, ltype, strerror(errno)));
 112                         return -1;
 113                 }
 114                 tdb->locked[list+1].ltype = ltype;
 115                 tdb->num_locks++;
 116         }
 117         tdb->locked[list+1].count++;
 118         return 0;
 119 }
 120
 121 /* unlock the database: returns void because it's too late for errors. */
 122         /* changed to return int it may be interesting to know there
 123            has been an error  --simo */
 124 int tdb_unlock(struct tdb_context *tdb, int list, int ltype)
 125 {
 126         int ret = -1;
 127
 128         if (tdb->flags & TDB_NOLOCK)
 129                 return 0;
 130
 131         /* Sanity checks */
 132         if (list < -1 || list >= (int)tdb->header.hash_size) {
 133                 TDB_LOG((tdb, 0, "tdb_unlock: list %d invalid (%d)\n", list, tdb->header.hash_size));
 134                 return ret;
 135         }
 136
 137         if (tdb->locked[list+1].count==0) {
 138                 TDB_LOG((tdb, 0, "tdb_unlock: count is 0\n"));
 139                 return ret;
 140         }
 141
 142         if (tdb->locked[list+1].count == 1) {
 143                 /* Down to last nested lock: unlock underneath */
 144                 ret = tdb->methods->tdb_brlock(tdb, FREELIST_TOP+4*list, F_UNLCK, F_SETLKW, 0);
 145                 tdb->num_locks--;
 146         } else {
 147                 ret = 0;
 148         }
 149         tdb->locked[list+1].count--;
 150
 151         if (ret)
 152                 TDB_LOG((tdb, 0,"tdb_unlock: An error occurred unlocking!\n"));
 153         return ret;
 154 }
 155
 156
 157
 158 /* lock/unlock entire database */
 159 int tdb_lockall(struct tdb_context *tdb)
 160 {
 161         u32 i;
 162
 163         /* There are no locks on read-only dbs */
 164         if (tdb->read_only)
 165                 return TDB_ERRCODE(TDB_ERR_LOCK, -1);
 166         for (i = 0; i < tdb->header.hash_size; i++)
 167                 if (tdb_lock(tdb, i, F_WRLCK))
 168                         break;
 169
 170         /* If error, release locks we have... */
 171         if (i < tdb->header.hash_size) {
 172                 u32 j;
 173
 174                 for ( j = 0; j < i; j++)
 175                         tdb_unlock(tdb, j, F_WRLCK);
 176                 return TDB_ERRCODE(TDB_ERR_NOLOCK, -1);
 177         }
 178
 179         return 0;
 180 }
 181 void tdb_unlockall(struct tdb_context *tdb)
 182 {
 183         u32 i;
 184         for (i=0; i < tdb->header.hash_size; i++)
 185                 tdb_unlock(tdb, i, F_WRLCK);
 186 }
 187
 188 /* lock/unlock one hash chain. This is meant to be used to reduce
 189    contention - it cannot guarantee how many records will be locked */
 190 int tdb_chainlock(struct tdb_context *tdb, TDB_DATA key)
 191 {
 192         return tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
 193 }
 194
 195 int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
 196 {
 197         return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
 198 }
 199
 200 int tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key)
 201 {
 202         return tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_RDLCK);
 203 }
 204
 205 int tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key)
 206 {
 207         return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_RDLCK);
 208 }
 209
 210
 211
 212 /* record lock stops delete underneath */
 213 int tdb_lock_record(struct tdb_context *tdb, tdb_off_t off)
 214 {
 215         return off ? tdb->methods->tdb_brlock(tdb, off, F_RDLCK, F_SETLKW, 0) : 0;
 216 }
 217
 218 /*
 219   Write locks override our own fcntl readlocks, so check it here.
 220   Note this is meant to be F_SETLK, *not* F_SETLKW, as it's not
 221   an error to fail to get the lock here.
 222 */
 223 int tdb_write_lock_record(struct tdb_context *tdb, tdb_off_t off)
 224 {
 225         struct tdb_traverse_lock *i;
 226         for (i = &tdb->travlocks; i; i = i->next)
 227                 if (i->off == off)
 228                         return -1;
 229         return tdb->methods->tdb_brlock(tdb, off, F_WRLCK, F_SETLK, 1);
 230 }
 231
 232 /*
 233   Note this is meant to be F_SETLK, *not* F_SETLKW, as it's not
 234   an error to fail to get the lock here.
 235 */
 236 int tdb_write_unlock_record(struct tdb_context *tdb, tdb_off_t off)
 237 {
 238         return tdb->methods->tdb_brlock(tdb, off, F_UNLCK, F_SETLK, 0);
 239 }
 240
 241 /* fcntl locks don't stack: avoid unlocking someone else's */
 242 int tdb_unlock_record(struct tdb_context *tdb, tdb_off_t off)
 243 {
 244         struct tdb_traverse_lock *i;
 245         u32 count = 0;
 246
 247         if (off == 0)
 248                 return 0;
 249         for (i = &tdb->travlocks; i; i = i->next)
 250                 if (i->off == off)
 251                         count++;
 252         return (count == 1 ? tdb->methods->tdb_brlock(tdb, off, F_UNLCK, F_SETLKW, 0) : 0);
 253 }