Mojo + NaCl prototype.

mojo/nacl/generator/generate_nacl_bindings.py

+#!/usr/bin/python
+# Copyright 2014 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# pylint: disable=W0104,W0106,F0401,R0201
+
+import optparse
+import os.path
+import sys
+
+import interface
+
+
+def _ScriptDir():
+  return os.path.dirname(os.path.abspath(__file__))
+
+
+def _GetDirAbove(dirname):
+  """Returns the directory "above" this file containing |dirname| (which must
+  also be "above" this file)."""
+  path = _ScriptDir()
+  while True:
+    path, tail = os.path.split(path)
+    assert tail
+    if tail == dirname:
+      return path
+
+
+def _AddThirdPartyImportPath():
+  sys.path.append(os.path.join(_GetDirAbove("mojo"), "third_party"))

[Mark Seaborn, 2014/09/11 19:24:01]

Use '' quotes

[Nick Bray, 2014/09/11 20:24:07]

Done.  The irony being this was originally copied code.

+
+
+_AddThirdPartyImportPath()
+import jinja2
+
+loader = jinja2.FileSystemLoader(_ScriptDir())
+jinja_env = jinja2.Environment(loader=loader, keep_trailing_newline=True)
+
+
+# Accumulate lines of code with varying levels of indentation.
+class CodeWriter(object):
+  def __init__(self):
+    self._lines = []
+    self._margin = ''
+    self._margin_stack = []
+
+  def __lshift__(self, line):
+    self._lines.append((self._margin + line).rstrip())
+
+  def PushMargin(self):
+    self._margin_stack.append(self._margin)
+    self._margin += '  '
+
+  def PopMargin(self):
+    self._margin = self._margin_stack.pop()
+
+  def GetValue(self):
+    return '\n'.join(self._lines).rstrip() + '\n'
+
+  def Indent(self):
+    return Indent(self)
+
+
+# Context handler that automatically indents and dedents a CodeWriter
+class Indent(object):
+  def __init__(self, writer):
+    self._writer = writer
+
+  def __enter__(self):
+    self._writer.PushMargin()
+
+  def __exit__(self, type_, value, traceback):
+    self._writer.PopMargin()
+
+
+def TemplateFile(name):
+  return os.path.join(os.path.dirname(__file__), name)
+
+
+# Wraps comma separated lists as needed.
+def Wrap(pre, items, post):
+  complete = pre + ', '.join(items) + post
+  if len(complete) <= 80:
+    return [complete]
+  lines = [pre]
+  indent = '    '
+  for i, item in enumerate(items):
+    if i < len(items) - 1:
+      lines.append(indent + item + ',')
+    else:
+      lines.append(indent + item + post)
+  return lines
+

[Mark Seaborn, 2014/09/11 19:24:01]

Can you consistently put 2 empty lines between top-level decls, please?

[Nick Bray, 2014/09/11 20:24:08]

Done.

+def GeneratorWarning():
+  return ('// WARNING this file was generated by %s\n// Do not edit by hand.' %
+          os.path.basename(__file__))
+
+# Untrusted library implementing the public Mojo API.
+def GenerateLibMojo(functions, out):
+  template = jinja_env.get_template('libmojo.cc.tmpl')
+
+  code = CodeWriter()
+
+  for f in functions:
+    for line in Wrap('%s %s(' % (f.returnType, f.name), f.ParamList(), '){'):

[Mark Seaborn, 2014/09/11 19:24:01]

Nit: add space in ') {'

[Nick Bray, 2014/09/11 20:24:07]

Done.

+      code << line
+    num_params = len(f.params) + 2

[Mark Seaborn, 2014/09/11 19:24:01]

Add a comment: Add 2 for the operation ID and return value.

[Nick Bray, 2014/09/11 20:24:07]

Done.

+
+    with code.Indent():
+      code << 'uint32_t params[%d];' % num_params
+      return_type = f.resultParam.baseType
+      if return_type == 'MojoResult':
+        default = 'MOJO_RESULT_INVALID_ARGUMENT'
+      elif return_type == 'MojoTimeTicks':
+        default = '0'
+      else:
+        raise Exception('Unhandled return type: ' + return_type)
+      code << '%s %s = %s;' % (return_type, f.resultParam.name, default)
+
+      # Message ID
+      code << 'params[0] = %d;' % f.uid
+      # Parameter pointers
+      cast_template = 'params[%d] = reinterpret_cast<uint32_t>(%s);'
+      for p in f.params:
+        ptr = p.name
+        if p.IsPassedByValue():
+          ptr = '&' + ptr
+        code << cast_template % (p.uid + 1, ptr)
+      # Return value pointer
+      code << cast_template % (num_params - 1, '&' + f.resultParam.name)
+
+      code << 'DoMojoCall(params, sizeof(params));'
+      code << 'return %s;' % f.resultParam.name
+
+    code << '}'
+    code << ''
+
+  body = code.GetValue()
+  text = template.render(
+    generator_warning=GeneratorWarning(),
+    body=body)
+  out.write(text)
+
+
+# Parameters passed into trusted code are handled differently depending on

