Ports: Update the citron patches after upstreaming a few

This also switches to checking out a specific commit instead of just the
master HEAD, as the port linter requires a hash (which is imo pointless
in this case), and we can't provide a stable hash for the master branch
HEAD.

Ports/citron/patches/0003-Make-coroutines-a-noop.patch

@@ -0,0 +1,177 @@
+From ee5ca4723aa24d850d13c9a3fcbf7f23250cc4b7 Mon Sep 17 00:00:00 2001
+From: Ali Mohammad Pur <ali.mpfard@gmail.com>
+Date: Fri, 11 Feb 2022 16:37:54 +0330
+Subject: [PATCH 3/9] Make coroutines a noop
+
+Serenity doesn't have ucontext.
+---
+ src/coroutine.c | 41 +++++++++++++++++++++++++++++++++++++++--
+ 1 file changed, 39 insertions(+), 2 deletions(-)
+
+diff --git a/src/coroutine.c b/src/coroutine.c
+index 8497869..8215cfa 100644
+--- a/src/coroutine.c
++++ b/src/coroutine.c
+@@ -8,7 +8,7 @@
+ 
+ #if __APPLE__ && __MACH__
+ #    include <sys/ucontext.h>
+-#else
++#elif !defined(__serenity__)
+ #    include <ucontext.h>
+ #endif
+ 
+@@ -17,6 +17,7 @@
+ 
+ struct coroutine;
+ 
++#ifndef __serenity__
+ struct schedule {
+     char stack[STACK_SIZE];
+     ucontext_t main;
+@@ -36,9 +37,13 @@ struct coroutine {
+     int status;
+     char* stack;
+ };
++#endif
+ 
+ struct coroutine* _co_new(struct schedule* S, coroutine_func func, void* ud)
+ {
++#ifdef __serenity__
++    return NULL;
++#else
+     struct coroutine* co = malloc(sizeof(*co));
+     co->func = func;
+     co->ud = ud;
+@@ -48,16 +53,20 @@ struct coroutine* _co_new(struct schedule* S, coroutine_func func, void* ud)
+     co->status = COROUTINE_READY;
+     co->stack = NULL;
+     return co;
++#endif
+ }
+ 
+ void _co_delete(struct coroutine* co)
+ {
++#ifndef __serenity__
+     free(co->stack);
+     free(co);
++#endif
+ }
+ 
+ struct schedule* coroutine_open(void)
+ {
++#ifndef __serenity__
+     struct schedule* S = malloc(sizeof(*S));
+     S->nco = 0;
+     S->cap = DEFAULT_COROUTINE;
+@@ -65,10 +74,14 @@ struct schedule* coroutine_open(void)
+     S->co = malloc(sizeof(struct coroutine*) * S->cap);
+     memset(S->co, 0, sizeof(struct coroutine*) * S->cap);
+     return S;
++#else
++    return NULL;
++#endif
+ }
+ 
+ void coroutine_close(struct schedule* S)
+ {
++#ifndef __serenity__
+     int i;
+     for (i = 0; i < S->cap; i++) {
+         struct coroutine* co = S->co[i];
+@@ -79,10 +92,12 @@ void coroutine_close(struct schedule* S)
+     free(S->co);
+     S->co = NULL;
+     free(S);
++#endif
+ }
+ 
+ int coroutine_new(struct schedule* S, coroutine_func func, void* ud)
+ {
++#ifndef __serenity__
+     struct coroutine* co = _co_new(S, func, ud);
+     if (S->nco >= S->cap) {
+         int id = S->cap;
+@@ -105,10 +120,14 @@ int coroutine_new(struct schedule* S, coroutine_func func, void* ud)
+     }
+     assert(0);
+     return -1;
++#else
++    return 0;
++#endif
+ }
+ 
+ static void mainfunc(uint32_t low32, uint32_t hi32)
+ {
++#ifndef __serenity__
+     uintptr_t ptr = (uintptr_t)low32 | ((uintptr_t)hi32 << 32);
+     struct schedule* S = (struct schedule*)ptr;
+     int id = S->running;
+@@ -118,10 +137,12 @@ static void mainfunc(uint32_t low32, uint32_t hi32)
+     S->co[id] = NULL;
+     --S->nco;
+     S->running = -1;
++#endif
+ }
+ 
+ void coroutine_resume(struct schedule* S, int id)
+ {
++#ifndef __serenity__
+     assert(S->running == -1);
+     assert(id >= 0 && id < S->cap);
+     struct coroutine* C = S->co[id];
+@@ -150,8 +171,10 @@ void coroutine_resume(struct schedule* S, int id)
+     default:
+         assert(0);
+     }
++#endif
+ }
+ 
++#ifndef __serenity__
+ static void _save_stack(struct coroutine* C, char* top)
+ {
+     char dummy = 0;
+@@ -164,9 +187,11 @@ static void _save_stack(struct coroutine* C, char* top)
+     C->size = top - &dummy;
+     memcpy(C->stack, &dummy, C->size);
+ }
++#endif
+ 
+ void coroutine_yield(struct schedule* S)
+ {
++#ifndef __serenity__
+     int id = S->running;
+     assert(id >= 0);
+     struct coroutine* C = S->co[id];
+@@ -175,15 +200,27 @@ void coroutine_yield(struct schedule* S)
+     C->status = COROUTINE_SUSPEND;
+     S->running = -1;
+     swapcontext(&C->ctx, &S->main);
++#endif
+ }
+ 
+ int coroutine_status(struct schedule* S, int id)
+ {
++#ifndef __serenity__
+     assert(id >= 0 && id < S->cap);
+     if (S->co[id] == NULL) {
+         return COROUTINE_DEAD;
+     }
+     return S->co[id]->status;
++#else
++    return COROUTINE_DEAD;
++#endif
+ }
+ 
+-int coroutine_running(struct schedule* S) { return S->running; }
++int coroutine_running(struct schedule* S)
++{
++#ifndef __serenity__
++    return S->running;
++#else
++    return 0;
++#endif
++}
+-- 
+2.34.1
+