Quelle local_lock_internal.h Sprache: C

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_LOCAL_LOCK_H
# error "Do not include directly, include linux/local_lock.h"
#endif

#include <linux/percpu-defs.h>
#include <linux/lockdep.h>

#ifndef CONFIG_PREEMPT_RT

typedef struct {
#ifdef CONFIG_DEBUG_LOCK_ALLOC
struct lockdep_map dep_map;
struct task_struct *owner;
#endif
} local_lock_t;

/* local_trylock() and local_trylock_irqsave() only work with local_trylock_t */
typedef struct {
local_lock_t llock;
u8  acquired;
} local_trylock_t;

#ifdef CONFIG_DEBUG_LOCK_ALLOC
# define LOCAL_LOCK_DEBUG_INIT(lockname)  \
.dep_map = {     \
  .name = #lockname,   \
  .wait_type_inner = LD_WAIT_CONFIG, \
  .lock_type = LD_LOCK_PERCPU,  \
},      \
.owner = NULL,

# define LOCAL_TRYLOCK_DEBUG_INIT(lockname)  \
.llock = { LOCAL_LOCK_DEBUG_INIT((lockname).llock) },

static inline void local_lock_acquire(local_lock_t *l)
{
lock_map_acquire(&l->dep_map);
DEBUG_LOCKS_WARN_ON(l->owner);
l->owner = current;
}

static inline void local_trylock_acquire(local_lock_t *l)
{
lock_map_acquire_try(&l->dep_map);
DEBUG_LOCKS_WARN_ON(l->owner);
l->owner = current;
}

static inline void local_lock_release(local_lock_t *l)
{
DEBUG_LOCKS_WARN_ON(l->owner != current);
l->owner = NULL;
lock_map_release(&l->dep_map);
}

static inline void local_lock_debug_init(local_lock_t *l)
{
l->owner = NULL;
}
#else /* CONFIG_DEBUG_LOCK_ALLOC */
# define LOCAL_LOCK_DEBUG_INIT(lockname)
# define LOCAL_TRYLOCK_DEBUG_INIT(lockname)
static inline void local_lock_acquire(local_lock_t *l) { }
static inline void local_trylock_acquire(local_lock_t *l) { }
static inline void local_lock_release(local_lock_t *l) { }
static inline void local_lock_debug_init(local_lock_t *l) { }
#endif /* !CONFIG_DEBUG_LOCK_ALLOC */

#define INIT_LOCAL_LOCK(lockname) { LOCAL_LOCK_DEBUG_INIT(lockname) }
#define INIT_LOCAL_TRYLOCK(lockname) { LOCAL_TRYLOCK_DEBUG_INIT(lockname) }

#define __local_lock_init(lock)     \
do {        \
static struct lock_class_key __key;   \
        \
debug_check_no_locks_freed((void *)lock, sizeof(*lock));\
lockdep_init_map_type(&(lock)->dep_map, #lock, &__key,  \
         0, LD_WAIT_CONFIG, LD_WAIT_INV, \
         LD_LOCK_PERCPU);   \
local_lock_debug_init(lock);    \
} while (0)

#define __local_trylock_init(lock) __local_lock_init(lock.llock)

#define __spinlock_nested_bh_init(lock)    \
do {        \
static struct lock_class_key __key;   \
        \
debug_check_no_locks_freed((void *)lock, sizeof(*lock));\
lockdep_init_map_type(&(lock)->dep_map, #lock, &__key,  \
         0, LD_WAIT_CONFIG, LD_WAIT_INV, \
         LD_LOCK_NORMAL);   \
local_lock_debug_init(lock);    \
} while (0)

#define __local_lock_acquire(lock)     \
do {        \
  local_trylock_t *tl;     \
  local_lock_t *l;     \
         \
  l = (local_lock_t *)(lock);    \
  tl = (local_trylock_t *)l;    \
  _Generic((lock),     \
   local_trylock_t *: ({    \
    lockdep_assert(tl->acquired == 0); \
    WRITE_ONCE(tl->acquired, 1);  \
   }),      \
   local_lock_t *: (void)0);   \
  local_lock_acquire(l);     \
} while (0)

#define __local_lock(lock)     \
do {       \
  preempt_disable();    \
  __local_lock_acquire(lock);   \
} while (0)

#define __local_lock_irq(lock)     \
do {       \
  local_irq_disable();    \
  __local_lock_acquire(lock);   \
} while (0)

#define __local_lock_irqsave(lock, flags)   \
do {       \
  local_irq_save(flags);    \
  __local_lock_acquire(lock);   \
} while (0)

