mirrors/Astral
1
0
Fork 0
mirror of https://github.com/Mathewnd/Astral.git synced 2026-10-31 14:38:21 +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/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);