Changeset 10 for trunk/samba-3.0.25pre1/source/tdb/common/lock.c

Timestamp:

Mar 25, 2007, 1:33:05 PM (18 years ago)

Author:

Yuri Dario

Message:

Rewrote of locking code, closes ticket:4.

File:

• trunk/samba-3.0.25pre1/source/tdb/common/lock.c (modified) (8 diffs)

trunk/samba-3.0.25pre1/source/tdb/common/lock.c

@@ -29 +29 @@
 #include "tdb_private.h"
 
+#ifdef __OS2__
+#define INCL_ERRORS
+#define INCL_DOS
+#include <os2.h>
+#endif
+
+#if 0 // for debugging...
+#include "tdb/tools/printf.c" 
+
+#if 0
+#define F_GETLK         7               /* get record locking information */
+#define F_SETLK         8               /* set record locking information */
+#define F_SETLKW        9               /* F_SETLK; wait if blocked */
+#define F_RDLCK         1               /* shared or read lock */
+#define F_UNLCK         2               /* unlock */
+#define F_WRLCK         3               /* exclusive or write lock */
+#endif
+
+static char* lock_type( int lck)
+{
+        static char buffer[16];
+        switch(lck) {
+        case F_GETLK: return "F_GETLK";
+        case F_SETLK: return "F_SETLK";
+        case F_SETLKW: return "F_SETLKW";
+        default:
+                sprintf( buffer, "unknown %d", lck);
+        }
+        return buffer;
+}
+static char* read_type( int rw)
+{
+        static char buffer[16];
+        switch(rw) {
+        case F_RDLCK: return "F_RDLCK";
+        case F_UNLCK: return "F_UNLCK";
+        case F_WRLCK: return "F_WRLCK";
+        default:
+                sprintf( buffer, "unknown %d", rw);
+        }
+        return buffer;
+}
+#endif
+
+#ifdef __OS2__
+
+static int _mutex_brlock(struct tdb_context *tdb, tdb_off_t offset, 
+               int rw_type, int lck_type, int probe, size_t len)
+{
+        HMTX    hSem;
+        ULONG   ulTimeout;
+        APIRET  rc;
+        
+        switch( offset) {
+        case GLOBAL_LOCK:
+                hSem = tdb->hGlobalLock;
+                break;
+        case ACTIVE_LOCK:
+                hSem = tdb->hActiveLock;
+                break;
+        case TRANSACTION_LOCK:
+                hSem = tdb->hTransactionLock;
+                break;
+        default:
+                printf( "_mutex_brlock unknown offset %d\n", offset);
+                exit(1);
+        }
+        if (hSem == 0) {
+                printf( "_mutex_brlock unknown sem handle offset %d\n", offset);
+                exit(1);
+        }
+
+        if (lck_type == F_SETLKW)
+                ulTimeout = SEM_INDEFINITE_WAIT;
+        else
+                ulTimeout = SEM_IMMEDIATE_RETURN;
+
+        switch (rw_type) {
+        case F_UNLCK:
+                rc = DosReleaseMutexSem( hSem);
+                break;
+        case F_RDLCK:
+        case F_WRLCK:
+                rc = DosRequestMutexSem( hSem, ulTimeout);
+                break;
+        default:
+                printf( "_mutex_brlock unknown rw_type request %d\n", rw_type);
+                exit(1);
+                        break;
+        }
+
+        if (rc == NO_ERROR 
+                || rc == ERROR_SEM_OWNER_DIED
+                || rc == ERROR_NOT_OWNER)
+                return 0;
+
+        errno = EINVAL;
+#if 0
+        debug_printf("_mutex_brlock pid %X, failed (fd=%d) at offset %d rw_type=%d lck_type=%d len=%d, rc=%d\n", 
+                 getpid(), tdb->fd, offset, rw_type, lck_type, (int)len, rc);
+#endif
+        return TDB_ERRCODE(TDB_ERR_LOCK, -1);
+}
+
+#endif
+
 /* a byte range locking function - return 0 on success
    this functions locks/unlocks 1 byte at the specified offset.
@@ -40 +146 @@
                int rw_type, int lck_type, int probe, size_t len)
 {
+#ifdef __OS2__
+        APIRET      rc;
+        ULONG       fAccess = 0;
+        int         fLock = 0;
+        ULONG       ulTimeout;
+        off_t       cbFile;
+        off_t       offStart;
+        off_t       cbRange;
+
+        switch( offset) {
+        case GLOBAL_LOCK:
+        case ACTIVE_LOCK:
+        case TRANSACTION_LOCK:
+                return _mutex_brlock( tdb, offset, 
+                rw_type,  lck_type,  probe, len);
+        }
+
+        if (tdb->flags & TDB_NOLOCK) {
+                return 0;
+        }
+
+        if ((rw_type == F_WRLCK) && (tdb->read_only || tdb->traverse_read)) {
+                tdb->ecode = TDB_ERR_RDONLY;
+                return -1;
+        }
+
+#if 0
+        debug_printf("tdb_brlock pid %X, fd %d, lck_type %s, rw_type %s, offset %d, len %d\n",
+                getpid(), tdb->fd, lock_type(lck_type), read_type(rw_type), offset, len);
+#endif
+        
+        /* flags and order */
+        fAccess = 0; /* exclusive */
+        switch (rw_type)
+        {
+                case F_UNLCK:
+                        fLock = 0;
+                        break;
+                case F_RDLCK:
+                case F_WRLCK:
+                        fLock = 1;
+                        break;
+                default:
+                        break;
+        }
+        
+        if (lck_type == F_SETLKW)
+                ulTimeout = SEM_INDEFINITE_WAIT;
+        else
+                ulTimeout = SEM_IMMEDIATE_RETURN;
+        
+        FILELOCK   aflock[2];
+        bzero(&aflock[(fLock + 1) & 1], sizeof(aflock[0]));
+        aflock[fLock].lOffset = offset;
+        aflock[fLock].lRange  = len ? len : LONG_MAX;
+        rc = DosSetFileLocks(tdb->fd, &aflock[0], &aflock[1], SEM_IMMEDIATE_RETURN, fAccess);
+#if 0
+        if (rc != NO_ERROR) {
+                debug_printf("tdb_brlock pid %X, fd %d, rc=%d FAILED\n",
+                        getpid(), tdb->fd, rc);
+        }
+#endif
+        if (rc != NO_ERROR && lck_type == F_SETLKW) {
+#if 0
+                debug_printf("tdb_brlock pid %X, fd %d, rc=%d RETRY WAIT\n",
+                        getpid(), tdb->fd, rc);
+#endif
+                int     count = 10;
+                do {
+                        rc = DosSetFileLocks(tdb->fd, &aflock[0], &aflock[1], 1000, fAccess);
+#if 0
+                        debug_printf("tdb_brlock pid %X, fd %d, rc=%d RETRY WAIT(%d)\n",
+                                getpid(), tdb->fd, rc,count);
+#endif
+                        count--;
+                } while( count>0 && rc !=NO_ERROR);
+
+        }
+        if (rc != NO_ERROR) {
+                errno  = EINVAL;
+                /* Generic lock error. errno set by fcntl.
+                 * EAGAIN is an expected return from non-blocking
+                 * locks. */
+                if (!probe && lck_type != F_SETLK) {
+                        /* Ensure error code is set for log fun to examine. */
+                        tdb->ecode = TDB_ERR_LOCK;
+                        TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock failed (fd=%d) at offset %d rw_type=%d lck_type=%d len=%d\n", 
+                                 tdb->fd, offset, rw_type, lck_type, (int)len));
+                }
+#if 0
+                debug_printf("tdb_brlock pid %X, failed (fd=%d) at offset %d rw_type=%d lck_type=%d len=%d\n", 
+                         getpid(), tdb->fd, offset, rw_type, lck_type, (int)len);
+#endif
+                return TDB_ERRCODE(TDB_ERR_LOCK, -1);
+        }
+#if 0
+        debug_printf("tdb_brlock pid %X, fd %d, lck_type %s, rw_type %s, offset %d, len %d DONE\n",
+                getpid(), tdb->fd, lock_type(lck_type), read_type(rw_type), offset, len);
+#endif
+
+#else
+
         struct flock fl;
         int ret;
