SCPs can be 2LSs
authorBarret Rhoden <>
Mon, 13 Jul 2015 19:44:11 +0000 (15:44 -0400)
committerBarret Rhoden <>
Thu, 16 Jul 2015 20:07:52 +0000 (16:07 -0400)
Ever since SCPs had vcore context, we were pretty close to having them
run a 2LS.  The main thing is to not turn into an MCP and to not make
vcore requests (even though that is currently harmless).

In the current instatiation, deciding to be an MCP must be done early
on, before calling uthread_mcp_init.  There are some races associated
with upgrading from an SCP to an MCP on the fly, after the 2LS has been
running.  Until we have a compelling case for that, we won't support it.

For now, the default is that processes with 2LSs will be MCPs.  In the
future, we'll probably change that, such that environment variables and
compile time options can control whether or not a process is an MCP or
SCP, possibly with SCP by default.

This variable exists in parlib.c.  Other control variables that are part
of Parlib's API will go here as well.  These are things that
applications can expect to exist (until the API changes!).

user/parlib/parlib.c [new file with mode: 0644]

index 2f0923d..dee78e6 100644 (file)
@@ -76,6 +76,9 @@ struct sigdata *alloc_sigdata();
 void free_sigdata(struct sigdata *sigdata);
 void trigger_posix_signal(int sig_nr, struct siginfo *info, void *aux);
+/* Control variables */
+extern bool parlib_wants_to_be_mcp;    /* instructs the 2LS to be an MCP */
 #endif // !ASSEMBLER
diff --git a/user/parlib/parlib.c b/user/parlib/parlib.c
new file mode 100644 (file)
index 0000000..1c33153
--- /dev/null
@@ -0,0 +1,8 @@
+/* Copyright (c) 2015 Google, Inc.
+ * Barret Rhoden <>
+ * See LICENSE for details. */
+#include <parlib/parlib.h>
+/* Control variables */
+bool parlib_wants_to_be_mcp = TRUE;
index a7745f4..d5baeb6 100644 (file)
@@ -92,6 +92,22 @@ void uthread_mcp_init()
        /* Prevent this from happening more than once. */
+       /* Doing this after the init_once check, since we don't want to let the
+        * process/2LS change their mind about being an MCP or not once they have
+        * multiple threads.
+        *
+        * The reason is that once you set "MCP please" on, you could get
+        * interrupted into VC ctx, say for a syscall completion, and then make
+        * decisions based on the fact that you're an MCP (e.g., unblocking a
+        * uthread, asking for vcores, etc), even though you are not an MCP.
+        * Arguably, these things could happen for signals too, but all of this is
+        * less likely than if we have multiple threads.
+        *
+        * Also, we could just abort here, since they shouldn't be calling
+        * mcp_init() if they don't want to be an MCP. */
+       if (!parlib_wants_to_be_mcp)
+               return;
        /* Receive preemption events.  Note that this merely tells the kernel how to
         * send the messages, and does not necessarily provide storage space for the
         * messages.  What we're doing is saying that all PREEMPT and CHECK_MSGS