diff --git a/headers/private/kernel/lock.h b/headers/private/kernel/lock.h index 41f50acc2b..2a81321382 100644 --- a/headers/private/kernel/lock.h +++ b/headers/private/kernel/lock.h @@ -1,4 +1,5 @@ /* + * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de. * Copyright 2002-2008, Axel Dörfler, axeld@pinc-software.de. * Distributed under the terms of the MIT License. * @@ -18,11 +19,6 @@ typedef struct recursive_lock { int recursion; } recursive_lock; -typedef struct mutex { - sem_id sem; - thread_id holder; -} mutex; - typedef struct benaphore { sem_id sem; int32 count; @@ -39,31 +35,29 @@ typedef struct rw_lock { #define RW_MAX_READERS 1000000 -struct cutex_waiter; +struct mutex_waiter; -typedef struct cutex { +typedef struct mutex { const char* name; - struct cutex_waiter* waiters; + struct mutex_waiter* waiters; #ifdef KDEBUG thread_id holder; #else int32 count; #endif uint8 flags; -} cutex; +} mutex; -#define CUTEX_FLAG_CLONE_NAME 0x1 +#define MUTEX_FLAG_CLONE_NAME 0x1 #if 0 && KDEBUG // XXX disable this for now, it causes problems when including thread.h here # include #define ASSERT_LOCKED_RECURSIVE(r) { ASSERT(thread_get_current_thread_id() == (r)->holder); } #define ASSERT_LOCKED_MUTEX(m) { ASSERT(thread_get_current_thread_id() == (m)->holder); } -#define ASSERT_LOCKED_CUTEX(m) { ASSERT(thread_get_current_thread_id() == (m)->holder); } #else #define ASSERT_LOCKED_RECURSIVE(r) #define ASSERT_LOCKED_MUTEX(m) -#define ASSERT_LOCKED_CUTEX(m) #endif @@ -77,12 +71,6 @@ extern status_t recursive_lock_lock(recursive_lock *lock); extern void recursive_lock_unlock(recursive_lock *lock); extern int32 recursive_lock_get_recursion(recursive_lock *lock); -extern status_t mutex_init(mutex *m, const char *name); -extern void mutex_destroy(mutex *m); -extern status_t mutex_trylock(mutex *mutex); -extern status_t mutex_lock(mutex *m); -extern void mutex_unlock(mutex *m); - extern status_t benaphore_init(benaphore *ben, const char *name); extern void benaphore_destroy(benaphore *ben); @@ -121,35 +109,48 @@ extern status_t rw_lock_read_unlock(rw_lock *lock); extern status_t rw_lock_write_lock(rw_lock *lock); extern status_t rw_lock_write_unlock(rw_lock *lock); -extern void cutex_init(cutex* lock, const char *name); - // name is *not* cloned nor freed in cutex_destroy() -extern void cutex_init_etc(cutex* lock, const char *name, uint32 flags); -extern void cutex_destroy(cutex* lock); +extern void mutex_init(mutex* lock, const char *name); + // name is *not* cloned nor freed in mutex_destroy() +extern void mutex_init_etc(mutex* lock, const char *name, uint32 flags); +extern void mutex_destroy(mutex* lock); // implementation private: -extern status_t _cutex_lock(cutex* lock); -extern void _cutex_unlock(cutex* lock); -extern status_t _cutex_trylock(cutex* lock); +extern status_t _mutex_lock(mutex* lock, bool threadsLocked); +extern void _mutex_unlock(mutex* lock); +extern status_t _mutex_trylock(mutex* lock); static inline status_t -cutex_lock(cutex* lock) +mutex_lock(mutex* lock) { #ifdef KDEBUG - return _cutex_lock(lock); + return _mutex_lock(lock, false); #else if (atomic_add(&lock->count, -1) < 0) - return _cutex_lock(lock); + return _mutex_lock(lock, false); return B_OK; #endif } static inline status_t -cutex_trylock(cutex* lock) +mutex_lock_threads_locked(mutex* lock) { #ifdef KDEBUG - return _cutex_trylock(lock); + return _mutex_lock(lock, true); +#else + if (atomic_add(&lock->count, -1) < 0) + return _mutex_lock(lock, true); + return B_OK; +#endif +} + + +static inline status_t +mutex_trylock(mutex* lock) +{ +#ifdef KDEBUG + return _mutex_trylock(lock); #else if (atomic_test_and_set(&lock->count, -1, 0) != 0) return B_WOULD_BLOCK; @@ -159,13 +160,13 @@ cutex_trylock(cutex* lock) static inline void -cutex_unlock(cutex* lock) +mutex_unlock(mutex* lock) { #ifdef KDEBUG - _cutex_unlock(lock); + _mutex_unlock(lock); #else if (atomic_add(&lock->count, 1) < -1) - _cutex_unlock(lock); + _mutex_unlock(lock); #endif } diff --git a/headers/private/kernel/thread_types.h b/headers/private/kernel/thread_types.h index f6a774250d..bba4fee42e 100644 --- a/headers/private/kernel/thread_types.h +++ b/headers/private/kernel/thread_types.h @@ -62,7 +62,7 @@ enum { THREAD_BLOCK_TYPE_CONDITION_VARIABLE = 1, THREAD_BLOCK_TYPE_SNOOZE = 2, THREAD_BLOCK_TYPE_SIGNAL = 3, - THREAD_BLOCK_TYPE_CUTEX = 4, + THREAD_BLOCK_TYPE_MUTEX = 4, THREAD_BLOCK_TYPE_OTHER = 9999, THREAD_BLOCK_TYPE_USER_BASE = 10000 diff --git a/headers/private/kernel/util/AutoLock.h b/headers/private/kernel/util/AutoLock.h index 96339d2e30..e51cd88509 100644 --- a/headers/private/kernel/util/AutoLock.h +++ b/headers/private/kernel/util/AutoLock.h @@ -67,24 +67,6 @@ public: // BenaphoreLocker typedef AutoLocker BenaphoreLocker; -// CutexLocking -class CutexLocking { -public: - inline bool Lock(cutex *lockable) - { - cutex_lock(lockable); - return true; - } - - inline void Unlock(cutex *lockable) - { - cutex_unlock(lockable); - } -}; - -// CutexLocker -typedef AutoLocker CutexLocker; - // InterruptsLocking class InterruptsLocking { public: @@ -171,7 +153,6 @@ using BPrivate::AutoLocker; using BPrivate::MutexLocker; using BPrivate::RecursiveLocker; using BPrivate::BenaphoreLocker; -using BPrivate::CutexLocker; using BPrivate::InterruptsLocker; using BPrivate::SpinLocker; using BPrivate::InterruptsSpinLocker; diff --git a/headers/private/kernel/vm_types.h b/headers/private/kernel/vm_types.h index 199210e65e..b9305391a0 100644 --- a/headers/private/kernel/vm_types.h +++ b/headers/private/kernel/vm_types.h @@ -135,7 +135,7 @@ struct vm_dummy_page : vm_page { }; struct vm_cache { - cutex lock; + mutex lock; struct vm_area *areas; vint32 ref_count; struct list_link consumer_link; diff --git a/src/add-ons/kernel/drivers/arch/x86/keyboard/keyboard.c b/src/add-ons/kernel/drivers/arch/x86/keyboard/keyboard.c index b124381438..4654ac5294 100644 --- a/src/add-ons/kernel/drivers/arch/x86/keyboard/keyboard.c +++ b/src/add-ons/kernel/drivers/arch/x86/keyboard/keyboard.c @@ -265,8 +265,7 @@ keyboard_open(const char *name, uint32 flags, void **cookie) if (keyboard_sem < 0) panic("could not create keyboard sem!\n"); - if (mutex_init(&keyboard_read_mutex, "keyboard_read_mutex") < 0) - panic("could not create keyboard read mutex!\n"); + mutex_init(&keyboard_read_mutex, "keyboard_read_mutex"); shift = false; sControl = false; diff --git a/src/add-ons/kernel/drivers/tty/driver.cpp b/src/add-ons/kernel/drivers/tty/driver.cpp index bf25eff7df..fa5e0c87af 100644 --- a/src/add-ons/kernel/drivers/tty/driver.cpp +++ b/src/add-ons/kernel/drivers/tty/driver.cpp @@ -51,25 +51,16 @@ init_driver(void) memset(gDeviceNames, 0, sizeof(gDeviceNames)); - // create the global mutex - status_t error = mutex_init(&gGlobalTTYLock, "tty global"); + // create the request mutex + status_t error = recursive_lock_init(&gTTYRequestLock, "tty requests"); if (error != B_OK) return error; - // create the cookie mutex - error = mutex_init(&gTTYCookieLock, "tty cookies"); - if (error != B_OK) { - mutex_destroy(&gGlobalTTYLock); - return error; - } + // create the global mutex + mutex_init(&gGlobalTTYLock, "tty global"); - // create the request mutex - error = recursive_lock_init(&gTTYRequestLock, "tty requests"); - if (error != B_OK) { - mutex_destroy(&gTTYCookieLock); - mutex_destroy(&gGlobalTTYLock); - return error; - } + // create the cookie mutex + mutex_init(&gTTYCookieLock, "tty cookies"); // create driver name array and initialize basic TTY structures diff --git a/src/add-ons/kernel/drivers/tty/master.cpp b/src/add-ons/kernel/drivers/tty/master.cpp index d7b262a4e4..86e987a62b 100644 --- a/src/add-ons/kernel/drivers/tty/master.cpp +++ b/src/add-ons/kernel/drivers/tty/master.cpp @@ -42,13 +42,9 @@ create_master_cookie(master_cookie *&cookie, struct tty *master, if (cookie == NULL) return B_NO_MEMORY; - status_t error = mutex_init(&cookie->lock, "tty lock"); - if (error != B_OK) { - free(cookie); - return error; - } + mutex_init(&cookie->lock, "tty lock"); - error = init_tty_cookie(cookie, master, slave, openMode); + status_t error = init_tty_cookie(cookie, master, slave, openMode); if (error != B_OK) { mutex_destroy(&cookie->lock); free(cookie); diff --git a/src/add-ons/kernel/drivers/tty/tty.cpp b/src/add-ons/kernel/drivers/tty/tty.cpp index 2b20ee045f..148b7c5809 100644 --- a/src/add-ons/kernel/drivers/tty/tty.cpp +++ b/src/add-ons/kernel/drivers/tty/tty.cpp @@ -1866,7 +1866,7 @@ dump_tty_struct(struct tty& tty) kprintf(" open_count: %ld\n", tty.open_count); kprintf(" select_pool: %p\n", tty.select_pool); kprintf(" pending_eof: %lu\n", tty.pending_eof); - kprintf(" lock.sem: %ld\n", tty.lock->sem); + kprintf(" lock: %ld\n", &tty.lock); kprintf(" input_buffer:\n"); kprintf(" first: %ld\n", tty.input_buffer.first); diff --git a/src/add-ons/kernel/file_cache/log.cpp b/src/add-ons/kernel/file_cache/log.cpp index 257ecc46c7..c426f1f47a 100644 --- a/src/add-ons/kernel/file_cache/log.cpp +++ b/src/add-ons/kernel/file_cache/log.cpp @@ -386,14 +386,12 @@ init_log(void) sLogEntrySem = create_sem(kNumLogEntries, "cache log entries"); if (sLogEntrySem >= B_OK) { - if (mutex_init(&sLock, "log cache module") >= B_OK) { - register_kernel_daemon(log_writer_daemon, NULL, kLogWriterFrequency); - register_generic_syscall(CACHE_LOG_SYSCALLS, log_control, 1, 0); + mutex_init(&sLock, "log cache module"); + register_kernel_daemon(log_writer_daemon, NULL, kLogWriterFrequency); + register_generic_syscall(CACHE_LOG_SYSCALLS, log_control, 1, 0); - TRACE(("** - log init\n")); - return B_OK; - } - delete_sem(sLogEntrySem); + TRACE(("** - log init\n")); + return B_OK; } close(sLogFile); diff --git a/src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp b/src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp index 98e93dfa6b..5e96e280f1 100644 --- a/src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp +++ b/src/add-ons/kernel/network/protocols/tcp/TCPEndpoint.cpp @@ -429,9 +429,6 @@ TCPEndpoint::~TCPEndpoint() status_t TCPEndpoint::InitCheck() const { - if (fLock.sem < B_OK) - return fLock.sem; - if (fReceiveList.InitCheck() < B_OK) return fReceiveList.InitCheck(); @@ -2175,7 +2172,9 @@ TCPEndpoint::Dump() const kprintf("TCP endpoint %p\n", this); kprintf(" state: %s\n", name_for_state(fState)); kprintf(" flags: 0x%lx\n", fFlags); - kprintf(" lock: { sem: %ld, holder: %ld }\n", fLock.sem, fLock.holder); +#ifdef KDEBUG + kprintf(" lock: { %p, holder: %ld }\n", &fLock, fLock.holder); +#endif kprintf(" accept sem: %ld\n", fAcceptSemaphore); kprintf(" options: 0x%lx\n", (uint32)fOptions); kprintf(" send\n"); diff --git a/src/add-ons/kernel/network/protocols/tcp/tcp.cpp b/src/add-ons/kernel/network/protocols/tcp/tcp.cpp index e8b78d6464..48f06fa4d9 100644 --- a/src/add-ons/kernel/network/protocols/tcp/tcp.cpp +++ b/src/add-ons/kernel/network/protocols/tcp/tcp.cpp @@ -721,13 +721,10 @@ tcp_error_reply(net_protocol* protocol, net_buffer* causedError, uint32 code, static status_t tcp_init() { - status_t status = mutex_init(&sEndpointManagersLock, - "endpoint managers lock"); + mutex_init(&sEndpointManagersLock, "endpoint managers lock"); - if (status < B_OK) - return status; - - status = gStackModule->register_domain_protocols(AF_INET, SOCK_STREAM, 0, + status_t status = gStackModule->register_domain_protocols(AF_INET, + SOCK_STREAM, 0, "network/protocols/tcp/v1", "network/protocols/ipv4/v1", NULL); diff --git a/src/libs/compat/freebsd_network/compat/sys/haiku-module.h b/src/libs/compat/freebsd_network/compat/sys/haiku-module.h index 60b0bde683..aa6df2e160 100644 --- a/src/libs/compat/freebsd_network/compat/sys/haiku-module.h +++ b/src/libs/compat/freebsd_network/compat/sys/haiku-module.h @@ -9,7 +9,7 @@ #include #include -#include +#include #include #undef ASSERT diff --git a/src/libs/compat/freebsd_network/mutex.c b/src/libs/compat/freebsd_network/mutex.c index e27c4362cd..326dac2ddd 100644 --- a/src/libs/compat/freebsd_network/mutex.c +++ b/src/libs/compat/freebsd_network/mutex.c @@ -20,8 +20,7 @@ void mtx_init(struct mtx *m, const char *name, const char *type, int opts) { if (opts == MTX_DEF) { - if (mutex_init(&m->u.mutex, name) < B_OK) - panic("Panic! Dance like it's 1979, we ran out of semaphores"); + mutex_init_etc(&m->u.mutex, name, MUTEX_FLAG_CLONE_NAME); } else if (opts == MTX_RECURSE) { if (recursive_lock_init(&m->u.recursive, name) < B_OK) panic("Hell just froze as someone was trying to init a recursive mutex."); diff --git a/src/libs/compat/freebsd_network/taskqueue.c b/src/libs/compat/freebsd_network/taskqueue.c index 1e3c9206da..0d39516e91 100644 --- a/src/libs/compat/freebsd_network/taskqueue.c +++ b/src/libs/compat/freebsd_network/taskqueue.c @@ -45,10 +45,7 @@ _taskqueue_create(const char *name, int mflags, int fast, if (fast) { tq->tq_spinlock = 0; } else { - if (mutex_init(&tq->tq_mutex, name) < B_OK) { - free(tq); - return NULL; - } + mutex_init_etc(&tq->tq_mutex, name, MUTEX_FLAG_CLONE_NAME); } strlcpy(tq->tq_name, name, sizeof(tq->tq_name)); diff --git a/src/system/kernel/Notifications.cpp b/src/system/kernel/Notifications.cpp index e94ada5af7..cdb8a39038 100644 --- a/src/system/kernel/Notifications.cpp +++ b/src/system/kernel/Notifications.cpp @@ -154,9 +154,7 @@ NotificationManager::~NotificationManager() status_t NotificationManager::_Init() { - status_t status = mutex_init(&fLock, "notification manager"); - if (status < B_OK) - return status; + mutex_init(&fLock, "notification manager"); return fServiceHash.InitCheck(); } diff --git a/src/system/kernel/arch/generic/generic_vm_physical_page_mapper.cpp b/src/system/kernel/arch/generic/generic_vm_physical_page_mapper.cpp index d78c87b6ab..a245d12385 100644 --- a/src/system/kernel/arch/generic/generic_vm_physical_page_mapper.cpp +++ b/src/system/kernel/arch/generic/generic_vm_physical_page_mapper.cpp @@ -282,8 +282,7 @@ generic_vm_physical_page_mapper_init(kernel_args *args, memset(virtual_pmappings, 0, sizeof(paddr_chunk_desc *) * num_virtual_chunks); first_free_vmapping = 0; queue_init(&mapped_paddr_lru); - sMutex.sem = -1; - sMutex.holder = -1; + mutex_init(&sMutex, "iospace_mutex"); sChunkAvailableSem = -1; TRACE(("generic_vm_physical_page_mapper_init: done\n")); @@ -332,7 +331,6 @@ generic_vm_physical_page_mapper_init_post_area(kernel_args *args) status_t generic_vm_physical_page_mapper_init_post_sem(kernel_args *args) { - mutex_init(&sMutex, "iospace_mutex"); sChunkAvailableSem = create_sem(1, "iospace chunk available"); return sChunkAvailableSem >= B_OK ? B_OK : sChunkAvailableSem; diff --git a/src/system/kernel/cache/file_cache.cpp b/src/system/kernel/cache/file_cache.cpp index 83375c2687..9d52ed1ba5 100644 --- a/src/system/kernel/cache/file_cache.cpp +++ b/src/system/kernel/cache/file_cache.cpp @@ -119,7 +119,7 @@ reserve_pages(file_cache_ref *ref, size_t reservePages, bool isWrite) { if (vm_low_memory_state() != B_NO_LOW_MEMORY) { vm_cache *cache = ref->cache; - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); if (list_is_empty(&cache->consumers) && cache->areas == NULL && access_is_sequential(ref)) { @@ -153,7 +153,7 @@ reserve_pages(file_cache_ref *ref, size_t reservePages, bool isWrite) } } } - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); } vm_page_reserve_pages(reservePages); @@ -208,7 +208,7 @@ read_into_cache(file_cache_ref *ref, void *cookie, off_t offset, } push_access(ref, offset, bufferSize, false); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_page_unreserve_pages(lastReservedPages); // read file into reserved pages @@ -229,7 +229,7 @@ read_into_cache(file_cache_ref *ref, void *cookie, off_t offset, } } - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); for (int32 i = 0; i < pageIndex; i++) { busyConditions[i].Unpublish(); @@ -263,7 +263,7 @@ read_into_cache(file_cache_ref *ref, void *cookie, off_t offset, } reserve_pages(ref, reservePages, false); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); // make the pages accessible in the cache for (int32 i = pageIndex; i-- > 0;) { @@ -292,7 +292,7 @@ read_from_file(file_cache_ref *ref, void *cookie, off_t offset, vec.iov_len = bufferSize; push_access(ref, offset, bufferSize, false); - cutex_unlock(&ref->cache->lock); + mutex_unlock(&ref->cache->lock); vm_page_unreserve_pages(lastReservedPages); status_t status = vfs_read_pages(ref->vnode, cookie, offset + pageOffset, @@ -300,7 +300,7 @@ read_from_file(file_cache_ref *ref, void *cookie, off_t offset, if (status == B_OK) reserve_pages(ref, reservePages, false); - cutex_lock(&ref->cache->lock); + mutex_lock(&ref->cache->lock); return status; } @@ -351,7 +351,7 @@ write_to_cache(file_cache_ref *ref, void *cookie, off_t offset, } push_access(ref, offset, bufferSize, true); - cutex_unlock(&ref->cache->lock); + mutex_unlock(&ref->cache->lock); vm_page_unreserve_pages(lastReservedPages); // copy contents (and read in partially written pages first) @@ -433,7 +433,7 @@ write_to_cache(file_cache_ref *ref, void *cookie, off_t offset, if (status == B_OK) reserve_pages(ref, reservePages, true); - cutex_lock(&ref->cache->lock); + mutex_lock(&ref->cache->lock); // unmap the pages again @@ -482,7 +482,7 @@ write_to_file(file_cache_ref *ref, void *cookie, off_t offset, int32 pageOffset, vec.iov_len = bufferSize; push_access(ref, offset, bufferSize, true); - cutex_unlock(&ref->cache->lock); + mutex_unlock(&ref->cache->lock); vm_page_unreserve_pages(lastReservedPages); status_t status = B_OK; @@ -508,7 +508,7 @@ write_to_file(file_cache_ref *ref, void *cookie, off_t offset, int32 pageOffset, if (status == B_OK) reserve_pages(ref, reservePages, true); - cutex_lock(&ref->cache->lock); + mutex_lock(&ref->cache->lock); return status; } @@ -604,7 +604,7 @@ cache_io(void *_cacheRef, void *cookie, off_t offset, addr_t buffer, size_t reservePages = 0; reserve_pages(ref, lastReservedPages, doWrite); - CutexLocker locker(cache->lock); + MutexLocker locker(cache->lock); while (bytesLeft > 0) { // check if this page is already in memory @@ -780,7 +780,7 @@ cache_prefetch_vnode(struct vnode *vnode, off_t offset, size_t size) off_t lastOffset = offset; size_t lastSize = 0; - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); for (; bytesLeft > 0; offset += B_PAGE_SIZE) { // check if this page is already in memory @@ -792,9 +792,9 @@ cache_prefetch_vnode(struct vnode *vnode, off_t offset, size_t size) // if busy retry again later ConditionVariableEntry entry; entry.Add(page); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); entry.Wait(); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); goto restart; } @@ -825,7 +825,7 @@ cache_prefetch_vnode(struct vnode *vnode, off_t offset, size_t size) read_into_cache(ref, lastOffset, lastLeft, NULL, 0); out: - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_cache_release_ref(cache); #endif } @@ -985,7 +985,7 @@ file_cache_set_size(void *_cacheRef, off_t newSize) if (ref == NULL) return B_OK; - CutexLocker _(ref->cache->lock); + MutexLocker _(ref->cache->lock); off_t offset = ref->cache->virtual_size; off_t size = newSize; diff --git a/src/system/kernel/fs/IOScheduler.cpp b/src/system/kernel/fs/IOScheduler.cpp index 60efe398b8..b73ab7e076 100644 --- a/src/system/kernel/fs/IOScheduler.cpp +++ b/src/system/kernel/fs/IOScheduler.cpp @@ -66,9 +66,6 @@ IOScheduler::~IOScheduler() status_t IOScheduler::InitCheck() const { - if (fLock.sem < B_OK) - return fLock.sem; - if (fThread < B_OK) return fThread; diff --git a/src/system/kernel/fs/rootfs.cpp b/src/system/kernel/fs/rootfs.cpp index bfc40cde23..e9de8ec64a 100644 --- a/src/system/kernel/fs/rootfs.cpp +++ b/src/system/kernel/fs/rootfs.cpp @@ -357,9 +357,7 @@ rootfs_mount(fs_volume *volume, const char *device, uint32 flags, fs->id = volume->id; fs->next_vnode_id = 1; - err = mutex_init(&fs->lock, "rootfs_mutex"); - if (err < B_OK) - goto err1; + mutex_init(&fs->lock, "rootfs_mutex"); fs->vnode_list_hash = hash_init(ROOTFS_HASH_SIZE, (addr_t)&vnode->all_next - (addr_t)vnode, &rootfs_vnode_compare_func, &rootfs_vnode_hash_func); @@ -388,7 +386,6 @@ err3: hash_uninit(fs->vnode_list_hash); err2: mutex_destroy(&fs->lock); -err1: free(fs); return err; diff --git a/src/system/kernel/fs/vfs.cpp b/src/system/kernel/fs/vfs.cpp index c3f08a81e6..5854e88465 100644 --- a/src/system/kernel/fs/vfs.cpp +++ b/src/system/kernel/fs/vfs.cpp @@ -1514,12 +1514,12 @@ disconnect_mount_or_vnode_fds(struct fs_mount *mount, while (true) { struct io_context *context = NULL; - sem_id contextMutex = -1; + bool contextLocked = false; struct team *team = NULL; team_id lastTeamID; cpu_status state = disable_interrupts(); - GRAB_TEAM_LOCK(); + SpinLocker teamsLock(team_spinlock); lastTeamID = peek_next_thread_id(); if (nextTeamID < lastTeamID) { @@ -1531,12 +1531,20 @@ disconnect_mount_or_vnode_fds(struct fs_mount *mount, if (team) { context = (io_context *)team->io_context; - contextMutex = context->io_mutex.sem; + + // Some acrobatics to lock the context in a safe way + // (cf. _kern_get_next_fd_info() for details). + GRAB_THREAD_LOCK(); + teamsLock.Unlock(); + contextLocked = mutex_lock_threads_locked(&context->io_mutex) + == B_OK; + RELEASE_THREAD_LOCK(); + nextTeamID++; } } - RELEASE_TEAM_LOCK(); + teamsLock.Unlock(); restore_interrupts(state); if (context == NULL) @@ -1546,7 +1554,7 @@ disconnect_mount_or_vnode_fds(struct fs_mount *mount, // safe access to the team structure, we now need to lock the mutex // manually - if (acquire_sem(contextMutex) != B_OK) { + if (!contextLocked) { // team seems to be gone, go over to the next team continue; } @@ -1554,8 +1562,6 @@ disconnect_mount_or_vnode_fds(struct fs_mount *mount, // the team cannot be deleted completely while we're owning its // io_context mutex, so we can safely play with it now - context->io_mutex.holder = thread_get_current_thread_id(); - replace_vnode_if_disconnected(mount, vnodeToDisconnect, context->root, sRoot, true); replace_vnode_if_disconnected(mount, vnodeToDisconnect, context->cwd, @@ -4141,11 +4147,7 @@ vfs_new_io_context(void *_parentContext) + sizeof(struct select_sync*) * tableSize + (tableSize + 7) / 8); - if (mutex_init(&context->io_mutex, "I/O context") < 0) { - free(context->fds); - free(context); - return NULL; - } + mutex_init(&context->io_mutex, "I/O context"); // Copy all parent file descriptors @@ -4403,20 +4405,14 @@ vfs_init(kernel_args *args) sRoot = NULL; - if (mutex_init(&sFileSystemsMutex, "vfs_lock") < 0) - panic("vfs_init: error allocating file systems lock\n"); + mutex_init(&sFileSystemsMutex, "vfs_lock"); if (recursive_lock_init(&sMountOpLock, "vfs_mount_op_lock") < 0) panic("vfs_init: error allocating mount op lock\n"); - if (mutex_init(&sMountMutex, "vfs_mount_lock") < 0) - panic("vfs_init: error allocating mount lock\n"); - - if (mutex_init(&sVnodeCoveredByMutex, "vfs_vnode_covered_by_lock") < 0) - panic("vfs_init: error allocating vnode::covered_by lock\n"); - - if (mutex_init(&sVnodeMutex, "vfs_vnode_lock") < 0) - panic("vfs_init: error allocating vnode lock\n"); + mutex_init(&sMountMutex, "vfs_mount_lock"); + mutex_init(&sVnodeCoveredByMutex, "vfs_vnode_covered_by_lock"); + mutex_init(&sVnodeMutex, "vfs_vnode_lock"); if (benaphore_init(&sIOContextRootLock, "io_context::root lock") < 0) panic("vfs_init: error allocating io_context::root lock\n"); @@ -7000,26 +6996,31 @@ _kern_get_next_fd_info(team_id teamID, uint32 *_cookie, fd_info *info, return B_BAD_VALUE; struct io_context *context = NULL; - sem_id contextMutex = -1; struct team *team = NULL; cpu_status state = disable_interrupts(); GRAB_TEAM_LOCK(); + bool contextLocked = false; team = team_get_team_struct_locked(teamID); if (team) { + // We cannot lock the IO context while holding the team lock, nor can + // we just drop the team lock, since it might be deleted in the + // meantime. team_remove_team() acquires the thread lock when removing + // the team from the team hash table, though. Hence we switch to the + // thread lock and use mutex_lock_threads_locked(). context = (io_context *)team->io_context; - contextMutex = context->io_mutex.sem; - } - RELEASE_TEAM_LOCK(); + GRAB_THREAD_LOCK(); + RELEASE_TEAM_LOCK(); + contextLocked = mutex_lock_threads_locked(&context->io_mutex) == B_OK; + RELEASE_THREAD_LOCK(); + } else + RELEASE_TEAM_LOCK(); + restore_interrupts(state); - // we now have a context - since we couldn't lock it while having - // safe access to the team structure, we now need to lock the mutex - // manually - - if (context == NULL || acquire_sem(contextMutex) != B_OK) { + if (!contextLocked) { // team doesn't exit or seems to be gone return B_BAD_TEAM_ID; } @@ -7027,8 +7028,6 @@ _kern_get_next_fd_info(team_id teamID, uint32 *_cookie, fd_info *info, // the team cannot be deleted completely while we're owning its // io_context mutex, so we can safely play with it now - context->io_mutex.holder = thread_get_current_thread_id(); - uint32 slot = *_cookie; struct file_descriptor *descriptor; diff --git a/src/system/kernel/heap.cpp b/src/system/kernel/heap.cpp index bbf5e81bc0..fff5720fc8 100644 --- a/src/system/kernel/heap.cpp +++ b/src/system/kernel/heap.cpp @@ -469,8 +469,8 @@ heap_validate_heap(heap_allocator *heap) // #pragma mark - Heap functions -heap_allocator * -heap_attach(addr_t base, size_t size, bool postSem) +static heap_allocator * +heap_attach(addr_t base, size_t size) { heap_allocator *heap = (heap_allocator *)base; base += sizeof(heap_allocator); @@ -517,16 +517,7 @@ heap_attach(addr_t base, size_t size, bool postSem) heap->free_pages = &heap->page_table[0]; heap->page_table[0].prev = NULL; - if (postSem) { - if (mutex_init(&heap->lock, "heap_mutex") < 0) { - panic("heap_attach(): error creating heap mutex\n"); - return NULL; - } - } else { - // pre-init the mutex to at least fall through any semaphore calls - heap->lock.sem = -1; - heap->lock.holder = -1; - } + mutex_init(&heap->lock, "heap_mutex"); heap->next = NULL; dprintf("heap_attach: attached to %p - usable range 0x%08lx - 0x%08lx\n", @@ -1014,7 +1005,7 @@ heap_grow_thread(void *) } heap_allocator *newHeap = heap_attach((addr_t)heapAddress, - HEAP_GROW_SIZE, true); + HEAP_GROW_SIZE); if (newHeap == NULL) { panic("heap_grower: could not attach additional heap!\n"); delete_area(heapArea); @@ -1038,7 +1029,7 @@ heap_grow_thread(void *) status_t heap_init(addr_t base, size_t size) { - sHeapList = heap_attach(base, size, false); + sHeapList = heap_attach(base, size); // set up some debug commands add_debugger_command_etc("heap", &dump_heap_list, @@ -1063,12 +1054,6 @@ heap_init(addr_t base, size_t size) status_t heap_init_post_sem() { - // create the lock for the initial heap - if (mutex_init(&sHeapList->lock, "heap_mutex") < B_OK) { - panic("heap_init_post_sem(): error creating heap mutex\n"); - return B_ERROR; - } - sHeapGrowSem = create_sem(0, "heap_grow_sem"); if (sHeapGrowSem < 0) { panic("heap_init_post_sem(): failed to create heap grow sem\n"); @@ -1097,7 +1082,7 @@ heap_init_post_thread() return area; } - sGrowHeap = heap_attach((addr_t)dedicated, HEAP_DEDICATED_GROW_SIZE, true); + sGrowHeap = heap_attach((addr_t)dedicated, HEAP_DEDICATED_GROW_SIZE); if (sGrowHeap == NULL) { panic("heap_init_post_thread(): failed to attach dedicated grow heap\n"); delete_area(area); diff --git a/src/system/kernel/image.c b/src/system/kernel/image.c index c894a0c3a3..20f4ff36a6 100644 --- a/src/system/kernel/image.c +++ b/src/system/kernel/image.c @@ -274,7 +274,8 @@ image_init(void) add_debugger_command("team_images", &dump_images_list, "Dump all registered images from the current team"); #endif - return mutex_init(&sImageMutex, "image"); + mutex_init(&sImageMutex, "image"); + return B_OK; } diff --git a/src/system/kernel/kernel_daemon.c b/src/system/kernel/kernel_daemon.c index 7a57f9a52e..34dc1817f0 100644 --- a/src/system/kernel/kernel_daemon.c +++ b/src/system/kernel/kernel_daemon.c @@ -127,8 +127,7 @@ kernel_daemon_init(void) { thread_id thread; - if (mutex_init(&sDaemonMutex, "kernel daemon") < B_OK) - return B_ERROR; + mutex_init(&sDaemonMutex, "kernel daemon"); list_init(&sDaemons); diff --git a/src/system/kernel/lock.cpp b/src/system/kernel/lock.cpp index 3c26f7160f..cad7328572 100644 --- a/src/system/kernel/lock.cpp +++ b/src/system/kernel/lock.cpp @@ -23,14 +23,14 @@ #include -struct cutex_waiter { +struct mutex_waiter { struct thread* thread; - cutex_waiter* next; // next in queue - cutex_waiter* last; // last in queue (valid for the first in queue) + mutex_waiter* next; // next in queue + mutex_waiter* last; // last in queue (valid for the first in queue) }; -#define CUTEX_FLAG_OWNS_NAME CUTEX_FLAG_CLONE_NAME -#define CUTEX_FLAG_RELEASED 0x2 +#define MUTEX_FLAG_OWNS_NAME MUTEX_FLAG_CLONE_NAME +#define MUTEX_FLAG_RELEASED 0x2 int32 @@ -110,106 +110,6 @@ recursive_lock_unlock(recursive_lock *lock) // #pragma mark - -status_t -mutex_init(mutex *m, const char *name) -{ - if (m == NULL) - return EINVAL; - - if (name == NULL) - name = "mutex_sem"; - - m->holder = -1; - - m->sem = create_sem(1, name); - if (m->sem >= B_OK) - return B_OK; - - return m->sem; -} - - -void -mutex_destroy(mutex *mutex) -{ - if (mutex == NULL) - return; - - if (mutex->sem >= 0) { - delete_sem(mutex->sem); - mutex->sem = -1; - } - mutex->holder = -1; -} - - -status_t -mutex_trylock(mutex *mutex) -{ - thread_id me = thread_get_current_thread_id(); - status_t status; - - if (kernel_startup) - return B_OK; - - status = acquire_sem_etc(mutex->sem, 1, B_RELATIVE_TIMEOUT, 0); - if (status < B_OK) - return status; - - if (me == mutex->holder) { - panic("mutex_trylock failure: mutex %p (sem = 0x%lx) acquired twice by" - " thread 0x%lx\n", mutex, mutex->sem, me); - } - - mutex->holder = me; - return B_OK; -} - - -status_t -mutex_lock(mutex *mutex) -{ - thread_id me = thread_get_current_thread_id(); - status_t status; - - if (kernel_startup) - return B_OK; - - status = acquire_sem(mutex->sem); - if (status < B_OK) - return status; - - if (me == mutex->holder) { - panic("mutex_lock failure: mutex %p (sem = 0x%lx) acquired twice by" - " thread 0x%lx\n", mutex, mutex->sem, me); - } - - mutex->holder = me; - return B_OK; -} - - -void -mutex_unlock(mutex *mutex) -{ - thread_id me = thread_get_current_thread_id(); - - if (kernel_startup) - return; - - if (me != mutex->holder) { - panic("mutex_unlock failure: thread 0x%lx is trying to release mutex %p" - " (current holder 0x%lx)\n", me, mutex, mutex->holder); - } - - mutex->holder = -1; - release_sem_etc(mutex->sem, 1, 0/*B_DO_NOT_RESCHEDULE*/); -} - - -// #pragma mark - - - status_t benaphore_init(benaphore *ben, const char *name) { @@ -299,7 +199,7 @@ rw_lock_write_unlock(rw_lock *lock) void -cutex_init(cutex* lock, const char *name) +mutex_init(mutex* lock, const char *name) { lock->name = name; lock->waiters = NULL; @@ -313,23 +213,23 @@ cutex_init(cutex* lock, const char *name) void -cutex_init_etc(cutex* lock, const char *name, uint32 flags) +mutex_init_etc(mutex* lock, const char *name, uint32 flags) { - lock->name = (flags & CUTEX_FLAG_CLONE_NAME) != 0 ? strdup(name) : name; + lock->name = (flags & MUTEX_FLAG_CLONE_NAME) != 0 ? strdup(name) : name; lock->waiters = NULL; #ifdef KDEBUG lock->holder = -1; #else lock->count = 0; #endif - lock->flags = flags & CUTEX_FLAG_CLONE_NAME; + lock->flags = flags & MUTEX_FLAG_CLONE_NAME; } void -cutex_destroy(cutex* lock) +mutex_destroy(mutex* lock) { - char* name = (lock->flags & CUTEX_FLAG_CLONE_NAME) != 0 + char* name = (lock->flags & MUTEX_FLAG_CLONE_NAME) != 0 ? (char*)lock->name : NULL; // unblock all waiters @@ -338,16 +238,14 @@ cutex_destroy(cutex* lock) #ifdef KDEBUG if (lock->waiters != NULL && thread_get_current_thread_id() != lock->holder) { - panic("cutex_destroy(): there are blocking threads, but caller doesn't " + panic("mutex_destroy(): there are blocking threads, but caller doesn't " "hold the lock (%p)", lock); - locker.Unlock(); - if (_cutex_lock(lock) != B_OK) + if (_mutex_lock(lock, true) != B_OK) return; - locker.Lock(); } #endif - while (cutex_waiter* waiter = lock->waiters) { + while (mutex_waiter* waiter = lock->waiters) { // dequeue lock->waiters = waiter->next; @@ -364,16 +262,17 @@ cutex_destroy(cutex* lock) status_t -_cutex_lock(cutex* lock) +_mutex_lock(mutex* lock, bool threadsLocked) { #ifdef KDEBUG - if (!kernel_startup && !are_interrupts_enabled()) { - panic("_cutex_unlock(): called with interrupts disabled for lock %p", + if (!kernel_startup && !threadsLocked && !are_interrupts_enabled()) { + panic("_mutex_unlock(): called with interrupts disabled for lock %p", lock); } #endif - InterruptsSpinLocker _(thread_spinlock); + // lock only, if !threadsLocked + InterruptsSpinLocker locker(thread_spinlock, false, !threadsLocked); // Might have been released after we decremented the count, but before // we acquired the spinlock. @@ -383,14 +282,14 @@ _cutex_lock(cutex* lock) return B_OK; } #else - if ((lock->flags & CUTEX_FLAG_RELEASED) != 0) { - lock->flags &= ~CUTEX_FLAG_RELEASED; + if ((lock->flags & MUTEX_FLAG_RELEASED) != 0) { + lock->flags &= ~MUTEX_FLAG_RELEASED; return B_OK; } #endif // enqueue in waiter list - cutex_waiter waiter; + mutex_waiter waiter; waiter.thread = thread_get_current_thread(); waiter.next = NULL; @@ -402,7 +301,7 @@ _cutex_lock(cutex* lock) lock->waiters->last = &waiter; // block - thread_prepare_to_block(waiter.thread, 0, THREAD_BLOCK_TYPE_CUTEX, lock); + thread_prepare_to_block(waiter.thread, 0, THREAD_BLOCK_TYPE_MUTEX, lock); status_t error = thread_block_locked(waiter.thread); #ifdef KDEBUG @@ -415,20 +314,20 @@ _cutex_lock(cutex* lock) void -_cutex_unlock(cutex* lock) +_mutex_unlock(mutex* lock) { InterruptsSpinLocker _(thread_spinlock); #ifdef KDEBUG if (thread_get_current_thread_id() != lock->holder) { - panic("_cutex_unlock() failure: thread %ld is trying to release " - "cutex %p (current holder %ld)\n", thread_get_current_thread_id(), + panic("_mutex_unlock() failure: thread %ld is trying to release " + "mutex %p (current holder %ld)\n", thread_get_current_thread_id(), lock, lock->holder); return; } #endif - cutex_waiter* waiter = lock->waiters; + mutex_waiter* waiter = lock->waiters; if (waiter != NULL) { // dequeue the first waiter lock->waiters = waiter->next; @@ -451,14 +350,14 @@ _cutex_unlock(cutex* lock) #ifdef KDEBUG lock->holder = -1; #else - lock->flags |= CUTEX_FLAG_RELEASED; + lock->flags |= MUTEX_FLAG_RELEASED; #endif } } status_t -_cutex_trylock(cutex* lock) +_mutex_trylock(mutex* lock) { #ifdef KDEBUG InterruptsSpinLocker _(thread_spinlock); @@ -473,21 +372,21 @@ _cutex_trylock(cutex* lock) static int -dump_cutex_info(int argc, char** argv) +dump_mutex_info(int argc, char** argv) { if (argc < 2) { print_debugger_command_usage(argv[0]); return 0; } - cutex* lock = (cutex*)strtoul(argv[1], NULL, 0); + mutex* lock = (mutex*)strtoul(argv[1], NULL, 0); if (!IS_KERNEL_ADDRESS(lock)) { kprintf("invalid address: %p\n", lock); return 0; } - kprintf("cutex %p:\n", lock); + kprintf("mutex %p:\n", lock); kprintf(" name: %s\n", lock->name); kprintf(" flags: 0x%x\n", lock->flags); #ifdef KDEBUG @@ -497,7 +396,7 @@ dump_cutex_info(int argc, char** argv) #endif kprintf(" waiting threads:"); - cutex_waiter* waiter = lock->waiters; + mutex_waiter* waiter = lock->waiters; while (waiter != NULL) { kprintf(" %ld", waiter->thread->id); waiter = waiter->next; @@ -514,9 +413,9 @@ dump_cutex_info(int argc, char** argv) void lock_debug_init() { - add_debugger_command_etc("cutex", &dump_cutex_info, - "Dump info about a cutex", - "\n" - "Prints info about the specified cutex.\n" - " - pointer to the cutex to print the info for.\n", 0); + add_debugger_command_etc("mutex", &dump_mutex_info, + "Dump info about a mutex", + "\n" + "Prints info about the specified mutex.\n" + " - pointer to the mutex to print the info for.\n", 0); } diff --git a/src/system/kernel/syscalls.cpp b/src/system/kernel/syscalls.cpp index 6d114d805a..079d4b7376 100644 --- a/src/system/kernel/syscalls.cpp +++ b/src/system/kernel/syscalls.cpp @@ -211,10 +211,7 @@ status_t generic_syscall_init(void) { list_init(&sGenericSyscalls); - if (mutex_init(&sGenericSyscallLock, "generic syscall") != B_OK) { - panic("generic_syscall_init(): mutex init failed"); - return B_ERROR; - } + mutex_init(&sGenericSyscallLock, "generic syscall"); #if SYSCALL_TRACING add_debugger_command_etc("straced", &dump_syscall_tracing, diff --git a/src/system/kernel/thread.cpp b/src/system/kernel/thread.cpp index 303b8e603f..38af02dbb0 100644 --- a/src/system/kernel/thread.cpp +++ b/src/system/kernel/thread.cpp @@ -1145,8 +1145,8 @@ _dump_thread_info(struct thread *thread) kprintf("signal\n"); break; - case THREAD_BLOCK_TYPE_CUTEX: - kprintf("cutex %p\n", thread->wait.object); + case THREAD_BLOCK_TYPE_MUTEX: + kprintf("mutex %p\n", thread->wait.object); break; case THREAD_BLOCK_TYPE_OTHER: @@ -1320,8 +1320,8 @@ dump_thread_list(int argc, char **argv) kprintf("signal "); break; - case THREAD_BLOCK_TYPE_CUTEX: - kprintf("cutex %p ", thread->wait.object); + case THREAD_BLOCK_TYPE_MUTEX: + kprintf("mutex %p ", thread->wait.object); break; case THREAD_BLOCK_TYPE_OTHER: diff --git a/src/system/kernel/util/cbuf.c b/src/system/kernel/util/cbuf.c index aa1028d182..55eccf32cf 100644 --- a/src/system/kernel/util/cbuf.c +++ b/src/system/kernel/util/cbuf.c @@ -950,10 +950,7 @@ cbuf_init(void) // add the debug command add_debugger_command("cbuf_freelist", &dbg_dump_cbuf_freelists, "Dumps the cbuf free lists"); - if (mutex_init(&sFreeBufferListMutex, "cbuf_free_list") < B_OK) { - panic("cbuf_init: error creating cbuf_free_list mutex\n"); - return B_NO_MEMORY; - } + mutex_init(&sFreeBufferListMutex, "cbuf_free_list"); // errors are fatal, that's why we don't clean up here diff --git a/src/system/kernel/vm/vm.cpp b/src/system/kernel/vm/vm.cpp index 6da69d55d1..b936e71f3d 100644 --- a/src/system/kernel/vm/vm.cpp +++ b/src/system/kernel/vm/vm.cpp @@ -1236,7 +1236,7 @@ map_backing_store(vm_address_space *addressSpace, vm_cache *cache, TRACE(("map_backing_store: aspace %p, cache %p, *vaddr %p, offset 0x%Lx, size %lu, addressSpec %ld, wiring %d, protection %d, _area %p, area_name '%s'\n", addressSpace, cache, *_virtualAddress, offset, size, addressSpec, wiring, protection, _area, areaName)); - ASSERT_LOCKED_CUTEX(&cache->lock); + ASSERT_LOCKED_MUTEX(&cache->lock); vm_area *area = create_area_struct(addressSpace, areaName, wiring, protection); @@ -1267,7 +1267,7 @@ map_backing_store(vm_address_space *addressSpace, vm_cache *cache, goto err1; } - cutex_lock(&newCache->lock); + mutex_lock(&newCache->lock); newCache->type = CACHE_TYPE_RAM; newCache->temporary = 1; newCache->scan_skip = cache->scan_skip; @@ -1310,7 +1310,7 @@ map_backing_store(vm_address_space *addressSpace, vm_cache *cache, // point the cache back to the area vm_cache_insert_area_locked(cache, area); if (mapping == REGION_PRIVATE_MAP) - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); // insert the area in the global area hash table acquire_sem_etc(sAreaHashLock, WRITE_COUNT, 0 ,0); @@ -1328,10 +1328,10 @@ err2: // We created this cache, so we must delete it again. Note, that we // need to temporarily unlock the source cache or we'll otherwise // deadlock, since vm_cache_remove_consumer will try to lock it too. - cutex_unlock(&cache->lock); - cutex_unlock(&sourceCache->lock); + mutex_unlock(&cache->lock); + mutex_unlock(&sourceCache->lock); vm_cache_release_ref(cache); - cutex_lock(&sourceCache->lock); + mutex_lock(&sourceCache->lock); } err1: free(area->name); @@ -1525,13 +1525,13 @@ vm_create_anonymous_area(team_id team, const char *name, void **address, break; } - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); status = map_backing_store(addressSpace, cache, address, 0, size, addressSpec, wiring, protection, REGION_NO_PRIVATE_MAP, &area, name, unmapAddressRange); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); if (status < B_OK) { vm_cache_release_ref(cache); @@ -1554,7 +1554,7 @@ vm_create_anonymous_area(team_id team, const char *name, void **address, vm_page_reserve_pages(reservePages); // Allocate and map all pages for this area - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); off_t offset = 0; for (addr_t address = area->base; address < area->base + (area->size - 1); @@ -1579,7 +1579,7 @@ vm_create_anonymous_area(team_id team, const char *name, void **address, vm_map_page(area, page, address, protection); } - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_page_unreserve_pages(reservePages); break; } @@ -1595,7 +1595,7 @@ vm_create_anonymous_area(team_id team, const char *name, void **address, if (!kernel_startup) panic("ALREADY_WIRED flag used outside kernel startup\n"); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); map->ops->lock(map); for (addr_t virtualAddress = area->base; virtualAddress < area->base @@ -1622,7 +1622,7 @@ vm_create_anonymous_area(team_id team, const char *name, void **address, } map->ops->unlock(map); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); break; } @@ -1638,7 +1638,7 @@ vm_create_anonymous_area(team_id team, const char *name, void **address, off_t offset = 0; vm_page_reserve_pages(reservePages); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); map->ops->lock(map); for (virtualAddress = area->base; virtualAddress < area->base @@ -1660,7 +1660,7 @@ vm_create_anonymous_area(team_id team, const char *name, void **address, } map->ops->unlock(map); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_page_unreserve_pages(reservePages); break; } @@ -1739,13 +1739,13 @@ vm_map_physical_memory(team_id team, const char *name, void **_address, cache->type = CACHE_TYPE_DEVICE; cache->virtual_size = size; - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); status_t status = map_backing_store(locker.AddressSpace(), cache, _address, 0, size, addressSpec & ~B_MTR_MASK, B_FULL_LOCK, protection, REGION_NO_PRIVATE_MAP, &area, name, false); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); if (status < B_OK) vm_cache_release_ref(cache); @@ -1821,13 +1821,13 @@ vm_create_null_area(team_id team, const char *name, void **address, cache->type = CACHE_TYPE_NULL; cache->virtual_size = size; - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); status = map_backing_store(locker.AddressSpace(), cache, address, 0, size, addressSpec, 0, B_KERNEL_READ_AREA, REGION_NO_PRIVATE_MAP, &area, name, false); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); if (status < B_OK) { vm_cache_release_ref(cache); @@ -1929,14 +1929,14 @@ _vm_map_file(team_id team, const char *name, void **_address, uint32 addressSpec if (status < B_OK) return status; - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); vm_area *area; status = map_backing_store(locker.AddressSpace(), cache, _address, offset, size, addressSpec, 0, protection, mapping, &area, name, addressSpec == B_EXACT_ADDRESS); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); if (status < B_OK || mapping == REGION_PRIVATE_MAP) { // map_backing_store() cannot know we no longer need the ref @@ -1971,14 +1971,14 @@ vm_area_get_locked_cache(vm_area *area) vm_cache_acquire_ref(cache); locker.Unlock(); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); locker.Lock(); if (cache == area->cache) return cache; // the cache changed in the meantime - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_cache_release_ref(cache); } } @@ -1987,7 +1987,7 @@ vm_area_get_locked_cache(vm_area *area) void vm_area_put_locked_cache(vm_cache *cache) { - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_cache_release_ref(cache); } @@ -2207,7 +2207,7 @@ vm_copy_on_write_area(vm_cache* lowerCache) return B_NO_MEMORY; } - cutex_lock(&upperCache->lock); + mutex_lock(&upperCache->lock); upperCache->type = CACHE_TYPE_RAM; upperCache->temporary = 1; @@ -3852,10 +3852,10 @@ retry: vm_cache_acquire_ref(source); - cutex_lock(&source->lock); + mutex_lock(&source->lock); if (source->busy) { - cutex_unlock(&source->lock); + mutex_unlock(&source->lock); vm_cache_release_ref(source); goto retry; } @@ -3889,7 +3889,7 @@ fault_remove_dummy_page(vm_dummy_page &dummyPage, bool isLocked) { vm_cache *cache = dummyPage.cache; if (!isLocked) - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); if (dummyPage.state == PAGE_STATE_BUSY) { vm_cache_remove_page(cache, &dummyPage); @@ -3898,7 +3898,7 @@ fault_remove_dummy_page(vm_dummy_page &dummyPage, bool isLocked) } if (!isLocked) - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_cache_release_ref(cache); } @@ -3923,7 +3923,7 @@ fault_find_page(vm_translation_map *map, vm_cache *topCache, vm_page *page = NULL; vm_cache_acquire_ref(cache); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); // we release this later in the loop while (cache != NULL) { @@ -3947,9 +3947,9 @@ fault_find_page(vm_translation_map *map, vm_cache *topCache, { ConditionVariableEntry entry; entry.Add(page); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); entry.Wait(); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); } if (cache->busy) { @@ -3958,7 +3958,7 @@ fault_find_page(vm_translation_map *map, vm_cache *topCache, // the top cache. ConditionVariableEntry entry; entry.Add(cache); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_cache_release_ref(cache); entry.Wait(); *_restart = true; @@ -3982,7 +3982,7 @@ fault_find_page(vm_translation_map *map, vm_cache *topCache, ConditionVariable busyCondition; busyCondition.Publish(page, "page"); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); // get a virtual address for the page iovec vec; @@ -3997,7 +3997,7 @@ fault_find_page(vm_translation_map *map, vm_cache *topCache, map->ops->put_physical_page((addr_t)vec.iov_base); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); if (status < B_OK) { // on error remove and free the page @@ -4008,7 +4008,7 @@ fault_find_page(vm_translation_map *map, vm_cache *topCache, vm_cache_remove_page(cache, page); vm_page_set_state(page, PAGE_STATE_FREE); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_cache_release_ref(cache); return status; } @@ -4031,16 +4031,16 @@ fault_find_page(vm_translation_map *map, vm_cache *topCache, // the source cache is currently in the process of being merged // with his only consumer (cacheRef); since its pages are moved // upwards, too, we try this cache again - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); thread_yield(true); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); if (cache->busy) { // The cache became busy, which means, it is about to be // removed by vm_cache_remove_consumer(). We start again with // the top cache. ConditionVariableEntry entry; entry.Add(cache); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_cache_release_ref(cache); entry.Wait(); *_restart = true; @@ -4051,7 +4051,7 @@ fault_find_page(vm_translation_map *map, vm_cache *topCache, } else if (status < B_OK) nextCache = NULL; - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); // at this point, we still hold a ref to this cache (through lastCacheRef) cache = nextCache; @@ -4066,7 +4066,7 @@ fault_find_page(vm_translation_map *map, vm_cache *topCache, // Read-only pages come in the deepest cache - only the // top most cache may have direct write access. vm_cache_acquire_ref(cache); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); if (cache->busy) { // The cache became busy, which means, it is about to be @@ -4074,7 +4074,7 @@ fault_find_page(vm_translation_map *map, vm_cache *topCache, // the top cache. ConditionVariableEntry entry; entry.Add(cache); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_cache_release_ref(cache); entry.Wait(); *_restart = true; @@ -4085,7 +4085,7 @@ fault_find_page(vm_translation_map *map, vm_cache *topCache, // for, but it could as well be a dummy page from someone // else or an otherwise busy page. We can't really handle // that here. Hence we completely restart this functions. - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_cache_release_ref(cache); *_restart = true; } @@ -4128,7 +4128,7 @@ fault_get_page(vm_translation_map *map, vm_cache *topCache, off_t cacheOffset, break; // Remove the dummy page, if it has been inserted. - cutex_lock(&topCache->lock); + mutex_lock(&topCache->lock); if (dummyPage.state == PAGE_STATE_BUSY) { ASSERT_PRINT(dummyPage.cache == topCache, "dummy page: %p\n", @@ -4136,7 +4136,7 @@ fault_get_page(vm_translation_map *map, vm_cache *topCache, off_t cacheOffset, fault_remove_dummy_page(dummyPage, true); } - cutex_unlock(&topCache->lock); + mutex_unlock(&topCache->lock); } if (page == NULL) { @@ -4175,9 +4175,9 @@ fault_get_page(vm_translation_map *map, vm_cache *topCache, off_t cacheOffset, // This is not the top cache into which we inserted the dummy page, // let's remove it from there. We need to temporarily unlock our // cache to comply with the cache locking policy. - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); fault_remove_dummy_page(dummyPage, false); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); } } @@ -4225,8 +4225,8 @@ if (cacheOffset == 0x12000) if (sourcePage->state != PAGE_STATE_MODIFIED) vm_page_set_state(sourcePage, PAGE_STATE_ACTIVE); - cutex_unlock(&cache->lock); - cutex_lock(&topCache->lock); + mutex_unlock(&cache->lock); + mutex_lock(&topCache->lock); // Since the top cache has been unlocked for a while, someone else // (vm_cache_remove_consumer()) might have replaced our dummy page. @@ -4244,9 +4244,9 @@ if (cacheOffset == 0x12000) // The page is busy, wait till it becomes unbusy. ConditionVariableEntry entry; entry.Add(newPage); - cutex_unlock(&topCache->lock); + mutex_unlock(&topCache->lock); entry.Wait(); - cutex_lock(&topCache->lock); + mutex_lock(&topCache->lock); } if (newPage) { @@ -4358,7 +4358,7 @@ vm_soft_fault(addr_t originalAddress, bool isWrite, bool isUser) } } - cutex_unlock(&topCache->lock); + mutex_unlock(&topCache->lock); // The top most cache has no fault handler, so let's see if the cache or its sources // already have the page we're searching for (we're going from top to bottom) @@ -4408,7 +4408,7 @@ vm_soft_fault(addr_t originalAddress, bool isWrite, bool isUser) vm_map_page(area, page, address, newProtection); - cutex_unlock(&pageSource->lock); + mutex_unlock(&pageSource->lock); vm_cache_release_ref(pageSource); } diff --git a/src/system/kernel/vm/vm_cache.cpp b/src/system/kernel/vm/vm_cache.cpp index 0a61fbf394..cfdba6bbc1 100644 --- a/src/system/kernel/vm/vm_cache.cpp +++ b/src/system/kernel/vm/vm_cache.cpp @@ -159,7 +159,7 @@ delete_cache(vm_cache* cache) if (cache->source) vm_cache_remove_consumer(cache->source, cache); - cutex_destroy(&cache->lock); + mutex_destroy(&cache->lock); free(cache); } @@ -194,7 +194,7 @@ vm_cache_create(vm_store* store) if (cache == NULL) return NULL; - cutex_init(&cache->lock, "vm_cache"); + mutex_init(&cache->lock, "vm_cache"); list_init_etc(&cache->consumers, offsetof(vm_cache, consumer_link)); cache->page_list = NULL; cache->areas = NULL; @@ -265,7 +265,7 @@ vm_cache_release_ref(vm_cache* cache) vm_cache* c; bool locked = false; if (cacheRef->lock.holder != find_thread(NULL)) { - cutex_lock(&cacheRef->lock); + mutex_lock(&cacheRef->lock); locked = true; } for (a = cacheRef->areas; a != NULL; a = a->cache_next) @@ -278,7 +278,7 @@ vm_cache_release_ref(vm_cache* cache) if (cacheRef->ref_count < min) panic("cache_ref %p has too little ref_count!!!!", cacheRef); if (locked) - cutex_unlock(&cacheRef->lock); + mutex_unlock(&cacheRef->lock); } #endif return; @@ -310,7 +310,7 @@ vm_cache_acquire_page_cache_ref(vm_page* page) vm_page* vm_cache_lookup_page(vm_cache* cache, off_t offset) { - ASSERT_LOCKED_CUTEX(&cache->lock); + ASSERT_LOCKED_MUTEX(&cache->lock); struct page_lookup_key key; key.offset = (uint32)(offset >> PAGE_SHIFT); @@ -336,7 +336,7 @@ vm_cache_insert_page(vm_cache* cache, vm_page* page, off_t offset) { TRACE(("vm_cache_insert_page: cache %p, page %p, offset %Ld\n", cache, page, offset)); - ASSERT_LOCKED_CUTEX(&cache->lock); + ASSERT_LOCKED_MUTEX(&cache->lock); if (page->cache != NULL) { panic("insert page %p into cache %p: page cache is set to %p\n", @@ -383,7 +383,7 @@ void vm_cache_remove_page(vm_cache* cache, vm_page* page) { TRACE(("vm_cache_remove_page: cache %p, page %p\n", cache, page)); - ASSERT_LOCKED_CUTEX(&cache->lock); + ASSERT_LOCKED_MUTEX(&cache->lock); if (page->cache != cache) { panic("remove page %p from cache %p: page cache is set to %p\n", page, @@ -421,9 +421,9 @@ vm_cache_write_modified(vm_cache* cache, bool fsReenter) if (cache->temporary) return B_OK; - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); status_t status = vm_page_write_modified_pages(cache, fsReenter); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); return status; } @@ -438,7 +438,7 @@ vm_cache_set_minimal_commitment_locked(vm_cache* cache, off_t commitment) { TRACE(("vm_cache_set_minimal_commitment_locked(cache %p, commitment %Ld)\n", cache, commitment)); - ASSERT_LOCKED_CUTEX(&cache->lock); + ASSERT_LOCKED_MUTEX(&cache->lock); vm_store* store = cache->store; status_t status = B_OK; @@ -471,7 +471,7 @@ vm_cache_resize(vm_cache* cache, off_t newSize) { TRACE(("vm_cache_resize(cache %p, newSize %Ld) old size %Ld\n", cache, newSize, cache->virtual_size)); - ASSERT_LOCKED_CUTEX(&cache->lock); + ASSERT_LOCKED_MUTEX(&cache->lock); status_t status = cache->store->ops->commit(cache->store, newSize); if (status != B_OK) @@ -502,9 +502,9 @@ vm_cache_resize(vm_cache* cache, off_t newSize) // wait for page to become unbusy ConditionVariableEntry entry; entry.Add(page); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); entry.Wait(); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); // restart from the start of the list page = cache->page_list; @@ -534,7 +534,7 @@ void vm_cache_remove_consumer(vm_cache* cache, vm_cache* consumer) { TRACE(("remove consumer vm cache %p from cache %p\n", consumer, cache)); - ASSERT_LOCKED_CUTEX(&consumer->lock); + ASSERT_LOCKED_MUTEX(&consumer->lock); // Remove the store ref before locking the cache. Otherwise we'd call into // the VFS while holding the cache lock, which would reverse the usual @@ -543,7 +543,7 @@ vm_cache_remove_consumer(vm_cache* cache, vm_cache* consumer) cache->store->ops->release_ref(cache->store); // remove the consumer from the cache, but keep its reference until later - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); list_remove_item(&cache->consumers, consumer); consumer->source = NULL; @@ -569,10 +569,10 @@ vm_cache_remove_consumer(vm_cache* cache, vm_cache* consumer) // need to unlock our cache now busyCondition.Publish(cache, "cache"); cache->busy = true; - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); - cutex_lock(&consumer->lock); - cutex_lock(&cache->lock); + mutex_lock(&consumer->lock); + mutex_lock(&cache->lock); if (cache->areas != NULL || cache->source == NULL || list_is_empty(&cache->consumers) @@ -583,7 +583,7 @@ vm_cache_remove_consumer(vm_cache* cache, vm_cache* consumer) merge = false; cache->busy = false; busyCondition.Unpublish(); - cutex_unlock(&consumer->lock); + mutex_unlock(&consumer->lock); vm_cache_release_ref(consumer); } } @@ -637,14 +637,14 @@ vm_cache_remove_consumer(vm_cache* cache, vm_cache* consumer) vm_cache* newSource = cache->source; // The remaining consumer has gotten a new source - cutex_lock(&newSource->lock); + mutex_lock(&newSource->lock); list_remove_item(&newSource->consumers, cache); list_add_item(&newSource->consumers, consumer); consumer->source = newSource; cache->source = NULL; - cutex_unlock(&newSource->lock); + mutex_unlock(&newSource->lock); // Release the other reference to the cache - we take over // its reference of its source cache; we can do this here @@ -654,7 +654,7 @@ if (cache->ref_count < 2) panic("cacheRef %p ref count too low!\n", cache); vm_cache_release_ref(cache); - cutex_unlock(&consumer->lock); + mutex_unlock(&consumer->lock); vm_cache_release_ref(consumer); } @@ -662,7 +662,7 @@ panic("cacheRef %p ref count too low!\n", cache); busyCondition.Unpublish(); } - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_cache_release_ref(cache); } @@ -676,8 +676,8 @@ void vm_cache_add_consumer_locked(vm_cache* cache, vm_cache* consumer) { TRACE(("add consumer vm cache %p to cache %p\n", consumer, cache)); - ASSERT_LOCKED_CUTEX(&cache->lock); - ASSERT_LOCKED_CUTEX(&consumer->lock); + ASSERT_LOCKED_MUTEX(&cache->lock); + ASSERT_LOCKED_MUTEX(&consumer->lock); consumer->source = cache; list_add_item(&cache->consumers, consumer); @@ -696,7 +696,7 @@ status_t vm_cache_insert_area_locked(vm_cache* cache, vm_area* area) { TRACE(("vm_cache_insert_area_locked(cache %p, area %p)\n", cache, area)); - ASSERT_LOCKED_CUTEX(&cache->lock); + ASSERT_LOCKED_MUTEX(&cache->lock); area->cache_next = cache->areas; if (area->cache_next) @@ -716,7 +716,7 @@ vm_cache_remove_area(vm_cache* cache, vm_area* area) { TRACE(("vm_cache_remove_area(cache %p, area %p)\n", cache, area)); - CutexLocker locker(cache->lock); + MutexLocker locker(cache->lock); if (area->cache_prev) area->cache_prev->cache_next = area->cache_next; diff --git a/src/system/kernel/vm/vm_daemons.cpp b/src/system/kernel/vm/vm_daemons.cpp index e4561b7634..08b82f7a39 100644 --- a/src/system/kernel/vm/vm_daemons.cpp +++ b/src/system/kernel/vm/vm_daemons.cpp @@ -66,15 +66,15 @@ PageCacheLocker::Lock(vm_page* page, bool dontWait) return false; if (dontWait) { - if (cutex_trylock(&cache->lock) != B_OK) { + if (mutex_trylock(&cache->lock) != B_OK) { vm_cache_release_ref(cache); return false; } } else - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); if (cache != page->cache || _IgnorePage(page)) { - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_cache_release_ref(cache); return false; } @@ -91,7 +91,7 @@ PageCacheLocker::Unlock() return; vm_cache* cache = fPage->cache; - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); vm_cache_release_ref(cache); fPage = NULL; diff --git a/src/system/kernel/vm/vm_low_memory.cpp b/src/system/kernel/vm/vm_low_memory.cpp index 9a3c7aea28..f36361d18d 100644 --- a/src/system/kernel/vm/vm_low_memory.cpp +++ b/src/system/kernel/vm/vm_low_memory.cpp @@ -184,8 +184,7 @@ vm_low_memory_init(void) status_t vm_low_memory_init_post_thread(void) { - if (mutex_init(&sLowMemoryMutex, "low memory") < B_OK) - return B_ERROR; + mutex_init(&sLowMemoryMutex, "low memory"); sLowMemoryWaitSem = create_sem(0, "low memory wait"); if (sLowMemoryWaitSem < B_OK) diff --git a/src/system/kernel/vm/vm_page.cpp b/src/system/kernel/vm/vm_page.cpp index 190ca997e9..b288f80c46 100644 --- a/src/system/kernel/vm/vm_page.cpp +++ b/src/system/kernel/vm/vm_page.cpp @@ -1043,7 +1043,7 @@ page_writer(void* /*unused*/) for (uint32 i = 0; i < numPages; i++) { vm_cache *cache = u.pages[i]->cache; - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); if (writeStatus[i] == B_OK) { // put it into the active queue @@ -1069,7 +1069,7 @@ page_writer(void* /*unused*/) busyConditions[i].Unpublish(); u.caches[i] = cache; - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); } for (uint32 i = 0; i < numPages; i++) { @@ -1156,7 +1156,7 @@ steal_page(vm_page *page, bool stealActive) { fCache = vm_cache_acquire_page_cache_ref(page); if (fCache != NULL) { - if (cutex_trylock(&fCache->lock) != B_OK) + if (mutex_trylock(&fCache->lock) != B_OK) return; fOwnsLock = true; @@ -1169,7 +1169,7 @@ steal_page(vm_page *page, bool stealActive) ~PageCacheTryLocker() { if (fOwnsLock) - cutex_unlock(&fCache->lock); + mutex_unlock(&fCache->lock); if (fCache != NULL) vm_cache_release_ref(fCache); } @@ -1345,9 +1345,9 @@ vm_page_write_modified_pages(vm_cache *cache, bool fsReenter) // clear the modified flag vm_clear_map_flags(page, PAGE_MODIFIED); - cutex_unlock(&cache->lock); + mutex_unlock(&cache->lock); status_t status = write_page(page, fsReenter); - cutex_lock(&cache->lock); + mutex_lock(&cache->lock); InterruptsSpinLocker locker(&sPageLock); diff --git a/src/system/libroot/os/driver_settings.c b/src/system/libroot/os/driver_settings.c index 82c721b747..f0c258eadd 100644 --- a/src/system/libroot/os/driver_settings.c +++ b/src/system/libroot/os/driver_settings.c @@ -657,7 +657,8 @@ driver_settings_init(kernel_args *args) status_t driver_settings_init_post_sem(kernel_args *args) { - return mutex_init(&sLock, "driver settings"); + mutex_init(&sLock, "driver settings"); + return B_OK; } #endif