| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 // WARNING this file was generated by generate_nacl_bindings.py | |
| 6 // Do not edit by hand. | |
| 7 | |
| 8 #include "mojo/nacl/sfi/nacl_bindings/mojo_syscall.h" | |
| 9 | |
| 10 #include <stdio.h> | |
| 11 | |
| 12 #include "mojo/nacl/sfi/nacl_bindings/mojo_syscall_internal.h" | |
| 13 #include "mojo/public/c/system/buffer.h" | |
| 14 #include "mojo/public/c/system/data_pipe.h" | |
| 15 #include "mojo/public/c/system/handle.h" | |
| 16 #include "mojo/public/c/system/message_pipe.h" | |
| 17 #include "mojo/public/c/system/result.h" | |
| 18 #include "mojo/public/c/system/time.h" | |
| 19 #include "mojo/public/platform/native/system_impl_private.h" | |
| 20 #include "native_client/src/public/chrome_main.h" | |
| 21 #include "native_client/src/public/nacl_app.h" | |
| 22 #include "native_client/src/trusted/desc/nacl_desc_custom.h" | |
| 23 | |
| 24 MojoHandle g_mojo_handle = MOJO_HANDLE_INVALID; | |
| 25 MojoSystemImpl g_mojo_system = nullptr; | |
| 26 | |
| 27 namespace { | |
| 28 | |
| 29 MojoResult _MojoGetInitialHandle(MojoHandle* handle) { | |
| 30 *handle = g_mojo_handle; | |
| 31 return MOJO_RESULT_OK; | |
| 32 } | |
| 33 | |
| 34 void MojoDescDestroy(void* handle) { | |
| 35 } | |
| 36 | |
| 37 ssize_t MojoDescSendMsg(void* handle, | |
| 38 const struct NaClImcTypedMsgHdr* msg, | |
| 39 int flags) { | |
| 40 struct NaClApp* nap = static_cast<struct NaClApp*>(handle); | |
| 41 | |
| 42 if (msg->iov_length != 1 || msg->ndesc_length != 0) { | |
| 43 return -1; | |
| 44 } | |
| 45 | |
| 46 uint32_t volatile* params = static_cast<uint32_t volatile*>(msg->iov[0].base); | |
| 47 size_t num_params = msg->iov[0].length / sizeof(*params); | |
| 48 | |
| 49 if (num_params < 1) { | |
| 50 return -1; | |
| 51 } | |
| 52 | |
| 53 uint32_t msg_type = params[0]; | |
| 54 switch (msg_type) { | |
| 55 case 0: { | |
| 56 if (num_params != 3) { | |
| 57 return -1; | |
| 58 } | |
| 59 MojoHandle volatile* handle_ptr; | |
| 60 MojoHandle handle_value; | |
| 61 MojoResult volatile* result_ptr; | |
| 62 MojoResult result_value; | |
| 63 { | |
| 64 ScopedCopyLock copy_lock(nap); | |
| 65 if (!ConvertScalarInOut(nap, params[1], false, &handle_value, | |
| 66 &handle_ptr)) { | |
| 67 return -1; | |
| 68 } | |
| 69 if (!ConvertScalarOutput(nap, params[2], false, &result_ptr)) { | |
| 70 return -1; | |
| 71 } | |
| 72 } | |
| 73 | |
| 74 result_value = _MojoGetInitialHandle(&handle_value); | |
| 75 | |
| 76 { | |
| 77 ScopedCopyLock copy_lock(nap); | |
| 78 *handle_ptr = handle_value; | |
| 79 *result_ptr = result_value; | |
| 80 } | |
| 81 | |
| 82 return 0; | |
| 83 } | |
| 84 case 1: { | |
| 85 if (num_params != 2) { | |
| 86 return -1; | |
| 87 } | |
| 88 MojoTimeTicks volatile* result_ptr; | |
| 89 MojoTimeTicks result_value; | |
| 90 { | |
| 91 ScopedCopyLock copy_lock(nap); | |
| 92 if (!ConvertScalarOutput(nap, params[1], false, &result_ptr)) { | |
| 93 return -1; | |
| 94 } | |
| 95 } | |
| 96 | |
| 97 result_value = MojoSystemImplGetTimeTicksNow(g_mojo_system); | |
| 98 | |
| 99 { | |
| 100 ScopedCopyLock copy_lock(nap); | |
| 101 *result_ptr = result_value; | |
| 102 } | |
| 103 | |
| 104 return 0; | |
| 105 } | |
| 106 case 2: { | |
| 107 if (num_params != 3) { | |
| 108 return -1; | |
| 109 } | |
| 110 MojoHandle handle_value; | |
| 111 MojoResult volatile* result_ptr; | |
| 112 MojoResult result_value; | |
| 113 { | |
| 114 ScopedCopyLock copy_lock(nap); | |
| 115 if (!ConvertScalarInput(nap, params[1], &handle_value)) { | |
| 116 return -1; | |
| 117 } | |
| 118 if (!ConvertScalarOutput(nap, params[2], false, &result_ptr)) { | |
| 119 return -1; | |
| 120 } | |
| 121 } | |
| 122 | |
| 123 result_value = MojoSystemImplClose(g_mojo_system, handle_value); | |
| 124 | |
| 125 { | |
| 126 ScopedCopyLock copy_lock(nap); | |
| 127 *result_ptr = result_value; | |
| 128 } | |
| 129 | |
| 130 return 0; | |
| 131 } | |
| 132 case 3: { | |
| 133 if (num_params != 4) { | |
| 134 return -1; | |
| 135 } | |
| 136 MojoHandle handle_value; | |
| 137 MojoHandleRights volatile* rights_ptr; | |
| 138 MojoHandleRights rights_value; | |
| 139 MojoResult volatile* result_ptr; | |
| 140 MojoResult result_value; | |
| 141 { | |
| 142 ScopedCopyLock copy_lock(nap); | |
| 143 if (!ConvertScalarInput(nap, params[1], &handle_value)) { | |
| 144 return -1; | |
| 145 } | |
| 146 if (!ConvertScalarInOut(nap, params[2], false, &rights_value, | |
| 147 &rights_ptr)) { | |
| 148 return -1; | |
| 149 } | |
| 150 if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) { | |
| 151 return -1; | |
| 152 } | |
| 153 } | |
| 154 | |
| 155 result_value = | |
| 156 MojoSystemImplGetRights(g_mojo_system, handle_value, &rights_value); | |
| 157 | |
| 158 { | |
| 159 ScopedCopyLock copy_lock(nap); | |
| 160 *rights_ptr = rights_value; | |
| 161 *result_ptr = result_value; | |
| 162 } | |
| 163 | |
| 164 return 0; | |
| 165 } | |
| 166 case 4: { | |
| 167 if (num_params != 5) { | |
| 168 return -1; | |
| 169 } | |
| 170 MojoHandle handle_value; | |
| 171 MojoHandleRights rights_to_remove_value; | |
| 172 MojoHandle volatile* new_handle_ptr; | |
| 173 MojoHandle new_handle_value; | |
| 174 MojoResult volatile* result_ptr; | |
| 175 MojoResult result_value; | |
| 176 { | |
| 177 ScopedCopyLock copy_lock(nap); | |
| 178 if (!ConvertScalarInput(nap, params[1], &handle_value)) { | |
| 179 return -1; | |
| 180 } | |
| 181 if (!ConvertScalarInput(nap, params[2], &rights_to_remove_value)) { | |
| 182 return -1; | |
| 183 } | |
| 184 if (!ConvertScalarInOut(nap, params[3], false, &new_handle_value, | |
| 185 &new_handle_ptr)) { | |
| 186 return -1; | |
| 187 } | |
| 188 if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) { | |
| 189 return -1; | |
| 190 } | |
| 191 } | |
| 192 | |
| 193 result_value = MojoSystemImplDuplicateHandleWithReducedRights( | |
| 194 g_mojo_system, handle_value, rights_to_remove_value, | |
| 195 &new_handle_value); | |
| 196 | |
| 197 { | |
| 198 ScopedCopyLock copy_lock(nap); | |
| 199 *new_handle_ptr = new_handle_value; | |
| 200 *result_ptr = result_value; | |
| 201 } | |
| 202 | |
| 203 return 0; | |
| 204 } | |
| 205 case 5: { | |
| 206 if (num_params != 4) { | |
| 207 return -1; | |
| 208 } | |
| 209 MojoHandle handle_value; | |
| 210 MojoHandle volatile* new_handle_ptr; | |
| 211 MojoHandle new_handle_value; | |
| 212 MojoResult volatile* result_ptr; | |
| 213 MojoResult result_value; | |
| 214 { | |
| 215 ScopedCopyLock copy_lock(nap); | |
| 216 if (!ConvertScalarInput(nap, params[1], &handle_value)) { | |
| 217 return -1; | |
| 218 } | |
| 219 if (!ConvertScalarInOut(nap, params[2], false, &new_handle_value, | |
| 220 &new_handle_ptr)) { | |
| 221 return -1; | |
| 222 } | |
| 223 if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) { | |
| 224 return -1; | |
| 225 } | |
| 226 } | |
| 227 | |
| 228 result_value = MojoSystemImplDuplicateHandle(g_mojo_system, handle_value, | |
| 229 &new_handle_value); | |
| 230 | |
| 231 { | |
| 232 ScopedCopyLock copy_lock(nap); | |
| 233 *new_handle_ptr = new_handle_value; | |
| 234 *result_ptr = result_value; | |
| 235 } | |
| 236 | |
| 237 return 0; | |
| 238 } | |
| 239 case 6: { | |
| 240 if (num_params != 6) { | |
| 241 return -1; | |
| 242 } | |
| 243 MojoHandle handle_value; | |
| 244 MojoHandleSignals signals_value; | |
| 245 MojoDeadline deadline_value; | |
| 246 MojoHandleSignalsState volatile* signals_state_ptr; | |
| 247 MojoHandleSignalsState signals_state_value; | |
| 248 MojoResult volatile* result_ptr; | |
| 249 MojoResult result_value; | |
| 250 { | |
| 251 ScopedCopyLock copy_lock(nap); | |
| 252 if (!ConvertScalarInput(nap, params[1], &handle_value)) { | |
| 253 return -1; | |
| 254 } | |
| 255 if (!ConvertScalarInput(nap, params[2], &signals_value)) { | |
| 256 return -1; | |
| 257 } | |
| 258 if (!ConvertScalarInput(nap, params[3], &deadline_value)) { | |
| 259 return -1; | |
| 260 } | |
| 261 if (!ConvertScalarOutput(nap, params[4], true, &signals_state_ptr)) { | |
| 262 return -1; | |
| 263 } | |
| 264 if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) { | |
| 265 return -1; | |
| 266 } | |
| 267 } | |
| 268 | |
| 269 result_value = MojoSystemImplWait( | |
| 270 g_mojo_system, handle_value, signals_value, deadline_value, | |
| 271 signals_state_ptr ? &signals_state_value : nullptr); | |
| 272 | |
| 273 { | |
| 274 ScopedCopyLock copy_lock(nap); | |
| 275 if (signals_state_ptr) { | |
| 276 memcpy_volatile_out(signals_state_ptr, &signals_state_value, | |
| 277 sizeof(MojoHandleSignalsState)); | |
| 278 } | |
| 279 *result_ptr = result_value; | |
| 280 } | |
| 281 | |
| 282 return 0; | |
| 283 } | |
| 284 case 7: { | |
| 285 if (num_params != 8) { | |
| 286 return -1; | |
| 287 } | |
| 288 const MojoHandle* handles; | |
| 289 const MojoHandleSignals* signals; | |
| 290 uint32_t num_handles_value; | |
| 291 MojoDeadline deadline_value; | |
| 292 uint32_t volatile* result_index_ptr; | |
| 293 uint32_t result_index_value; | |
| 294 struct MojoHandleSignalsState* signals_states; | |
| 295 MojoResult volatile* result_ptr; | |
| 296 MojoResult result_value; | |
| 297 { | |
| 298 ScopedCopyLock copy_lock(nap); | |
| 299 if (!ConvertScalarInput(nap, params[3], &num_handles_value)) { | |
| 300 return -1; | |
| 301 } | |
| 302 if (!ConvertScalarInput(nap, params[4], &deadline_value)) { | |
| 303 return -1; | |
| 304 } | |
| 305 if (!ConvertScalarInOut(nap, params[5], true, &result_index_value, | |
| 306 &result_index_ptr)) { | |
| 307 return -1; | |
| 308 } | |
| 309 if (!ConvertScalarOutput(nap, params[7], false, &result_ptr)) { | |
| 310 return -1; | |
| 311 } | |
| 312 if (!ConvertArray(nap, params[1], num_handles_value, sizeof(*handles), | |
| 313 false, &handles)) { | |
| 314 return -1; | |
| 315 } | |
| 316 if (!ConvertArray(nap, params[2], num_handles_value, sizeof(*signals), | |
| 317 false, &signals)) { | |
| 318 return -1; | |
| 319 } | |
| 320 if (!ConvertArray(nap, params[6], num_handles_value, | |
| 321 sizeof(*signals_states), true, &signals_states)) { | |
| 322 return -1; | |
| 323 } | |
| 324 } | |
| 325 | |
| 326 result_value = MojoSystemImplWaitMany( | |
| 327 g_mojo_system, handles, signals, num_handles_value, deadline_value, | |
| 328 result_index_ptr ? &result_index_value : nullptr, signals_states); | |
| 329 | |
| 330 { | |
| 331 ScopedCopyLock copy_lock(nap); | |
| 332 if (result_index_ptr) { | |
| 333 *result_index_ptr = result_index_value; | |
| 334 } | |
| 335 *result_ptr = result_value; | |
| 336 } | |
| 337 | |
| 338 return 0; | |
| 339 } | |
| 340 case 8: { | |
| 341 if (num_params != 5) { | |
| 342 return -1; | |
| 343 } | |
| 344 const struct MojoCreateMessagePipeOptions* options; | |
| 345 MojoHandle volatile* message_pipe_handle0_ptr; | |
| 346 MojoHandle message_pipe_handle0_value; | |
| 347 MojoHandle volatile* message_pipe_handle1_ptr; | |
| 348 MojoHandle message_pipe_handle1_value; | |
| 349 MojoResult volatile* result_ptr; | |
| 350 MojoResult result_value; | |
| 351 { | |
| 352 ScopedCopyLock copy_lock(nap); | |
| 353 if (!ConvertExtensibleStructInput(nap, params[1], true, &options)) { | |
| 354 return -1; | |
| 355 } | |
| 356 if (!ConvertScalarInOut(nap, params[2], false, | |
| 357 &message_pipe_handle0_value, | |
| 358 &message_pipe_handle0_ptr)) { | |
| 359 return -1; | |
| 360 } | |
| 361 if (!ConvertScalarInOut(nap, params[3], false, | |
| 362 &message_pipe_handle1_value, | |
| 363 &message_pipe_handle1_ptr)) { | |
| 364 return -1; | |
| 365 } | |
| 366 if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) { | |
| 367 return -1; | |
| 368 } | |
| 369 } | |
| 370 | |
| 371 result_value = MojoSystemImplCreateMessagePipe( | |
| 372 g_mojo_system, options, &message_pipe_handle0_value, | |
| 373 &message_pipe_handle1_value); | |
| 374 | |
| 375 { | |
| 376 ScopedCopyLock copy_lock(nap); | |
| 377 *message_pipe_handle0_ptr = message_pipe_handle0_value; | |
| 378 *message_pipe_handle1_ptr = message_pipe_handle1_value; | |
| 379 *result_ptr = result_value; | |
| 380 } | |
| 381 | |
| 382 return 0; | |
| 383 } | |
| 384 case 9: { | |
| 385 if (num_params != 8) { | |
| 386 return -1; | |
| 387 } | |
| 388 MojoHandle message_pipe_handle_value; | |
| 389 const void* bytes; | |
| 390 uint32_t num_bytes_value; | |
| 391 const MojoHandle* handles; | |
| 392 uint32_t num_handles_value; | |
| 393 MojoWriteMessageFlags flags_value; | |
| 394 MojoResult volatile* result_ptr; | |
| 395 MojoResult result_value; | |
| 396 { | |
| 397 ScopedCopyLock copy_lock(nap); | |
| 398 if (!ConvertScalarInput(nap, params[1], &message_pipe_handle_value)) { | |
| 399 return -1; | |
| 400 } | |
| 401 if (!ConvertScalarInput(nap, params[3], &num_bytes_value)) { | |
| 402 return -1; | |
| 403 } | |
| 404 if (!ConvertScalarInput(nap, params[5], &num_handles_value)) { | |
| 405 return -1; | |
| 406 } | |
| 407 if (!ConvertScalarInput(nap, params[6], &flags_value)) { | |
| 408 return -1; | |
| 409 } | |
| 410 if (!ConvertScalarOutput(nap, params[7], false, &result_ptr)) { | |
| 411 return -1; | |
| 412 } | |
| 413 if (!ConvertArray(nap, params[2], num_bytes_value, 1, true, &bytes)) { | |
| 414 return -1; | |
| 415 } | |
| 416 if (!ConvertArray(nap, params[4], num_handles_value, sizeof(*handles), | |
| 417 true, &handles)) { | |
| 418 return -1; | |
| 419 } | |
| 420 } | |
| 421 | |
| 422 result_value = MojoSystemImplWriteMessage( | |
| 423 g_mojo_system, message_pipe_handle_value, bytes, num_bytes_value, | |
| 424 handles, num_handles_value, flags_value); | |
| 425 | |
| 426 { | |
| 427 ScopedCopyLock copy_lock(nap); | |
| 428 *result_ptr = result_value; | |
| 429 } | |
| 430 | |
| 431 return 0; | |
| 432 } | |
| 433 case 10: { | |
| 434 if (num_params != 8) { | |
| 435 return -1; | |
| 436 } | |
| 437 MojoHandle message_pipe_handle_value; | |
| 438 void* bytes; | |
| 439 uint32_t volatile* num_bytes_ptr; | |
| 440 uint32_t num_bytes_value; | |
| 441 MojoHandle* handles; | |
| 442 uint32_t volatile* num_handles_ptr; | |
| 443 uint32_t num_handles_value; | |
| 444 MojoReadMessageFlags flags_value; | |
| 445 MojoResult volatile* result_ptr; | |
| 446 MojoResult result_value; | |
| 447 { | |
| 448 ScopedCopyLock copy_lock(nap); | |
| 449 if (!ConvertScalarInput(nap, params[1], &message_pipe_handle_value)) { | |
| 450 return -1; | |
| 451 } | |
| 452 if (!ConvertScalarInOut(nap, params[3], true, &num_bytes_value, | |
| 453 &num_bytes_ptr)) { | |
| 454 return -1; | |
| 455 } | |
| 456 if (!ConvertScalarInOut(nap, params[5], true, &num_handles_value, | |
| 457 &num_handles_ptr)) { | |
| 458 return -1; | |
| 459 } | |
| 460 if (!ConvertScalarInput(nap, params[6], &flags_value)) { | |
| 461 return -1; | |
| 462 } | |
| 463 if (!ConvertScalarOutput(nap, params[7], false, &result_ptr)) { | |
| 464 return -1; | |
| 465 } | |
| 466 if (!ConvertArray(nap, params[2], num_bytes_value, 1, true, &bytes)) { | |
| 467 return -1; | |
| 468 } | |
| 469 if (!ConvertArray(nap, params[4], num_handles_value, sizeof(*handles), | |
| 470 true, &handles)) { | |
| 471 return -1; | |
| 472 } | |
| 473 } | |
| 474 | |
| 475 result_value = MojoSystemImplReadMessage( | |
| 476 g_mojo_system, message_pipe_handle_value, bytes, | |
| 477 num_bytes_ptr ? &num_bytes_value : nullptr, handles, | |
| 478 num_handles_ptr ? &num_handles_value : nullptr, flags_value); | |
| 479 | |
| 480 { | |
| 481 ScopedCopyLock copy_lock(nap); | |
| 482 if (num_bytes_ptr) { | |
| 483 *num_bytes_ptr = num_bytes_value; | |
| 484 } | |
| 485 if (num_handles_ptr) { | |
| 486 *num_handles_ptr = num_handles_value; | |
| 487 } | |
| 488 *result_ptr = result_value; | |
| 489 } | |
| 490 | |
| 491 return 0; | |
| 492 } | |
| 493 case 11: { | |
| 494 if (num_params != 5) { | |
| 495 return -1; | |
| 496 } | |
| 497 const struct MojoCreateDataPipeOptions* options; | |
| 498 MojoHandle volatile* data_pipe_producer_handle_ptr; | |
| 499 MojoHandle data_pipe_producer_handle_value; | |
| 500 MojoHandle volatile* data_pipe_consumer_handle_ptr; | |
| 501 MojoHandle data_pipe_consumer_handle_value; | |
| 502 MojoResult volatile* result_ptr; | |
| 503 MojoResult result_value; | |
| 504 { | |
| 505 ScopedCopyLock copy_lock(nap); | |
| 506 if (!ConvertExtensibleStructInput(nap, params[1], true, &options)) { | |
| 507 return -1; | |
| 508 } | |
| 509 if (!ConvertScalarInOut(nap, params[2], false, | |
| 510 &data_pipe_producer_handle_value, | |
| 511 &data_pipe_producer_handle_ptr)) { | |
| 512 return -1; | |
| 513 } | |
| 514 if (!ConvertScalarInOut(nap, params[3], false, | |
| 515 &data_pipe_consumer_handle_value, | |
| 516 &data_pipe_consumer_handle_ptr)) { | |
| 517 return -1; | |
| 518 } | |
| 519 if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) { | |
| 520 return -1; | |
| 521 } | |
| 522 } | |
| 523 | |
| 524 result_value = MojoSystemImplCreateDataPipe( | |
| 525 g_mojo_system, options, &data_pipe_producer_handle_value, | |
| 526 &data_pipe_consumer_handle_value); | |
| 527 | |
| 528 { | |
| 529 ScopedCopyLock copy_lock(nap); | |
| 530 *data_pipe_producer_handle_ptr = data_pipe_producer_handle_value; | |
| 531 *data_pipe_consumer_handle_ptr = data_pipe_consumer_handle_value; | |
| 532 *result_ptr = result_value; | |
| 533 } | |
| 534 | |
| 535 return 0; | |
| 536 } | |
| 537 case 12: { | |
| 538 if (num_params != 4) { | |
| 539 return -1; | |
| 540 } | |
| 541 MojoHandle data_pipe_producer_handle_value; | |
| 542 const struct MojoDataPipeProducerOptions* options; | |
| 543 MojoResult volatile* result_ptr; | |
| 544 MojoResult result_value; | |
| 545 { | |
| 546 ScopedCopyLock copy_lock(nap); | |
| 547 if (!ConvertScalarInput(nap, params[1], | |
| 548 &data_pipe_producer_handle_value)) { | |
| 549 return -1; | |
| 550 } | |
| 551 if (!ConvertExtensibleStructInput(nap, params[2], true, &options)) { | |
| 552 return -1; | |
| 553 } | |
| 554 if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) { | |
| 555 return -1; | |
| 556 } | |
| 557 } | |
| 558 | |
| 559 result_value = MojoSystemImplSetDataPipeProducerOptions( | |
| 560 g_mojo_system, data_pipe_producer_handle_value, options); | |
| 561 | |
| 562 { | |
| 563 ScopedCopyLock copy_lock(nap); | |
| 564 *result_ptr = result_value; | |
| 565 } | |
| 566 | |
| 567 return 0; | |
| 568 } | |
| 569 case 13: { | |
| 570 if (num_params != 5) { | |
| 571 return -1; | |
| 572 } | |
| 573 MojoHandle data_pipe_producer_handle_value; | |
| 574 struct MojoDataPipeProducerOptions* options; | |
| 575 uint32_t options_num_bytes_value; | |
| 576 MojoResult volatile* result_ptr; | |
| 577 MojoResult result_value; | |
| 578 { | |
| 579 ScopedCopyLock copy_lock(nap); | |
| 580 if (!ConvertScalarInput(nap, params[1], | |
| 581 &data_pipe_producer_handle_value)) { | |
| 582 return -1; | |
| 583 } | |
| 584 if (!ConvertScalarInput(nap, params[3], &options_num_bytes_value)) { | |
| 585 return -1; | |
| 586 } | |
| 587 if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) { | |
| 588 return -1; | |
| 589 } | |
| 590 if (!ConvertArray(nap, params[2], options_num_bytes_value, 1, false, | |
| 591 &options)) { | |
| 592 return -1; | |
| 593 } | |
| 594 } | |
| 595 | |
| 596 result_value = MojoSystemImplGetDataPipeProducerOptions( | |
| 597 g_mojo_system, data_pipe_producer_handle_value, options, | |
| 598 options_num_bytes_value); | |
| 599 | |
| 600 { | |
| 601 ScopedCopyLock copy_lock(nap); | |
| 602 *result_ptr = result_value; | |
| 603 } | |
| 604 | |
| 605 return 0; | |
| 606 } | |
| 607 case 14: { | |
| 608 if (num_params != 6) { | |
| 609 return -1; | |
| 610 } | |
| 611 MojoHandle data_pipe_producer_handle_value; | |
| 612 const void* elements; | |
| 613 uint32_t volatile* num_bytes_ptr; | |
| 614 uint32_t num_bytes_value; | |
| 615 MojoWriteDataFlags flags_value; | |
| 616 MojoResult volatile* result_ptr; | |
| 617 MojoResult result_value; | |
| 618 { | |
| 619 ScopedCopyLock copy_lock(nap); | |
| 620 if (!ConvertScalarInput(nap, params[1], | |
| 621 &data_pipe_producer_handle_value)) { | |
| 622 return -1; | |
| 623 } | |
| 624 if (!ConvertScalarInOut(nap, params[3], false, &num_bytes_value, | |
| 625 &num_bytes_ptr)) { | |
| 626 return -1; | |
| 627 } | |
| 628 if (!ConvertScalarInput(nap, params[4], &flags_value)) { | |
| 629 return -1; | |
| 630 } | |
| 631 if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) { | |
| 632 return -1; | |
| 633 } | |
| 634 if (!ConvertArray(nap, params[2], num_bytes_value, 1, false, | |
| 635 &elements)) { | |
| 636 return -1; | |
| 637 } | |
| 638 } | |
| 639 | |
| 640 result_value = MojoSystemImplWriteData( | |
| 641 g_mojo_system, data_pipe_producer_handle_value, elements, | |
| 642 &num_bytes_value, flags_value); | |
| 643 | |
| 644 { | |
| 645 ScopedCopyLock copy_lock(nap); | |
| 646 *num_bytes_ptr = num_bytes_value; | |
| 647 *result_ptr = result_value; | |
| 648 } | |
| 649 | |
| 650 return 0; | |
| 651 } | |
| 652 case 15: | |
| 653 fprintf(stderr, "MojoBeginWriteData not implemented\n"); | |
| 654 return -1; | |
| 655 case 16: { | |
| 656 if (num_params != 4) { | |
| 657 return -1; | |
| 658 } | |
| 659 MojoHandle data_pipe_producer_handle_value; | |
| 660 uint32_t num_bytes_written_value; | |
| 661 MojoResult volatile* result_ptr; | |
| 662 MojoResult result_value; | |
| 663 { | |
| 664 ScopedCopyLock copy_lock(nap); | |
| 665 if (!ConvertScalarInput(nap, params[1], | |
| 666 &data_pipe_producer_handle_value)) { | |
| 667 return -1; | |
| 668 } | |
| 669 if (!ConvertScalarInput(nap, params[2], &num_bytes_written_value)) { | |
| 670 return -1; | |
| 671 } | |
| 672 if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) { | |
| 673 return -1; | |
| 674 } | |
| 675 } | |
| 676 | |
| 677 result_value = MojoSystemImplEndWriteData(g_mojo_system, | |
| 678 data_pipe_producer_handle_value, | |
| 679 num_bytes_written_value); | |
| 680 | |
| 681 { | |
| 682 ScopedCopyLock copy_lock(nap); | |
| 683 *result_ptr = result_value; | |
| 684 } | |
| 685 | |
| 686 return 0; | |
| 687 } | |
| 688 case 17: { | |
| 689 if (num_params != 4) { | |
| 690 return -1; | |
| 691 } | |
| 692 MojoHandle data_pipe_consumer_handle_value; | |
| 693 const struct MojoDataPipeConsumerOptions* options; | |
| 694 MojoResult volatile* result_ptr; | |
| 695 MojoResult result_value; | |
| 696 { | |
| 697 ScopedCopyLock copy_lock(nap); | |
| 698 if (!ConvertScalarInput(nap, params[1], | |
| 699 &data_pipe_consumer_handle_value)) { | |
| 700 return -1; | |
| 701 } | |
| 702 if (!ConvertExtensibleStructInput(nap, params[2], true, &options)) { | |
| 703 return -1; | |
| 704 } | |
| 705 if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) { | |
| 706 return -1; | |
| 707 } | |
| 708 } | |
| 709 | |
| 710 result_value = MojoSystemImplSetDataPipeConsumerOptions( | |
| 711 g_mojo_system, data_pipe_consumer_handle_value, options); | |
| 712 | |
| 713 { | |
| 714 ScopedCopyLock copy_lock(nap); | |
| 715 *result_ptr = result_value; | |
| 716 } | |
| 717 | |
| 718 return 0; | |
| 719 } | |
| 720 case 18: { | |
| 721 if (num_params != 5) { | |
| 722 return -1; | |
| 723 } | |
| 724 MojoHandle data_pipe_consumer_handle_value; | |
| 725 struct MojoDataPipeConsumerOptions* options; | |
| 726 uint32_t options_num_bytes_value; | |
| 727 MojoResult volatile* result_ptr; | |
| 728 MojoResult result_value; | |
| 729 { | |
| 730 ScopedCopyLock copy_lock(nap); | |
| 731 if (!ConvertScalarInput(nap, params[1], | |
| 732 &data_pipe_consumer_handle_value)) { | |
| 733 return -1; | |
| 734 } | |
| 735 if (!ConvertScalarInput(nap, params[3], &options_num_bytes_value)) { | |
| 736 return -1; | |
| 737 } | |
| 738 if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) { | |
| 739 return -1; | |
| 740 } | |
| 741 if (!ConvertArray(nap, params[2], options_num_bytes_value, 1, false, | |
| 742 &options)) { | |
| 743 return -1; | |
| 744 } | |
| 745 } | |
| 746 | |
| 747 result_value = MojoSystemImplGetDataPipeConsumerOptions( | |
| 748 g_mojo_system, data_pipe_consumer_handle_value, options, | |
| 749 options_num_bytes_value); | |
| 750 | |
| 751 { | |
| 752 ScopedCopyLock copy_lock(nap); | |
| 753 *result_ptr = result_value; | |
| 754 } | |
| 755 | |
| 756 return 0; | |
| 757 } | |
| 758 case 19: { | |
| 759 if (num_params != 6) { | |
| 760 return -1; | |
| 761 } | |
| 762 MojoHandle data_pipe_consumer_handle_value; | |
| 763 void* elements; | |
| 764 uint32_t volatile* num_bytes_ptr; | |
| 765 uint32_t num_bytes_value; | |
| 766 MojoReadDataFlags flags_value; | |
| 767 MojoResult volatile* result_ptr; | |
| 768 MojoResult result_value; | |
| 769 { | |
| 770 ScopedCopyLock copy_lock(nap); | |
| 771 if (!ConvertScalarInput(nap, params[1], | |
| 772 &data_pipe_consumer_handle_value)) { | |
| 773 return -1; | |
| 774 } | |
| 775 if (!ConvertScalarInOut(nap, params[3], false, &num_bytes_value, | |
| 776 &num_bytes_ptr)) { | |
| 777 return -1; | |
| 778 } | |
| 779 if (!ConvertScalarInput(nap, params[4], &flags_value)) { | |
| 780 return -1; | |
| 781 } | |
| 782 if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) { | |
| 783 return -1; | |
| 784 } | |
| 785 if (!ConvertArray(nap, params[2], num_bytes_value, 1, false, | |
| 786 &elements)) { | |
| 787 return -1; | |
| 788 } | |
| 789 } | |
| 790 | |
| 791 result_value = | |
| 792 MojoSystemImplReadData(g_mojo_system, data_pipe_consumer_handle_value, | |
| 793 elements, &num_bytes_value, flags_value); | |
| 794 | |
| 795 { | |
| 796 ScopedCopyLock copy_lock(nap); | |
| 797 *num_bytes_ptr = num_bytes_value; | |
| 798 *result_ptr = result_value; | |
| 799 } | |
| 800 | |
| 801 return 0; | |
| 802 } | |
| 803 case 20: | |
| 804 fprintf(stderr, "MojoBeginReadData not implemented\n"); | |
| 805 return -1; | |
| 806 case 21: { | |
| 807 if (num_params != 4) { | |
| 808 return -1; | |
| 809 } | |
| 810 MojoHandle data_pipe_consumer_handle_value; | |
| 811 uint32_t num_bytes_read_value; | |
| 812 MojoResult volatile* result_ptr; | |
| 813 MojoResult result_value; | |
| 814 { | |
| 815 ScopedCopyLock copy_lock(nap); | |
| 816 if (!ConvertScalarInput(nap, params[1], | |
| 817 &data_pipe_consumer_handle_value)) { | |
| 818 return -1; | |
| 819 } | |
| 820 if (!ConvertScalarInput(nap, params[2], &num_bytes_read_value)) { | |
| 821 return -1; | |
| 822 } | |
| 823 if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) { | |
| 824 return -1; | |
| 825 } | |
| 826 } | |
| 827 | |
| 828 result_value = MojoSystemImplEndReadData( | |
| 829 g_mojo_system, data_pipe_consumer_handle_value, num_bytes_read_value); | |
| 830 | |
| 831 { | |
| 832 ScopedCopyLock copy_lock(nap); | |
| 833 *result_ptr = result_value; | |
| 834 } | |
| 835 | |
| 836 return 0; | |
| 837 } | |
| 838 case 22: { | |
| 839 if (num_params != 5) { | |
| 840 return -1; | |
| 841 } | |
| 842 const struct MojoCreateSharedBufferOptions* options; | |
| 843 uint64_t num_bytes_value; | |
| 844 MojoHandle volatile* shared_buffer_handle_ptr; | |
| 845 MojoHandle shared_buffer_handle_value; | |
| 846 MojoResult volatile* result_ptr; | |
| 847 MojoResult result_value; | |
| 848 { | |
| 849 ScopedCopyLock copy_lock(nap); | |
| 850 if (!ConvertExtensibleStructInput(nap, params[1], true, &options)) { | |
| 851 return -1; | |
| 852 } | |
| 853 if (!ConvertScalarInput(nap, params[2], &num_bytes_value)) { | |
| 854 return -1; | |
| 855 } | |
| 856 if (!ConvertScalarInOut(nap, params[3], false, | |
| 857 &shared_buffer_handle_value, | |
| 858 &shared_buffer_handle_ptr)) { | |
| 859 return -1; | |
| 860 } | |
| 861 if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) { | |
| 862 return -1; | |
| 863 } | |
| 864 } | |
| 865 | |
| 866 result_value = MojoSystemImplCreateSharedBuffer( | |
| 867 g_mojo_system, options, num_bytes_value, &shared_buffer_handle_value); | |
| 868 | |
| 869 { | |
| 870 ScopedCopyLock copy_lock(nap); | |
| 871 *shared_buffer_handle_ptr = shared_buffer_handle_value; | |
| 872 *result_ptr = result_value; | |
| 873 } | |
| 874 | |
| 875 return 0; | |
| 876 } | |
| 877 case 23: { | |
| 878 if (num_params != 5) { | |
| 879 return -1; | |
| 880 } | |
| 881 MojoHandle buffer_handle_value; | |
| 882 const struct MojoDuplicateBufferHandleOptions* options; | |
| 883 MojoHandle volatile* new_buffer_handle_ptr; | |
| 884 MojoHandle new_buffer_handle_value; | |
| 885 MojoResult volatile* result_ptr; | |
| 886 MojoResult result_value; | |
| 887 { | |
| 888 ScopedCopyLock copy_lock(nap); | |
| 889 if (!ConvertScalarInput(nap, params[1], &buffer_handle_value)) { | |
| 890 return -1; | |
| 891 } | |
| 892 if (!ConvertExtensibleStructInput(nap, params[2], true, &options)) { | |
| 893 return -1; | |
| 894 } | |
| 895 if (!ConvertScalarInOut(nap, params[3], false, &new_buffer_handle_value, | |
| 896 &new_buffer_handle_ptr)) { | |
| 897 return -1; | |
| 898 } | |
| 899 if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) { | |
| 900 return -1; | |
| 901 } | |
| 902 } | |
| 903 | |
| 904 result_value = MojoSystemImplDuplicateBufferHandle( | |
| 905 g_mojo_system, buffer_handle_value, options, | |
| 906 &new_buffer_handle_value); | |
| 907 | |
| 908 { | |
| 909 ScopedCopyLock copy_lock(nap); | |
| 910 *new_buffer_handle_ptr = new_buffer_handle_value; | |
| 911 *result_ptr = result_value; | |
| 912 } | |
| 913 | |
| 914 return 0; | |
| 915 } | |
| 916 case 24: { | |
| 917 if (num_params != 5) { | |
| 918 return -1; | |
| 919 } | |
| 920 MojoHandle buffer_handle_value; | |
| 921 struct MojoBufferInformation* info; | |
| 922 uint32_t info_num_bytes_value; | |
| 923 MojoResult volatile* result_ptr; | |
| 924 MojoResult result_value; | |
| 925 { | |
| 926 ScopedCopyLock copy_lock(nap); | |
| 927 if (!ConvertScalarInput(nap, params[1], &buffer_handle_value)) { | |
| 928 return -1; | |
| 929 } | |
| 930 if (!ConvertScalarInput(nap, params[3], &info_num_bytes_value)) { | |
| 931 return -1; | |
| 932 } | |
| 933 if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) { | |
| 934 return -1; | |
| 935 } | |
| 936 if (!ConvertArray(nap, params[2], info_num_bytes_value, 1, false, | |
| 937 &info)) { | |
| 938 return -1; | |
| 939 } | |
| 940 } | |
| 941 | |
| 942 result_value = MojoSystemImplGetBufferInformation( | |
| 943 g_mojo_system, buffer_handle_value, info, info_num_bytes_value); | |
| 944 | |
| 945 { | |
| 946 ScopedCopyLock copy_lock(nap); | |
| 947 *result_ptr = result_value; | |
| 948 } | |
| 949 | |
| 950 return 0; | |
| 951 } | |
| 952 case 25: | |
| 953 fprintf(stderr, "MojoMapBuffer not implemented\n"); | |
| 954 return -1; | |
| 955 case 26: | |
| 956 fprintf(stderr, "MojoUnmapBuffer not implemented\n"); | |
| 957 return -1; | |
| 958 } | |
| 959 | |
| 960 return -1; | |
| 961 } | |
| 962 | |
| 963 ssize_t MojoDescRecvMsg(void* handle, | |
| 964 struct NaClImcTypedMsgHdr* msg, | |
| 965 int flags) { | |
| 966 return -1; | |
| 967 } | |
| 968 | |
| 969 struct NaClDesc* MakeMojoDesc(struct NaClApp* nap) { | |
| 970 struct NaClDescCustomFuncs funcs = NACL_DESC_CUSTOM_FUNCS_INITIALIZER; | |
| 971 funcs.Destroy = MojoDescDestroy; | |
| 972 funcs.SendMsg = MojoDescSendMsg; | |
| 973 funcs.RecvMsg = MojoDescRecvMsg; | |
| 974 return NaClDescMakeCustomDesc(nap, &funcs); | |
| 975 } | |
| 976 | |
| 977 void MojoDisabledDescDestroy(void* handle) { | |
| 978 } | |
| 979 | |
| 980 ssize_t MojoDisabledDescSendMsg(void* handle, | |
| 981 const struct NaClImcTypedMsgHdr* msg, | |
| 982 int flags) { | |
| 983 fprintf(stderr, "Mojo is not currently supported."); | |
| 984 abort(); | |
| 985 } | |
| 986 | |
| 987 ssize_t MojoDisabledDescRecvMsg(void* handle, | |
| 988 struct NaClImcTypedMsgHdr* msg, | |
| 989 int flags) { | |
| 990 fprintf(stderr, "Mojo is not currently supported."); | |
| 991 abort(); | |
| 992 } | |
| 993 | |
| 994 struct NaClDesc* MakeDisabledMojoDesc(struct NaClApp* nap) { | |
| 995 struct NaClDescCustomFuncs funcs = NACL_DESC_CUSTOM_FUNCS_INITIALIZER; | |
| 996 funcs.Destroy = MojoDisabledDescDestroy; | |
| 997 funcs.SendMsg = MojoDisabledDescSendMsg; | |
| 998 funcs.RecvMsg = MojoDisabledDescRecvMsg; | |
| 999 return NaClDescMakeCustomDesc(nap, &funcs); | |
| 1000 } | |
| 1001 | |
| 1002 } // namespace | |
| 1003 | |
| 1004 // The value for this FD must not conflict with uses inside Chromium. However, | |
| 1005 // mojo/nacl doesn't depend on any Chromium headers, so we can't use a #define | |
| 1006 // from there. | |
| 1007 #define NACL_MOJO_DESC (NACL_CHROME_DESC_BASE + 3) | |
| 1008 | |
| 1009 MojoResult InjectMojo(struct NaClApp* nap, MojoHandle handle) { | |
| 1010 NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeMojoDesc(nap)); | |
| 1011 g_mojo_system = MojoSystemImplCreateImpl(); | |
| 1012 return MojoSystemImplTransferHandle(MojoSystemImplGetDefaultImpl(), handle, | |
| 1013 g_mojo_system, &g_mojo_handle); | |
| 1014 } | |
| 1015 | |
| 1016 void InjectDisabledMojo(struct NaClApp* nap) { | |
| 1017 NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeDisabledMojoDesc(nap)); | |
| 1018 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2051163002:
Nuke NaCl SFI, part 1. (Closed)
Base URL: https://github.com/domokit/mojo.git@master