X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftdb2%2Flock.c;h=666aa09038a731d2f8c0b36d605c08c8d5409235;hp=8bd9c4f0f4bca5c9a5079a74120919a1ae73c3d5;hb=838db0d7ea37fc2a21d03d159b55b042f8144cb3;hpb=0693529224e36235fc615fa323e57d5b07879e3f

diff --git a/ccan/tdb2/lock.c b/ccan/tdb2/lock.c
index 8bd9c4f0..666aa090 100644
--- a/ccan/tdb2/lock.c
+++ b/ccan/tdb2/lock.c
@@ -60,34 +60,64 @@ static bool check_lock_pid(struct tdb_context *tdb,
 	return false;
 }
 
-static int fcntl_lock(struct tdb_context *tdb,
-		      int rw, off_t off, off_t len, bool waitflag)
+int tdb_fcntl_lock(int fd, int rw, off_t off, off_t len, bool waitflag,
+		   void *unused)
 {
 	struct flock fl;
+	int ret;
+
+	do {
+		fl.l_type = rw;
+		fl.l_whence = SEEK_SET;
+		fl.l_start = off;
+		fl.l_len = len;
 
-	fl.l_type = rw;
-	fl.l_whence = SEEK_SET;
-	fl.l_start = off;
-	fl.l_len = len;
-	fl.l_pid = 0;
+		if (waitflag)
+			ret = fcntl(fd, F_SETLKW, &fl);
+		else
+			ret = fcntl(fd, F_SETLK, &fl);
+	} while (ret != 0 && errno == EINTR);
+	return ret;
+}
 
