Added a string channel (though I haven't hooked it up yet).

Then I proceeded to make an awful lot of changes in the process of
porting to Linux, to try to figure out the magic problem I was having,
where things were working in a debugger, but not outside it.

Most of them seemed to not be necessary. It looks like the problem
was, I somehow started to get a poll trigger for the stdout fd to be
readable before the stdin trigger.

I don't know why my machine suddenly freaked out, but the issue does
make sense. Stdin and stdout are the same underlying pty when I'm
running at the command line, but the debugger has them as two pipes,
and not a terminal.

Some of the work I did was useful, or made things simpler: For instance:

1) I moved the 'stop the world' used in Garbage Collection from a spin
   lock to use progressive locking.

2) I added an option to protect the entire heap, and align allocs to
   the page, so if there's a pointer math error, I can detect it as it
   happens.

Author: viega

include/adts/dt_lists.h

@@ -3,9 +3,9 @@
 #include "n00b.h"
 
 typedef struct {
+    n00b_rw_lock_t lock;
     int64_t      **data;
     uint64_t       noscan;
-    n00b_rw_lock_t lock;
     int32_t        append_ix          : 30;
     // The actual length if treated properly. We should be
     // careful about it.

include/adts/duration.h

@@ -48,3 +48,9 @@ n00b_timeval_to_duration(struct timeval *s)
 {
     return n00b_new(n00b_type_duration(), n00b_kw("timeval", s));
 }
+
+static inline void
+n00b_write_now(n00b_duration_t *output)
+{
+    clock_gettime(CLOCK_REALTIME, output);
+}

include/channels/channel_buffer.h

@@ -21,3 +21,15 @@ extern n00b_channel_t *_n00b_io_buf_channel(n00b_buf_t *, bool, ...);
     _n00b_out_buf_channel(buffer, __VA_ARGS__ __VA_OPT__(, ) 0ULL, 0ULL)
 #define n00b_io_buf_channel(buffer, ...) \
     _n00b_io_buf_channel(buffer, __VA_ARGS__ __VA_OPT__(, ) 0ULL, 0ULL)
+
+static inline n00b_buf_t *
+n00b_channel_extract_buffer(n00b_channel_t *s)
+{
+    n00b_buffer_channel_t *c = (void *)s->cookie;
+
+    if (!n00b_type_is_buffer(n00b_get_my_type(c->buffer))) {
+        return NULL;
+    }
+
+    return c->buffer;
+}

include/channels/channel_fd.h

@@ -18,9 +18,6 @@ extern void           *_n00b_read_file(n00b_string_t *, ...);
 extern n00b_channel_t *_n00b_create_listener(n00b_net_addr_t *, ...);
 extern n00b_channel_t *_n00b_channel_connect(n00b_net_addr_t *, ...);
 
-extern void n00b_channel_fd_pause_reads(n00b_channel_t *);
-extern void n00b_channel_fd_unpause_reads(n00b_channel_t *);
-
 #define n00b_new_fd_channel(fdstrm, ...) \
     _n00b_new_fd_channel(fdstrm, N00B_VA(__VA_ARGS__));
 

include/channels/channel_string.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "n00b.h"
+
+typedef struct {
+    n00b_list_t *l;
+    int          ix;
+} n00b_string_channel_t;
+
+extern n00b_channel_t *
+_n00b_new_string_channel(n00b_string_t *, ...);
+
+#define n00b_string_channel(string, ...) \
+    _n00b_in_buf_channel(string, __VA_ARGS__ __VA_OPT__(, ) 0ULL)

include/channels/fd_event.h

@@ -53,8 +53,6 @@ struct n00b_fd_stream_t {
     unsigned int             needs_r          : 1;
     unsigned int             r_added          : 1;
     unsigned int             w_added          : 1;
-    unsigned int             pause_req        : 1; // request pause.
-    unsigned int             is_paused        : 1; // Paused.
     // This is set externally if the dispatcher should not do the r/w
     // itself for a stream.  In that case, you probably set the notify
     // callback.
@@ -214,28 +212,6 @@ n00b_fd_is_other(n00b_fd_stream_t *s)
               || n00b_fd_is_link(s)));
 }
 
-// This is potentially racy, but ideally shouldn't be good design to
-// use willy nilly, so didn't work to get it fully safe.
-static inline void
-n00b_fd_pause_reads(n00b_fd_stream_t *s)
-{
-    if (!s->is_paused) {
-        s->pause_req = true;
-    }
-
-    n00b_list_append(s->evloop->pending, s);
-}
-
-static inline void
-n00b_fd_unpause_reads(n00b_fd_stream_t *s)
-{
-    if (s->is_paused) {
-        s->pause_req = true;
-    }
-
-    n00b_list_append(s->evloop->pending, s);
-}
-
 #ifdef N00B_USE_INTERNAL_API
 typedef bool (*n00b_condition_test_fn)(void *);
 extern bool n00b_condition_poll(n00b_condition_test_fn, void *, int to);

