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