[kernel] Add capabilities to handles

This change finally adds capabilities to handles. Included changes:

- j6_handle_t is now again 64 bits, with the highest 8 bits being a type
  code, and the next highest 24 bits being the capability mask, so that
  programs can check type/caps without calling the kernel.
- The definitions grammar now includes a `capabilities [ ]` section on
  objects, to list what capabilities are relevant.
- j6/caps.h is auto-generated from object capability lists
- init_libj6 again sets __handle_self and __handle_sys, this is a bit
  of a hack.
- A new syscall, j6_handle_list, will return the list of existing
  handles owned by the calling process.
- syscall_verify.cpp.cog now actually checks that the needed
  capabilities exist on handles before allowing the call.

scripts/definitions/types/__init__.py

@@ -5,16 +5,13 @@ def _indent(x):
 class CName(str): pass
 class Description(str): pass
 class Import(str): pass
+class Caps(list): pass
 
 class Options(dict):
     def __init__(self, opts = tuple()):
         for opt in opts:
             parts = opt.split(":", 1)
-            self[parts[0]] = "".join(parts[1:])
-
-    def __str__(self):
-        if not self: return ""
-        return "[{}]".format(" ".join(self.keys()))
+            self[parts[0]] = self.get(parts[0], []) + ["".join(parts[1:])]
 
 class UID(int):
     def __str__(self):

scripts/definitions/types/function.py

@@ -43,6 +43,11 @@ class Param:
         self.options = opts
         self.desc = desc
 
+        self.caps = set()
+        for key, values in opts.items():
+            if key == "cap":
+                self.caps.update(values)
+
     def __str__(self):
         return "param {} {} {}  {}".format(
                 self.name, repr(self.type), self.options, self.desc or "")

scripts/definitions/types/object.py

@@ -1,8 +1,8 @@
 from . import _indent
-from . import Options
+from . import Caps, Options
 
 class Object:
-    def __init__(self, name, uid, typename=None, opts=Options(), desc="", children=tuple(), cname=None):
+    def __init__(self, name, uid, typename=None, opts=Options(), caps=Caps(), desc="", children=tuple(), cname=None):
         self.name = name
         self.uid = uid
         self.options = opts
@@ -11,6 +11,8 @@ class Object:
         self.methods = children
         self.cname = cname or name
 
+        self.caps = set(caps)
+
         from . import ObjectRef
         self.__ref = ObjectRef(name)