liberregxml/src/erregrwlock.c File Reference

liberreg - read and write lock routines More...

#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <glib.h>
#include "erregrwlock.h"
#include "erreglog.h"

Go to the source code of this file.

Defines
#define	LOCK_FILE   "/lockfile"
#define	read_lock()   lock_reg(F_SETLK, F_RDLCK)
#define	readw_lock()   lock_reg(F_SETLKW, F_RDLCK)
#define	write_lock()   lock_reg(F_SETLK, F_WRLCK)
#define	writew_lock()   lock_reg(F_SETLKW, F_WRLCK)
#define	un_lock()   lock_reg(F_SETLK, F_UNLCK)
Functions
static int	lock_reg (int cmd, int type)
gboolean	erRegRWLockInit (void)
void	erRegRWLockDestroy (void)
gboolean	erRegReadLock (void)
gboolean	erRegWriteLock (void)
gboolean	erRegUnlock (void)
lock_state_t	erRegGetLockState (void)
Variables
static int	g_lock_fd = -1
static pthread_mutex_t	g_mutex
static lock_state_t	g_lock_state = lock_none

---

Detailed Description

liberreg - read and write lock routines

Copyright (C) 2007 iRex Technologies B.V. All rights reserved.

Definition in file erregrwlock.c.

---

Define Documentation

#define LOCK_FILE   "/lockfile"

Definition at line 61 of file erregrwlock.c.

 

#define read_lock

(

)

lock_reg(F_SETLK, F_RDLCK)

Definition at line 80 of file erregrwlock.c.

 

#define readw_lock

(

)

lock_reg(F_SETLKW, F_RDLCK)

Definition at line 81 of file erregrwlock.c.

 

#define un_lock

(

)

lock_reg(F_SETLK, F_UNLCK)

Definition at line 84 of file erregrwlock.c.

 

#define write_lock

(

)

lock_reg(F_SETLK, F_WRLCK)

Definition at line 82 of file erregrwlock.c.

 

#define writew_lock

(

)

lock_reg(F_SETLKW, F_WRLCK)

Definition at line 83 of file erregrwlock.c.

---

Function Documentation

lock_state_t erRegGetLockState

(

void

)

inquire current lock state on registry

Definition at line 273 of file erregrwlock.c.

{
    return g_lock_state;
}

gboolean erRegReadLock

(

void

)

put read lock on registry, call it when reading registry notes: don't forget using erRegUnlock() to release the lock afterwards

Definition at line 156 of file erregrwlock.c.

{
    ERREG_RWLOCK_LOGPRINTF("entry");
    g_assert(g_lock_fd >= 0);

    gboolean bRet = FALSE;  // FALSE = error
    int rc;

    // get mutex to block other threads
    rc = pthread_mutex_lock(&g_mutex);
    if (rc != 0)
    {
        // mutex error
        ERREG_RWLOCK_ERRORPRINTF("Could not lock mutex, error [%d] [%s]", rc, strerror(rc));
        g_assert_not_reached();
    }
    else
    {
        // get file lock
        rc = readw_lock();
        if (rc == -1)
        {
            // file lock error
            ERREG_RWLOCK_ERRORPRINTF("Could not lock file, error [%d] [%s]", errno, strerror(errno));
            g_assert_not_reached();
        }
        else
        {
            // file lock obtained
            ERREG_RWLOCK_LOGPRINTF("Obtained RLock.");
            g_lock_state = lock_read;
            bRet = TRUE;  // TRUE = ok
        }
    }

    return bRet;
}

void erRegRWLockDestroy

(

void

)

destroy resource for rwlock when exit an application which calls erRegRWLockInit() before

Definition at line 126 of file erregrwlock.c.

{
    ERREG_RWLOCK_LOGPRINTF("entry");
    g_assert(g_lock_fd >= 0);

    int rc;

    // close file for inter-process locking, this implicitly releases the lock
    rc = close(g_lock_fd);
    if (rc != 0)
    {
        // file error
        ERREG_RWLOCK_ERRORPRINTF("Could not close file, error [%d] [%s]", errno, strerror(errno));
        g_assert_not_reached();
    }
    g_lock_fd = -1;

    // destroy mutex for inter-thread locking
    rc = pthread_mutex_destroy(&(g_mutex));
    if (rc != 0)
    {
        // mutex error
        ERREG_RWLOCK_ERRORPRINTF("Could not destroy mutex, error [%d] [%s]", rc, strerror(rc));
        g_assert_not_reached();
    }

    g_lock_state = lock_none;
}