@@ -62 +270 @@
         } while (ret == -1 && errno == EINTR);
 
-#ifndef __OS2__
-        /* Sigh - again locking errors on OS/2 */
         if (ret == -1) {
                 /* Generic lock error. errno set by fcntl.
@@ -76 +282 @@
                 return TDB_ERRCODE(TDB_ERR_LOCK, -1);
         }
+
 #endif
         return 0;
@@ -89 +296 @@
 int tdb_brlock_upgrade(struct tdb_context *tdb, tdb_off_t offset, size_t len)
 {
+#ifdef __OS2__
+        // YD we use exclusive locks, no need to upgrade.
+        return 0;
+#else
         int count = 1000;
         while (count--) {
@@ -98 +309 @@
                         break;
                 }
+
                 /* sleep for as short a time as we can - more portable than usleep() */
                 tv.tv_sec = 0;
@@ -103 +315 @@
                 select(0, NULL, NULL, NULL, &tv);
         }
+
         TDB_LOG((tdb, TDB_DEBUG_TRACE,"tdb_brlock_upgrade failed at offset %d\n", offset));
         return -1;
+#endif
 }
 
@@ -414 +628 @@
         return (count == 1 ? tdb->methods->tdb_brlock(tdb, off, F_UNLCK, F_SETLKW, 0, 1) : 0);
 }
+