#define __local_trylock(lock)     \
({       \
  local_trylock_t *tl;    \
        \
  preempt_disable();    \
  tl = (lock);     \
  if (READ_ONCE(tl->acquired)) {   \
   preempt_enable();   \
   tl = NULL;    \
  } else {     \
   WRITE_ONCE(tl->acquired, 1);  \
   local_trylock_acquire(   \
    (local_lock_t *)tl);  \
  }      \
  !!tl;      \
})

#define __local_trylock_irqsave(lock, flags)   \
({       \
  local_trylock_t *tl;    \
        \
  local_irq_save(flags);    \
  tl = (lock);     \
  if (READ_ONCE(tl->acquired)) {   \
   local_irq_restore(flags);  \
   tl = NULL;    \
  } else {     \
   WRITE_ONCE(tl->acquired, 1);  \
   local_trylock_acquire(   \
    (local_lock_t *)tl);  \
  }      \
  !!tl;      \
})

#define __local_lock_release(lock)     \
do {        \
  local_trylock_t *tl;     \
  local_lock_t *l;     \
         \
  l = (local_lock_t *)(lock);    \
  tl = (local_trylock_t *)l;    \
  local_lock_release(l);     \
  _Generic((lock),     \
   local_trylock_t *: ({    \
    lockdep_assert(tl->acquired == 1); \
    WRITE_ONCE(tl->acquired, 0);  \
   }),      \
   local_lock_t *: (void)0);   \
} while (0)

#define __local_unlock(lock)     \
do {       \
  __local_lock_release(lock);   \
  preempt_enable();    \
} while (0)

#define __local_unlock_irq(lock)    \
do {       \
  __local_lock_release(lock);   \
  local_irq_enable();    \
} while (0)

#define __local_unlock_irqrestore(lock, flags)   \
do {       \
  __local_lock_release(lock);   \
  local_irq_restore(flags);   \
} while (0)

#define __local_lock_nested_bh(lock)    \
do {       \
  lockdep_assert_in_softirq();   \
  local_lock_acquire((lock));   \
} while (0)

#define __local_unlock_nested_bh(lock)    \
local_lock_release((lock))

#else /* !CONFIG_PREEMPT_RT */

/*
* On PREEMPT_RT local_lock maps to a per CPU spinlock, which protects the
* critical section while staying preemptible.
*/
typedef spinlock_t local_lock_t;
typedef spinlock_t local_trylock_t;

#define INIT_LOCAL_LOCK(lockname) __LOCAL_SPIN_LOCK_UNLOCKED((lockname))
#define INIT_LOCAL_TRYLOCK(lockname) __LOCAL_SPIN_LOCK_UNLOCKED((lockname))

#define __local_lock_init(l)     \
do {       \
  local_spin_lock_init((l));   \
} while (0)

#define __local_trylock_init(l)   __local_lock_init(l)

#define __local_lock(__lock)     \
do {       \
  migrate_disable();    \
  spin_lock((__lock));    \
} while (0)

#define __local_lock_irq(lock)   __local_lock(lock)

#define __local_lock_irqsave(lock, flags)   \
do {       \
  typecheck(unsigned long, flags);  \
  flags = 0;     \
  __local_lock(lock);    \
} while (0)

#define __local_unlock(__lock)     \
do {       \
  spin_unlock((__lock));    \
  migrate_enable();    \
} while (0)

#define __local_unlock_irq(lock)  __local_unlock(lock)

#define __local_unlock_irqrestore(lock, flags) __local_unlock(lock)

#define __local_lock_nested_bh(lock)    \
do {        \
lockdep_assert_in_softirq_func();   \
spin_lock((lock));     \
} while (0)

#define __local_unlock_nested_bh(lock)    \
do {        \
spin_unlock((lock));     \
} while (0)

#define __local_trylock(lock)     \
({       \
  int __locked;     \
        \
  if (in_nmi() | in_hardirq()) {   \
   __locked = 0;    \
  } else {     \
   migrate_disable();   \
   __locked = spin_trylock((lock)); \
   if (!__locked)    \
    migrate_enable();  \
  }      \
  __locked;     \
})

#define __local_trylock_irqsave(lock, flags)   \
({       \
  typecheck(unsigned long, flags);  \
  flags = 0;     \
  __local_trylock(lock);    \
})

#endif /* CONFIG_PREEMPT_RT */

quality23%

¤ Dauer der Verarbeitung: 0.14 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.