gboolean erRegRWLockInit

(

void

)

Initilize resource for rwlock when launching an application which wants to access registry

Returns:

TRUE means initialization succeeds, otherwise returns FALSE

Definition at line 88 of file erregrwlock.c.

{
    ERREG_RWLOCK_LOGPRINTF("entry");
    g_assert(g_lock_fd < 0);

    gboolean bRet = FALSE;  // FALSE = error
    int rc;

    // initialise mutex for inter-thread locking
    rc = pthread_mutex_init(&(g_mutex), NULL);
    if (rc != 0)
    {
        // mutex error
        ERREG_RWLOCK_ERRORPRINTF("Could not initialize mutex, error [%d] [%s]", rc, strerror(rc));
        g_assert_not_reached();
    }
    else
    {
        // open file for inter-process locking
        g_lock_fd = open(DATADIR LOCK_FILE, O_RDWR | O_CREAT);
        if (g_lock_fd < 0)
        {
            // file error
            ERREG_RWLOCK_ERRORPRINTF("Could not open file [%s], error [%d] [%s]", DATADIR LOCK_FILE, errno, strerror(errno));
            g_assert_not_reached();
        }
        else
        {
            // filed opened ok
            bRet = TRUE;
        }
    }

    g_lock_state = lock_none;
    return bRet;
}

gboolean erRegUnlock

(

void

)

release lock(read or write) on registry

Definition at line 234 of file erregrwlock.c.

{
    ERREG_RWLOCK_LOGPRINTF("entry");
    g_assert(g_lock_fd >= 0);

    gboolean bRet = FALSE;  // FALSE = error
    int rc;

    // release file lock
    rc = un_lock();
    if (rc == -1)
    {
        // file unlock error
        ERREG_RWLOCK_ERRORPRINTF("Could not release file lock, error [%d] [%s]", errno, strerror(errno));
        g_assert_not_reached();
    }
    else
    {
        // release mutex
        rc = pthread_mutex_unlock(&g_mutex);
        if (rc != 0)
        {
            // mutex error
            ERREG_RWLOCK_ERRORPRINTF("Could not release mutex, error [%d] [%s]", rc, strerror(rc));
            g_assert_not_reached();
        }
        else
        {
            // locks released ok
            ERREG_RWLOCK_LOGPRINTF("Released Lock");
            g_lock_state = lock_none;
            bRet = TRUE;  // TRUE = ok
        }
    }

    return bRet;
}

gboolean erRegWriteLock

(

void

)

put write lock on registry, call it when writing registry notes: don't forget using erRegUnlock() to release the lock afterwards

Definition at line 195 of file erregrwlock.c.

{
    ERREG_RWLOCK_LOGPRINTF("entry");
    g_assert(g_lock_fd >= 0);

    gboolean bRet = FALSE;  // FALSE = error
    int rc;

    // get mutex to block other threads
    rc = pthread_mutex_lock(&g_mutex);
    if (rc != 0)
    {
        // mutex error
        ERREG_RWLOCK_ERRORPRINTF("Could not lock mutex, error [%d] [%s]", rc, strerror(rc));
        g_assert_not_reached();
    }
    else
    {
        // get file lock
        rc = writew_lock();
        if (rc == -1)
        {
            // file lock error
            ERREG_RWLOCK_ERRORPRINTF("Could not lock file, error [%d] [%s]", errno, strerror(errno));
            g_assert_not_reached();
        }
        else
        {
            // file lock obtained
            ERREG_RWLOCK_LOGPRINTF("Obtained WLock");
            g_lock_state = lock_write;
            bRet = TRUE;  // TRUE = ok
        }
    }

    return bRet;
}

static int lock_reg	(	int	cmd,
		int	type
	)			[static]

Definition at line 69 of file erregrwlock.c.

{
    struct flock lock;
    lock.l_type   = type;
    lock.l_start  = 0;
    lock.l_whence = SEEK_SET;
    lock.l_len    = 0;

    return fcntl(g_lock_fd, cmd, &lock);
}

---

Variable Documentation

int g_lock_fd = -1 [static]

Definition at line 64 of file erregrwlock.c.

lock_state_t g_lock_state = lock_none [static]

Definition at line 66 of file erregrwlock.c.

pthread_mutex_t g_mutex [static]

Definition at line 65 of file erregrwlock.c.