1 /* 2 * Polymorphic locking functions (aka poor man templates) 3 * 4 * Copyright Red Hat, Inc. 2017, 2018 5 * 6 * Author: Paolo Bonzini <pbonzini@redhat.com> 7 * 8 * This work is licensed under the terms of the GNU LGPL, version 2 or later. 9 * See the COPYING.LIB file in the top-level directory. 10 * 11 */ 12 13 #ifndef QEMU_LOCKABLE_H 14 #define QEMU_LOCKABLE_H 15 16 #include "qemu/coroutine-core.h" 17 #include "qemu/thread.h" 18 19 typedef void QemuLockUnlockFunc(void *); 20 21 struct QemuLockable { 22 void *object; 23 QemuLockUnlockFunc *lock; 24 QemuLockUnlockFunc *unlock; 25 }; 26 27 static inline __attribute__((__always_inline__)) QemuLockable * 28 qemu_make_lockable(void *x, QemuLockable *lockable) 29 { 30 /* 31 * We cannot test this in a macro, otherwise we get compiler 32 * warnings like "the address of 'm' will always evaluate as 'true'". 33 */ 34 return x ? lockable : NULL; 35 } 36 37 static inline __attribute__((__always_inline__)) QemuLockable * 38 qemu_null_lockable(void *x) 39 { 40 if (x != NULL) { 41 qemu_build_not_reached(); 42 } 43 return NULL; 44 } 45 46 /* 47 * In C, compound literals have the lifetime of an automatic variable. 48 * In C++ it would be different, but then C++ wouldn't need QemuLockable 49 * either... 50 */ 51 #define QML_OBJ_(x, name) (&(QemuLockable) { \ 52 .object = (x), \ 53 .lock = (QemuLockUnlockFunc *) qemu_ ## name ## _lock, \ 54 .unlock = (QemuLockUnlockFunc *) qemu_ ## name ## _unlock \ 55 }) 56 57 /** 58 * QEMU_MAKE_LOCKABLE - Make a polymorphic QemuLockable 59 * 60 * @x: a lock object (currently one of QemuMutex, QemuRecMutex, 61 * CoMutex, QemuSpin). 62 * 63 * Returns a QemuLockable object that can be passed around 64 * to a function that can operate with locks of any kind, or 65 * NULL if @x is %NULL. 66 * 67 * Note the special case for void *, so that we may pass "NULL". 68 */ 69 #define QEMU_MAKE_LOCKABLE(x) \ 70 _Generic((x), QemuLockable *: (x), \ 71 void *: qemu_null_lockable(x), \ 72 QemuMutex *: qemu_make_lockable(x, QML_OBJ_(x, mutex)), \ 73 QemuRecMutex *: qemu_make_lockable(x, QML_OBJ_(x, rec_mutex)), \ 74 CoMutex *: qemu_make_lockable(x, QML_OBJ_(x, co_mutex)), \ 75 QemuSpin *: qemu_make_lockable(x, QML_OBJ_(x, spin))) 76 77 /** 78 * QEMU_MAKE_LOCKABLE_NONNULL - Make a polymorphic QemuLockable 79 * 80 * @x: a lock object (currently one of QemuMutex, QemuRecMutex, 81 * CoMutex, QemuSpin). 82 * 83 * Returns a QemuLockable object that can be passed around 84 * to a function that can operate with locks of any kind. 85 */ 86 #define QEMU_MAKE_LOCKABLE_NONNULL(x) \ 87 _Generic((x), QemuLockable *: (x), \ 88 QemuMutex *: QML_OBJ_(x, mutex), \ 89 QemuRecMutex *: QML_OBJ_(x, rec_mutex), \ 90 CoMutex *: QML_OBJ_(x, co_mutex), \ 91 QemuSpin *: QML_OBJ_(x, spin)) 92 93 static inline void qemu_lockable_lock(QemuLockable *x) 94 { 95 x->lock(x->object); 96 } 97 98 static inline void qemu_lockable_unlock(QemuLockable *x) 99 { 100 x->unlock(x->object); 101 } 102 103 static inline QemuLockable *qemu_lockable_auto_lock(QemuLockable *x) 104 { 105 qemu_lockable_lock(x); 106 return x; 107 } 108 109 static inline void qemu_lockable_auto_unlock(QemuLockable *x) 110 { 111 if (x) { 112 qemu_lockable_unlock(x); 113 } 114 } 115 116 G_DEFINE_AUTOPTR_CLEANUP_FUNC(QemuLockable, qemu_lockable_auto_unlock) 117 118 #define WITH_QEMU_LOCK_GUARD_(x, var) \ 119 for (g_autoptr(QemuLockable) var = \ 120 qemu_lockable_auto_lock(QEMU_MAKE_LOCKABLE_NONNULL((x))); \ 121 var; \ 122 qemu_lockable_auto_unlock(var), var = NULL) 123 124 /** 125 * WITH_QEMU_LOCK_GUARD - Lock a lock object for scope 126 * 127 * @x: a lock object (currently one of QemuMutex, CoMutex, QemuSpin). 128 * 129 * This macro defines a lock scope such that entering the scope takes the lock 130 * and leaving the scope releases the lock. Return statements are allowed 131 * within the scope and release the lock. Break and continue statements leave 132 * the scope early and release the lock. 133 * 134 * WITH_QEMU_LOCK_GUARD(&mutex) { 135 * ... 136 * if (error) { 137 * return; <-- mutex is automatically unlocked 138 * } 139 * 140 * if (early_exit) { 141 * break; <-- leave this scope early 142 * } 143 * ... 144 * } 145 */ 146 #define WITH_QEMU_LOCK_GUARD(x) \ 147 WITH_QEMU_LOCK_GUARD_((x), glue(qemu_lockable_auto, __COUNTER__)) 148 149 /** 150 * QEMU_LOCK_GUARD - Lock an object until the end of the scope 151 * 152 * @x: a lock object (currently one of QemuMutex, CoMutex, QemuSpin). 153 * 154 * This macro takes a lock until the end of the scope. Return statements 155 * release the lock. 156 * 157 * ... <-- mutex not locked 158 * QEMU_LOCK_GUARD(&mutex); <-- mutex locked from here onwards 159 * ... 160 * if (error) { 161 * return; <-- mutex is automatically unlocked 162 * } 163 */ 164 #define QEMU_LOCK_GUARD(x) \ 165 g_autoptr(QemuLockable) \ 166 glue(qemu_lockable_auto, __COUNTER__) G_GNUC_UNUSED = \ 167 qemu_lockable_auto_lock(QEMU_MAKE_LOCKABLE((x))) 168 169 #endif 170