include/channels/filter.h

@@ -72,3 +72,7 @@ typedef struct {
     n00b_filter_impl *impl;
     int               policy;
 } n00b_filter_spec_t;
+
+extern n00b_filter_spec_t *n00b_filter_apply_color(void);
+extern n00b_filter_spec_t *n00b_filter_json(void);
+extern n00b_filter_spec_t *n00b_filter_marshal(void);

include/channels/proc.h

@@ -38,9 +38,10 @@ typedef struct {
     n00b_list_t          *pending_stderr_subs;
     n00b_lock_t           run_lock;
     n00b_condition_t      cv;
-    n00b_buf_t           *cap_in;
-    n00b_buf_t           *cap_out;
-    n00b_buf_t           *cap_err;
+    n00b_channel_t       *cap_in;
+    n00b_channel_t       *cap_out;
+    n00b_channel_t       *cap_err;
+    n00b_channel_t       *exit_cb;
     n00b_post_fork_hook_t hook;
     void                 *param;
     struct winsize        dimensions;
@@ -167,7 +168,7 @@ n00b_proc_get_stdout_capture(n00b_proc_t *proc)
     if (!proc->cap_out) {
         N00B_CRAISE("stdout was not monitored for this process.");
     }
-    return proc->cap_out;
+    return n00b_channel_extract_buffer(proc->cap_out);
 }
 
 static inline n00b_buf_t *
@@ -178,7 +179,7 @@ n00b_proc_get_stderr_capture(n00b_proc_t *proc)
     if (!proc->cap_err) {
         N00B_CRAISE("stderr was not monitored for this process.");
     }
-    return proc->cap_err;
+    return n00b_channel_extract_buffer(proc->cap_err);
 }
 
 static inline n00b_buf_t *
@@ -190,7 +191,7 @@ n00b_proc_get_stdin_capture(n00b_proc_t *proc)
         N00B_CRAISE("stdin was not monitored for this process.");
     }
 
-    return proc->cap_in;
+    return n00b_channel_extract_buffer(proc->cap_in);
 }
 
 static inline bool

include/channels/terminal_io.h

@@ -3,6 +3,9 @@
 n00b_channel_t *n00b_chan_stdin(void);
 n00b_channel_t *n00b_chan_stdout(void);
 n00b_channel_t *n00b_chan_stderr(void);
+n00b_channel_t *n00b_chan_raw_stdin(void);
+n00b_channel_t *n00b_chan_raw_stdout(void);
+n00b_channel_t *n00b_chan_raw_stderr(void);
 
 extern void n00b_terminal_dimensions(size_t *cols, size_t *rows);
 extern void n00b_termcap_apply_raw_mode(struct termios *termcap);

include/core/locks.h

@@ -1,7 +1,6 @@
 #pragma once
 #include "n00b/base.h"
 
-extern bool n00b_is_world_stopped(void);
 extern bool n00b_abort_signal;
 
 // Must be a power of 2.

include/core/thread.h

@@ -63,14 +63,24 @@ typedef struct {
 } n00b_global_thread_info_t;
 
 // Use the first one on thread first start-up only.
-extern void n00b_gts_start(void);
-extern void n00b_gts_suspend(void);
-extern void n00b_gts_resume(void);
-extern void n00b_gts_checkin(void);
-extern void n00b_gts_stop_the_world(void);
-extern void n00b_gts_restart_the_world(void);
+extern void _n00b_gts_start(char *, int);
+extern void _n00b_gts_suspend(char *, int);
+extern void _n00b_gts_resume(char *, int);
+extern void _n00b_gts_might_stop(char *, int);
+extern void _n00b_gts_stop_the_world(char *, int);
+extern void _n00b_gts_wont_stop(char *, int);
+extern void _n00b_gts_restart_the_world(char *, int);
+extern void n00b_gts_reacquire(void);
 extern void n00b_gts_notify_abort(void);
 
