VirtualBox

Changeset 48940 in vbox for trunk


Ignore:
Timestamp:
Oct 7, 2013 9:26:19 PM (11 years ago)
Author:
vboxsync
Message:

Additions/haiku: Whitespace and svn:keyword cleanups by scm.

Location:
trunk/src/VBox/Additions/haiku
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/haiku/SharedFolders/OpenHashTable.h

    r43364 r48940  
    267267
    268268        if (returnElements)
    269                 {
     269                {
    270270            ValueType** nextPointer = &result;
    271271
    … …  
    348348
    349349    class Iterator
    350         {
     350        {
    351351    public:
    352352        Iterator(const HashTable* table)

  • trunk/src/VBox/Additions/haiku/SharedFolders/kernel_cpp.h

    r43363 r48940  
    4848operator new(size_t size) throw (std::bad_alloc)
    4949{
    50         // we don't actually throw any exceptions, but we have to
    51         // keep the prototype as specified in <new>, or else GCC 3
    52         // won't like us
    53         return malloc(size);
     50        // we don't actually throw any exceptions, but we have to
     51        // keep the prototype as specified in <new>, or else GCC 3
     52        // won't like us
     53        return malloc(size);
    5454}
    5555
    … …  
    5858operator new[](size_t size) throw (std::bad_alloc)
    5959{
    60         return malloc(size);
     60        return malloc(size);
    6161}
    6262
    … …  
    6565operator new(size_t size, const std::nothrow_t &) throw ()
    6666{
    67         return malloc(size);
     67        return malloc(size);
    6868}
    6969
    … …  
    7272operator new[](size_t size, const std::nothrow_t &) throw ()
    7373{
    74         return malloc(size);
     74        return malloc(size);
    7575}
    7676
    … …  
    7979operator new(size_t size, const mynothrow_t &) throw ()
    8080{
    81         return malloc(size);
     81        return malloc(size);
    8282}
    8383
    … …  
    8686operator new[](size_t size, const mynothrow_t &) throw ()
    8787{
    88         return malloc(size);
     88        return malloc(size);
    8989}
    9090
    … …  
    9393operator delete(void *ptr) throw ()
    9494{
    95         free(ptr);
     95        free(ptr);
    9696}
    9797
    … …  
    100100operator delete[](void *ptr) throw ()
    101101{
    102         free(ptr);
     102        free(ptr);
    103103}
    104104
    105 #endif  // #if _KERNEL_MODE
     105#endif  // #if _KERNEL_MODE
    106106
    107 #endif  // __cplusplus
     107#endif  // __cplusplus
    108108
    109 #endif  /* KERNEL_CPP_H */
     109#endif  /* KERNEL_CPP_H */

  • trunk/src/VBox/Additions/haiku/SharedFolders/lock.h

    r43363 r48940  
    3636
    3737typedef struct mutex {
    38         const char*                             name;
    39         struct mutex_waiter*    waiters;
    40 #if KDEBUG
    41         thread_id                               holder;
    42 #else
    43         int32                                   count;
    44         uint16                                  ignore_unlock_count;
    45 #endif
    46         uint8                                   flags;
     38        const char*                             name;
     39        struct mutex_waiter*    waiters;
     40#if KDEBUG
     41        thread_id                               holder;
     42#else
     43        int32                                   count;
     44        uint16                                  ignore_unlock_count;
     45#endif
     46        uint8                                   flags;
    4747} mutex;
    4848
    49 #define MUTEX_FLAG_CLONE_NAME   0x1
     49#define MUTEX_FLAG_CLONE_NAME   0x1
    5050
    5151
    5252typedef struct recursive_lock {
    53         mutex           lock;
     53        mutex           lock;
    5454#if !KDEBUG
    55         thread_id       holder;
    56 #endif
    57         int                     recursion;
     55        thread_id       holder;
     56#endif
     57        int                     recursion;
    5858} recursive_lock;
    5959
    … …  
    6262
    6363typedef struct rw_lock {
    64         const char*                             name;
    65         struct rw_lock_waiter*  waiters;
    66         thread_id                               holder;
    67         vint32                                  count;
    68         int32                                   owner_count;
    69         int16                                   active_readers;
    70                                                                 // Only > 0 while a writer is waiting: number
    71                                                                 // of active readers when the first waiting
    72                                                                 // writer started waiting.
    73         int16                                   pending_readers;
    74                                                                 // Number of readers that have already
    75                                                                 // incremented "count", but have not yet started
    76                                                                 // to wait at the time the last writer unlocked.
    77         uint32                                  flags;
     64        const char*                             name;
     65        struct rw_lock_waiter*  waiters;
     66        thread_id                               holder;
     67        vint32                                  count;
     68        int32                                   owner_count;
     69        int16                                   active_readers;
     70                                                                // Only > 0 while a writer is waiting: number
     71                                                                // of active readers when the first waiting
     72                                                                // writer started waiting.
     73        int16                                   pending_readers;
     74                                                                // Number of readers that have already
     75                                                                // incremented "count", but have not yet started
     76                                                                // to wait at the time the last writer unlocked.
     77        uint32                                  flags;
    7878} rw_lock;
    7979
    80 #define RW_LOCK_WRITER_COUNT_BASE       0x10000
    81 
    82 #define RW_LOCK_FLAG_CLONE_NAME 0x1
    83 
    84 
    85 #if KDEBUG
    86 #       define KDEBUG_RW_LOCK_DEBUG 0
    87                 // Define to 1 if you want to use ASSERT_READ_LOCKED_RW_LOCK().
    88                 // The rw_lock will just behave like a recursive locker then.
    89 #       define ASSERT_LOCKED_RECURSIVE(r) \
    90                 { ASSERT(find_thread(NULL) == (r)->lock.holder); }
    91 #       define ASSERT_LOCKED_MUTEX(m) { ASSERT(find_thread(NULL) == (m)->holder); }
    92 #       define ASSERT_WRITE_LOCKED_RW_LOCK(l) \
    93                 { ASSERT(find_thread(NULL) == (l)->holder); }
    94 #       if KDEBUG_RW_LOCK_DEBUG
    95 #               define ASSERT_READ_LOCKED_RW_LOCK(l) \
    96                         { ASSERT(find_thread(NULL) == (l)->holder); }
    97 #       else
    98 #               define ASSERT_READ_LOCKED_RW_LOCK(l) do {} while (false)
    99 #       endif
    100 #else
    101 #       define ASSERT_LOCKED_RECURSIVE(r)               do {} while (false)
    102 #       define ASSERT_LOCKED_MUTEX(m)                   do {} while (false)
    103 #       define ASSERT_WRITE_LOCKED_RW_LOCK(m)   do {} while (false)
    104 #       define ASSERT_READ_LOCKED_RW_LOCK(l)    do {} while (false)
     80#define RW_LOCK_WRITER_COUNT_BASE       0x10000
     81
     82#define RW_LOCK_FLAG_CLONE_NAME 0x1
     83
     84
     85#if KDEBUG
     86#       define KDEBUG_RW_LOCK_DEBUG 0
     87                // Define to 1 if you want to use ASSERT_READ_LOCKED_RW_LOCK().
     88                // The rw_lock will just behave like a recursive locker then.
     89#       define ASSERT_LOCKED_RECURSIVE(r) \
     90                { ASSERT(find_thread(NULL) == (r)->lock.holder); }
     91#       define ASSERT_LOCKED_MUTEX(m) { ASSERT(find_thread(NULL) == (m)->holder); }
     92#       define ASSERT_WRITE_LOCKED_RW_LOCK(l) \
     93                { ASSERT(find_thread(NULL) == (l)->holder); }
     94#       if KDEBUG_RW_LOCK_DEBUG
     95#               define ASSERT_READ_LOCKED_RW_LOCK(l) \
     96                        { ASSERT(find_thread(NULL) == (l)->holder); }
     97#       else
     98#               define ASSERT_READ_LOCKED_RW_LOCK(l) do {} while (false)
     99#       endif
     100#else
     101#       define ASSERT_LOCKED_RECURSIVE(r)               do {} while (false)
     102#       define ASSERT_LOCKED_MUTEX(m)                   do {} while (false)
     103#       define ASSERT_WRITE_LOCKED_RW_LOCK(m)   do {} while (false)
     104#       define ASSERT_READ_LOCKED_RW_LOCK(l)    do {} while (false)
    105105#endif
    106106
    … …  
    108108// static initializers
    109109#if KDEBUG
    110 #       define MUTEX_INITIALIZER(name)                  { name, NULL, -1, 0 }
    111 #       define RECURSIVE_LOCK_INITIALIZER(name) { MUTEX_INITIALIZER(name), 0 }
    112 #else
    113 #       define MUTEX_INITIALIZER(name)                  { name, NULL, 0, 0, 0 }
    114 #       define RECURSIVE_LOCK_INITIALIZER(name) { MUTEX_INITIALIZER(name), -1, 0 }
    115 #endif
    116 
    117 #define RW_LOCK_INITIALIZER(name)                       { name, NULL, -1, 0, 0, 0 }
    118 
    119 
    120 #if KDEBUG
    121 #       define RECURSIVE_LOCK_HOLDER(recursiveLock)     ((recursiveLock)->lock.holder)
    122 #else
    123 #       define RECURSIVE_LOCK_HOLDER(recursiveLock)     ((recursiveLock)->holder)
     110#       define MUTEX_INITIALIZER(name)                  { name, NULL, -1, 0 }
     111#       define RECURSIVE_LOCK_INITIALIZER(name) { MUTEX_INITIALIZER(name), 0 }
     112#else
     113#       define MUTEX_INITIALIZER(name)                  { name, NULL, 0, 0, 0 }
     114#       define RECURSIVE_LOCK_INITIALIZER(name) { MUTEX_INITIALIZER(name), -1, 0 }
     115#endif
     116
     117#define RW_LOCK_INITIALIZER(name)                       { name, NULL, -1, 0, 0, 0 }
     118
     119
     120#if KDEBUG
     121#       define RECURSIVE_LOCK_HOLDER(recursiveLock)     ((recursiveLock)->lock.holder)
     122#else
     123#       define RECURSIVE_LOCK_HOLDER(recursiveLock)     ((recursiveLock)->holder)
    124124#endif
    125125
    … …  
    129129#endif
    130130
    131 extern void     recursive_lock_init(recursive_lock *lock, const char *name);
    132         // name is *not* cloned nor freed in recursive_lock_destroy()
     131extern void     recursive_lock_init(recursive_lock *lock, const char *name);
     132        // name is *not* cloned nor freed in recursive_lock_destroy()
    133133extern void recursive_lock_init_etc(recursive_lock *lock, const char *name,
    134         uint32 flags);
     134        uint32 flags);
    135135extern void recursive_lock_destroy(recursive_lock *lock);
    136136extern status_t recursive_lock_lock(recursive_lock *lock);
    … …  
    140140
    141141extern void rw_lock_init(rw_lock* lock, const char* name);
    142         // name is *not* cloned nor freed in rw_lock_destroy()
     142        // name is *not* cloned nor freed in rw_lock_destroy()
    143143extern void rw_lock_init_etc(rw_lock* lock, const char* name, uint32 flags);
    144144extern void rw_lock_destroy(rw_lock* lock);
    … …  
    146146
    147147extern void mutex_init(mutex* lock, const char* name);
    148         // name is *not* cloned nor freed in mutex_destroy()
     148        // name is *not* cloned nor freed in mutex_destroy()
    149149extern void mutex_init_etc(mutex* lock, const char* name, uint32 flags);
    150150extern void mutex_destroy(mutex* lock);
    151151extern status_t mutex_switch_lock(mutex* from, mutex* to);
    152         // Unlocks "from" and locks "to" such that unlocking and starting to wait
    153         // for the lock is atomically. I.e. if "from" guards the object "to" belongs
    154         // to, the operation is safe as long as "from" is held while destroying
    155         // "to".
     152        // Unlocks "from" and locks "to" such that unlocking and starting to wait
     153        // for the lock is atomically. I.e. if "from" guards the object "to" belongs
     154        // to, the operation is safe as long as "from" is held while destroying
     155        // "to".
    156156extern status_t mutex_switch_from_read_lock(rw_lock* from, mutex* to);
    157         // Like mutex_switch_lock(), just for a switching from a read-locked
    158         // rw_lock.
     157        // Like mutex_switch_lock(), just for a switching from a read-locked
     158        // rw_lock.
    159159
    160160
    … …  
    163163extern status_t _rw_lock_read_lock(rw_lock* lock);
    164164extern status_t _rw_lock_read_lock_with_timeout(rw_lock* lock,
    165         uint32 timeoutFlags, bigtime_t timeout);
     165        uint32 timeoutFlags, bigtime_t timeout);
    166166extern void _rw_lock_read_unlock(rw_lock* lock, bool threadsLocked);
    167167extern void _rw_lock_write_unlock(rw_lock* lock, bool threadsLocked);
    … …  
    171171extern status_t _mutex_trylock(mutex* lock);
    172172extern status_t _mutex_lock_with_timeout(mutex* lock, uint32 timeoutFlags,
    173         bigtime_t timeout);
     173        bigtime_t timeout);
    174174
    175175
    … …  
    178178{
    179179#if KDEBUG_RW_LOCK_DEBUG
    180         return rw_lock_write_lock(lock);
    181 #else
    182         int32 oldCount = atomic_add(&lock->count, 1);
    183         if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
    184                 return _rw_lock_read_lock(lock);
    185         return B_OK;
     180        return rw_lock_write_lock(lock);
     181#else
     182        int32 oldCount = atomic_add(&lock->count, 1);
     183        if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
     184                return _rw_lock_read_lock(lock);
     185        return B_OK;
    186186#endif
    187187}
    … …  
    190190static inline status_t
    191191rw_lock_read_lock_with_timeout(rw_lock* lock, uint32 timeoutFlags,
    192         bigtime_t timeout)
     192        bigtime_t timeout)
    193193{
    194194#if KDEBUG_RW_LOCK_DEBUG
    195         return mutex_lock_with_timeout(lock, timeoutFlags, timeout);
    196 #else
    197         int32 oldCount = atomic_add(&lock->count, 1);
    198         if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
    199                 return _rw_lock_read_lock_with_timeout(lock, timeoutFlags, timeout);
    200         return B_OK;
     195        return mutex_lock_with_timeout(lock, timeoutFlags, timeout);
     196#else
     197        int32 oldCount = atomic_add(&lock->count, 1);
     198        if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
     199                return _rw_lock_read_lock_with_timeout(lock, timeoutFlags, timeout);
     200        return B_OK;
    201201#endif
    202202}
    … …  
    207207{
    208208#if KDEBUG_RW_LOCK_DEBUG
    209         rw_lock_write_unlock(lock);
    210 #else
    211         int32 oldCount = atomic_add(&lock->count, -1);
    212         if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
    213                 _rw_lock_read_unlock(lock, false);
     209        rw_lock_write_unlock(lock);
     210#else
     211        int32 oldCount = atomic_add(&lock->count, -1);
     212        if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
     213                _rw_lock_read_unlock(lock, false);
    214214#endif
    215215}
    … …  
    219219rw_lock_write_unlock(rw_lock* lock)
    220220{
    221         _rw_lock_write_unlock(lock, false);
     221        _rw_lock_write_unlock(lock, false);
    222222}
    223223
    … …  
    227227{
    228228#if KDEBUG
    229         return _mutex_lock(lock, false);
    230 #else
    231         if (atomic_add(&lock->count, -1) < 0)
    232                 return _mutex_lock(lock, false);
    233         return B_OK;
     229        return _mutex_lock(lock, false);
     230#else
     231        if (atomic_add(&lock->count, -1) < 0)
     232                return _mutex_lock(lock, false);
     233        return B_OK;
    234234#endif
    235235}
    … …  
    240240{
    241241#if KDEBUG
    242         return _mutex_lock(lock, true);
    243 #else
    244         if (atomic_add(&lock->count, -1) < 0)
    245                 return _mutex_lock(lock, true);
    246         return B_OK;
     242        return _mutex_lock(lock, true);
     243#else
     244        if (atomic_add(&lock->count, -1) < 0)
     245                return _mutex_lock(lock, true);
     246        return B_OK;
    247247#endif
    248248}
    … …  
    253253{
    254254#if KDEBUG
    255         return _mutex_trylock(lock);
    256 #else
    257         if (atomic_test_and_set(&lock->count, -1, 0) != 0)
    258                 return B_WOULD_BLOCK;
    259         return B_OK;
     255        return _mutex_trylock(lock);
     256#else
     257        if (atomic_test_and_set(&lock->count, -1, 0) != 0)
     258                return B_WOULD_BLOCK;
     259        return B_OK;
    260260#endif
    261261}
    … …  
    266266{
    267267#if KDEBUG
    268         return _mutex_lock_with_timeout(lock, timeoutFlags, timeout);
    269 #else
    270         if (atomic_add(&lock->count, -1) < 0)
    271                 return _mutex_lock_with_timeout(lock, timeoutFlags, timeout);
    272         return B_OK;
     268        return _mutex_lock_with_timeout(lock, timeoutFlags, timeout);
     269#else
     270        if (atomic_add(&lock->count, -1) < 0)
     271                return _mutex_lock_with_timeout(lock, timeoutFlags, timeout);
     272        return B_OK;
    273273#endif
    274274}
    … …  
    279279{
    280280#if !KDEBUG
    281         if (atomic_add(&lock->count, 1) < -1)
    282 #endif
    283                 _mutex_unlock(lock, false);
     281        if (atomic_add(&lock->count, 1) < -1)
     282#endif
     283                _mutex_unlock(lock, false);
    284284}
    285285
    … …  
    289289{
    290290#if KDEBUG
    291         lock->holder = thread;
     291        lock->holder = thread;
    292292#endif
    293293}
    … …  
    300300#endif
    301301
    302 #endif  /* _KERNEL_LOCK_H */
     302#endif  /* _KERNEL_LOCK_H */

  • trunk/src/VBox/Additions/haiku/include/lock.h

    r43363 r48940  
    2828
    2929/** @todo r=ramshankar: Eventually this file should be shipped by Haiku and
    30  *        should be removed from the VBox tree. */
     30 *        should be removed from the VBox tree. */
    3131
    3232#ifndef _KERNEL_LOCK_H
    … …  
    3939
    4040typedef struct mutex {
    41         const char*                             name;
    42         struct mutex_waiter*    waiters;
    43 #if KDEBUG
    44         thread_id                               holder;
    45 #else
    46         int32                                   count;
    47         uint16                                  ignore_unlock_count;
    48 #endif
    49         uint8                                   flags;
     41        const char*                             name;
     42        struct mutex_waiter*    waiters;
     43#if KDEBUG
     44        thread_id                               holder;
     45#else
     46        int32                                   count;
     47        uint16                                  ignore_unlock_count;
     48#endif
     49        uint8                                   flags;
    5050} mutex;
    5151
    52 #define MUTEX_FLAG_CLONE_NAME   0x1
     52#define MUTEX_FLAG_CLONE_NAME   0x1
    5353
    5454
    5555typedef struct recursive_lock {
    56         mutex           lock;
     56        mutex           lock;
    5757#if !KDEBUG
    58         thread_id       holder;
    59 #endif
    60         int                     recursion;
     58        thread_id       holder;
     59#endif
     60        int                     recursion;
    6161} recursive_lock;
    6262
    … …  
    6565
    6666typedef struct rw_lock {
    67         const char*                             name;
    68         struct rw_lock_waiter*  waiters;
    69         thread_id                               holder;
    70         vint32                                  count;
    71         int32                                   owner_count;
    72         int16                                   active_readers;
    73                                                                 // Only > 0 while a writer is waiting: number
    74                                                                 // of active readers when the first waiting
    75                                                                 // writer started waiting.
    76         int16                                   pending_readers;
    77                                                                 // Number of readers that have already
    78                                                                 // incremented "count", but have not yet started
    79                                                                 // to wait at the time the last writer unlocked.
    80         uint32                                  flags;
     67        const char*                             name;
     68        struct rw_lock_waiter*  waiters;
     69        thread_id                               holder;
     70        vint32                                  count;
     71        int32                                   owner_count;
     72        int16                                   active_readers;
     73                                                                // Only > 0 while a writer is waiting: number
     74                                                                // of active readers when the first waiting
     75                                                                // writer started waiting.
     76        int16                                   pending_readers;
     77                                                                // Number of readers that have already
     78                                                                // incremented "count", but have not yet started
     79                                                                // to wait at the time the last writer unlocked.
     80        uint32                                  flags;
    8181} rw_lock;
    8282
    83 #define RW_LOCK_WRITER_COUNT_BASE       0x10000
    84 
    85 #define RW_LOCK_FLAG_CLONE_NAME 0x1
    86 
    87 
    88 #if KDEBUG
    89 #       define KDEBUG_RW_LOCK_DEBUG 0
    90                 // Define to 1 if you want to use ASSERT_READ_LOCKED_RW_LOCK().
    91                 // The rw_lock will just behave like a recursive locker then.
    92 #       define ASSERT_LOCKED_RECURSIVE(r) \
    93                 { ASSERT(find_thread(NULL) == (r)->lock.holder); }
    94 #       define ASSERT_LOCKED_MUTEX(m) { ASSERT(find_thread(NULL) == (m)->holder); }
    95 #       define ASSERT_WRITE_LOCKED_RW_LOCK(l) \
    96                 { ASSERT(find_thread(NULL) == (l)->holder); }
    97 #       if KDEBUG_RW_LOCK_DEBUG
    98 #               define ASSERT_READ_LOCKED_RW_LOCK(l) \
    99                         { ASSERT(find_thread(NULL) == (l)->holder); }
    100 #       else
    101 #               define ASSERT_READ_LOCKED_RW_LOCK(l) do {} while (false)
    102 #       endif
    103 #else
    104 #       define ASSERT_LOCKED_RECURSIVE(r)               do {} while (false)
    105 #       define ASSERT_LOCKED_MUTEX(m)                   do {} while (false)
    106 #       define ASSERT_WRITE_LOCKED_RW_LOCK(m)   do {} while (false)
    107 #       define ASSERT_READ_LOCKED_RW_LOCK(l)    do {} while (false)
     83#define RW_LOCK_WRITER_COUNT_BASE       0x10000
     84
     85#define RW_LOCK_FLAG_CLONE_NAME 0x1
     86
     87
     88#if KDEBUG
     89#       define KDEBUG_RW_LOCK_DEBUG 0
     90                // Define to 1 if you want to use ASSERT_READ_LOCKED_RW_LOCK().
     91                // The rw_lock will just behave like a recursive locker then.
     92#       define ASSERT_LOCKED_RECURSIVE(r) \
     93                { ASSERT(find_thread(NULL) == (r)->lock.holder); }
     94#       define ASSERT_LOCKED_MUTEX(m) { ASSERT(find_thread(NULL) == (m)->holder); }
     95#       define ASSERT_WRITE_LOCKED_RW_LOCK(l) \
     96                { ASSERT(find_thread(NULL) == (l)->holder); }
     97#       if KDEBUG_RW_LOCK_DEBUG
     98#               define ASSERT_READ_LOCKED_RW_LOCK(l) \
     99                        { ASSERT(find_thread(NULL) == (l)->holder); }
     100#       else
     101#               define ASSERT_READ_LOCKED_RW_LOCK(l) do {} while (false)
     102#       endif
     103#else
     104#       define ASSERT_LOCKED_RECURSIVE(r)               do {} while (false)
     105#       define ASSERT_LOCKED_MUTEX(m)                   do {} while (false)
     106#       define ASSERT_WRITE_LOCKED_RW_LOCK(m)   do {} while (false)
     107#       define ASSERT_READ_LOCKED_RW_LOCK(l)    do {} while (false)
    108108#endif
    109109
    … …  
    111111// static initializers
    112112#if KDEBUG
    113 #       define MUTEX_INITIALIZER(name)                  { name, NULL, -1, 0 }
    114 #       define RECURSIVE_LOCK_INITIALIZER(name) { MUTEX_INITIALIZER(name), 0 }
    115 #else
    116 #       define MUTEX_INITIALIZER(name)                  { name, NULL, 0, 0, 0 }
    117 #       define RECURSIVE_LOCK_INITIALIZER(name) { MUTEX_INITIALIZER(name), -1, 0 }
    118 #endif
    119 
    120 #define RW_LOCK_INITIALIZER(name)                       { name, NULL, -1, 0, 0, 0 }
    121 
    122 
    123 #if KDEBUG
    124 #       define RECURSIVE_LOCK_HOLDER(recursiveLock)     ((recursiveLock)->lock.holder)
    125 #else
    126 #       define RECURSIVE_LOCK_HOLDER(recursiveLock)     ((recursiveLock)->holder)
     113#       define MUTEX_INITIALIZER(name)                  { name, NULL, -1, 0 }
     114#       define RECURSIVE_LOCK_INITIALIZER(name) { MUTEX_INITIALIZER(name), 0 }
     115#else
     116#       define MUTEX_INITIALIZER(name)                  { name, NULL, 0, 0, 0 }
     117#       define RECURSIVE_LOCK_INITIALIZER(name) { MUTEX_INITIALIZER(name), -1, 0 }
     118#endif
     119
     120#define RW_LOCK_INITIALIZER(name)                       { name, NULL, -1, 0, 0, 0 }
     121
     122
     123#if KDEBUG
     124#       define RECURSIVE_LOCK_HOLDER(recursiveLock)     ((recursiveLock)->lock.holder)
     125#else
     126#       define RECURSIVE_LOCK_HOLDER(recursiveLock)     ((recursiveLock)->holder)
    127127#endif
    128128
    … …  
    132132#endif
    133133
    134 extern void     recursive_lock_init(recursive_lock *lock, const char *name);
    135         // name is *not* cloned nor freed in recursive_lock_destroy()
     134extern void     recursive_lock_init(recursive_lock *lock, const char *name);
     135        // name is *not* cloned nor freed in recursive_lock_destroy()
    136136extern void recursive_lock_init_etc(recursive_lock *lock, const char *name,
    137         uint32 flags);
     137        uint32 flags);
    138138extern void recursive_lock_destroy(recursive_lock *lock);
    139139extern status_t recursive_lock_lock(recursive_lock *lock);
    … …  
    143143
    144144extern void rw_lock_init(rw_lock* lock, const char* name);
    145         // name is *not* cloned nor freed in rw_lock_destroy()
     145        // name is *not* cloned nor freed in rw_lock_destroy()
    146146extern void rw_lock_init_etc(rw_lock* lock, const char* name, uint32 flags);
    147147extern void rw_lock_destroy(rw_lock* lock);
    … …  
    149149
    150150extern void mutex_init(mutex* lock, const char* name);
    151         // name is *not* cloned nor freed in mutex_destroy()
     151        // name is *not* cloned nor freed in mutex_destroy()
    152152extern void mutex_init_etc(mutex* lock, const char* name, uint32 flags);
    153153extern void mutex_destroy(mutex* lock);
    154154extern status_t mutex_switch_lock(mutex* from, mutex* to);
    155         // Unlocks "from" and locks "to" such that unlocking and starting to wait
    156         // for the lock is atomically. I.e. if "from" guards the object "to" belongs
    157         // to, the operation is safe as long as "from" is held while destroying
    158         // "to".
     155        // Unlocks "from" and locks "to" such that unlocking and starting to wait
     156        // for the lock is atomically. I.e. if "from" guards the object "to" belongs
     157        // to, the operation is safe as long as "from" is held while destroying
     158        // "to".
    159159extern status_t mutex_switch_from_read_lock(rw_lock* from, mutex* to);
    160         // Like mutex_switch_lock(), just for a switching from a read-locked
    161         // rw_lock.
     160        // Like mutex_switch_lock(), just for a switching from a read-locked
     161        // rw_lock.
    162162
    163163
    … …  
    166166extern status_t _rw_lock_read_lock(rw_lock* lock);
    167167extern status_t _rw_lock_read_lock_with_timeout(rw_lock* lock,
    168         uint32 timeoutFlags, bigtime_t timeout);
     168        uint32 timeoutFlags, bigtime_t timeout);
    169169extern void _rw_lock_read_unlock(rw_lock* lock, bool threadsLocked);
    170170extern void _rw_lock_write_unlock(rw_lock* lock, bool threadsLocked);
    … …  
    174174extern status_t _mutex_trylock(mutex* lock);
    175175extern status_t _mutex_lock_with_timeout(mutex* lock, uint32 timeoutFlags,
    176         bigtime_t timeout);
     176        bigtime_t timeout);
    177177
    178178
    … …  
    181181{
    182182#if KDEBUG_RW_LOCK_DEBUG
    183         return rw_lock_write_lock(lock);
    184 #else
    185         int32 oldCount = atomic_add(&lock->count, 1);
    186         if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
    187                 return _rw_lock_read_lock(lock);
    188         return B_OK;
     183        return rw_lock_write_lock(lock);
     184#else
     185        int32 oldCount = atomic_add(&lock->count, 1);
     186        if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
     187                return _rw_lock_read_lock(lock);
     188        return B_OK;
    189189#endif
    190190}
    … …  
    193193static inline status_t
    194194rw_lock_read_lock_with_timeout(rw_lock* lock, uint32 timeoutFlags,
    195         bigtime_t timeout)
     195        bigtime_t timeout)
    196196{
    197197#if KDEBUG_RW_LOCK_DEBUG
    198         return mutex_lock_with_timeout(lock, timeoutFlags, timeout);
    199 #else
    200         int32 oldCount = atomic_add(&lock->count, 1);
    201         if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
    202                 return _rw_lock_read_lock_with_timeout(lock, timeoutFlags, timeout);
    203         return B_OK;
     198        return mutex_lock_with_timeout(lock, timeoutFlags, timeout);
     199#else
     200        int32 oldCount = atomic_add(&lock->count, 1);
     201        if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
     202                return _rw_lock_read_lock_with_timeout(lock, timeoutFlags, timeout);
     203        return B_OK;
    204204#endif
    205205}
    … …  
    210210{
    211211#if KDEBUG_RW_LOCK_DEBUG
    212         rw_lock_write_unlock(lock);
    213 #else
    214         int32 oldCount = atomic_add(&lock->count, -1);
    215         if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
    216                 _rw_lock_read_unlock(lock, false);
     212        rw_lock_write_unlock(lock);
     213#else
     214        int32 oldCount = atomic_add(&lock->count, -1);
     215        if (oldCount >= RW_LOCK_WRITER_COUNT_BASE)
     216                _rw_lock_read_unlock(lock, false);
    217217#endif
    218218}
    … …  
    222222rw_lock_write_unlock(rw_lock* lock)
    223223{
    224         _rw_lock_write_unlock(lock, false);
     224        _rw_lock_write_unlock(lock, false);
    225225}
    226226
    … …  
    230230{
    231231#if KDEBUG
    232         return _mutex_lock(lock, false);
    233 #else
    234         if (atomic_add(&lock->count, -1) < 0)
    235                 return _mutex_lock(lock, false);
    236         return B_OK;
     232        return _mutex_lock(lock, false);
     233#else
     234        if (atomic_add(&lock->count, -1) < 0)
     235                return _mutex_lock(lock, false);
     236        return B_OK;
    237237#endif
    238238}
    … …  
    243243{
    244244#if KDEBUG
    245         return _mutex_lock(lock, true);
    246 #else
    247         if (atomic_add(&lock->count, -1) < 0)
    248                 return _mutex_lock(lock, true);
    249         return B_OK;
     245        return _mutex_lock(lock, true);
     246#else
     247        if (atomic_add(&lock->count, -1) < 0)
     248                return _mutex_lock(lock, true);
     249        return B_OK;
    250250#endif
    251251}
    … …  
    256256{
    257257#if KDEBUG
    258         return _mutex_trylock(lock);
    259 #else
    260         if (atomic_test_and_set(&lock->count, -1, 0) != 0)
    261                 return B_WOULD_BLOCK;
    262         return B_OK;
     258        return _mutex_trylock(lock);
     259#else
     260        if (atomic_test_and_set(&lock->count, -1, 0) != 0)
     261                return B_WOULD_BLOCK;
     262        return B_OK;
    263263#endif
    264264}
    … …  
    269269{
    270270#if KDEBUG
    271         return _mutex_lock_with_timeout(lock, timeoutFlags, timeout);
    272 #else
    273         if (atomic_add(&lock->count, -1) < 0)
    274                 return _mutex_lock_with_timeout(lock, timeoutFlags, timeout);
    275         return B_OK;
     271        return _mutex_lock_with_timeout(lock, timeoutFlags, timeout);
     272#else
     273        if (atomic_add(&lock->count, -1) < 0)
     274                return _mutex_lock_with_timeout(lock, timeoutFlags, timeout);
     275        return B_OK;
    276276#endif
    277277}
    … …  
    282282{
    283283#if !KDEBUG
    284         if (atomic_add(&lock->count, 1) < -1)
    285 #endif
    286                 _mutex_unlock(lock, false);
     284        if (atomic_add(&lock->count, 1) < -1)
     285#endif
     286                _mutex_unlock(lock, false);
    287287}
    288288
    … …  
    292292{
    293293#if KDEBUG
    294         lock->holder = thread;
     294        lock->holder = thread;
    295295#endif
    296296}
    … …  
    303303#endif
    304304
    305 #endif  /* _KERNEL_LOCK_H */
     305#endif  /* _KERNEL_LOCK_H */
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette