Changeset cc7a8d8 in rtems-libbsd


Ignore:
Timestamp:
Nov 15, 2017, 10:49:09 AM (19 months ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
eeb3fd5d9b07ac9a2e280cff60a1b762bd273a8d, 1e989998de954bef51e6c19cc3d64d39f32100aa
Children:
b5822c2
Parents:
97a98f6
git-author:
Sebastian Huber <sebastian.huber@…> (11/15/17 10:49:09)
git-committer:
Sebastian Huber <sebastian.huber@…> (11/16/17 08:02:28)
Message:

SX(9): Implement with reader/writer lock

Files:
3 edited

Legend:

Unmodified
Added
Removed
  • freebsd/sys/sys/_sx.h

    r97a98f6 rcc7a8d8  
    3232#define _SYS__SX_H_
    3333#ifdef __rtems__
    34 #include <machine/rtems-bsd-mutex.h>
     34#include <machine/rtems-bsd-rwlock.h>
    3535#endif /* __rtems__ */
    3636
     
    4343        volatile uintptr_t      sx_lock;
    4444#else /* __rtems__ */
    45         rtems_bsd_mutex mutex;
     45        rtems_bsd_rwlock        rwlock;
    4646#endif /* __rtems__ */
    4747};
  • freebsd/sys/sys/sx.h

    r97a98f6 rcc7a8d8  
    4545#ifdef __rtems__
    4646#define SX_NOINLINE 1
    47 #define _sx_slock _bsd__sx_xlock
    48 #define sx_try_slock_ _bsd_sx_try_xlock_
    49 #define _sx_sunlock _bsd__sx_xunlock
    5047#endif /* __rtems__ */
    5148/*
  • rtemsbsd/rtems/rtems-kernel-sx.c

    r97a98f6 rcc7a8d8  
    88
    99/*
    10  * Copyright (c) 2009-2015 embedded brains GmbH.  All rights reserved.
     10 * Copyright (c) 2009, 2017 embedded brains GmbH.  All rights reserved.
    1111 *
    1212 *  embedded brains GmbH
     
    1515 *  Germany
    1616 *  <rtems@embedded-brains.de>
     17 *
     18 * Copyright (c) 2006 John Baldwin <jhb@FreeBSD.org>
     19 * All rights reserved.
    1720 *
    1821 * Redistribution and use in source and binary forms, with or without
     
    3942
    4043#include <machine/rtems-bsd-kernel-space.h>
    41 #include <machine/rtems-bsd-muteximpl.h>
     44#include <machine/rtems-bsd-rwlockimpl.h>
    4245#include <machine/rtems-bsd-thread.h>
    4346
     
    6063};
    6164
    62 #define sx_xholder(sx) rtems_bsd_mutex_owner(&(sx)->mutex)
    63 
    64 #define sx_recursed(sx) rtems_bsd_mutex_recursed(&(sx)->mutex)
     65#define sx_xholder(sx) rtems_bsd_rwlock_wowner(&(sx)->rwlock)
     66
     67#define sx_recursed(sx) rtems_bsd_rwlock_recursed(&(sx)->rwlock)
    6568
    6669void
     
    7477lock_sx(struct lock_object *lock, uintptr_t how)
    7578{
    76 
    77         sx_xlock((struct sx *)lock);
     79        struct sx *sx;
     80
     81        sx = (struct sx *)lock;
     82        if (how)
     83                sx_slock(sx);
     84        else
     85                sx_xlock(sx);
    7886}
    7987
     
    8189unlock_sx(struct lock_object *lock)
    8290{
    83 
    84         sx_xunlock((struct sx *)lock);
    85         return (0);
     91        struct sx *sx;
     92
     93        sx = (struct sx *)lock;
     94        sx_assert(sx, SA_LOCKED | SA_NOTRECURSED);
     95        if (sx->rwlock.readers > 0) {
     96                sx_sunlock(sx);
     97                return (1);
     98        } else {
     99                sx_xunlock(sx);
     100                return (0);
     101        }
    86102}
    87103
     
    103119                flags |= LO_RECURSABLE;
    104120
    105         rtems_bsd_mutex_init(&sx->lock_object, &sx->mutex, &lock_class_sx,
     121        rtems_bsd_rwlock_init(&sx->lock_object, &sx->rwlock, &lock_class_sx,
    106122            description, NULL, flags);
    107123}
     
    111127{
    112128
    113         rtems_bsd_mutex_destroy(&sx->lock_object, &sx->mutex);
     129        rtems_bsd_rwlock_destroy(&sx->lock_object, &sx->rwlock);
    114130}
    115131
     
    117133_sx_xlock(struct sx *sx, int opts, const char *file, int line)
    118134{
    119         rtems_bsd_mutex_lock(&sx->lock_object, &sx->mutex);
    120 
     135
     136        rtems_bsd_rwlock_wlock(&sx->lock_object, &sx->rwlock);
    121137        return (0);
    122138}
     
    125141sx_try_xlock_(struct sx *sx, const char *file, int line)
    126142{
    127         return (rtems_bsd_mutex_trylock(&sx->lock_object, &sx->mutex));
     143
     144        return (rtems_bsd_rwlock_try_wlock(&sx->lock_object, &sx->rwlock));
    128145}
    129146
     
    131148_sx_xunlock(struct sx *sx, const char *file, int line)
    132149{
    133         rtems_bsd_mutex_unlock(&sx->mutex);
     150
     151        rtems_bsd_rwlock_wunlock(&sx->rwlock);
    134152}
    135153
     
    137155sx_try_upgrade_(struct sx *sx, const char *file, int line)
    138156{
    139         return (1);
     157
     158        return (rtems_bsd_rwlock_try_upgrade(&sx->rwlock));
    140159}
    141160
     
    143162sx_downgrade_(struct sx *sx, const char *file, int line)
    144163{
    145         /* Do nothing */
     164
     165        rtems_bsd_rwlock_downgrade(&sx->rwlock);
     166}
     167
     168int
     169_sx_slock(struct sx *sx, int opts, const char *file, int line)
     170{
     171
     172        rtems_bsd_rwlock_rlock(&sx->lock_object, &sx->rwlock);
     173        return (0);
     174}
     175
     176int
     177sx_try_slock_(struct sx *sx, const char *file, int line)
     178{
     179
     180        return (rtems_bsd_rwlock_try_rlock(&sx->lock_object, &sx->rwlock));
     181}
     182
     183void
     184_sx_sunlock(struct sx *sx, const char *file, int line)
     185{
     186
     187        rtems_bsd_rwlock_runlock(&sx->rwlock);
    146188}
    147189
     
    155197_sx_assert(const struct sx *sx, int what, const char *file, int line)
    156198{
    157         const char *name = rtems_bsd_mutex_name(&sx->mutex);
     199        const char *name = rtems_bsd_rwlock_name(&sx->rwlock);
     200        int slocked = 0;
    158201
    159202        switch (what) {
     
    161204        case SA_SLOCKED | SA_NOTRECURSED:
    162205        case SA_SLOCKED | SA_RECURSED:
     206                slocked = 1;
     207                /* FALLTHROUGH */
    163208        case SA_LOCKED:
    164209        case SA_LOCKED | SA_NOTRECURSED:
    165210        case SA_LOCKED | SA_RECURSED:
     211                /*
     212                 * If some other thread has an exclusive lock or we
     213                 * have one and are asserting a shared lock, fail.
     214                 * Also, if no one has a lock at all, fail.
     215                 */
     216                if ((sx->rwlock.readers == 0 && sx_xholder(sx) == NULL) ||
     217                    (sx->rwlock.readers == 0 && (slocked ||
     218                    sx_xholder(sx) != _Thread_Get_executing())))
     219                        panic("Lock %s not %slocked @ %s:%d\n",
     220                            name, slocked ? "share " : "",
     221                            file, line);
     222
     223                if (sx->rwlock.readers == 0) {
     224                        if (sx_recursed(sx)) {
     225                                if (what & SA_NOTRECURSED)
     226                                        panic("Lock %s recursed @ %s:%d\n",
     227                                            name, file,
     228                                            line);
     229                        } else if (what & SA_RECURSED)
     230                                panic("Lock %s not recursed @ %s:%d\n",
     231                                    name, file, line);
     232                }
     233                break;
    166234        case SA_XLOCKED:
    167235        case SA_XLOCKED | SA_NOTRECURSED:
    168236        case SA_XLOCKED | SA_RECURSED:
    169237                if (sx_xholder(sx) != _Thread_Get_executing())
    170                         panic("Lock %s not exclusively locked @ %s:%d\n", name,
    171                             file, line);
     238                        panic("Lock %s not exclusively locked @ %s:%d\n",
     239                            name, file, line);
    172240                if (sx_recursed(sx)) {
    173241                        if (what & SA_NOTRECURSED)
    174                                 panic("Lock %s recursed @ %s:%d\n", name, file,
    175                                     line);
     242                                panic("Lock %s recursed @ %s:%d\n",
     243                                    name, file, line);
    176244                } else if (what & SA_RECURSED)
    177                         panic("Lock %s not recursed @ %s:%d\n", name, file,
    178                             line);
     245                        panic("Lock %s not recursed @ %s:%d\n",
     246                            name, file, line);
    179247                break;
    180248        case SA_UNLOCKED:
    181 #ifdef WITNESS
    182                 witness_assert(&sx->lock_object, what, file, line);
    183 #else
    184249                /*
    185250                 * If we hold an exclusve lock fail.  We can't
     
    188253                 */
    189254                if (sx_xholder(sx) == _Thread_Get_executing())
    190                         panic("Lock %s exclusively locked @ %s:%d\n", name,
    191                             file, line);
    192 #endif
     255                        panic("Lock %s exclusively locked @ %s:%d\n",
     256                            name, file, line);
    193257                break;
    194258        default:
     
    202266sx_xlocked(struct sx *sx)
    203267{
    204         return (rtems_bsd_mutex_owned(&sx->mutex));
    205 }
     268
     269        return (rtems_bsd_rwlock_wowned(&sx->rwlock));
     270}
Note: See TracChangeset for help on using the changeset viewer.