[Mark Seaborn, 2014/09/11 19:24:02]

Can you make this more explicit by starting with: "ParamImpl instances are used
for generating trusted code."

This helps me know where to look for who calls methods of ParamImpl.

[Nick Bray, 2014/09/11 20:24:08]

Clarified, although these instances will likely crosscut and handle all stages
of parameter transfer.  Right now the untrusted scheme is pretty simple so
ParamImpls were not used, but that will likely change.

+# details of the parameter. Encapsulate these differences in a polymorphic type.
+class ParamImpl(object):

[Mark Seaborn, 2014/09/11 19:24:01]

For each overridden method, can you add something like:

  # Returns C++ code for reading in and validating a parameter.
  def ConvertParam(self):
    raise NotImplemented()

This makes it clearer what's supposed to be overridden.

[Nick Bray, 2014/09/11 20:24:08]

Done.

+  def __init__(self, param):
+    self.param = param
+
+  def CopyOut(self, code):
+    pass
+
+  def IsArray(self):
+    return False
+
+
+class ScalarInputImpl(ParamImpl):
+  def DeclareVars(self, code):
+    code << '%s %s_value;' % (self.param.baseType, self.param.name)
+
+  def ConvertParam(self):
+    p = self.param
+    return ('ConvertScalarInput(nap, params[%d], &%s_value)' %
+            (p.uid + 1, p.name))
+
+  def CallParam(self):
+    return '%s_value' % self.param.name
+
+
+class ScalarOutputImpl(ParamImpl):
+  def DeclareVars(self, code):
+    code << '%s volatile* %s_ptr;' % (self.param.baseType, self.param.name)
+    code << '%s %s_value;' % (self.param.baseType, self.param.name)
+
+  def ConvertParam(self):
+    p = self.param
+    return 'ConvertScalarOutput(nap, params[%d], &%s_ptr)' % (p.uid + 1, p.name)
+
+  def CallParam(self):
+    return '&%s_value' % self.param.name
+
+  def CopyOut(self, code):
+    name = self.param.name
+    code << '*%s_ptr = %s_value;' % (name, name)
+
+
+class ScalarInOutImpl(ParamImpl):
+  def DeclareVars(self, code):
+    code << '%s volatile* %s_ptr;' % (self.param.baseType, self.param.name)
+    code << '%s %s_value;' % (self.param.baseType, self.param.name)
+
+  def ConvertParam(self):
+    p = self.param
+    return ('ConvertScalarInOut(nap, params[%d], %s, &%s_value, &%s_ptr)' %
+            (p.uid + 1, CBool(p.isOptional), p.name, p.name))
+
+  def CallParam(self):
+    name = self.param.name
+    expr = '&%s_value' % name
+    if self.param.isOptional:
+      expr = '%s_ptr ? %s : NULL' % (name, expr)
+    return expr
+
+  def CopyOut(self, code):
+    name = self.param.name
+    if self.param.isOptional:
+      code << 'if (%s_ptr != NULL) {' % (name)
+      with code.Indent():
+        code << '*%s_ptr = %s_value;' % (name, name)
+      code << '}'
+    else:
+      code << '*%s_ptr = %s_value;' % (name, name)
+
+
+class ArrayImpl(ParamImpl):
+  def DeclareVars(self, code):
+    code << '%s %s;' % (self.param.paramType, self.param.name)
+
+  def ConvertParam(self):
+    p = self.param
+    if p.baseType == 'void':
+      return ('ConvertBytes(nap, params[%d], %s, %s, &%s)' %

[Mark Seaborn, 2014/09/11 19:24:01]

Why have separate ConvertBytes/ConvertArray functions?  Can you have just
ConvertArray and pass an element size of 1 when baseType == 'void'?

[Nick Bray, 2014/09/11 20:24:08]

Done.  I am not convinced adding an extra parameter that can typically be
derived from type information is the best idea, but I can live with it.

+              (p.uid + 1, p.size + '_value', CBool(p.isOptional), p.name))
+    else:
+      return ('ConvertArray(nap, params[%d], %s, %s, &%s)' %
+              (p.uid + 1, p.size + '_value', CBool(p.isOptional), p.name))
+
+  def CallParam(self):
+    return self.param.name
+
+  def IsArray(self):
+    return True
+
+
+class StructInputImpl(ParamImpl):
+  def DeclareVars(self, code):
+    code << '%s %s;' % (self.param.paramType, self.param.name)
+
+  def ConvertParam(self):
+    p = self.param
+    return ('ConvertStruct(nap, params[%d], %s, &%s)' %
+            (p.uid + 1, CBool(p.isOptional), p.name))
+
+  def CallParam(self):
+    return self.param.name
+
+
+def ImplForParam(p):
+  if p.IsScalar():
+    if p.isOutput:
+      if p.isInput:
+        return ScalarInOutImpl(p)
+      else:
+        return ScalarOutputImpl(p)
+    else:
+      return ScalarInputImpl(p)
+  elif p.isArray:
+    return ArrayImpl(p)
+  elif p.isStruct:
+    return StructInputImpl(p)
+  else:
+    assert False, p
+
+
+def CBool(value):
+  return 'true' if value else 'false'
+
+# A trusted wrapper that validates the arguments passed from untrusted code
+# before passing them to the underlying public Mojo API.
+def GenerateMojoSyscall(functions, out):
+  template = jinja_env.get_template('mojo_syscall.cc.tmpl')
+
+  code = CodeWriter()
+  code.PushMargin()
+
+  for f in functions:
+    impls = [ImplForParam(p) for p in f.params]
+    impls.append(ImplForParam(f.resultParam))
+
+    code << 'case %d:' % f.uid
+
+    code.PushMargin()
+
+    code << '{'
+
+    with code.Indent():
+      num_params = len(f.params) + 2
+      code << 'if (num_params != %d) {' % num_params
+      with code.Indent():
+        code << 'return -1;'
+      code << '}'
+
+      # Declare temporaries.
+      for impl in impls:
+        impl.DeclareVars(code)
+
+      def ConvertParam(code, impl):
+        code << 'if (!%s) {' % impl.ConvertParam()
+        with code.Indent():
+          code << 'return -1;'
+        code << '}'
+
+      code << '{'
+      with code.Indent():
+        code << 'ScopedCopyLock copy_lock(nap);'
+        # Convert and validate pointers in two passes.
+        # Arrays cannot be validated util the size parameter has been converted.

