diff --git a/kernel-src/arch/x86-64/hpet.c b/kernel-src/arch/x86-64/hpet.c index 37063c49..75e57498 100644 --- a/kernel-src/arch/x86-64/hpet.c +++ b/kernel-src/arch/x86-64/hpet.c @@ -87,7 +87,7 @@ static timekeeper_source_info_t *hpet_init(void) { uacpi_table tbl; struct acpi_hpet *table; - MUTEX_ACQUIRE(&init_mutex, false); + MUTEX_ACQUIRE(&init_mutex); if (timekeeper_source_info.hz) { // already initialized by someone else goto leave; diff --git a/kernel-src/arch/x86-64/tsc.c b/kernel-src/arch/x86-64/tsc.c index 463772d2..e39e9b82 100644 --- a/kernel-src/arch/x86-64/tsc.c +++ b/kernel-src/arch/x86-64/tsc.c @@ -26,7 +26,7 @@ static MUTEX_DEFINE(init_mutex); static time_t hz; static timekeeper_source_info_t *tsc_init(void) { - MUTEX_ACQUIRE(&init_mutex, false); + MUTEX_ACQUIRE(&init_mutex); __assert(tsc_probe()); timekeeper_source_info_t *timekeeper_source_info = alloc(sizeof(timekeeper_source_info_t)); diff --git a/kernel-src/fs/devfs.c b/kernel-src/fs/devfs.c index 5716feeb..8c917436 100644 --- a/kernel-src/fs/devfs.c +++ b/kernel-src/fs/devfs.c @@ -21,7 +21,7 @@ static uintmax_t currentinode; static vfsops_t vfsops; static vops_t vnops; -#define INTERNAL_LOCK(v) MUTEX_ACQUIRE(&(v)->lock, false) +#define INTERNAL_LOCK(v) MUTEX_ACQUIRE(&(v)->lock) #define INTERNAL_UNLOCK(v) MUTEX_RELEASE(&(v)->lock); static int devfs_mount(vfs_t **vfs, vnode_t *mountpoint, vnode_t *backing, void *data) { @@ -112,7 +112,7 @@ int devfs_lookup(vnode_t *node, char *name, vnode_t **result, cred_t *cred) { void *v; INTERNAL_LOCK(node); - MUTEX_ACQUIRE(&tablelock, false); + MUTEX_ACQUIRE(&tablelock); int error = hashtable_get(&devnode->children, &v, name, strlen(name)); MUTEX_RELEASE(&tablelock); if (error) { @@ -518,7 +518,7 @@ int devfs_register(devops_t *devops, char *name, int type, int major, int minor, int key[2] = {major, minor}; - MUTEX_ACQUIRE(&tablelock, false); + MUTEX_ACQUIRE(&tablelock); int error = hashtable_set(&devtable, master, key, sizeof(key), true); MUTEX_RELEASE(&tablelock); if (error) { @@ -550,7 +550,7 @@ int devfs_register(devops_t *devops, char *name, int type, int major, int minor, VOP_RELEASE(dir); if (error) { - MUTEX_ACQUIRE(&tablelock, false); + MUTEX_ACQUIRE(&tablelock); __assert(hashtable_remove(&devtable, key, sizeof(key) == 0)); MUTEX_RELEASE(&tablelock); slab_free(nodecache, master); @@ -570,7 +570,7 @@ int devfs_register(devops_t *devops, char *name, int type, int major, int minor, // allocate a pointer node to the master node associated with device major and minor int devfs_getnode(vnode_t *physical, int major, int minor, vnode_t **node) { int key[2] = {major, minor}; - MUTEX_ACQUIRE(&tablelock, false); + MUTEX_ACQUIRE(&tablelock); void *r; int err = hashtable_get(&devtable, &r, key, sizeof(key)); MUTEX_RELEASE(&tablelock); @@ -596,7 +596,7 @@ int devfs_getnode(vnode_t *physical, int major, int minor, vnode_t **node) { void devfs_remove(char *name, int major, int minor) { int key[2] = {major, minor}; // remove devtable reference - MUTEX_ACQUIRE(&tablelock, false); + MUTEX_ACQUIRE(&tablelock); __assert(hashtable_remove(&devtable, key, sizeof(key)) == 0); MUTEX_RELEASE(&tablelock); diff --git a/kernel-src/fs/ext2.c b/kernel-src/fs/ext2.c index a286d78b..24b4f2c0 100644 --- a/kernel-src/fs/ext2.c +++ b/kernel-src/fs/ext2.c @@ -176,7 +176,7 @@ typedef uint32_t blockptr_t; #define ASSERT_UNCLEAN(fs, x) \ if (!(x)) { \ printf("ext2: assert %s on line %d on function %s failed. setting filesystem as unclean\n", #x, __LINE__, __func__); \ - MUTEX_ACQUIRE(&fs->superblocklock, false); \ + MUTEX_ACQUIRE(&fs->superblocklock); \ fs->superblock.state = SB_STATE_UNCLEAN; \ syncsuperblock(fs); \ MUTEX_RELEASE(&fs->superblocklock); \ @@ -219,7 +219,7 @@ static int syncsuperblock(ext2fs_t *fs) { } static int changedircount(ext2fs_t *fs, int bg, int change) { - MUTEX_ACQUIRE(&fs->descriptorlock, false); + MUTEX_ACQUIRE(&fs->descriptorlock); blockgroupdesc_t desc; size_t count; int e = vfs_read(fs->backing, &desc, sizeof(blockgroupdesc_t), DESC_GETDISKOFFSET(fs, bg), &count, 0); @@ -237,7 +237,7 @@ static int changedircount(ext2fs_t *fs, int bg, int change) { // allocates either a block or an inode static int allocatestructure(ext2fs_t *fs, uintmax_t *retid, bool inode) { - MUTEX_ACQUIRE(&fs->descriptorlock, false); + MUTEX_ACQUIRE(&fs->descriptorlock); uint8_t *bm = NULL; uintmax_t bg = inode ? fs->lowestfreeinodebg : fs->lowestfreeblockbg; @@ -331,7 +331,7 @@ static int allocatestructure(ext2fs_t *fs, uintmax_t *retid, bool inode) { *retid = structurefound; // update superblock unallocated structure count - MUTEX_ACQUIRE(&fs->superblocklock, false); + MUTEX_ACQUIRE(&fs->superblocklock); if (inode) fs->superblock.unallocatedinodes -= 1; else @@ -353,7 +353,7 @@ static int freestructure(ext2fs_t *fs, uintmax_t id, bool inode) { int e = 0; uint8_t *bm = NULL; int bg = inode ? INODE_GETGROUP(fs, id) : BLOCK_GETGROUP(fs, id); - MUTEX_ACQUIRE(&fs->descriptorlock, false); + MUTEX_ACQUIRE(&fs->descriptorlock); blockgroupdesc_t desc; size_t readc; @@ -407,7 +407,7 @@ static int freestructure(ext2fs_t *fs, uintmax_t id, bool inode) { } // update superblock unallocated structure count - MUTEX_ACQUIRE(&fs->superblocklock, false); + MUTEX_ACQUIRE(&fs->superblocklock); if (inode) fs->superblock.unallocatedinodes += 1; else @@ -455,7 +455,7 @@ static int writeinode(ext2fs_t *fs, inode_t *buffer, int inode) { if (count != sizeof(blockgroupdesc_t)) return EIO; - MUTEX_ACQUIRE(&fs->inodewritelock, false); + MUTEX_ACQUIRE(&fs->inodewritelock); // write inode from buffer e = vfs_write(fs->backing, buffer, sizeof(inode_t), INODE_GETDISKOFFSET(fs, BLOCK_GETDISKOFFSET(fs, desc.inodetable), inode), &count, 0); MUTEX_RELEASE(&fs->inodewritelock); @@ -1189,7 +1189,7 @@ static int ext2_lookup(vnode_t *vnode, char *name, vnode_t **result, cred_t *cre if (err) goto cleanup; - MUTEX_ACQUIRE(&fs->inodetablelock, false); + MUTEX_ACQUIRE(&fs->inodetablelock); void *tablev; // check if it isn't already in the inode table @@ -1501,7 +1501,7 @@ static int internalcreate(vnode_t *parent, char *name, vattr_t *attr, int type, if (err) goto cleanup; - MUTEX_ACQUIRE(&fs->inodetablelock, false); + MUTEX_ACQUIRE(&fs->inodetablelock); err = hashtable_set(&fs->inodetable, newnode, &newnode->id, sizeof(newnode->id), true); MUTEX_RELEASE(&fs->inodetablelock); ASSERT_UNCLEAN(fs, err == 0); @@ -1591,7 +1591,7 @@ static int ext2_munmap(vnode_t *node, void *addr, uintmax_t offset, int flags, c static int handleinodeunlink(ext2fs_t *fs, ext2node_t *node, int inode, ext2node_t *known) { bool isdir = false; void *v; - MUTEX_ACQUIRE(&fs->inodetablelock, false); + MUTEX_ACQUIRE(&fs->inodetablelock); int err = hashtable_get(&fs->inodetable, &v, &inode, sizeof(inode)); if (err == ENOENT) { __assert(known == NULL); @@ -1805,7 +1805,7 @@ static int ext2_sync(vnode_t *vnode) { } static int ext2_lock(vnode_t *vnode) { - MUTEX_ACQUIRE(&vnode->lock, false); + MUTEX_ACQUIRE(&vnode->lock); return 0; } @@ -1828,7 +1828,7 @@ static int ext2_inactive(vnode_t *vnode) { } else { // the node does not have any more links on the file system nor references and // we should free it completely from the filesystem. - MUTEX_ACQUIRE(&fs->inodetablelock, false); + MUTEX_ACQUIRE(&fs->inodetablelock); __assert(hashtable_remove(&fs->inodetable, &node->id, sizeof(node->id)) == 0); MUTEX_RELEASE(&fs->inodetablelock); @@ -1845,7 +1845,7 @@ static int ext2_inactive(vnode_t *vnode) { static int ext2_root(vfs_t *vfs, vnode_t **vnodep) { ext2fs_t *fs = (ext2fs_t *)vfs; int err = 0; - MUTEX_ACQUIRE(&fs->rootlock, false); + MUTEX_ACQUIRE(&fs->rootlock); if (fs->root) { *vnodep = &fs->root->vnode; goto leave; diff --git a/kernel-src/fs/file.c b/kernel-src/fs/file.c index 840be859..53ed06e8 100644 --- a/kernel-src/fs/file.c +++ b/kernel-src/fs/file.c @@ -71,7 +71,7 @@ static int growtable(int newcount) { file_t *fd_get(int fd) { proc_t *proc = current_thread()->proc; - MUTEX_ACQUIRE(&proc->fdmutex, false); + MUTEX_ACQUIRE(&proc->fdmutex); file_t *file = fd < proc->fdcount ? proc->fd[fd].file : NULL; if (file) @@ -85,7 +85,7 @@ file_t *fd_get(int fd) { int fd_setflags(int fd, int flags) { int error = 0; proc_t *proc = current_thread()->proc; - MUTEX_ACQUIRE(&proc->fdmutex, false); + MUTEX_ACQUIRE(&proc->fdmutex); if (proc->fd[fd].file) proc->fd[fd].flags = flags; @@ -99,7 +99,7 @@ int fd_setflags(int fd, int flags) { int fd_getflags(int fd, int *flags) { int error = 0; proc_t *proc = current_thread()->proc; - MUTEX_ACQUIRE(&proc->fdmutex, false); + MUTEX_ACQUIRE(&proc->fdmutex); if (proc->fd[fd].file) *flags = proc->fd[fd].flags; @@ -120,7 +120,7 @@ int fd_new(int flags, file_t **rfile, int *rfd) { return ENOMEM; proc_t *proc = current_thread()->proc; - MUTEX_ACQUIRE(&proc->fdmutex, false); + MUTEX_ACQUIRE(&proc->fdmutex); // find first free fd int fd = getfree(proc->fdfirst); @@ -149,7 +149,7 @@ int fd_new(int flags, file_t **rfile, int *rfd) { int fd_close(int fd) { proc_t *proc = current_thread()->proc; - MUTEX_ACQUIRE(&proc->fdmutex, false); + MUTEX_ACQUIRE(&proc->fdmutex); file_t *file = fd < proc->fdcount ? proc->fd[fd].file : NULL; if (file) { @@ -173,7 +173,7 @@ int fd_close(int fd) { int fd_clone(proc_t *targproc) { proc_t *proc = current_thread()->proc; int error = 0; - MUTEX_ACQUIRE(&proc->fdmutex, false); + MUTEX_ACQUIRE(&proc->fdmutex); targproc->fdcount = proc->fdcount; targproc->fdfirst = proc->fdfirst; @@ -199,7 +199,7 @@ int fd_clone(proc_t *targproc) { int fd_insert(file_t *file, int *fdp) { proc_t *proc = current_thread()->proc; int err = 0; - MUTEX_ACQUIRE(&proc->fdmutex, false); + MUTEX_ACQUIRE(&proc->fdmutex); int fd = getfree(0); if (fd == -1) { @@ -226,7 +226,7 @@ int fd_dup(int oldfd, int newfd, bool exact, int fdflags, int *retfd) { if (newfd < 0 || newfd >= FDTABLE_LIMIT) return EBADF; - MUTEX_ACQUIRE(&proc->fdmutex, false); + MUTEX_ACQUIRE(&proc->fdmutex); file_t *file = oldfd < proc->fdcount ? proc->fd[oldfd].file : NULL; if (file == NULL) { diff --git a/kernel-src/fs/pipefs.c b/kernel-src/fs/pipefs.c index 7d204b91..7bb140d1 100644 --- a/kernel-src/fs/pipefs.c +++ b/kernel-src/fs/pipefs.c @@ -17,7 +17,7 @@ static uintmax_t currentinode; static vops_t vnops; -#define INTERNAL_LOCK(v) MUTEX_ACQUIRE(&(v)->lock, false) +#define INTERNAL_LOCK(v) MUTEX_ACQUIRE(&(v)->lock) #define INTERNAL_UNLOCK(v) MUTEX_RELEASE(&(v)->lock) int pipefs_close(vnode_t *node, int flags, cred_t *cred) { diff --git a/kernel-src/fs/sockfs.c b/kernel-src/fs/sockfs.c index 58e7eb9a..8d7b752d 100644 --- a/kernel-src/fs/sockfs.c +++ b/kernel-src/fs/sockfs.c @@ -13,7 +13,7 @@ static scache_t *nodecache; static uintmax_t currentinode; -#define INTERNAL_LOCK(v) MUTEX_ACQUIRE(&(v)->lock, false) +#define INTERNAL_LOCK(v) MUTEX_ACQUIRE(&(v)->lock) #define INTERNAL_UNLOCK(v) MUTEX_RELEASE(&(v)->lock) int sockfs_open(vnode_t **node, int flags, cred_t *cred) { diff --git a/kernel-src/fs/tmpfs.c b/kernel-src/fs/tmpfs.c index 2ec25cfe..1fbc48a8 100644 --- a/kernel-src/fs/tmpfs.c +++ b/kernel-src/fs/tmpfs.c @@ -503,7 +503,7 @@ static int tmpfs_sync(vnode_t *node) { } static int tmpfs_lock(vnode_t *node) { - MUTEX_ACQUIRE(&node->lock, false); + MUTEX_ACQUIRE(&node->lock); return 0; } diff --git a/kernel-src/fs/vfs.c b/kernel-src/fs/vfs.c index 1f53c2bb..e74eec38 100644 --- a/kernel-src/fs/vfs.c +++ b/kernel-src/fs/vfs.c @@ -243,7 +243,7 @@ int vfs_write_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size goto leave; } - MUTEX_ACQUIRE(&node->size_lock, false); + MUTEX_ACQUIRE(&node->size_lock); vattr_t attr; VOP_LOCK(node); @@ -365,7 +365,7 @@ int vfs_read_iovec(vnode_t *node, iovec_iterator_t *iovec_iterator, size_t size, size_t nodesize = 0; - MUTEX_ACQUIRE(&node->size_lock, false); + MUTEX_ACQUIRE(&node->size_lock); if (node->type == V_TYPE_REGULAR) { vattr_t attr; VOP_LOCK(node); @@ -837,7 +837,7 @@ int vfs_lookup(vnode_t **result, vnode_t *start, char *path, char *lastcomp, int vnode_t *derefstart = current; if (*linkderef == '/' && current_thread() && current_thread()->proc) { - MUTEX_ACQUIRE(¤t_thread()->proc->mutex, false); + MUTEX_ACQUIRE(¤t_thread()->proc->mutex); derefstart = current_thread()->proc->root; VOP_HOLD(derefstart); MUTEX_RELEASE(¤t_thread()->proc->mutex); diff --git a/kernel-src/include/kernel/file.h b/kernel-src/include/kernel/file.h index 8d397bfb..e1c03c34 100644 --- a/kernel-src/include/kernel/file.h +++ b/kernel-src/include/kernel/file.h @@ -30,7 +30,7 @@ int fd_setflags(int fd, int flags); int fd_getflags(int fd, int *flags); int fd_insert(file_t *file, int *fdp); -#define FILE_LOCK(x) MUTEX_ACQUIRE(&(x)->mutex, false) +#define FILE_LOCK(x) MUTEX_ACQUIRE(&(x)->mutex) #define FILE_UNLOCK(x) MUTEX_RELEASE(&(x)->mutex) #define FILE_READ 1 diff --git a/kernel-src/include/kernel/proc.h b/kernel-src/include/kernel/proc.h index 4159ddd0..a31a6f0a 100644 --- a/kernel-src/include/kernel/proc.h +++ b/kernel-src/include/kernel/proc.h @@ -86,7 +86,7 @@ typedef struct proc_t { // the acquire of the pid table mutex is done here to prevent a nasty race condition where sched_inactiveproc could be called multiple times // due to the pid table itself not holding any references to the process #define PROC_RELEASE(v) {\ - MUTEX_ACQUIRE(&proc_pid_table_mutex, false); \ + MUTEX_ACQUIRE(&proc_pid_table_mutex); \ if (__atomic_sub_fetch(&(v)->refcount, 1, __ATOMIC_SEQ_CST) == 0) {\ proc_inactive(v); \ (v) = NULL; \ diff --git a/kernel-src/include/logging.h b/kernel-src/include/logging.h index fadd22a0..9a8407df 100644 --- a/kernel-src/include/logging.h +++ b/kernel-src/include/logging.h @@ -18,7 +18,7 @@ extern mutex_t printf_mutex; #define printf(...) { \ if (likely(current_thread())) {\ - MUTEX_ACQUIRE(&printf_mutex, false); \ + MUTEX_ACQUIRE(&printf_mutex); \ } else { \ while (MUTEX_TRY(&printf_mutex) == false) CPU_PAUSE(); \ } \ diff --git a/kernel-src/include/mutex.h b/kernel-src/include/mutex.h index 0029cca3..1e513a3f 100644 --- a/kernel-src/include/mutex.h +++ b/kernel-src/include/mutex.h @@ -8,11 +8,11 @@ typedef semaphore_t mutex_t; #define MUTEX_INIT(m) \ SEMAPHORE_INIT(m, 1); -#define MUTEX_ACQUIRE(m, i) \ - semaphore_wait(m, i) +#define MUTEX_ACQUIRE(m) \ + semaphore_wait(m, false) -#define MUTEX_ACQUIRE_TIMED(m, t, i) \ - semaphore_timedwait(m, t, i) +#define MUTEX_ACQUIRE_TIMED(m, t) \ + semaphore_timedwait(m, t, false) #define MUTEX_RELEASE(m) \ semaphore_signal(m) diff --git a/kernel-src/io/acpi/dev.c b/kernel-src/io/acpi/dev.c index 73e604fc..ff22c57a 100644 --- a/kernel-src/io/acpi/dev.c +++ b/kernel-src/io/acpi/dev.c @@ -39,7 +39,7 @@ static int read(int minor, iovec_iterator_t *iovec_iterator, size_t size, uintma if (error) return error; - MUTEX_ACQUIRE(&mutex, false); + MUTEX_ACQUIRE(&mutex); for (;;) { int revents = internalpoll(&desc.data[0], POLLIN); @@ -97,7 +97,7 @@ static int write(int minor, iovec_iterator_t *iovec_iterator, size_t size, uintm } static int poll(int minor, polldata_t *data, int events) { - MUTEX_ACQUIRE(&mutex, false); + MUTEX_ACQUIRE(&mutex); int revents = internalpoll(data, events); MUTEX_RELEASE(&mutex); return revents; diff --git a/kernel-src/io/acpi/glue.c b/kernel-src/io/acpi/glue.c index bb2519f6..4cfa8e6f 100644 --- a/kernel-src/io/acpi/glue.c +++ b/kernel-src/io/acpi/glue.c @@ -457,11 +457,11 @@ void uacpi_kernel_free_mutex(uacpi_handle mut) { uacpi_status uacpi_kernel_acquire_mutex( uacpi_handle mut, uacpi_u16 timeout) { if (timeout == 0xFFFF) { - MUTEX_ACQUIRE(mut, false); + MUTEX_ACQUIRE(mut); return UACPI_STATUS_OK; } - bool didacquire = MUTEX_ACQUIRE_TIMED(mut, timeout * 1000, false); + bool didacquire = MUTEX_ACQUIRE_TIMED(mut, timeout * 1000); return didacquire ? UACPI_STATUS_OK : UACPI_STATUS_TIMEOUT; } diff --git a/kernel-src/io/block/block.c b/kernel-src/io/block/block.c index 18522308..cabdcc3a 100644 --- a/kernel-src/io/block/block.c +++ b/kernel-src/io/block/block.c @@ -58,7 +58,7 @@ static hashtable_t blocktable; static blockdesc_t *getdesc(int id) { void *ret; - MUTEX_ACQUIRE(&tablemutex, false); + MUTEX_ACQUIRE(&tablemutex); int err = hashtable_get(&blocktable, &ret, &id, sizeof(id)); MUTEX_RELEASE(&tablemutex); return err ? NULL : ret; @@ -181,7 +181,7 @@ static devops_t devops = { }; static int registerdesc(blockdesc_t *desc, char *name) { - MUTEX_ACQUIRE(&tablemutex, false); + MUTEX_ACQUIRE(&tablemutex); int id = currentid++; int ret = hashtable_set(&blocktable, desc, &id, sizeof(id), true); MUTEX_RELEASE(&tablemutex); diff --git a/kernel-src/io/console.c b/kernel-src/io/console.c index 3254a871..8368509c 100644 --- a/kernel-src/io/console.c +++ b/kernel-src/io/console.c @@ -15,7 +15,7 @@ static thread_t *thread; static tty_t *tty; size_t console_write(char *str, size_t count) { - MUTEX_ACQUIRE(&writemutex, false); + MUTEX_ACQUIRE(&writemutex); term_write(str, count); diff --git a/kernel-src/io/keyboard.c b/kernel-src/io/keyboard.c index a387b3cf..4660c8d4 100644 --- a/kernel-src/io/keyboard.c +++ b/kernel-src/io/keyboard.c @@ -148,7 +148,7 @@ static mutex_t tablelock; static keyboard_t* getkb(int kb) { void *kbp = NULL; - MUTEX_ACQUIRE(&tablelock, false); + MUTEX_ACQUIRE(&tablelock); hashtable_get(&kbtable, &kbp, &kb, sizeof(kb)); MUTEX_RELEASE(&tablelock); return kbp; @@ -226,7 +226,7 @@ keyboard_t *keyboard_new() { if (kb == NULL) return NULL; - MUTEX_ACQUIRE(&tablelock, false); + MUTEX_ACQUIRE(&tablelock); if (hashtable_set(&kbtable, kb, ¤tkbnum, sizeof(currentkbnum), true)) { MUTEX_RELEASE(&tablelock); diff --git a/kernel-src/io/mouse.c b/kernel-src/io/mouse.c index 774da4ae..48eb5e46 100644 --- a/kernel-src/io/mouse.c +++ b/kernel-src/io/mouse.c @@ -49,7 +49,7 @@ static mutex_t tablelock; static mouse_t* getmouse(int mouse) { void *mousep = NULL; - MUTEX_ACQUIRE(&tablelock, false); + MUTEX_ACQUIRE(&tablelock); hashtable_get(&mousetable, &mousep, &mouse, sizeof(mouse)); MUTEX_RELEASE(&tablelock); return mousep; @@ -78,7 +78,7 @@ static int read(int minor, iovec_iterator_t *iovec_iterator, size_t size, uintma if (packetcount == 0) return error; - MUTEX_ACQUIRE(&mouse->readmutex, false); + MUTEX_ACQUIRE(&mouse->readmutex); // wait until there is data to read or return if nonblock for (;;) { polldesc_t desc = {0}; @@ -140,7 +140,7 @@ static int poll(int minor, polldata_t *data, int events) { if (mouse == NULL) return POLLERR; - MUTEX_ACQUIRE(&mouse->readmutex, false); + MUTEX_ACQUIRE(&mouse->readmutex); long ipl = interrupt_raiseipl(IPL_MOUSE); spinlock_acquire(&mouse->lock); @@ -163,7 +163,7 @@ mouse_t *mouse_new() { if (mouse == NULL) return NULL; - MUTEX_ACQUIRE(&tablelock, false); + MUTEX_ACQUIRE(&tablelock); if (hashtable_set(&mousetable, mouse, ¤tnum, sizeof(currentnum), true)) { MUTEX_RELEASE(&tablelock); diff --git a/kernel-src/io/net/arp.c b/kernel-src/io/net/arp.c index 22bc4466..ae3f6318 100644 --- a/kernel-src/io/net/arp.c +++ b/kernel-src/io/net/arp.c @@ -78,7 +78,7 @@ static void set(netdev_t *netdev, uint32_t ip, mac_t mac, timespec_t time) { static void cleanupthreadfn() { for (;;) { sched_sleep_us(1000000); // 1 second - MUTEX_ACQUIRE(&cachelock, false); + MUTEX_ACQUIRE(&cachelock); timespec_t currtime = timekeeper_time(); hashentry_t entrybuffer; HASHTABLE_FOREACH(&caches) { @@ -164,7 +164,7 @@ static void handlerthreadfn() { switch (entry.opcode) { case OPCODE_REPLY: // add to cache - MUTEX_ACQUIRE(&cachelock, false); + MUTEX_ACQUIRE(&cachelock); timespec_t time = timekeeper_time(); set(entry.netdev, entry.ip, entry.mac, time); EVENT_SIGNAL(&addedevent); @@ -237,7 +237,7 @@ static int sendrequest(netdev_t *netdev, uint32_t ip) { } int arp_lookup(netdev_t *netdev, uint32_t ip, mac_t *mac) { - MUTEX_ACQUIRE(&cachelock, false); + MUTEX_ACQUIRE(&cachelock); int e = 0; if (get(netdev, ip, mac) == 0) goto cleanup; @@ -266,7 +266,7 @@ int arp_lookup(netdev_t *netdev, uint32_t ip, mac_t *mac) { MUTEX_RELEASE(&cachelock); int timedout = EVENT_WAIT(&eventlistener, to); - MUTEX_ACQUIRE(&cachelock, false); + MUTEX_ACQUIRE(&cachelock); time = timekeeper_time(); if (get(netdev, ip, mac) == 0) { diff --git a/kernel-src/io/net/ipv4.c b/kernel-src/io/net/ipv4.c index 83bdbc44..7267682a 100644 --- a/kernel-src/io/net/ipv4.c +++ b/kernel-src/io/net/ipv4.c @@ -21,7 +21,7 @@ static size_t routingtablesize; static routingentry_t getroute(uint32_t ip) { routingentry_t selected = {0}; - MUTEX_ACQUIRE(&routingtablelock, false); + MUTEX_ACQUIRE(&routingtablelock); for (int i = 0; i < routingtablesize; ++i) { if (routingtable[i].netdev == NULL || (routingtable[i].mask & ip) != (routingtable[i].addr & routingtable[i].mask)) @@ -44,7 +44,7 @@ int ipv4_addroute(netdev_t *netdev, uint32_t addr, uint32_t gateway, uint32_t ma .weight = weight }; - MUTEX_ACQUIRE(&routingtablelock, false); + MUTEX_ACQUIRE(&routingtablelock); int error = 0; int i; diff --git a/kernel-src/io/net/localsocket.c b/kernel-src/io/net/localsocket.c index 50e0aa72..d705ba65 100644 --- a/kernel-src/io/net/localsocket.c +++ b/kernel-src/io/net/localsocket.c @@ -150,12 +150,12 @@ static int internalpoll(socket_t *socket, polldata_t *data, int events) { int localsock_poll(socket_t *socket, polldata_t *data, int events) { localsocket_t *localsocket = (localsocket_t *)socket; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); if (localsocket->binding) - MUTEX_ACQUIRE(&localsocket->binding->mutex, false); + MUTEX_ACQUIRE(&localsocket->binding->mutex); if (localsocket->pair) - MUTEX_ACQUIRE(&localsocket->pair->mutex, false); + MUTEX_ACQUIRE(&localsocket->pair->mutex); int revents = internalpoll(socket, data, events); @@ -308,7 +308,7 @@ static int recvctrl(socket_t *socket, sockctrl_t *ctrl, size_t len, bool *trunca static int localsock_send(socket_t *socket, sockdesc_t *sockdesc) { localsocket_t *localsocket = (localsocket_t *)socket; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); int error; localpair_t *pair = localsocket->pair; @@ -318,7 +318,7 @@ static int localsock_send(socket_t *socket, sockdesc_t *sockdesc) { goto leave; } - MUTEX_ACQUIRE(&pair->mutex, false); + MUTEX_ACQUIRE(&pair->mutex); // check/wait for space for (;;) { @@ -349,7 +349,7 @@ static int localsock_send(socket_t *socket, sockdesc_t *sockdesc) { poll_leave(&desc); poll_destroydesc(&desc); - MUTEX_ACQUIRE(&pair->mutex, false); + MUTEX_ACQUIRE(&pair->mutex); if (error) goto leave; } @@ -393,7 +393,7 @@ static int localsock_recv(socket_t *socket, sockdesc_t *sockdesc) { localsocket_t *localsocket = (localsocket_t *)socket; uintmax_t flags = sockdesc->flags; sockdesc->flags = 0; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); int error; localpair_t *pair = localsocket->pair; @@ -403,7 +403,7 @@ static int localsock_recv(socket_t *socket, sockdesc_t *sockdesc) { goto leave; } - MUTEX_ACQUIRE(&pair->mutex, false); + MUTEX_ACQUIRE(&pair->mutex); // check/wait for data for (;;) { @@ -440,7 +440,7 @@ static int localsock_recv(socket_t *socket, sockdesc_t *sockdesc) { poll_leave(&desc); poll_destroydesc(&desc); - MUTEX_ACQUIRE(&pair->mutex, false); + MUTEX_ACQUIRE(&pair->mutex); if (error) goto leave; } @@ -499,7 +499,7 @@ static int localsock_accept(socket_t *_server, socket_t *_clientconnection, sock localsocket_t *server = (localsocket_t *)_server; localsocket_t *clientconnection = (localsocket_t *)_clientconnection; - MUTEX_ACQUIRE(&server->socket.mutex, false); + MUTEX_ACQUIRE(&server->socket.mutex); binding_t *binding = server->binding; int error; @@ -508,7 +508,7 @@ static int localsock_accept(socket_t *_server, socket_t *_clientconnection, sock goto leave; } - MUTEX_ACQUIRE(&server->binding->mutex, false); + MUTEX_ACQUIRE(&server->binding->mutex); if (server->backlog == NULL) { error = EINVAL; @@ -533,7 +533,7 @@ static int localsock_accept(socket_t *_server, socket_t *_clientconnection, sock poll_destroydesc(&desc); pair = popbacklog(server); - MUTEX_ACQUIRE(&pair->mutex, false); + MUTEX_ACQUIRE(&pair->mutex); if (pair->client == NULL) { // client closed the connection, delete the pair and keep trying free(pair); @@ -559,7 +559,7 @@ static int localsock_accept(socket_t *_server, socket_t *_clientconnection, sock if (error) goto leave; - MUTEX_ACQUIRE(&binding->mutex, false); + MUTEX_ACQUIRE(&binding->mutex); } // we have a valid pair and we have acquired the mutex already @@ -588,7 +588,7 @@ static int localsock_connect(socket_t *socket, sockaddr_t *addr, uintmax_t flags vnode_t *result = NULL; binding_t *binding = NULL; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); // listening/bound socket if (localsocket->backlog || localsocket->binding) { error = EOPNOTSUPP; @@ -633,7 +633,7 @@ static int localsock_connect(socket_t *socket, sockaddr_t *addr, uintmax_t flags } // and if the server has not closed the socket and is listening - MUTEX_ACQUIRE(&binding->mutex, false); + MUTEX_ACQUIRE(&binding->mutex); localsocket_t *server = binding->server; if (server == NULL || server->backlog == NULL) { error = ECONNREFUSED; @@ -676,7 +676,7 @@ static int localsock_connect(socket_t *socket, sockaddr_t *addr, uintmax_t flags if (error) goto leave; - MUTEX_ACQUIRE(&binding->mutex, false); + MUTEX_ACQUIRE(&binding->mutex); if (binding->server == NULL) { // server closed while we waited! // release the vnode so it can get deleted and set the binding to NULL as we can't be sure on its state anymore. @@ -697,7 +697,7 @@ static int localsock_connect(socket_t *socket, sockaddr_t *addr, uintmax_t flags pair->server = server; pair->client = localsocket; MUTEX_INIT(&pair->mutex); - MUTEX_ACQUIRE(&pair->mutex, false); + MUTEX_ACQUIRE(&pair->mutex); pushbacklog(server, pair); @@ -756,7 +756,7 @@ static int localsock_connect(socket_t *socket, sockaddr_t *addr, uintmax_t flags static int localsock_listen(socket_t *socket, int backlogsize) { localsocket_t *localsocket = (localsocket_t *)socket; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); int error = 0; // already listening @@ -769,7 +769,7 @@ static int localsock_listen(socket_t *socket, int backlogsize) { goto leave; } - MUTEX_ACQUIRE(&localsocket->binding->mutex, false); + MUTEX_ACQUIRE(&localsocket->binding->mutex); localsocket->backlog = alloc(backlogsize * sizeof(localpair_t *)); if (localsocket->backlog == NULL) { @@ -793,7 +793,7 @@ static void localsock_destroy(socket_t *socket) { // disconnect the socket (connected/connecting sockets) localpair_t *pair = localsocket->pair; if (localsocket->pair) { - MUTEX_ACQUIRE(&pair->mutex, false); + MUTEX_ACQUIRE(&pair->mutex); localsocket_t **peerp; localsocket_t **ourp; @@ -818,7 +818,7 @@ static void localsock_destroy(socket_t *socket) { // leave binding (bound socket) binding_t *binding = localsocket->binding; if (binding) { - MUTEX_ACQUIRE(&binding->mutex, false); + MUTEX_ACQUIRE(&binding->mutex); __assert(binding->vnode); binding->server = NULL; MUTEX_RELEASE(&binding->mutex); @@ -832,7 +832,7 @@ static void localsock_destroy(socket_t *socket) { if (pair == NULL) continue; - MUTEX_ACQUIRE(&pair->mutex, false); + MUTEX_ACQUIRE(&pair->mutex); if (pair->client == NULL) { // client gave up free(pair); @@ -866,7 +866,7 @@ static void localsock_destroy(socket_t *socket) { } static int localsock_bind(socket_t *socket, sockaddr_t *addr, cred_t *cred) { - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); int error; char *path = NULL; vnode_t *refnode = NULL; @@ -924,11 +924,11 @@ static int localsock_bind(socket_t *socket, sockaddr_t *addr, cred_t *cred) { static size_t localsocket_datacount(socket_t *socket) { localsocket_t *localsocket = (localsocket_t *)socket; size_t nbytes = 0; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); if (localsocket->pair == NULL) goto cleanup; - MUTEX_ACQUIRE(&localsocket->pair->mutex, false); + MUTEX_ACQUIRE(&localsocket->pair->mutex); nbytes = RINGBUFFER_DATACOUNT(&localsocket->ringbuffer); MUTEX_RELEASE(&localsocket->pair->mutex); @@ -940,7 +940,7 @@ static size_t localsocket_datacount(socket_t *socket) { // only called on vnode remove (vfs_inactive) void localsock_leavebinding(vnode_t *vnode) { binding_t *binding = vnode->socketbinding; - MUTEX_ACQUIRE(&binding->mutex, false); + MUTEX_ACQUIRE(&binding->mutex); if (binding->server) { // server socket still exists, so don't free the structure and only remove the vnode pointer from it binding->vnode = NULL; @@ -985,7 +985,7 @@ int localsock_pair(socket_t **ret1, socket_t **ret2) { static int localsock_getname(socket_t *socket, sockaddr_t *addr) { localsocket_t *localsocket = (localsocket_t *)socket; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); if (localsocket->bindpath) strcpy(addr->path, localsocket->bindpath); else diff --git a/kernel-src/io/net/netdev.c b/kernel-src/io/net/netdev.c index 4d3b1adc..f30b80f6 100644 --- a/kernel-src/io/net/netdev.c +++ b/kernel-src/io/net/netdev.c @@ -11,7 +11,7 @@ static mutex_t tablelock; static devops_t devops = {0}; int netdev_register(netdev_t *netdev, char *name) { - MUTEX_ACQUIRE(&tablelock, false); + MUTEX_ACQUIRE(&tablelock); int e = hashtable_set(&nametable, netdev, name, strlen(name), true); if (e) goto leave; @@ -27,7 +27,7 @@ int netdev_register(netdev_t *netdev, char *name) { } netdev_t *netdev_getdev(char *name) { - MUTEX_ACQUIRE(&tablelock, false); + MUTEX_ACQUIRE(&tablelock); netdev_t *netdev = NULL; void *tmp; diff --git a/kernel-src/io/net/tcp.c b/kernel-src/io/net/tcp.c index 190c7f05..859a2a8c 100644 --- a/kernel-src/io/net/tcp.c +++ b/kernel-src/io/net/tcp.c @@ -329,7 +329,7 @@ static void inactivetcb(tcb_t *tcb) { } static tcb_t *tcbget(connkey_t *key, bool getlistening) { - MUTEX_ACQUIRE(&conntablemutex, false); + MUTEX_ACQUIRE(&conntablemutex); void *v; tcb_t *tcb; @@ -352,7 +352,7 @@ static tcb_t *tcbget(connkey_t *key, bool getlistening) { } static int tcbset(tcb_t *tcb, connkey_t *key, bool remove) { - MUTEX_ACQUIRE(&conntablemutex, false); + MUTEX_ACQUIRE(&conntablemutex); int error; if (remove) { @@ -738,7 +738,7 @@ static void tcp_handleclose(tcb_t *tcb) { // for a listening socket we also have to flush out the backlog. tcb_t *backlogtcb; while (ringbuffer_read(&tcb->backlog, &backlogtcb, sizeof(tcb_t *))) { - MUTEX_ACQUIRE(&backlogtcb->mutex, false); + MUTEX_ACQUIRE(&backlogtcb->mutex); tcp_handleclose(backlogtcb); MUTEX_RELEASE(&backlogtcb->mutex); } @@ -898,7 +898,7 @@ __attribute__((noreturn)) static void tcp_worker() { __assert(!"Bad task type"); } - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); if (tasktype == TASK_TYPE_TIMEOUT && tcb->state != TCB_STATE_CLOSED && tcb->state != TCB_STATE_ABORT) { tcp_handletimeout(tcb); @@ -950,7 +950,7 @@ __attribute__((noreturn)) static void tcp_worker() { break; } - MUTEX_ACQUIRE(&newtcb->mutex, false); + MUTEX_ACQUIRE(&newtcb->mutex); newtcb->state = TCB_STATE_SYNRECEIVED; newtcb->parent = tcb; TCB_HOLD(tcb); // for parent ref @@ -1055,7 +1055,7 @@ __attribute__((noreturn)) static void tcp_worker() { itimer_pause(&tcb->itimer, NULL, NULL); tcb->state = TCB_STATE_ESTABILISHED; tcb->sndunack += 1; - MUTEX_ACQUIRE(&tcb->parent->mutex, false); + MUTEX_ACQUIRE(&tcb->parent->mutex); if (tcb->parent->state == TCB_STATE_CLOSED) { // listening socket was closed in the mean time. close the connection tcp_handleclose(tcb); @@ -1244,7 +1244,7 @@ static int tcp_send(socket_t *socket, sockdesc_t *sockdesc) { return ENOTCONN; tcpsocket_t *tcpsocket = (tcpsocket_t *)socket; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); tcb_t *tcb = tcpsocket->tcb; int error = 0; if (tcb == NULL) { @@ -1252,7 +1252,7 @@ static int tcp_send(socket_t *socket, sockdesc_t *sockdesc) { return ENOTCONN; } - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); if (tcb->reset) { if (current_thread()->proc) signal_signalproc(current_thread()->proc, SIGPIPE); @@ -1296,7 +1296,7 @@ static int tcp_send(socket_t *socket, sockdesc_t *sockdesc) { int error = poll_dowait(&polldesc, 0); poll_leave(&polldesc); poll_destroydesc(&polldesc); - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); if (error) goto leave; @@ -1328,13 +1328,13 @@ static int tcp_recv(socket_t *socket, sockdesc_t *sockdesc) { sockdesc->flags = 0; int error = 0; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); tcb_t *tcb = tcpsocket->tcb; if (tcb == NULL) { MUTEX_RELEASE(&socket->mutex); return ENOTCONN; } - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); if (tcb->state == TCB_STATE_CLOSED || tcb->state == TCB_STATE_SYNSENT || tcb->state == TCB_STATE_SYNRECEIVED) { error = ENOTCONN; goto cleanup; @@ -1378,7 +1378,7 @@ static int tcp_recv(socket_t *socket, sockdesc_t *sockdesc) { poll_leave(&desc); poll_destroydesc(&desc); - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); if (error) goto cleanup; @@ -1413,7 +1413,7 @@ static int tcp_recv(socket_t *socket, sockdesc_t *sockdesc) { static int tcp_poll(socket_t *socket, polldata_t *data, int events) { tcpsocket_t *tcpsocket = (tcpsocket_t *)socket; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); int revents = 0; if (tcpsocket->tcb == NULL) { // socket has never connected @@ -1421,7 +1421,7 @@ static int tcp_poll(socket_t *socket, polldata_t *data, int events) { goto leave; } - MUTEX_ACQUIRE(&tcpsocket->tcb->mutex, false); + MUTEX_ACQUIRE(&tcpsocket->tcb->mutex); revents = internalpoll(tcpsocket->tcb, data, events); @@ -1444,7 +1444,7 @@ static int tcp_bind(socket_t *socket, sockaddr_t *addr, cred_t *cred) { return error; } - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); tcb_t *tcb = tcpsocket->tcb; if (tcb == NULL) { tcb = allocatetcb(1); // smallest possible buffers TODO not even allocate those @@ -1456,7 +1456,7 @@ static int tcp_bind(socket_t *socket, sockaddr_t *addr, cred_t *cred) { TCB_HOLD(tcb); // for the release later } - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); int error; if (tcb->state != TCB_STATE_CLOSED || tcb->port) { @@ -1491,7 +1491,7 @@ static int tcp_connect(socket_t *socket, sockaddr_t *addr, uintmax_t flags, cred if (mtu == 0 || self == 0) return ENETUNREACH; // no route to ip in routing table - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); tcb_t *tcb = tcpsocket->tcb; if (tcb == NULL) { tcb = allocatetcb(mtu); @@ -1516,7 +1516,7 @@ static int tcp_connect(socket_t *socket, sockaddr_t *addr, uintmax_t flags, cred return EISCONN; } - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); polldesc_t polldesc = {0}; int error = poll_initdesc(&polldesc, 1); @@ -1609,7 +1609,7 @@ static int tcp_connect(socket_t *socket, sockaddr_t *addr, uintmax_t flags, cred static int tcp_listen(socket_t *socket, int backlog) { tcpsocket_t *tcpsocket = (tcpsocket_t *)socket; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); tcb_t *tcb = tcpsocket->tcb; if (tcb == NULL) { tcb = allocatetcb(1); // smallest possible buffers TODO not even allocate those @@ -1670,7 +1670,7 @@ static int tcp_accept(socket_t *server, socket_t *client, sockaddr_t *addr, uint tcpsocket_t *tcpserver = (tcpsocket_t *)server; tcpsocket_t *tcpclient = (tcpsocket_t *)client; // no need to lock client, only one thread is supposed to have a reference to it right now. - MUTEX_ACQUIRE(&server->mutex, false); + MUTEX_ACQUIRE(&server->mutex); tcb_t *tcb = tcpserver->tcb; int error = 0; @@ -1679,7 +1679,7 @@ static int tcp_accept(socket_t *server, socket_t *client, sockaddr_t *addr, uint return EINVAL; } - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); if (tcb->state != TCB_STATE_LISTEN) { error = EINVAL; @@ -1713,7 +1713,7 @@ static int tcp_accept(socket_t *server, socket_t *client, sockaddr_t *addr, uint poll_leave(&desc); poll_destroydesc(&desc); - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); if (error) goto cleanup; @@ -1738,12 +1738,12 @@ static int tcp_accept(socket_t *server, socket_t *client, sockaddr_t *addr, uint static size_t tcp_datacount(socket_t *socket) { tcpsocket_t *tcpsocket = (tcpsocket_t *)socket; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); size_t count = 0; if (tcpsocket->tcb == NULL) goto cleanup; - MUTEX_ACQUIRE(&tcpsocket->tcb->mutex, false); + MUTEX_ACQUIRE(&tcpsocket->tcb->mutex); count = RINGBUFFER_DATACOUNT(&tcpsocket->tcb->receivebuffer); @@ -1759,7 +1759,7 @@ static void tcp_destroy(socket_t *socket) { // no need to acquire the socket mutex as we have the last reference to it tcb_t *tcb = tcpsocket->tcb; if (tcb) { - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); if (tcb->state != TCB_STATE_CLOSED && tcb->state != TCB_STATE_ABORT) tcp_handleclose(tcb); @@ -1773,11 +1773,11 @@ static void tcp_destroy(socket_t *socket) { static int tcp_getname(socket_t *socket, sockaddr_t *addr) { tcpsocket_t *tcpsocket = (tcpsocket_t *)socket; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); tcb_t *tcb = tcpsocket->tcb; if (tcb) { - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); addr->ipv4addr.addr = 0; addr->ipv4addr.port = tcb->port; @@ -1794,11 +1794,11 @@ static int tcp_getname(socket_t *socket, sockaddr_t *addr) { static int tcp_getpeername(socket_t *socket, sockaddr_t *addr) { tcpsocket_t *tcpsocket = (tcpsocket_t *)socket; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); tcb_t *tcb = tcpsocket->tcb; if (tcb) { - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); addr->ipv4addr.addr = tcb->key.peer; addr->ipv4addr.port = tcb->key.peerport; @@ -1819,7 +1819,7 @@ static int tcp_setopt(socket_t *socket, int optname, void *buffer, size_t len, c tcb_t *tcb = tcpsocket->tcb; if (tcb) { - MUTEX_ACQUIRE(&tcb->mutex, false); + MUTEX_ACQUIRE(&tcb->mutex); switch (optname) { case SO_KEEPALIVE: diff --git a/kernel-src/io/net/udp.c b/kernel-src/io/net/udp.c index e5c033a6..7460f62a 100644 --- a/kernel-src/io/net/udp.c +++ b/kernel-src/io/net/udp.c @@ -140,7 +140,7 @@ static int udp_bind(socket_t *socket, sockaddr_t *addr, cred_t *cred) { } int e; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); if (socket->state != SOCKET_STATE_UNBOUND) { e = EINVAL; goto cleanup; @@ -183,7 +183,7 @@ static int internalpoll(socket_t *socket, polldata_t *data, int events) { static int udp_send(socket_t *socket, sockdesc_t *sockdesc) { udpsocket_t *udpsocket = (udpsocket_t *)socket; int e; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); if (sockdesc->addr == NULL && socket->state != SOCKET_STATE_CONNECTED) { e = ENOTCONN; @@ -218,7 +218,7 @@ static int udp_recv(socket_t *socket, sockdesc_t *sockdesc) { sockdesc->flags = 0; int e = 0; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); if (udpsocket->port == 0) { e = EINVAL; @@ -256,7 +256,7 @@ static int udp_recv(socket_t *socket, sockdesc_t *sockdesc) { if (e) return e; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); } // this abuses an asterisk on the ringbuffer implementation that makes it not need locking when @@ -311,7 +311,7 @@ static void udp_destroy(socket_t *socket) { static int udp_getname(socket_t *socket, sockaddr_t *addr) { udpsocket_t *udpsocket = (udpsocket_t *)socket; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); addr->ipv4addr.addr = udpsocket->address; addr->ipv4addr.port = udpsocket->port; MUTEX_RELEASE(&socket->mutex); @@ -320,7 +320,7 @@ static int udp_getname(socket_t *socket, sockaddr_t *addr) { static int udp_getpeername(socket_t *socket, sockaddr_t *addr) { udpsocket_t *udpsocket = (udpsocket_t *)socket; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); addr->ipv4addr.addr = udpsocket->peeraddress; addr->ipv4addr.port = udpsocket->peerport; MUTEX_RELEASE(&socket->mutex); @@ -329,7 +329,7 @@ static int udp_getpeername(socket_t *socket, sockaddr_t *addr) { static int udp_poll(socket_t *socket, polldata_t *data, int events) { int revents = 0; - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); revents = internalpoll(socket, data, events); diff --git a/kernel-src/io/term.c b/kernel-src/io/term.c index 68648b30..aa51d32a 100644 --- a/kernel-src/io/term.c +++ b/kernel-src/io/term.c @@ -23,7 +23,7 @@ static struct flanterm_context *term_ctx; static mutex_t term_mutex; void term_write(char *str, size_t count) { - MUTEX_ACQUIRE(&term_mutex, false); + MUTEX_ACQUIRE(&term_mutex); flanterm_write(term_ctx, str, count); MUTEX_RELEASE(&term_mutex); } diff --git a/kernel-src/io/tty.c b/kernel-src/io/tty.c index eb08b301..007c2f99 100644 --- a/kernel-src/io/tty.c +++ b/kernel-src/io/tty.c @@ -119,7 +119,7 @@ void tty_process(tty_t *tty, char c) { flush = true; if (flush) { - MUTEX_ACQUIRE(&tty->readmutex, false); + MUTEX_ACQUIRE(&tty->readmutex); ringbuffer_write(&tty->readbuffer, tty->devicebuffer, tty->devicepos); @@ -134,7 +134,7 @@ void tty_process(tty_t *tty, char c) { if (echoc) tty->writetodevice(tty->deviceinternal, &c, 1); - MUTEX_ACQUIRE(&tty->readmutex, false); + MUTEX_ACQUIRE(&tty->readmutex); ringbuffer_write(&tty->readbuffer, &c, 1); poll_event(&tty->pollheader, POLLIN); @@ -157,7 +157,7 @@ static int internalpoll(tty_t *tty, polldata_t *data, int events) { if (events & POLLOUT) revents |= POLLOUT; - MUTEX_ACQUIRE(&tty->readmutex, false); + MUTEX_ACQUIRE(&tty->readmutex); if ((events & POLLIN) && RINGBUFFER_DATACOUNT(&tty->readbuffer)) revents |= POLLIN; @@ -193,7 +193,7 @@ static int read(int minor, iovec_iterator_t *iovec_iterator, size_t size, uintma // read data and if theres nothing just return if (min == 0 && time == 0) { - MUTEX_ACQUIRE(&tty->readmutex, false); + MUTEX_ACQUIRE(&tty->readmutex); *readc = iovec_iterator_read_from_ringbuffer(iovec_iterator, &tty->readbuffer, size); int error = 0; @@ -225,7 +225,7 @@ static int read(int minor, iovec_iterator_t *iovec_iterator, size_t size, uintma if (revents) { // theres data to read - MUTEX_ACQUIRE(&tty->readmutex, false); + MUTEX_ACQUIRE(&tty->readmutex); size_t actuallyread = iovec_iterator_read_from_ringbuffer(iovec_iterator, &tty->readbuffer, spaceleft); @@ -414,7 +414,7 @@ static int open(int minor, vnode_t **vnode, int flags) { } static int allocminor(tty_t *tty) { - MUTEX_ACQUIRE(&listmutex, false); + MUTEX_ACQUIRE(&listmutex); int i; for (i = 0; i < TTY_MAX_COUNT; ++i) { @@ -429,7 +429,7 @@ static int allocminor(tty_t *tty) { } static void freeminor(int minor) { - MUTEX_ACQUIRE(&listmutex, false); + MUTEX_ACQUIRE(&listmutex); __assert(ttylist[minor]); ttylist[minor] = NULL; MUTEX_RELEASE(&listmutex); diff --git a/kernel-src/mm/pmm.c b/kernel-src/mm/pmm.c index 1ae265e0..df715550 100644 --- a/kernel-src/mm/pmm.c +++ b/kernel-src/mm/pmm.c @@ -132,7 +132,7 @@ void *pmm_getpageaddress(page_t *page) { void pmm_hold(void *addr) { page_t *page = &pages[((uintptr_t)addr / PAGE_SIZE)]; - MUTEX_ACQUIRE(&freelistmutex, false); + MUTEX_ACQUIRE(&freelistmutex); internalhold(page); MUTEX_RELEASE(&freelistmutex); } @@ -144,7 +144,7 @@ void pmm_release(void *addr) { uintmax_t newrefcount = __atomic_sub_fetch(&page->refcount, 1, __ATOMIC_SEQ_CST); if (newrefcount == 0) { __assert((page->flags & PAGE_FLAGS_DIRTY) == 0); - MUTEX_ACQUIRE(&freelistmutex, false); + MUTEX_ACQUIRE(&freelistmutex); insertinfreelist(page); if (page->backing == NULL) page->flags |= PAGE_FLAGS_FREE; @@ -160,7 +160,7 @@ static void doalloc(page_t *page) { void *pmm_allocpage(int section) { retry: - MUTEX_ACQUIRE(&freelistmutex, false); + MUTEX_ACQUIRE(&freelistmutex); page_t *page = NULL; // try to take a free anonymous page @@ -274,7 +274,7 @@ void *pmm_alloc(size_t size, int section) { if (size == 1) return pmm_allocpage(section); - MUTEX_ACQUIRE(&freelistmutex, false); + MUTEX_ACQUIRE(&freelistmutex); uintmax_t page = 0; size_t found = 0; diff --git a/kernel-src/mm/slab.c b/kernel-src/mm/slab.c index 520111cb..dcd75864 100644 --- a/kernel-src/mm/slab.c +++ b/kernel-src/mm/slab.c @@ -143,7 +143,7 @@ static slab_t *returnobject(scache_t *cache, void *obj) { } void *slab_allocate(scache_t *cache) { - MUTEX_ACQUIRE(&cache->mutex, false); + MUTEX_ACQUIRE(&cache->mutex); slab_t *slab = NULL; if (cache->partial != NULL) slab = cache->partial; @@ -192,7 +192,7 @@ void *slab_allocate(scache_t *cache) { } void slab_free(scache_t *cache, void *addr) { - MUTEX_ACQUIRE(&cache->mutex, false); + MUTEX_ACQUIRE(&cache->mutex); slab_t *slab = returnobject(cache, addr); __assert(slab); @@ -284,7 +284,7 @@ static size_t purge(scache_t *cache, size_t maxcount){ } void slab_freecache(scache_t *cache) { - MUTEX_ACQUIRE(&cache->mutex, false); + MUTEX_ACQUIRE(&cache->mutex); __assert(cache->partial == NULL); __assert(cache->full == NULL); diff --git a/kernel-src/mm/vmm.c b/kernel-src/mm/vmm.c index aa90068e..98f59f31 100644 --- a/kernel-src/mm/vmm.c +++ b/kernel-src/mm/vmm.c @@ -44,7 +44,7 @@ static vmmrange_t *allocrange() { vmmcache_t *cache = cachelist; vmmrange_t *range = NULL; while (cache) { - MUTEX_ACQUIRE(&cache->header.lock, false); + MUTEX_ACQUIRE(&cache->header.lock); if (cache->header.freecount > 0) { --cache->header.freecount; uintmax_t r = getentrynumber(cache); @@ -66,7 +66,7 @@ static vmmrange_t *allocrange() { static void freerange(vmmrange_t *range) { vmmcache_t *cache = (vmmcache_t *)ROUND_DOWN((uintptr_t)range, PAGE_SIZE); - MUTEX_ACQUIRE(&cache->header.lock, false); + MUTEX_ACQUIRE(&cache->header.lock); int rangeoffset = ((uintptr_t)range - (uintptr_t)cache->ranges) / sizeof(vmmrange_t); range->size = 0; @@ -501,7 +501,7 @@ int vmm_changemmuflags(void *base, size_t size, mmuflags_t mmuflags, int flags) if (space == NULL) return ENOMEM; - MUTEX_ACQUIRE(&space->lock, false); + MUTEX_ACQUIRE(&space->lock); int error = changemap(space, base, size, false, flags, mmuflags); arch_mmu_invalidate_range(base, size); @@ -536,7 +536,7 @@ bool vmm_pagefault(void *addr, bool user, int actions) { return false; } - MUTEX_ACQUIRE(&space->lock, false); + MUTEX_ACQUIRE(&space->lock); vmmrange_t *range = getrange(space, addr); bool status = false; @@ -665,7 +665,7 @@ void *vmm_getphysical(void *addr, bool hold) { if (space == NULL) return NULL; - MUTEX_ACQUIRE(&space->lock, false); + MUTEX_ACQUIRE(&space->lock); void *physical = arch_mmu_getphysical(current_vmm_context()->pagetable, addr); @@ -695,7 +695,7 @@ void *vmm_map(void *addr, volatile size_t size, int flags, mmuflags_t mmuflags, if (space == NULL) return NULL; - MUTEX_ACQUIRE(&space->lock, false); + MUTEX_ACQUIRE(&space->lock); vmmrange_t *range = NULL; void *start = getfreerange(space, addr, size); @@ -803,7 +803,7 @@ void vmm_unmap(void *addr, size_t size, int flags) { if (space == NULL) return; - MUTEX_ACQUIRE(&space->lock, false); + MUTEX_ACQUIRE(&space->lock); // make memory inacessible changemap(space, addr, size, false, flags, 0); @@ -858,7 +858,7 @@ vmmcontext_t *vmm_fork(vmmcontext_t *oldcontext) { if (newcontext == NULL) return NULL; - MUTEX_ACQUIRE(&oldcontext->space.lock, false); + MUTEX_ACQUIRE(&oldcontext->space.lock); vmmrange_t *range = oldcontext->space.ranges; diff --git a/kernel-src/mm/vmmcache.c b/kernel-src/mm/vmmcache.c index b2e60784..f9ab2c25 100644 --- a/kernel-src/mm/vmmcache.c +++ b/kernel-src/mm/vmmcache.c @@ -18,7 +18,7 @@ static eventheader_t pagereadyevent; size_t vmmcache_cachedpages; #define HOLD_LOCK() \ - MUTEX_ACQUIRE(&mutex, false); + MUTEX_ACQUIRE(&mutex); #define RELEASE_LOCK() \ MUTEX_RELEASE(&mutex); diff --git a/kernel-src/sys/proc.c b/kernel-src/sys/proc.c index f418c0b1..89383060 100644 --- a/kernel-src/sys/proc.c +++ b/kernel-src/sys/proc.c @@ -24,7 +24,7 @@ pid_t proc_allocate_pid(void) { } proc_t *proc_get_from_pid(int pid) { - MUTEX_ACQUIRE(&proc_pid_table_mutex, false); + MUTEX_ACQUIRE(&proc_pid_table_mutex); void *_proc = NULL; hashtable_get(&pid_table, &_proc, &pid, sizeof(pid)); proc_t *proc = _proc; @@ -37,7 +37,7 @@ proc_t *proc_get_from_pid(int pid) { } int proc_signal_all(int signal, proc_t *sender) { - MUTEX_ACQUIRE(&proc_pid_table_mutex, false); + MUTEX_ACQUIRE(&proc_pid_table_mutex); pid_t senderpgid = sender ? jobctl_getpgid(sender) : 0; @@ -108,7 +108,7 @@ proc_t *proc_create() { proc->umask = 022; // default umask // add to pid table - MUTEX_ACQUIRE(&proc_pid_table_mutex, false); + MUTEX_ACQUIRE(&proc_pid_table_mutex); if (hashtable_set(&pid_table, proc, &proc->pid, sizeof(proc->pid), true)) { MUTEX_RELEASE(&proc_pid_table_mutex); free(proc->fd); @@ -255,7 +255,7 @@ void proc_exit(void) { itimer_pause(&proc->timer.profiling, NULL, NULL); // zombify the proc - MUTEX_ACQUIRE(&proc->mutex, false); + MUTEX_ACQUIRE(&proc->mutex); VOP_RELEASE(proc->root); VOP_RELEASE(proc->cwd); @@ -264,7 +264,7 @@ void proc_exit(void) { proc_t *lastchild = proc->child; - MUTEX_ACQUIRE(&init_proc->mutex, false); + MUTEX_ACQUIRE(&init_proc->mutex); int belowzombiecount = 0; diff --git a/kernel-src/sys/syscalls/fork.c b/kernel-src/sys/syscalls/fork.c index cc25e506..14218d47 100644 --- a/kernel-src/sys/syscalls/fork.c +++ b/kernel-src/sys/syscalls/fork.c @@ -35,7 +35,7 @@ syscallret_t syscall_fork(context_t *ctx) { if (ret.errno) goto cleanup; - MUTEX_ACQUIRE(&proc->mutex, false); + MUTEX_ACQUIRE(&proc->mutex); nproc->parent = proc; nproc->sibling = proc->child; diff --git a/kernel-src/sys/syscalls/futex.c b/kernel-src/sys/syscalls/futex.c index f898a533..fe8eb6f4 100644 --- a/kernel-src/sys/syscalls/futex.c +++ b/kernel-src/sys/syscalls/futex.c @@ -72,7 +72,7 @@ syscallret_t syscall_futex(context_t *, uint32_t *futexp, int op, uint32_t value if (ret.errno) return ret; - MUTEX_ACQUIRE(&futexmutex, false); + MUTEX_ACQUIRE(&futexmutex); bool doleave = true; uint32_t word; @@ -130,7 +130,7 @@ syscallret_t syscall_futex(context_t *, uint32_t *futexp, int op, uint32_t value if (desc.event) revents = desc.event->revents; - MUTEX_ACQUIRE(&futexmutex, false); + MUTEX_ACQUIRE(&futexmutex); if (revents == 0 || ret.errno == EINTR) { // timed out or interrupted diff --git a/kernel-src/sys/syscalls/open.c b/kernel-src/sys/syscalls/open.c index b8c52518..3bf84a60 100644 --- a/kernel-src/sys/syscalls/open.c +++ b/kernel-src/sys/syscalls/open.c @@ -85,7 +85,7 @@ syscallret_t syscall_openat(context_t *context, int dirfd, char *path, int flags goto cleanup; if (vnode->type == V_TYPE_REGULAR && (flags & O_TRUNC) && (flags & FILE_WRITE)) { - MUTEX_ACQUIRE(&vnode->size_lock, false); + MUTEX_ACQUIRE(&vnode->size_lock); VOP_LOCK(vnode); ret.errno = VOP_RESIZE(vnode, 0, ¤t_thread()->proc->cred); diff --git a/kernel-src/sys/syscalls/print.c b/kernel-src/sys/syscalls/print.c index 676131ef..c274fb32 100644 --- a/kernel-src/sys/syscalls/print.c +++ b/kernel-src/sys/syscalls/print.c @@ -17,7 +17,7 @@ syscallret_t syscall_print(context_t *context, char *message) { initialized = true; } - MUTEX_ACQUIRE(&mutex, false); + MUTEX_ACQUIRE(&mutex); arch_e9_puts(message); arch_e9_putc('\n'); MUTEX_RELEASE(&mutex); diff --git a/kernel-src/sys/syscalls/setitimer.c b/kernel-src/sys/syscalls/setitimer.c index 3ae3c8d8..55a89ebc 100644 --- a/kernel-src/sys/syscalls/setitimer.c +++ b/kernel-src/sys/syscalls/setitimer.c @@ -36,7 +36,7 @@ syscallret_t syscall_getitimer(context_t *context, int which, itimerval_t *value return ret; } - MUTEX_ACQUIRE(¤t_thread()->proc->timer.mutex, false); + MUTEX_ACQUIRE(¤t_thread()->proc->timer.mutex); uintmax_t oldremaining, oldrepeat; itimer_pause(itimer, &oldremaining, &oldrepeat); @@ -76,7 +76,7 @@ syscallret_t syscall_setitimer(context_t *context, int which, itimerval_t *unew, return ret; } - MUTEX_ACQUIRE(¤t_thread()->proc->timer.mutex, false); + MUTEX_ACQUIRE(¤t_thread()->proc->timer.mutex); uintmax_t oldremaining, oldrepeat; itimer_pause(itimer, &oldremaining, &oldrepeat); diff --git a/kernel-src/sys/syscalls/setsockopt.c b/kernel-src/sys/syscalls/setsockopt.c index 6780ee2b..d52f63ed 100644 --- a/kernel-src/sys/syscalls/setsockopt.c +++ b/kernel-src/sys/syscalls/setsockopt.c @@ -43,7 +43,7 @@ syscallret_t syscall_setsockopt(context_t *, int fd, int level, int optname, voi socket_t *socket = SOCKFS_SOCKET_FROM_NODE(file->vnode); - MUTEX_ACQUIRE(&socket->mutex, false); + MUTEX_ACQUIRE(&socket->mutex); switch (optname) { case SO_BINDTODEVICE: { if (val) { diff --git a/kernel-src/sys/syscalls/truncate.c b/kernel-src/sys/syscalls/truncate.c index 3915d0aa..c949018e 100644 --- a/kernel-src/sys/syscalls/truncate.c +++ b/kernel-src/sys/syscalls/truncate.c @@ -17,7 +17,7 @@ syscallret_t syscall_ftruncate(int fd, size_t size) { goto cleanup; } - MUTEX_ACQUIRE(&file->vnode->size_lock, false); + MUTEX_ACQUIRE(&file->vnode->size_lock); VOP_LOCK(file->vnode); ret.errno = VOP_RESIZE(file->vnode, size, ¤t_thread()->proc->cred); diff --git a/kernel-src/sys/syscalls/waitpid.c b/kernel-src/sys/syscalls/waitpid.c index bc04c911..15069dff 100644 --- a/kernel-src/sys/syscalls/waitpid.c +++ b/kernel-src/sys/syscalls/waitpid.c @@ -21,7 +21,7 @@ syscallret_t syscall_waitpid(context_t *context, pid_t pid, int *status, int opt thread_t *thread = current_thread(); proc_t *proc = thread->proc; - MUTEX_ACQUIRE(&proc->mutex, false); + MUTEX_ACQUIRE(&proc->mutex); proc_t *prev = NULL; proc_t *iterator = proc->child; @@ -53,7 +53,7 @@ syscallret_t syscall_waitpid(context_t *context, pid_t pid, int *status, int opt ret.errno = EINTR; return ret; } - MUTEX_ACQUIRE(&proc->mutex, false); + MUTEX_ACQUIRE(&proc->mutex); prev = NULL; iterator = proc->child; desired = NULL; // set as null to be certain another thread didn't get it diff --git a/kernel-src/sys/timekeeper.c b/kernel-src/sys/timekeeper.c index 09a7d08c..42a7823d 100644 --- a/kernel-src/sys/timekeeper.c +++ b/kernel-src/sys/timekeeper.c @@ -72,7 +72,7 @@ static void timekeeper_sync_isr(isr_t *, context_t *) { // their offsets to the passed microseconds of the calling CPU in ticks. this isn't 100% precise but its not // exactly possible to be void timekeeper_sync(void) { - MUTEX_ACQUIRE(&sync_mutex, false); + MUTEX_ACQUIRE(&sync_mutex); bool int_status = interrupt_set(false); sync_go_ahead = false; diff --git a/kernel-src/sys/topology.c b/kernel-src/sys/topology.c index 1e503838..da3d3515 100644 --- a/kernel-src/sys/topology.c +++ b/kernel-src/sys/topology.c @@ -11,7 +11,7 @@ static MUTEX_DEFINE(allocate_mutex); static SPINLOCK_DEFINE(tree_lock); topology_node_t *topology_create_node(void) { - MUTEX_ACQUIRE(&allocate_mutex, false); + MUTEX_ACQUIRE(&allocate_mutex); if (unlikely(slab_cache == NULL)) { slab_cache = slab_newcache(sizeof(topology_node_t), 0, NULL, NULL); __assert(slab_cache);