+int tdb_fcntl_unlock(int fd, int rw, off_t off, off_t len, void *unused)
+{
+	struct flock fl;
+	int ret;
+
+	do {
+		fl.l_type = F_UNLCK;
+		fl.l_whence = SEEK_SET;
+		fl.l_start = off;
+		fl.l_len = len;
+
+		ret = fcntl(fd, F_SETLKW, &fl);
+	} while (ret != 0 && errno == EINTR);
+	return ret;
+}
+
+static int lock(struct tdb_context *tdb,
+		      int rw, off_t off, off_t len, bool waitflag)
+{
+	int ret;
 	if (tdb->file->allrecord_lock.count == 0
 	    && tdb->file->num_lockrecs == 0) {
 		tdb->file->locker = getpid();
 	}
 
-	add_stat(tdb, lock_lowlevel, 1);
-	if (waitflag)
-		return fcntl(tdb->file->fd, F_SETLKW, &fl);
-	else {
-		add_stat(tdb, lock_nonblock, 1);
-		return fcntl(tdb->file->fd, F_SETLK, &fl);
+	tdb->stats.lock_lowlevel++;
+	ret = tdb->lock_fn(tdb->file->fd, rw, off, len, waitflag,
+			   tdb->lock_data);
+	if (!waitflag) {
+		tdb->stats.lock_nonblock++;
+		if (ret != 0)
+			tdb->stats.lock_nonblock_fail++;
 	}
+	return ret;
 }
 
-static int fcntl_unlock(struct tdb_context *tdb, int rw, off_t off, off_t len)
+static int unlock(struct tdb_context *tdb, int rw, off_t off, off_t len)
 {
-	struct flock fl;
 #if 0 /* Check they matched up locks and unlocks correctly. */
 	char line[80];
 	FILE *locks;
@@ -146,13 +176,7 @@ static int fcntl_unlock(struct tdb_context *tdb, int rw, off_t off, off_t len)
 	fclose(locks);
 #endif
 
-	fl.l_type = F_UNLCK;
-	fl.l_whence = SEEK_SET;
-	fl.l_start = off;
-	fl.l_len = len;
-	fl.l_pid = 0;
-
-	return fcntl(tdb->file->fd, F_SETLKW, &fl);
+	return tdb->unlock_fn(tdb->file->fd, rw, off, len, tdb->lock_data);
 }
 
 /* a byte range locking function - return 0 on success
@@ -183,16 +207,13 @@ static enum TDB_ERROR tdb_brlock(struct tdb_context *tdb,
 				  (long long)(offset + len));
 	}
 
-	do {
-		ret = fcntl_lock(tdb, rw_type, offset, len,
-				 flags & TDB_LOCK_WAIT);
-	} while (ret == -1 && errno == EINTR);
-
-	if (ret == -1) {
+	ret = lock(tdb, rw_type, offset, len, flags & TDB_LOCK_WAIT);
+	if (ret != 0) {
 		/* Generic lock error. errno set by fcntl.
 		 * EAGAIN is an expected return from non-blocking
 		 * locks. */
-		if (!(flags & TDB_LOCK_PROBE) && errno != EAGAIN) {
+		if (!(flags & TDB_LOCK_PROBE)
+		    && (errno != EAGAIN && errno != EINTR)) {
 			tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
 				   "tdb_brlock failed (fd=%d) at"
 				   " offset %zu rw_type=%d flags=%d len=%zu:"
@@ -208,23 +229,19 @@ static enum TDB_ERROR tdb_brlock(struct tdb_context *tdb,
 static enum TDB_ERROR tdb_brunlock(struct tdb_context *tdb,
 				   int rw_type, tdb_off_t offset, size_t len)
 {
-	int ret;
-
 	if (tdb->flags & TDB_NOLOCK) {
 		return TDB_SUCCESS;
 	}
 
-	do {
-		ret = fcntl_unlock(tdb, rw_type, offset, len);
-	} while (ret == -1 && errno == EINTR);
+	if (!check_lock_pid(tdb, "tdb_brunlock", true))
+		return TDB_ERR_LOCK;
 
-	/* If we fail, *then* we verify that we owned the lock.  If not, ok. */
-	if (ret == -1 && check_lock_pid(tdb, "tdb_brunlock", false)) {
+	if (unlock(tdb, rw_type, offset, len) == -1) {
 		return tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
 				  "tdb_brunlock failed (fd=%d) at offset %zu"
-				  " rw_type=%d len=%zu",
+				  " rw_type=%d len=%zu: %s",
 				  tdb->file->fd, (size_t)offset, rw_type,
-				  (size_t)len);
+				  (size_t)len, strerror(errno));
 	}
 	return TDB_SUCCESS;
 }
@@ -276,8 +293,11 @@ enum TDB_ERROR tdb_allrecord_upgrade(struct tdb_context *tdb)
 		tv.tv_usec = 1;
 		select(0, NULL, NULL, NULL, &tv);
 	}
-	return tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
-			  "tdb_allrecord_upgrade failed");
+
+	if (errno != EAGAIN && errno != EINTR)
+		tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
+			   "tdb_allrecord_upgrade failed");
+	return TDB_ERR_LOCK;
 }
 
 static struct tdb_lock *find_nestlock(struct tdb_context *tdb, tdb_off_t offset,
@@ -342,7 +362,7 @@ static enum TDB_ERROR tdb_nest_lock(struct tdb_context *tdb,
 		return TDB_ERR_LOCK;
 	}
 
-	add_stat(tdb, locks, 1);
+	tdb->stats.locks++;
 
 	new_lck = find_nestlock(tdb, offset, NULL);
 	if (new_lck) {
@@ -361,12 +381,14 @@ static enum TDB_ERROR tdb_nest_lock(struct tdb_context *tdb,
 		return TDB_SUCCESS;
 	}
 
+#if 0
 	if (tdb->file->num_lockrecs
 	    && offset >= TDB_HASH_LOCK_START
 	    && offset < TDB_HASH_LOCK_START + TDB_HASH_LOCK_RANGE) {
 		return tdb_logerr(tdb, TDB_ERR_LOCK, TDB_LOG_ERROR,
 				  "tdb_nest_lock: already have a hash lock?");
 	}
+#endif
 
 	new_lck = (struct tdb_lock *)realloc(
 		tdb->file->lockrecs,
@@ -550,7 +572,7 @@ enum TDB_ERROR tdb_allrecord_lock(struct tdb_context *tdb, int ltype,
 				  " can't upgrade a write lock");
 	}
 
-	add_stat(tdb, locks, 1);
+	tdb->stats.locks++;
 again:
 	/* Lock hashes, gradually. */
 	ecode = tdb_lock_gradual(tdb, ltype, flags, TDB_HASH_LOCK_START,
@@ -699,7 +721,7 @@ enum TDB_ERROR tdb_lock_hashes(struct tdb_context *tdb,
 			       int ltype, enum tdb_lock_flags waitflag)
 {
 	/* FIXME: Do this properly, using hlock_range */
-	unsigned lock = TDB_HASH_LOCK_START
+	unsigned l = TDB_HASH_LOCK_START
 		+ (hash_lock >> (64 - TDB_HASH_LOCK_RANGE_BITS));
 
 	/* a allrecord lock allows us to avoid per chain locks */
@@ -732,14 +754,14 @@ enum TDB_ERROR tdb_lock_hashes(struct tdb_context *tdb,
 				  " already have expansion lock");
 	}
 
-	return tdb_nest_lock(tdb, lock, ltype, waitflag);
+	return tdb_nest_lock(tdb, l, ltype, waitflag);
 }
 
 enum TDB_ERROR tdb_unlock_hashes(struct tdb_context *tdb,
 				 tdb_off_t hash_lock,
 				 tdb_len_t hash_range, int ltype)
 {
-	unsigned lock = TDB_HASH_LOCK_START
+	unsigned l = TDB_HASH_LOCK_START
 		+ (hash_lock >> (64 - TDB_HASH_LOCK_RANGE_BITS));
 
 	if (tdb->flags & TDB_NOLOCK)
@@ -755,7 +777,7 @@ enum TDB_ERROR tdb_unlock_hashes(struct tdb_context *tdb,
 		return TDB_SUCCESS;
 	}
 
-	return tdb_nest_unlock(tdb, lock, ltype);
+	return tdb_nest_unlock(tdb, l, ltype);
 }
 
 /* Hash locks use TDB_HASH_LOCK_START + the next 30 bits.
@@ -832,6 +854,10 @@ void tdb_lock_cleanup(struct tdb_context *tdb)
 {
 	unsigned int i;
 
+	/* We don't want to warn: they're allowed to close tdb after fork. */
+	if (!check_lock_pid(tdb, "tdb_close", false))
+		return;
+
 	while (tdb->file->allrecord_lock.count
 	       && tdb->file->allrecord_lock.owner == tdb) {
 		tdb_allrecord_unlock(tdb, tdb->file->allrecord_lock.ltype);