mirrors/Astral
1
0
Fork 0
mirror of https://github.com/Mathewnd/Astral.git synced 2026-10-27 12:48:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

kernel: finish work of removing interruptible mutexes

Browse Source
This commit is contained in:
Matheus
2024-12-24 21:30:25 -03:00
parent 48643c4868
commit a6c169e5e6
42 changed files with 169 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files
kernel-src/arch/x86-64/hpet.c
+1 -1
View File
@@ -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;
kernel-src/arch/x86-64/tsc.c
+1 -1
View File
@@ -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));
kernel-src/fs/devfs.c
+6 -6
View File
@@ -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);
kernel-src/fs/ext2.c
+13 -13
View File
@@ -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;
kernel-src/fs/file.c
+8 -8
View File
@@ -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) {
kernel-src/fs/pipefs.c
+1 -1
View File
@@ -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) {
kernel-src/fs/sockfs.c
+1 -1
View File
@@ -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) {
kernel-src/fs/tmpfs.c
+1 -1
View File
@@ -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;
}
kernel-src/fs/vfs.c
+3 -3
View File
@@ -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(&current_thread()->proc->mutex, false);
MUTEX_ACQUIRE(&current_thread()->proc->mutex);
derefstart = current_thread()->proc->root;
VOP_HOLD(derefstart);
MUTEX_RELEASE(&current_thread()->proc->mutex);
kernel-src/include/kernel/file.h
+1 -1
View File
@@ -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
kernel-src/include/kernel/proc.h
+1 -1
View File
@@ -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; \
kernel-src/include/logging.h
+1 -1
View File
@@ -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(); \
} \
kernel-src/include/mutex.h
+4 -4
View File
@@ -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)
kernel-src/io/acpi/dev.c
+2 -2
View File
@@ -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;
kernel-src/io/acpi/glue.c
+2 -2
View File
@@ -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;
}
kernel-src/io/block/block.c
+2 -2
View File
@@ -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);
kernel-src/io/console.c
+1 -1
View File
@@ -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);
kernel-src/io/keyboard.c
+2 -2
View File
@@ -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, &currentkbnum, sizeof(currentkbnum), true)) {
MUTEX_RELEASE(&tablelock);
kernel-src/io/mouse.c
+4 -4
View File
@@ -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, &currentnum, sizeof(currentnum), true)) {
MUTEX_RELEASE(&tablelock);
kernel-src/io/net/arp.c
+4 -4
View File
@@ -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) {
kernel-src/io/net/ipv4.c
+2 -2
View File
@@ -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;
kernel-src/io/net/localsocket.c
+27 -27
View File
@@ -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
kernel-src/io/net/netdev.c
+2 -2
View File
@@ -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;
kernel-src/io/net/tcp.c
+30 -30
View File
@@ -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:
kernel-src/io/net/udp.c
+7 -7
View File
@@ -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);
kernel-src/io/term.c
+1 -1
View File
@@ -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);
}
kernel-src/io/tty.c
+7 -7
View File
@@ -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);
kernel-src/mm/pmm.c
+4 -4
View File
@@ -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;
kernel-src/mm/slab.c
+3 -3
View File
@@ -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);
kernel-src/mm/vmm.c
+8 -8
View File
@@ -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;
kernel-src/mm/vmmcache.c
+1 -1
View File
@@ -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);
kernel-src/sys/proc.c
+5 -5
View File
@@ -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;
kernel-src/sys/syscalls/fork.c
+1 -1
View File
@@ -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;
kernel-src/sys/syscalls/futex.c
+2 -2
View File
@@ -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
kernel-src/sys/syscalls/open.c
+1 -1
View File
@@ -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, &current_thread()->proc->cred);
kernel-src/sys/syscalls/print.c
+1 -1
View File
@@ -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);
kernel-src/sys/syscalls/setitimer.c
+2 -2
View File
@@ -36,7 +36,7 @@ syscallret_t syscall_getitimer(context_t *context, int which, itimerval_t *value
return ret;
}
MUTEX_ACQUIRE(&current_thread()->proc->timer.mutex, false);
MUTEX_ACQUIRE(&current_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(&current_thread()->proc->timer.mutex, false);
MUTEX_ACQUIRE(&current_thread()->proc->timer.mutex);
uintmax_t oldremaining, oldrepeat;
itimer_pause(itimer, &oldremaining, &oldrepeat);
kernel-src/sys/syscalls/setsockopt.c
+1 -1
View File
@@ -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) {
kernel-src/sys/syscalls/truncate.c
+1 -1
View File
@@ -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, &current_thread()->proc->cred);
kernel-src/sys/syscalls/waitpid.c
+2 -2
View File
@@ -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
kernel-src/sys/timekeeper.c
+1 -1
View File
@@ -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;
kernel-src/sys/topology.c
+1 -1
View File
@@ -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);