Changeset b5822c2 in rtems-libbsd


Ignore:
Timestamp:
Nov 17, 2017, 9:49:31 AM (19 months ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
eeb3fd5d9b07ac9a2e280cff60a1b762bd273a8d, 1e989998de954bef51e6c19cc3d64d39f32100aa
Children:
c360b1a
Parents:
cc7a8d8
Message:

Revert "SX(9): Implement with reader/writer lock"

This was accidentally committed.

This reverts commit cc7a8d87e7307db738bf39ab1ca3ce1053f1c163.

Files:
3 edited

Legend:

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

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

    rcc7a8d8 rb5822c2  
    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
    4750#endif /* __rtems__ */
    4851/*
  • rtemsbsd/rtems/rtems-kernel-sx.c

    rcc7a8d8 rb5822c2  
    88
    99/*
    10  * Copyright (c) 2009, 2017 embedded brains GmbH.  All rights reserved.
     10 * Copyright (c) 2009-2015 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.
    2017 *
    2118 * Redistribution and use in source and binary forms, with or without
     
    4239
    4340#include <machine/rtems-bsd-kernel-space.h>
    44 #include <machine/rtems-bsd-rwlockimpl.h>
     41#include <machine/rtems-bsd-muteximpl.h>
    4542#include <machine/rtems-bsd-thread.h>
    4643
     
    6360};
    6461
    65 #define sx_xholder(sx) rtems_bsd_rwlock_wowner(&(sx)->rwlock)
    66 
    67 #define sx_recursed(sx) rtems_bsd_rwlock_recursed(&(sx)->rwlock)
     62#define sx_xholder(sx) rtems_bsd_mutex_owner(&(sx)->mutex)
     63
     64#define sx_recursed(sx) rtems_bsd_mutex_recursed(&(sx)->mutex)
    6865
    6966void
     
    7774lock_sx(struct lock_object *lock, uintptr_t how)
    7875{
    79         struct sx *sx;
    80 
    81         sx = (struct sx *)lock;
    82         if (how)
    83                 sx_slock(sx);
    84         else
    85                 sx_xlock(sx);
     76
     77        sx_xlock((struct sx *)lock);
    8678}
    8779
     
    8981unlock_sx(struct lock_object *lock)
    9082{
    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         }
     83
     84        sx_xunlock((struct sx *)lock);
     85        return (0);
    10286}
    10387
     
    119103                flags |= LO_RECURSABLE;
    120104
    121         rtems_bsd_rwlock_init(&sx->lock_object, &sx->rwlock, &lock_class_sx,
     105        rtems_bsd_mutex_init(&sx->lock_object, &sx->mutex, &lock_class_sx,
    122106            description, NULL, flags);
    123107}
     
    127111{
    128112
    129         rtems_bsd_rwlock_destroy(&sx->lock_object, &sx->rwlock);
     113        rtems_bsd_mutex_destroy(&sx->lock_object, &sx->mutex);
    130114}
    131115
     
    133117_sx_xlock(struct sx *sx, int opts, const char *file, int line)
    134118{
    135 
    136         rtems_bsd_rwlock_wlock(&sx->lock_object, &sx->rwlock);
     119        rtems_bsd_mutex_lock(&sx->lock_object, &sx->mutex);
     120
    137121        return (0);
    138122}
     
    141125sx_try_xlock_(struct sx *sx, const char *file, int line)
    142126{
    143 
    144         return (rtems_bsd_rwlock_try_wlock(&sx->lock_object, &sx->rwlock));
     127        return (rtems_bsd_mutex_trylock(&sx->lock_object, &sx->mutex));
    145128}
    146129
     
    148131_sx_xunlock(struct sx *sx, const char *file, int line)
    149132{
    150 
    151         rtems_bsd_rwlock_wunlock(&sx->rwlock);
     133        rtems_bsd_mutex_unlock(&sx->mutex);
    152134}
    153135
     
    155137sx_try_upgrade_(struct sx *sx, const char *file, int line)
    156138{
    157 
    158         return (rtems_bsd_rwlock_try_upgrade(&sx->rwlock));
     139        return (1);
    159140}
    160141
     
    162143sx_downgrade_(struct sx *sx, const char *file, int line)
    163144{
    164 
    165         rtems_bsd_rwlock_downgrade(&sx->rwlock);
    166 }
    167 
    168 int
    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 
    176 int
    177 sx_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 
    183 void
    184 _sx_sunlock(struct sx *sx, const char *file, int line)
    185 {
    186 
    187         rtems_bsd_rwlock_runlock(&sx->rwlock);
     145        /* Do nothing */
    188146}
    189147
     
    197155_sx_assert(const struct sx *sx, int what, const char *file, int line)
    198156{
    199         const char *name = rtems_bsd_rwlock_name(&sx->rwlock);
    200         int slocked = 0;
     157        const char *name = rtems_bsd_mutex_name(&sx->mutex);
    201158
    202159        switch (what) {
     
    204161        case SA_SLOCKED | SA_NOTRECURSED:
    205162        case SA_SLOCKED | SA_RECURSED:
    206                 slocked = 1;
    207                 /* FALLTHROUGH */
    208163        case SA_LOCKED:
    209164        case SA_LOCKED | SA_NOTRECURSED:
    210165        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;
    234166        case SA_XLOCKED:
    235167        case SA_XLOCKED | SA_NOTRECURSED:
    236168        case SA_XLOCKED | SA_RECURSED:
    237169                if (sx_xholder(sx) != _Thread_Get_executing())
    238                         panic("Lock %s not exclusively locked @ %s:%d\n",
    239                             name, file, line);
     170                        panic("Lock %s not exclusively locked @ %s:%d\n", name,
     171                            file, line);
    240172                if (sx_recursed(sx)) {
    241173                        if (what & SA_NOTRECURSED)
    242                                 panic("Lock %s recursed @ %s:%d\n",
    243                                     name, file, line);
     174                                panic("Lock %s recursed @ %s:%d\n", name, file,
     175                                    line);
    244176                } else if (what & SA_RECURSED)
    245                         panic("Lock %s not recursed @ %s:%d\n",
    246                             name, file, line);
     177                        panic("Lock %s not recursed @ %s:%d\n", name, file,
     178                            line);
    247179                break;
    248180        case SA_UNLOCKED:
     181#ifdef WITNESS
     182                witness_assert(&sx->lock_object, what, file, line);
     183#else
    249184                /*
    250185                 * If we hold an exclusve lock fail.  We can't
     
    253188                 */
    254189                if (sx_xholder(sx) == _Thread_Get_executing())
    255                         panic("Lock %s exclusively locked @ %s:%d\n",
    256                             name, file, line);
     190                        panic("Lock %s exclusively locked @ %s:%d\n", name,
     191                            file, line);
     192#endif
    257193                break;
    258194        default:
     
    266202sx_xlocked(struct sx *sx)
    267203{
    268 
    269         return (rtems_bsd_rwlock_wowned(&sx->rwlock));
    270 }
     204        return (rtems_bsd_mutex_owned(&sx->mutex));
     205}
Note: See TracChangeset for help on using the changeset viewer.