[Mark Seaborn, 2014/09/11 19:24:01]

"until"

[Nick Bray, 2014/09/11 20:24:07]

Done.

+        for impl in impls:
+          if not impl.IsArray():
+            ConvertParam(code, impl)
+        for impl in impls:
+          if impl.IsArray():
+            ConvertParam(code, impl)
+      code << '}'
+      code << ''
+
+      # Call
+      getParams = [impl.CallParam() for impl in impls[:-1]]
+      code << 'result_value = %s(%s);' % (f.name, ', '.join(getParams))
+      code << ''
+
+      # Write outputs
+      code << '{'
+      with code.Indent():
+        code << 'ScopedCopyLock copy_lock(nap);'
+        for impl in impls:
+          impl.CopyOut(code)
+      code << '}'
+      code << ''
+
+      code << 'return 0;'
+    code << '}'
+
+    code.PopMargin()
+
+  body = code.GetValue()
+  text = template.render(
+    generator_warning=GeneratorWarning(),
+    body=body)
+  out.write(text)
+
+def OutFile(dir_path, name):
+  if not os.path.exists(dir_path):
+    os.makedirs(dir_path)
+  return open(os.path.join(dir_path, name), 'w')
+
+def main(args):
+  usage = 'usage: %prog [options]'
+  parser = optparse.OptionParser(usage=usage)
+  parser.add_option(
+      '-d',
+      dest='out_dir',
+      metavar='DIR',
+      help='output generated code into directory DIR')
+  options, args = parser.parse_args(args=args)
+  if not options.out_dir:
+    parser.error('-d is required')
+  if args:
+    parser.error('unexpected positional arguments: %s' % ' '.join(args))
+
+  mojo = interface.MakeInterface()
+
+  out = OutFile(options.out_dir, 'libmojo.cc')
+  GenerateLibMojo(mojo.functions, out)
+
+  out = OutFile(options.out_dir, 'mojo_syscall.cc')
+  GenerateMojoSyscall(mojo.functions, out)
+
+
+if __name__ == '__main__':
+  main(sys.argv[1:])