liberregxml/inc/erregrwlock.h File Reference

liberreg - read and write lock routines Before accessing registry, you should set lock on registry. using read lock for reading registry using write lock for writing registry More...

#include <glib.h>

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Enumerations
enum	lock_state_t { lock_none, lock_read, lock_write }
Functions
gboolean	erRegRWLockInit (void)
void	erRegRWLockDestroy (void)
gboolean	erRegReadLock (void)
gboolean	erRegWriteLock (void)
gboolean	erRegUnlock (void)
lock_state_t	erRegGetLockState (void)

---

Detailed Description

liberreg - read and write lock routines Before accessing registry, you should set lock on registry. using read lock for reading registry using write lock for writing registry

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

Definition in file erregrwlock.h.

---

Enumeration Type Documentation

enum lock_state_t

Enumerator:

lock_none
lock_read
lock_write

Definition at line 41 of file erregrwlock.h.

        {
            lock_none,
            lock_read,
            lock_write
        } lock_state_t;

---

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;
}