| OLD | NEW |
|---|
| (Empty) |
| 1 #!/usr/bin/python | |
| 2 # Copyright 2014 The Chromium Authors. All rights reserved. | |
| 3 # Use of this source code is governed by a BSD-style license that can be | |
| 4 # found in the LICENSE file. | |
| 5 | |
| 6 # pylint: disable=W0104,W0106,F0401,R0201 | |
| 7 | |
| 8 import errno | |
| 9 import optparse | |
| 10 import os.path | |
| 11 import sys | |
| 12 | |
| 13 import interface | |
| 14 | |
| 15 | |
| 16 def _ScriptDir(): | |
| 17 return os.path.dirname(os.path.abspath(__file__)) | |
| 18 | |
| 19 | |
| 20 def _GetDirAbove(dirname): | |
| 21 """Returns the directory "above" this file containing |dirname| (which must | |
| 22 also be "above" this file).""" | |
| 23 path = _ScriptDir() | |
| 24 while True: | |
| 25 path, tail = os.path.split(path) | |
| 26 assert tail | |
| 27 if tail == dirname: | |
| 28 return path | |
| 29 | |
| 30 | |
| 31 def _AddThirdPartyImportPath(): | |
| 32 sys.path.insert(0, os.path.join(_GetDirAbove('mojo'), 'third_party')) | |
| 33 | |
| 34 | |
| 35 _AddThirdPartyImportPath() | |
| 36 import jinja2 | |
| 37 | |
| 38 loader = jinja2.FileSystemLoader(_ScriptDir()) | |
| 39 jinja_env = jinja2.Environment(loader=loader, keep_trailing_newline=True) | |
| 40 | |
| 41 | |
| 42 # Accumulate lines of code with varying levels of indentation. | |
| 43 class CodeWriter(object): | |
| 44 def __init__(self): | |
| 45 self._lines = [] | |
| 46 self._margin = '' | |
| 47 self._margin_stack = [] | |
| 48 | |
| 49 def __lshift__(self, line): | |
| 50 self._lines.append((self._margin + line).rstrip()) | |
| 51 | |
| 52 def PushMargin(self): | |
| 53 self._margin_stack.append(self._margin) | |
| 54 self._margin += ' ' | |
| 55 | |
| 56 def PopMargin(self): | |
| 57 self._margin = self._margin_stack.pop() | |
| 58 | |
| 59 def GetValue(self): | |
| 60 return '\n'.join(self._lines).rstrip() + '\n' | |
| 61 | |
| 62 def Indent(self): | |
| 63 return Indent(self) | |
| 64 | |
| 65 | |
| 66 # Context handler that automatically indents and dedents a CodeWriter | |
| 67 class Indent(object): | |
| 68 def __init__(self, writer): | |
| 69 self._writer = writer | |
| 70 | |
| 71 def __enter__(self): | |
| 72 self._writer.PushMargin() | |
| 73 | |
| 74 def __exit__(self, type_, value, traceback): | |
| 75 self._writer.PopMargin() | |
| 76 | |
| 77 | |
| 78 def TemplateFile(name): | |
| 79 return os.path.join(os.path.dirname(__file__), name) | |
| 80 | |
| 81 | |
| 82 # Wraps comma separated lists as needed. | |
| 83 # TODO(teravest): Eliminate Wrap() and use "git cl format" when code is checked | |
| 84 # in. | |
| 85 def Wrap(pre, items, post): | |
| 86 complete = pre + ', '.join(items) + post | |
| 87 if len(complete) <= 80: | |
| 88 return [complete] | |
| 89 lines = [pre] | |
| 90 indent = ' ' | |
| 91 for i, item in enumerate(items): | |
| 92 if i < len(items) - 1: | |
| 93 lines.append(indent + item + ',') | |
| 94 else: | |
| 95 lines.append(indent + item + post) | |
| 96 return lines | |
| 97 | |
| 98 | |
| 99 def GeneratorWarning(): | |
| 100 return ('// WARNING this file was generated by %s\n// Do not edit by hand.' % | |
| 101 os.path.basename(__file__)) | |
| 102 | |
| 103 | |
| 104 # Untrusted library which thunks from the public Mojo API to the IRT interface | |
| 105 # implementing the public Mojo API. | |
| 106 def GenerateLibMojo(functions, out): | |
| 107 template = jinja_env.get_template('libmojo.cc.tmpl') | |
| 108 | |
| 109 code = CodeWriter() | |
| 110 | |
| 111 for f in functions: | |
| 112 for line in Wrap('%s %s(' % (f.return_type, f.name), f.ParamList(), ') {'): | |
| 113 code << line | |
| 114 | |
| 115 with code.Indent(): | |
| 116 code << 'struct nacl_irt_mojo* irt_mojo = get_irt_mojo();' | |
| 117 code << 'if (irt_mojo == NULL)' | |
| 118 with code.Indent(): | |
| 119 code << 'return MOJO_RESULT_INTERNAL;' | |
| 120 code << 'return irt_mojo->%s(%s);' % ( | |
| 121 f.name, ', '.join([p.name for p in f.params])) | |
| 122 | |
| 123 code << '}' | |
| 124 code << '' | |
| 125 | |
| 126 body = code.GetValue() | |
| 127 text = template.render( | |
| 128 generator_warning=GeneratorWarning(), | |
| 129 body=body) | |
| 130 out.write(text) | |
| 131 | |
| 132 | |
| 133 # Parameters passed into trusted code are handled differently depending on | |
| 134 # details of the parameter. ParamImpl instances encapsulate these differences | |
| 135 # and are used to generate the code that transfers parameters across the | |
| 136 # untrusted/trusted boundary. | |
| 137 class ParamImpl(object): | |
| 138 def __init__(self, param): | |
| 139 self.param = param | |
| 140 | |
| 141 # Declare whatever variables are needed to handle this particular parameter. | |
| 142 def DeclareVars(self, code): | |
| 143 raise NotImplementedError(type(self)) | |
| 144 | |
| 145 # Convert the untrusted representation of the parameter into a trusted | |
| 146 # representation, such as a scalar value or a trusted pointer into the | |
| 147 # untrusted address space. | |
| 148 def ConvertParam(self): | |
| 149 raise NotImplementedError(type(self)) | |
| 150 | |
| 151 # For this particular parameter, what expression should be passed when | |
| 152 # invoking the trusted Mojo API function? | |
| 153 def CallParam(self): | |
| 154 raise NotImplementedError(type(self)) | |
| 155 | |
| 156 # After invoking the trusted Mojo API function, transfer data back into | |
| 157 # untrusted memory. Overriden for Out and InOut parameters. | |
| 158 def CopyOut(self, code): | |
| 159 pass | |
| 160 | |
| 161 # Converting array parameters needs to be defered until after the scalar | |
| 162 # parameter containing the size of the array has itself been converted. | |
| 163 def IsArray(self): | |
| 164 return False | |
| 165 | |
| 166 | |
| 167 class ScalarInputImpl(ParamImpl): | |
| 168 def DeclareVars(self, code): | |
| 169 code << '%s %s_value;' % (self.param.base_type, self.param.name) | |
| 170 | |
| 171 def ConvertParam(self): | |
| 172 p = self.param | |
| 173 return ('ConvertScalarInput(nap, params[%d], &%s_value)' % | |
| 174 (p.uid + 1, p.name)) | |
| 175 | |
| 176 def CallParam(self): | |
| 177 return '%s_value' % self.param.name | |
| 178 | |
| 179 | |
| 180 class ScalarOutputImpl(ParamImpl): | |
| 181 def DeclareVars(self, code): | |
| 182 code << '%s volatile* %s_ptr;' % (self.param.base_type, self.param.name) | |
| 183 code << '%s %s_value;' % (self.param.base_type, self.param.name) | |
| 184 | |
| 185 def ConvertParam(self): | |
| 186 p = self.param | |
| 187 return ('ConvertScalarOutput(nap, params[%d], %s, &%s_ptr)' % | |
| 188 (p.uid + 1, CBool(p.is_optional), p.name)) | |
| 189 | |
| 190 def CallParam(self): | |
| 191 name = self.param.name | |
| 192 expr = '&%s_value' % name | |
| 193 if self.param.is_optional: | |
| 194 expr = '%s_ptr ? %s : NULL' % (name, expr) | |
| 195 return expr | |
| 196 | |
| 197 def CopyOut(self, code): | |
| 198 name = self.param.name | |
| 199 if self.param.is_struct: | |
| 200 # C++ errors when you try to copy a volatile struct pointer. | |
| 201 # (There are no default copy constructors for this case.) | |
| 202 # memcpy instead. | |
| 203 copy_stmt = ('memcpy_volatile_out(%s_ptr, &%s_value, sizeof(%s));' % | |
| 204 (name, name, self.param.base_type)) | |
| 205 else: | |
| 206 copy_stmt = '*%s_ptr = %s_value;' % (name, name) | |
| 207 | |
| 208 if self.param.is_optional: | |
| 209 code << 'if (%s_ptr != NULL) {' % (name) | |
| 210 with code.Indent(): | |
| 211 code << copy_stmt | |
| 212 code << '}' | |
| 213 else: | |
| 214 code << copy_stmt | |
| 215 | |
| 216 | |
| 217 class ScalarInOutImpl(ParamImpl): | |
| 218 def DeclareVars(self, code): | |
| 219 code << '%s volatile* %s_ptr;' % (self.param.base_type, self.param.name) | |
| 220 code << '%s %s_value;' % (self.param.base_type, self.param.name) | |
| 221 | |
| 222 def ConvertParam(self): | |
| 223 p = self.param | |
| 224 return ('ConvertScalarInOut(nap, params[%d], %s, &%s_value, &%s_ptr)' % | |
| 225 (p.uid + 1, CBool(p.is_optional), p.name, p.name)) | |
| 226 | |
| 227 def CallParam(self): | |
| 228 name = self.param.name | |
| 229 expr = '&%s_value' % name | |
| 230 if self.param.is_optional: | |
| 231 expr = '%s_ptr ? %s : NULL' % (name, expr) | |
| 232 return expr | |
| 233 | |
| 234 def CopyOut(self, code): | |
| 235 name = self.param.name | |
| 236 if self.param.is_optional: | |
| 237 code << 'if (%s_ptr != NULL) {' % (name) | |
| 238 with code.Indent(): | |
| 239 code << '*%s_ptr = %s_value;' % (name, name) | |
| 240 code << '}' | |
| 241 else: | |
| 242 code << '*%s_ptr = %s_value;' % (name, name) | |
| 243 | |
| 244 | |
| 245 class ArrayImpl(ParamImpl): | |
| 246 def DeclareVars(self, code): | |
| 247 code << '%s %s;' % (self.param.param_type, self.param.name) | |
| 248 | |
| 249 def ConvertParam(self): | |
| 250 p = self.param | |
| 251 if p.base_type == 'void': | |
| 252 element_size = '1' | |
| 253 else: | |
| 254 element_size = 'sizeof(*%s)' % p.name | |
| 255 | |
| 256 return ('ConvertArray(nap, params[%d], %s, %s, %s, &%s)' % | |
| 257 (p.uid + 1, p.size + '_value', element_size, CBool(p.is_optional), | |
| 258 p.name)) | |
| 259 | |
| 260 def CallParam(self): | |
| 261 return self.param.name | |
| 262 | |
| 263 def IsArray(self): | |
| 264 return True | |
| 265 | |
| 266 | |
| 267 class ExtensibleStructInputImpl(ParamImpl): | |
| 268 def DeclareVars(self, code): | |
| 269 code << '%s %s;' % (self.param.param_type, self.param.name) | |
| 270 | |
| 271 def ConvertParam(self): | |
| 272 p = self.param | |
| 273 return ('ConvertExtensibleStructInput(nap, params[%d], %s, &%s)' % | |
| 274 (p.uid + 1, CBool(p.is_optional), p.name)) | |
| 275 | |
| 276 def CallParam(self): | |
| 277 return self.param.name | |
| 278 | |
| 279 def ImplForParam(p): | |
| 280 if p.IsScalar(): | |
| 281 if p.is_output: | |
| 282 if p.is_input: | |
| 283 return ScalarInOutImpl(p) | |
| 284 else: | |
| 285 if p.is_always_written: | |
| 286 return ScalarOutputImpl(p) | |
| 287 else: | |
| 288 # Mojo defines that some of its outputs will not be set in specific | |
| 289 # cases. To avoid the complexity of determining if the output was set | |
| 290 # by Mojo, copy the output's current value (possibly junk) and copy it | |
| 291 # back to untrusted memory afterwards. | |
| 292 return ScalarInOutImpl(p) | |
| 293 else: | |
| 294 return ScalarInputImpl(p) | |
| 295 elif p.is_array: | |
| 296 return ArrayImpl(p) | |
| 297 elif p.is_struct: | |
| 298 if p.is_input and not p.is_output and p.is_extensible: | |
| 299 return ExtensibleStructInputImpl(p) | |
| 300 if not p.is_input and p.is_output and not p.is_extensible: | |
| 301 return ScalarOutputImpl(p) | |
| 302 assert False, p.name | |
| 303 | |
| 304 | |
| 305 def CBool(value): | |
| 306 return 'true' if value else 'false' | |
| 307 | |
| 308 | |
| 309 # A trusted wrapper that validates the arguments passed from untrusted code | |
| 310 # before passing them to the underlying public Mojo API. | |
| 311 def GenerateMojoSyscall(functions, out): | |
| 312 template = jinja_env.get_template('mojo_syscall.cc.tmpl') | |
| 313 | |
| 314 code = CodeWriter() | |
| 315 code.PushMargin() | |
| 316 | |
| 317 for f in functions: | |
| 318 impls = [ImplForParam(p) for p in f.params] | |
| 319 impls.append(ImplForParam(f.result_param)) | |
| 320 | |
| 321 code << 'case %d:' % f.uid | |
| 322 | |
| 323 code.PushMargin() | |
| 324 | |
| 325 code << '{' | |
| 326 | |
| 327 with code.Indent(): | |
| 328 num_params = len(f.params) + 2 | |
| 329 code << 'if (num_params != %d) {' % num_params | |
| 330 with code.Indent(): | |
| 331 code << 'return -1;' | |
| 332 code << '}' | |
| 333 | |
| 334 # Declare temporaries. | |
| 335 for impl in impls: | |
| 336 impl.DeclareVars(code) | |
| 337 | |
| 338 def ConvertParam(code, impl): | |
| 339 code << 'if (!%s) {' % impl.ConvertParam() | |
| 340 with code.Indent(): | |
| 341 code << 'return -1;' | |
| 342 code << '}' | |
| 343 | |
| 344 code << '{' | |
| 345 with code.Indent(): | |
| 346 code << 'ScopedCopyLock copy_lock(nap);' | |
| 347 # Convert and validate pointers in two passes. | |
| 348 # Arrays cannot be validated until the size parameter has been | |
| 349 # converted. | |
| 350 for impl in impls: | |
| 351 if not impl.IsArray(): | |
| 352 ConvertParam(code, impl) | |
| 353 for impl in impls: | |
| 354 if impl.IsArray(): | |
| 355 ConvertParam(code, impl) | |
| 356 code << '}' | |
| 357 code << '' | |
| 358 | |
| 359 # Call | |
| 360 getParams = [impl.CallParam() for impl in impls[:-1]] | |
| 361 code << 'result_value = %s(%s);' % (f.name, ', '.join(getParams)) | |
| 362 code << '' | |
| 363 | |
| 364 # Write outputs | |
| 365 code << '{' | |
| 366 with code.Indent(): | |
| 367 code << 'ScopedCopyLock copy_lock(nap);' | |
| 368 for impl in impls: | |
| 369 impl.CopyOut(code) | |
| 370 code << '}' | |
| 371 code << '' | |
| 372 | |
| 373 code << 'return 0;' | |
| 374 code << '}' | |
| 375 | |
| 376 code.PopMargin() | |
| 377 | |
| 378 body = code.GetValue() | |
| 379 text = template.render( | |
| 380 generator_warning=GeneratorWarning(), | |
| 381 body=body) | |
| 382 out.write(text) | |
| 383 | |
| 384 | |
| 385 # A header declaring the IRT interface for accessing Mojo functions. | |
| 386 def GenerateMojoIrtHeader(functions, out): | |
| 387 template = jinja_env.get_template('mojo_irt.h.tmpl') | |
| 388 code = CodeWriter() | |
| 389 | |
| 390 code << 'struct nacl_irt_mojo {' | |
| 391 with code.Indent(): | |
| 392 for f in functions: | |
| 393 for line in Wrap('%s (*%s)(' % (f.return_type, f.name), | |
| 394 f.ParamList(), | |
| 395 ');'): | |
| 396 code << line | |
| 397 | |
| 398 code << '};' | |
| 399 | |
| 400 body = code.GetValue() | |
| 401 | |
| 402 text = template.render( | |
| 403 generator_warning=GeneratorWarning(), | |
| 404 body=body) | |
| 405 out.write(text) | |
| 406 | |
| 407 # IRT interface which implements the Mojo public API. | |
| 408 def GenerateMojoIrtImplementation(functions, out): | |
| 409 template = jinja_env.get_template('mojo_irt.c.tmpl') | |
| 410 code = CodeWriter() | |
| 411 | |
| 412 for f in functions: | |
| 413 for line in Wrap('static %s irt_%s(' % (f.return_type, f.name), | |
| 414 f.ParamList(), | |
| 415 ') {'): | |
| 416 code << line | |
| 417 | |
| 418 # 2 extra parameters: message ID and return value. | |
| 419 num_params = len(f.params) + 2 | |
| 420 | |
| 421 with code.Indent(): | |
| 422 code << 'uint32_t params[%d];' % num_params | |
| 423 return_type = f.result_param.base_type | |
| 424 if return_type == 'MojoResult': | |
| 425 default = 'MOJO_RESULT_INVALID_ARGUMENT' | |
| 426 elif return_type == 'MojoTimeTicks': | |
| 427 default = '0' | |
| 428 else: | |
| 429 raise Exception('Unhandled return type: ' + return_type) | |
| 430 code << '%s %s = %s;' % (return_type, f.result_param.name, default) | |
| 431 | |
| 432 # Message ID | |
| 433 code << 'params[0] = %d;' % f.uid | |
| 434 # Parameter pointers | |
| 435 cast_template = 'params[%d] = (uint32_t)(%s);' | |
| 436 for p in f.params: | |
| 437 ptr = p.name | |
| 438 if p.IsPassedByValue(): | |
| 439 ptr = '&' + ptr | |
| 440 code << cast_template % (p.uid + 1, ptr) | |
| 441 # Return value pointer | |
| 442 code << cast_template % (num_params - 1, '&' + f.result_param.name) | |
| 443 | |
| 444 code << 'DoMojoCall(params, sizeof(params));' | |
| 445 code << 'return %s;' % f.result_param.name | |
| 446 | |
| 447 # Add body here. | |
| 448 code << "};" | |
| 449 code << "\n" | |
| 450 | |
| 451 # Now we've emitted all the functions, but we still need the struct | |
| 452 # definition. | |
| 453 code << 'struct nacl_irt_mojo kIrtMojo = {' | |
| 454 for f in functions: | |
| 455 with code.Indent(): | |
| 456 code << '&irt_%s,' % f.name | |
| 457 code << '};' | |
| 458 | |
| 459 body = code.GetValue() | |
| 460 | |
| 461 text = template.render( | |
| 462 generator_warning=GeneratorWarning(), | |
| 463 body=body) | |
| 464 out.write(text) | |
| 465 | |
| 466 | |
| 467 def OutFile(dir_path, name): | |
| 468 if not os.path.exists(dir_path): | |
| 469 try: | |
| 470 os.makedirs(dir_path) | |
| 471 except OSError as e: | |
| 472 # There may have been a race to create this directory. | |
| 473 if e.errno != errno.EEXIST: | |
| 474 raise | |
| 475 return open(os.path.join(dir_path, name), 'w') | |
| 476 | |
| 477 | |
| 478 def main(args): | |
| 479 usage = 'usage: %prog [options]' | |
| 480 parser = optparse.OptionParser(usage=usage) | |
| 481 parser.add_option( | |
| 482 '-d', | |
| 483 dest='out_dir', | |
| 484 metavar='DIR', | |
| 485 help='output generated code into directory DIR') | |
| 486 options, args = parser.parse_args(args=args) | |
| 487 if not options.out_dir: | |
| 488 parser.error('-d is required') | |
| 489 if args: | |
| 490 parser.error('unexpected positional arguments: %s' % ' '.join(args)) | |
| 491 | |
| 492 mojo = interface.MakeInterface() | |
| 493 | |
| 494 out = OutFile(options.out_dir, 'libmojo.cc') | |
| 495 GenerateLibMojo(mojo.functions, out) | |
| 496 | |
| 497 out = OutFile(options.out_dir, 'mojo_syscall.cc') | |
| 498 GenerateMojoSyscall(mojo.functions, out) | |
| 499 | |
| 500 out = OutFile(options.out_dir, 'mojo_irt.h') | |
| 501 GenerateMojoIrtHeader(mojo.functions, out) | |
| 502 | |
| 503 out = OutFile(options.out_dir, 'mojo_irt.c') | |
| 504 GenerateMojoIrtImplementation(mojo.functions, out) | |
| 505 | |
| 506 if __name__ == '__main__': | |
| 507 main(sys.argv[1:]) | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1279133006:
Removed unused mojo_nacl code and GYP targets. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master