source4/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 || tdb->traverse_read)) {
  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 (!probe && lck_type != F_SETLK) {
  69                         /* Ensure error code is set for log fun to examine. */
  70                         tdb->ecode = TDB_ERR_LOCK;
  71                         TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d lck_type=%d len=%d\n",
  72                                  tdb->fd, offset, rw_type, lck_type, (int)len));
  73                 }
  74                 return TDB_ERRCODE(TDB_ERR_LOCK, -1);
  75         }
  76         return 0;
  77 }
  78
  79
  80 /*
  81   upgrade a read lock to a write lock. This needs to be handled in a
  82   special way as some OSes (such as solaris) have too conservative
  83   deadlock detection and claim a deadlock when progress can be
  84   made. For those OSes we may loop for a while.
  85 */
  86 int tdb_brlock_upgrade(struct tdb_context *tdb, tdb_off_t offset, size_t len)
  87 {
  88         int count = 1000;
  89         while (count--) {
  90                 struct timeval tv;
  91                 if (tdb_brlock_len(tdb, offset, F_WRLCK, F_SETLKW, 1, len) == 0) {
  92                         return 0;
  93                 }
  94                 if (errno != EDEADLK) {
  95                         break;
  96                 }
  97                 /* sleep for as short a time as we can - more portable than usleep() */
  98                 tv.tv_sec = 0;
  99                 tv.tv_usec = 1;
 100                 select(0, NULL, NULL, NULL, &tv);
 101         }
 102         TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock_upgrade failed at offset %d\n", offset));
 103         return -1;
 104 }
 105
 106
 107 /* a byte range locking function - return 0 on success
 108    this functions locks/unlocks 1 byte at the specified offset.
 109
 110    On error, errno is also set so that errors are passed back properly
 111    through tdb_open(). */
 112 int tdb_brlock(struct tdb_context *tdb, tdb_off_t offset,
 113                int rw_type, int lck_type, int probe)
 114 {
 115         return tdb_brlock_len(tdb, offset, rw_type, lck_type, probe, 1);
 116 }
 117
 118 /* lock a list in the database. list -1 is the alloc list */
 119 int tdb_lock(struct tdb_context *tdb, int list, int ltype)
 120 {
 121         if (list < -1 || list >= (int)tdb->header.hash_size) {
 122                 TDB_LOG((tdb, TDB_DEBUG_ERROR,"tdb_lock: invalid list %d for ltype=%d\n",
 123                            list, ltype));
 124                 return -1;
 125         }
 126         if (tdb->flags & TDB_NOLOCK)
 127                 return 0;
 128
 129         /* Since fcntl locks don't nest, we do a lock for the first one,
 130            and simply bump the count for future ones */
 131         if (tdb->locked[list+1].count == 0) {
 132                 if (tdb->methods->tdb_brlock(tdb,FREELIST_TOP+4*list,ltype,F_SETLKW, 0)) {
 133                         TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_lock failed on list %d ltype=%d (%s)\n",
 134                                  list, ltype, strerror(errno)));
 135                         return -1;
 136                 }
 137                 tdb->locked[list+1].ltype = ltype;
 138                 tdb->num_locks++;
 139         }
 140         tdb->locked[list+1].count++;
 141         return 0;
 142 }
 143
 144 /* unlock the database: returns void because it's too late for errors. */
 145         /* changed to return int it may be interesting to know there
 146            has been an error  --simo */
 147 int tdb_unlock(struct tdb_context *tdb, int list, int ltype)
 148 {
 149         int ret = -1;
 150
 151         if (tdb->flags & TDB_NOLOCK)
 152                 return 0;
 153
 154         /* Sanity checks */
 155         if (list < -1 || list >= (int)tdb->header.hash_size) {
 156                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: list %d invalid (%d)\n", list, tdb->header.hash_size));
 157                 return ret;
 158         }
 159
 160         if (tdb->locked[list+1].count==0) {
 161                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: count is 0\n"));
 162                 return ret;
 163         }
 164
 165         if (tdb->locked[list+1].count == 1) {
 166                 /* Down to last nested lock: unlock underneath */
 167                 ret = tdb->methods->tdb_brlock(tdb, FREELIST_TOP+4*list, F_UNLCK, F_SETLKW, 0);
 168                 tdb->num_locks--;
 169         } else {
 170                 ret = 0;
 171         }
 172         tdb->locked[list+1].count--;
 173
 174         if (ret)
 175                 TDB_LOG((tdb, TDB_DEBUG_ERROR, "tdb_unlock: An error occurred unlocking!\n"));
 176         return ret;
 177 }
 178
 179
 180
 181 /* lock/unlock entire database */
 182 int tdb_lockall(struct tdb_context *tdb)
 183 {
 184         u32 i;
 185
 186         /* There are no locks on read-only dbs */
 187         if (tdb->read_only || tdb->traverse_read)
 188                 return TDB_ERRCODE(TDB_ERR_LOCK, -1);
 189         for (i = 0; i < tdb->header.hash_size; i++)
 190                 if (tdb_lock(tdb, i, F_WRLCK))
 191                         break;
 192
 193         /* If error, release locks we have... */
 194         if (i < tdb->header.hash_size) {
 195                 u32 j;
 196
 197                 for ( j = 0; j < i; j++)
 198                         tdb_unlock(tdb, j, F_WRLCK);
 199                 return TDB_ERRCODE(TDB_ERR_NOLOCK, -1);
 200         }
 201
 202         return 0;
 203 }
 204 void tdb_unlockall(struct tdb_context *tdb)
 205 {
 206         u32 i;
 207         for (i=0; i < tdb->header.hash_size; i++)
 208                 tdb_unlock(tdb, i, F_WRLCK);
 209 }
 210
 211 /* lock/unlock one hash chain. This is meant to be used to reduce
 212    contention - it cannot guarantee how many records will be locked */
 213 int tdb_chainlock(struct tdb_context *tdb, TDB_DATA key)
 214 {
 215         return tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
 216 }
 217
 218 int tdb_chainunlock(struct tdb_context *tdb, TDB_DATA key)
 219 {
 220         return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_WRLCK);
 221 }
 222
 223 int tdb_chainlock_read(struct tdb_context *tdb, TDB_DATA key)
 224 {
 225         return tdb_lock(tdb, BUCKET(tdb->hash_fn(&key)), F_RDLCK);
 226 }
 227
 228 int tdb_chainunlock_read(struct tdb_context *tdb, TDB_DATA key)
 229 {
 230         return tdb_unlock(tdb, BUCKET(tdb->hash_fn(&key)), F_RDLCK);
 231 }
 232
 233
 234
 235 /* record lock stops delete underneath */
 236 int tdb_lock_record(struct tdb_context *tdb, tdb_off_t off)
 237 {
 238         return off ? tdb->methods->tdb_brlock(tdb, off, F_RDLCK, F_SETLKW, 0) : 0;
 239 }
 240
 241 /*
 242   Write locks override our own fcntl readlocks, so check it here.
 243   Note this is meant to be F_SETLK, *not* F_SETLKW, as it's not
 244   an error to fail to get the lock here.
 245 */
 246 int tdb_write_lock_record(struct tdb_context *tdb, tdb_off_t off)
 247 {
 248         struct tdb_traverse_lock *i;
 249         for (i = &tdb->travlocks; i; i = i->next)
 250                 if (i->off == off)
 251                         return -1;
 252         return tdb->methods->tdb_brlock(tdb, off, F_WRLCK, F_SETLK, 1);
 253 }
 254
 255 /*
 256   Note this is meant to be F_SETLK, *not* F_SETLKW, as it's not
 257   an error to fail to get the lock here.
 258 */
 259 int tdb_write_unlock_record(struct tdb_context *tdb, tdb_off_t off)
 260 {
 261         return tdb->methods->tdb_brlock(tdb, off, F_UNLCK, F_SETLK, 0);
 262 }
 263
 264 /* fcntl locks don't stack: avoid unlocking someone else's */
 265 int tdb_unlock_record(struct tdb_context *tdb, tdb_off_t off)
 266 {
 267         struct tdb_traverse_lock *i;
 268         u32 count = 0;
 269
 270         if (off == 0)
 271                 return 0;
 272         for (i = &tdb->travlocks; i; i = i->next)
 273                 if (i->off == off)
 274                         count++;
 275         return (count == 1 ? tdb->methods->tdb_brlock(tdb, off, F_UNLCK, F_SETLKW, 0) : 0);
 276 }