+#define n00b_gts_start()             _n00b_gts_start(__FILE__, __LINE__)
+#define n00b_gts_suspend()           _n00b_gts_suspend(__FILE__, __LINE__)
+#define n00b_gts_resume()            _n00b_gts_resume(__FILE__, __LINE__)
+#define n00b_gts_might_stop()        _n00b_gts_might_stop(__FILE__, __LINE__)
+#define n00b_gts_wont_stop()         _n00b_gts_stop_the_world(__FILE__, __LINE__)
+#define n00b_gts_stop_the_world()    _n00b_gts_stop_the_world(__FILE__, __LINE__)
+#define n00b_gts_restart_the_world() _n00b_gts_restart_the_world(__FILE__, __LINE__)
+
 extern void           n00b_thread_stack_region(n00b_thread_t *);
 extern n00b_thread_t *n00b_thread_register(void);
 extern void           n00b_thread_unregister(void *);

include/core/tsi.h

@@ -50,6 +50,12 @@ typedef struct {
     // This flag is used for critical sections with private
     // data structures to suspend locking.
     int                        suspend_locking       : 1;
+    int                        gti_s                 : 1;
+    int                        gti_w                 : 1;
+    int                        gti_r;
+    char                      *gti_file;
+    int                        gti_line;
+    int                        gti_next;
 #if defined(N00B_ENABLE_ALLOC_DEBUG)
     int show_alloc_locations : 1;
 #endif
@@ -247,12 +253,17 @@ n00b_alloc_guard_next_new(void)
 #endif
 
 // Use to stash on the stack.
+#if 0
 #define n00b_push_heap(heap)                             \
     n00b_heap_t *__n00b_saved_heap = n00b_thread_heap(); \
     n00b_set_thread_heap(heap)
 
 #define n00b_pop_heap() \
     n00b_set_thread_heap(__n00b_saved_heap)
+#endif
+
+#define n00b_push_heap(heap)
+#define n00b_pop_heap()
 
 #ifdef N00B_USE_INTERNAL_API
 extern void

include/crypto/dt_crypto.h

@@ -6,6 +6,6 @@ typedef void *EVP_MD;
 typedef void *OSSL_PARAM;
 
 typedef struct {
+    EVP_MD_CTX  openssl_ctx;
     n00b_buf_t *digest;
-    EVP_MD_CTX openssl_ctx;
 } n00b_sha_t;

include/n00b.h

@@ -87,7 +87,7 @@ extern bool n00b_startup_complete;
 #include "channels/channel_topic.h"
 #include "channels/channel_exit.h"
 #include "channels/channel_proxy.h"
-// #include "channels/channel_string.h"
+#include "channels/channel_string.h"
 #include "channels/terminal_io.h"
 #include "channels/debug.h"
 

include/n00b/config.h

@@ -1,6 +1,5 @@
 #ifdef n00b_some_stuff_i_may_occasionally_enable_in_testing
 
-#define N00B_SHOW_GARBAGE_REPORTS
 #define N00B_USE_LOCK_DEBUGGING
 #define N00B_ENABLE_ALLOC_DEBUG_OPT_IN
 #define N00B_GC_SHOW_COLLECT_STACK_TRACES
@@ -13,7 +12,11 @@
 #else
 #endif
 
-#define N00B_USE_LOCK_DEBUGGING
+// #define N00B_GC_STATS
+// #define N00B_DEBUG_GC_ROOTS
+// #define N00B_FIND_SCRIBBLES
+// #define N00B_SCAN_ALLOC
+// #define N00B_USE_LOCK_DEBUGGING
 
 #pragma once
 // Home of anything remotely configurable. Don't change this file;
@@ -143,19 +146,6 @@
 #define N00B_DEFAULT_HEAP_SIZE (1 << 26) // 30 == 1 g
 #endif
 
-#ifndef N00B_SYSTEM_HEAP_SIZE
-// Can't be any smaller than this for startup.
-#define N00B_SYSTEM_HEAP_SIZE (1 << 24)
-#endif
-
-#ifndef N00B_START_STRING_HEAP_SIZE
-#define N00B_START_STRING_HEAP_SIZE (1 << 24)
-#endif
-
-#ifndef N00B_START_SCRATCH_HEAP_SIZE
-#define N00B_START_SCRATCH_HEAP_SIZE (1 << 18)
-#endif
-
 #ifndef N00B_MARSHAL_CHUNK_SIZE
 #define N00B_MARSHAL_CHUNK_SIZE 512
 #endif

include/text/breaks.h

@@ -24,7 +24,8 @@ static inline n00b_break_info_t *
 n00b_alloc_break_structure(n00b_string_t *s, int shift)
 {
     n00b_break_info_t *result;
-    int32_t            alloc_slots = n00b_max(n00b_string_codepoint_len(s) >> shift,
+    int32_t            alloc_slots = n00b_max(n00b_string_codepoint_len(s)
+                                       >> shift,
                                    n00b_minimum_break_slots);
 
     result = n00b_gc_flex_alloc(n00b_break_info_t, int32_t, alloc_slots, NULL);