| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2015 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/public/platform/nacl/mojo_irt.h" | |
| 9 | |
| 10 #include <stdio.h> | |
| 11 #include <string.h> | |
| 12 | |
| 13 #include "native_client/src/public/chrome_main.h" | |
| 14 #include "native_client/src/public/imc_syscalls.h" | |
| 15 #include "native_client/src/public/imc_types.h" | |
| 16 #include "native_client/src/public/irt_core.h" | |
| 17 | |
| 18 #define NACL_MOJO_DESC (NACL_CHROME_DESC_BASE + 3) | |
| 19 | |
| 20 static void DoMojoCall(uint32_t params[], nacl_abi_size_t num_params) { | |
| 21 struct NaClAbiNaClImcMsgIoVec iov[1] = { | |
| 22 {params, num_params} | |
| 23 }; | |
| 24 struct NaClAbiNaClImcMsgHdr msgh = {iov, 1, NULL, 0}; | |
| 25 // Note: return value unchecked. We're relying on the result parameter being | |
| 26 // unmodified - if the syscall fails, the Mojo function will return whatever | |
| 27 // the result parameter was initialized to before this function was called. | |
| 28 imc_sendmsg(NACL_MOJO_DESC, &msgh, 0); | |
| 29 } | |
| 30 | |
| 31 static MojoResult irt__MojoGetInitialHandle(MojoHandle* handle) { | |
| 32 uint32_t params[3]; | |
| 33 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 34 params[0] = 0; | |
| 35 params[1] = (uint32_t)(handle); | |
| 36 params[2] = (uint32_t)(&result); | |
| 37 DoMojoCall(params, sizeof(params)); | |
| 38 return result; | |
| 39 }; | |
| 40 | |
| 41 static MojoTimeTicks irt_MojoGetTimeTicksNow() { | |
| 42 uint32_t params[2]; | |
| 43 MojoTimeTicks result = 0; | |
| 44 params[0] = 1; | |
| 45 params[1] = (uint32_t)(&result); | |
| 46 DoMojoCall(params, sizeof(params)); | |
| 47 return result; | |
| 48 }; | |
| 49 | |
| 50 static MojoResult irt_MojoClose(MojoHandle handle) { | |
| 51 uint32_t params[3]; | |
| 52 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 53 params[0] = 2; | |
| 54 params[1] = (uint32_t)(&handle); | |
| 55 params[2] = (uint32_t)(&result); | |
| 56 DoMojoCall(params, sizeof(params)); | |
| 57 return result; | |
| 58 }; | |
| 59 | |
| 60 static MojoResult irt_MojoGetRights( | |
| 61 MojoHandle handle, | |
| 62 MojoHandleRights* rights) { | |
| 63 uint32_t params[4]; | |
| 64 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 65 params[0] = 3; | |
| 66 params[1] = (uint32_t)(&handle); | |
| 67 params[2] = (uint32_t)(rights); | |
| 68 params[3] = (uint32_t)(&result); | |
| 69 DoMojoCall(params, sizeof(params)); | |
| 70 return result; | |
| 71 }; | |
| 72 | |
| 73 static MojoResult irt_MojoDuplicateHandleWithReducedRights( | |
| 74 MojoHandle handle, | |
| 75 MojoHandleRights rights_to_remove, | |
| 76 MojoHandle* new_handle) { | |
| 77 uint32_t params[5]; | |
| 78 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 79 params[0] = 4; | |
| 80 params[1] = (uint32_t)(&handle); | |
| 81 params[2] = (uint32_t)(&rights_to_remove); | |
| 82 params[3] = (uint32_t)(new_handle); | |
| 83 params[4] = (uint32_t)(&result); | |
| 84 DoMojoCall(params, sizeof(params)); | |
| 85 return result; | |
| 86 }; | |
| 87 | |
| 88 static MojoResult irt_MojoDuplicateHandle( | |
| 89 MojoHandle handle, | |
| 90 MojoHandle* new_handle) { | |
| 91 uint32_t params[4]; | |
| 92 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 93 params[0] = 5; | |
| 94 params[1] = (uint32_t)(&handle); | |
| 95 params[2] = (uint32_t)(new_handle); | |
| 96 params[3] = (uint32_t)(&result); | |
| 97 DoMojoCall(params, sizeof(params)); | |
| 98 return result; | |
| 99 }; | |
| 100 | |
| 101 static MojoResult irt_MojoWait( | |
| 102 MojoHandle handle, | |
| 103 MojoHandleSignals signals, | |
| 104 MojoDeadline deadline, | |
| 105 struct MojoHandleSignalsState* signals_state) { | |
| 106 uint32_t params[6]; | |
| 107 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 108 params[0] = 6; | |
| 109 params[1] = (uint32_t)(&handle); | |
| 110 params[2] = (uint32_t)(&signals); | |
| 111 params[3] = (uint32_t)(&deadline); | |
| 112 params[4] = (uint32_t)(signals_state); | |
| 113 params[5] = (uint32_t)(&result); | |
| 114 DoMojoCall(params, sizeof(params)); | |
| 115 return result; | |
| 116 }; | |
| 117 | |
| 118 static MojoResult irt_MojoWaitMany( | |
| 119 const MojoHandle* handles, | |
| 120 const MojoHandleSignals* signals, | |
| 121 uint32_t num_handles, | |
| 122 MojoDeadline deadline, | |
| 123 uint32_t* result_index, | |
| 124 struct MojoHandleSignalsState* signals_states) { | |
| 125 uint32_t params[8]; | |
| 126 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 127 params[0] = 7; | |
| 128 params[1] = (uint32_t)(handles); | |
| 129 params[2] = (uint32_t)(signals); | |
| 130 params[3] = (uint32_t)(&num_handles); | |
| 131 params[4] = (uint32_t)(&deadline); | |
| 132 params[5] = (uint32_t)(result_index); | |
| 133 params[6] = (uint32_t)(signals_states); | |
| 134 params[7] = (uint32_t)(&result); | |
| 135 DoMojoCall(params, sizeof(params)); | |
| 136 return result; | |
| 137 }; | |
| 138 | |
| 139 static MojoResult irt_MojoCreateMessagePipe( | |
| 140 const struct MojoCreateMessagePipeOptions* options, | |
| 141 MojoHandle* message_pipe_handle0, | |
| 142 MojoHandle* message_pipe_handle1) { | |
| 143 uint32_t params[5]; | |
| 144 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 145 params[0] = 8; | |
| 146 params[1] = (uint32_t)(options); | |
| 147 params[2] = (uint32_t)(message_pipe_handle0); | |
| 148 params[3] = (uint32_t)(message_pipe_handle1); | |
| 149 params[4] = (uint32_t)(&result); | |
| 150 DoMojoCall(params, sizeof(params)); | |
| 151 return result; | |
| 152 }; | |
| 153 | |
| 154 static MojoResult irt_MojoWriteMessage( | |
| 155 MojoHandle message_pipe_handle, | |
| 156 const void* bytes, | |
| 157 uint32_t num_bytes, | |
| 158 const MojoHandle* handles, | |
| 159 uint32_t num_handles, | |
| 160 MojoWriteMessageFlags flags) { | |
| 161 uint32_t params[8]; | |
| 162 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 163 params[0] = 9; | |
| 164 params[1] = (uint32_t)(&message_pipe_handle); | |
| 165 params[2] = (uint32_t)(bytes); | |
| 166 params[3] = (uint32_t)(&num_bytes); | |
| 167 params[4] = (uint32_t)(handles); | |
| 168 params[5] = (uint32_t)(&num_handles); | |
| 169 params[6] = (uint32_t)(&flags); | |
| 170 params[7] = (uint32_t)(&result); | |
| 171 DoMojoCall(params, sizeof(params)); | |
| 172 return result; | |
| 173 }; | |
| 174 | |
| 175 static MojoResult irt_MojoReadMessage( | |
| 176 MojoHandle message_pipe_handle, | |
| 177 void* bytes, | |
| 178 uint32_t* num_bytes, | |
| 179 MojoHandle* handles, | |
| 180 uint32_t* num_handles, | |
| 181 MojoReadMessageFlags flags) { | |
| 182 uint32_t params[8]; | |
| 183 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 184 params[0] = 10; | |
| 185 params[1] = (uint32_t)(&message_pipe_handle); | |
| 186 params[2] = (uint32_t)(bytes); | |
| 187 params[3] = (uint32_t)(num_bytes); | |
| 188 params[4] = (uint32_t)(handles); | |
| 189 params[5] = (uint32_t)(num_handles); | |
| 190 params[6] = (uint32_t)(&flags); | |
| 191 params[7] = (uint32_t)(&result); | |
| 192 DoMojoCall(params, sizeof(params)); | |
| 193 return result; | |
| 194 }; | |
| 195 | |
| 196 static MojoResult irt_MojoCreateDataPipe( | |
| 197 const struct MojoCreateDataPipeOptions* options, | |
| 198 MojoHandle* data_pipe_producer_handle, | |
| 199 MojoHandle* data_pipe_consumer_handle) { | |
| 200 uint32_t params[5]; | |
| 201 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 202 params[0] = 11; | |
| 203 params[1] = (uint32_t)(options); | |
| 204 params[2] = (uint32_t)(data_pipe_producer_handle); | |
| 205 params[3] = (uint32_t)(data_pipe_consumer_handle); | |
| 206 params[4] = (uint32_t)(&result); | |
| 207 DoMojoCall(params, sizeof(params)); | |
| 208 return result; | |
| 209 }; | |
| 210 | |
| 211 static MojoResult irt_MojoSetDataPipeProducerOptions( | |
| 212 MojoHandle data_pipe_producer_handle, | |
| 213 const struct MojoDataPipeProducerOptions* options) { | |
| 214 uint32_t params[4]; | |
| 215 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 216 params[0] = 12; | |
| 217 params[1] = (uint32_t)(&data_pipe_producer_handle); | |
| 218 params[2] = (uint32_t)(options); | |
| 219 params[3] = (uint32_t)(&result); | |
| 220 DoMojoCall(params, sizeof(params)); | |
| 221 return result; | |
| 222 }; | |
| 223 | |
| 224 static MojoResult irt_MojoGetDataPipeProducerOptions( | |
| 225 MojoHandle data_pipe_producer_handle, | |
| 226 struct MojoDataPipeProducerOptions* options, | |
| 227 uint32_t options_num_bytes) { | |
| 228 uint32_t params[5]; | |
| 229 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 230 params[0] = 13; | |
| 231 params[1] = (uint32_t)(&data_pipe_producer_handle); | |
| 232 params[2] = (uint32_t)(options); | |
| 233 params[3] = (uint32_t)(&options_num_bytes); | |
| 234 params[4] = (uint32_t)(&result); | |
| 235 DoMojoCall(params, sizeof(params)); | |
| 236 return result; | |
| 237 }; | |
| 238 | |
| 239 static MojoResult irt_MojoWriteData( | |
| 240 MojoHandle data_pipe_producer_handle, | |
| 241 const void* elements, | |
| 242 uint32_t* num_bytes, | |
| 243 MojoWriteDataFlags flags) { | |
| 244 uint32_t params[6]; | |
| 245 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 246 params[0] = 14; | |
| 247 params[1] = (uint32_t)(&data_pipe_producer_handle); | |
| 248 params[2] = (uint32_t)(elements); | |
| 249 params[3] = (uint32_t)(num_bytes); | |
| 250 params[4] = (uint32_t)(&flags); | |
| 251 params[5] = (uint32_t)(&result); | |
| 252 DoMojoCall(params, sizeof(params)); | |
| 253 return result; | |
| 254 }; | |
| 255 | |
| 256 static MojoResult irt_MojoBeginWriteData( | |
| 257 MojoHandle data_pipe_producer_handle, | |
| 258 void** buffer, | |
| 259 uint32_t* buffer_num_bytes, | |
| 260 MojoWriteDataFlags flags) { | |
| 261 uint32_t params[6]; | |
| 262 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 263 params[0] = 15; | |
| 264 params[1] = (uint32_t)(&data_pipe_producer_handle); | |
| 265 params[2] = (uint32_t)(buffer); | |
| 266 params[3] = (uint32_t)(buffer_num_bytes); | |
| 267 params[4] = (uint32_t)(&flags); | |
| 268 params[5] = (uint32_t)(&result); | |
| 269 DoMojoCall(params, sizeof(params)); | |
| 270 return result; | |
| 271 }; | |
| 272 | |
| 273 static MojoResult irt_MojoEndWriteData( | |
| 274 MojoHandle data_pipe_producer_handle, | |
| 275 uint32_t num_bytes_written) { | |
| 276 uint32_t params[4]; | |
| 277 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 278 params[0] = 16; | |
| 279 params[1] = (uint32_t)(&data_pipe_producer_handle); | |
| 280 params[2] = (uint32_t)(&num_bytes_written); | |
| 281 params[3] = (uint32_t)(&result); | |
| 282 DoMojoCall(params, sizeof(params)); | |
| 283 return result; | |
| 284 }; | |
| 285 | |
| 286 static MojoResult irt_MojoSetDataPipeConsumerOptions( | |
| 287 MojoHandle data_pipe_consumer_handle, | |
| 288 const struct MojoDataPipeConsumerOptions* options) { | |
| 289 uint32_t params[4]; | |
| 290 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 291 params[0] = 17; | |
| 292 params[1] = (uint32_t)(&data_pipe_consumer_handle); | |
| 293 params[2] = (uint32_t)(options); | |
| 294 params[3] = (uint32_t)(&result); | |
| 295 DoMojoCall(params, sizeof(params)); | |
| 296 return result; | |
| 297 }; | |
| 298 | |
| 299 static MojoResult irt_MojoGetDataPipeConsumerOptions( | |
| 300 MojoHandle data_pipe_consumer_handle, | |
| 301 struct MojoDataPipeConsumerOptions* options, | |
| 302 uint32_t options_num_bytes) { | |
| 303 uint32_t params[5]; | |
| 304 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 305 params[0] = 18; | |
| 306 params[1] = (uint32_t)(&data_pipe_consumer_handle); | |
| 307 params[2] = (uint32_t)(options); | |
| 308 params[3] = (uint32_t)(&options_num_bytes); | |
| 309 params[4] = (uint32_t)(&result); | |
| 310 DoMojoCall(params, sizeof(params)); | |
| 311 return result; | |
| 312 }; | |
| 313 | |
| 314 static MojoResult irt_MojoReadData( | |
| 315 MojoHandle data_pipe_consumer_handle, | |
| 316 void* elements, | |
| 317 uint32_t* num_bytes, | |
| 318 MojoReadDataFlags flags) { | |
| 319 uint32_t params[6]; | |
| 320 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 321 params[0] = 19; | |
| 322 params[1] = (uint32_t)(&data_pipe_consumer_handle); | |
| 323 params[2] = (uint32_t)(elements); | |
| 324 params[3] = (uint32_t)(num_bytes); | |
| 325 params[4] = (uint32_t)(&flags); | |
| 326 params[5] = (uint32_t)(&result); | |
| 327 DoMojoCall(params, sizeof(params)); | |
| 328 return result; | |
| 329 }; | |
| 330 | |
| 331 static MojoResult irt_MojoBeginReadData( | |
| 332 MojoHandle data_pipe_consumer_handle, | |
| 333 const void** buffer, | |
| 334 uint32_t* buffer_num_bytes, | |
| 335 MojoReadDataFlags flags) { | |
| 336 uint32_t params[6]; | |
| 337 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 338 params[0] = 20; | |
| 339 params[1] = (uint32_t)(&data_pipe_consumer_handle); | |
| 340 params[2] = (uint32_t)(buffer); | |
| 341 params[3] = (uint32_t)(buffer_num_bytes); | |
| 342 params[4] = (uint32_t)(&flags); | |
| 343 params[5] = (uint32_t)(&result); | |
| 344 DoMojoCall(params, sizeof(params)); | |
| 345 return result; | |
| 346 }; | |
| 347 | |
| 348 static MojoResult irt_MojoEndReadData( | |
| 349 MojoHandle data_pipe_consumer_handle, | |
| 350 uint32_t num_bytes_read) { | |
| 351 uint32_t params[4]; | |
| 352 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 353 params[0] = 21; | |
| 354 params[1] = (uint32_t)(&data_pipe_consumer_handle); | |
| 355 params[2] = (uint32_t)(&num_bytes_read); | |
| 356 params[3] = (uint32_t)(&result); | |
| 357 DoMojoCall(params, sizeof(params)); | |
| 358 return result; | |
| 359 }; | |
| 360 | |
| 361 static MojoResult irt_MojoCreateSharedBuffer( | |
| 362 const struct MojoCreateSharedBufferOptions* options, | |
| 363 uint64_t num_bytes, | |
| 364 MojoHandle* shared_buffer_handle) { | |
| 365 uint32_t params[5]; | |
| 366 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 367 params[0] = 22; | |
| 368 params[1] = (uint32_t)(options); | |
| 369 params[2] = (uint32_t)(&num_bytes); | |
| 370 params[3] = (uint32_t)(shared_buffer_handle); | |
| 371 params[4] = (uint32_t)(&result); | |
| 372 DoMojoCall(params, sizeof(params)); | |
| 373 return result; | |
| 374 }; | |
| 375 | |
| 376 static MojoResult irt_MojoDuplicateBufferHandle( | |
| 377 MojoHandle buffer_handle, | |
| 378 const struct MojoDuplicateBufferHandleOptions* options, | |
| 379 MojoHandle* new_buffer_handle) { | |
| 380 uint32_t params[5]; | |
| 381 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 382 params[0] = 23; | |
| 383 params[1] = (uint32_t)(&buffer_handle); | |
| 384 params[2] = (uint32_t)(options); | |
| 385 params[3] = (uint32_t)(new_buffer_handle); | |
| 386 params[4] = (uint32_t)(&result); | |
| 387 DoMojoCall(params, sizeof(params)); | |
| 388 return result; | |
| 389 }; | |
| 390 | |
| 391 static MojoResult irt_MojoGetBufferInformation( | |
| 392 MojoHandle buffer_handle, | |
| 393 struct MojoBufferInformation* info, | |
| 394 uint32_t info_num_bytes) { | |
| 395 uint32_t params[5]; | |
| 396 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 397 params[0] = 24; | |
| 398 params[1] = (uint32_t)(&buffer_handle); | |
| 399 params[2] = (uint32_t)(info); | |
| 400 params[3] = (uint32_t)(&info_num_bytes); | |
| 401 params[4] = (uint32_t)(&result); | |
| 402 DoMojoCall(params, sizeof(params)); | |
| 403 return result; | |
| 404 }; | |
| 405 | |
| 406 static MojoResult irt_MojoMapBuffer( | |
| 407 MojoHandle buffer_handle, | |
| 408 uint64_t offset, | |
| 409 uint64_t num_bytes, | |
| 410 void** buffer, | |
| 411 MojoMapBufferFlags flags) { | |
| 412 uint32_t params[7]; | |
| 413 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 414 params[0] = 25; | |
| 415 params[1] = (uint32_t)(&buffer_handle); | |
| 416 params[2] = (uint32_t)(&offset); | |
| 417 params[3] = (uint32_t)(&num_bytes); | |
| 418 params[4] = (uint32_t)(buffer); | |
| 419 params[5] = (uint32_t)(&flags); | |
| 420 params[6] = (uint32_t)(&result); | |
| 421 DoMojoCall(params, sizeof(params)); | |
| 422 return result; | |
| 423 }; | |
| 424 | |
| 425 static MojoResult irt_MojoUnmapBuffer(void* buffer) { | |
| 426 uint32_t params[3]; | |
| 427 MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; | |
| 428 params[0] = 26; | |
| 429 params[1] = (uint32_t)(&buffer); | |
| 430 params[2] = (uint32_t)(&result); | |
| 431 DoMojoCall(params, sizeof(params)); | |
| 432 return result; | |
| 433 }; | |
| 434 | |
| 435 struct nacl_irt_mojo kIrtMojo = { | |
| 436 &irt__MojoGetInitialHandle, | |
| 437 &irt_MojoGetTimeTicksNow, | |
| 438 &irt_MojoClose, | |
| 439 &irt_MojoGetRights, | |
| 440 &irt_MojoDuplicateHandleWithReducedRights, | |
| 441 &irt_MojoDuplicateHandle, | |
| 442 &irt_MojoWait, | |
| 443 &irt_MojoWaitMany, | |
| 444 &irt_MojoCreateMessagePipe, | |
| 445 &irt_MojoWriteMessage, | |
| 446 &irt_MojoReadMessage, | |
| 447 &irt_MojoCreateDataPipe, | |
| 448 &irt_MojoSetDataPipeProducerOptions, | |
| 449 &irt_MojoGetDataPipeProducerOptions, | |
| 450 &irt_MojoWriteData, | |
| 451 &irt_MojoBeginWriteData, | |
| 452 &irt_MojoEndWriteData, | |
| 453 &irt_MojoSetDataPipeConsumerOptions, | |
| 454 &irt_MojoGetDataPipeConsumerOptions, | |
| 455 &irt_MojoReadData, | |
| 456 &irt_MojoBeginReadData, | |
| 457 &irt_MojoEndReadData, | |
| 458 &irt_MojoCreateSharedBuffer, | |
| 459 &irt_MojoDuplicateBufferHandle, | |
| 460 &irt_MojoGetBufferInformation, | |
| 461 &irt_MojoMapBuffer, | |
| 462 &irt_MojoUnmapBuffer, | |
| 463 }; | |
| 464 | |
| 465 | |
| 466 size_t mojo_irt_query(const char* interface_ident, | |
| 467 void* table, | |
| 468 size_t tablesize) { | |
| 469 static const size_t size = sizeof(kIrtMojo); | |
| 470 if (0 == strcmp(interface_ident, NACL_IRT_MOJO_v0_1)) { | |
| 471 if (size <= tablesize) { | |
| 472 memcpy(table, &kIrtMojo, size); | |
| 473 return size; | |
| 474 } | |
| 475 } | |
| 476 return 0; | |
| 477 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2051163002:
Nuke NaCl SFI, part 1. (Closed)
Base URL: https://github.com/domokit/mojo.git@master