sync.c revision 1.5
1 /* 2 * This file generated automatically from sync.xml by c_client.py. 3 * Edit at your peril. 4 */ 5 6 #ifdef HAVE_CONFIG_H 7 #include "config.h" 8 #endif 9 #include <stdlib.h> 10 #include <string.h> 11 #include <assert.h> 12 #include <stddef.h> /* for offsetof() */ 13 #include "xcbext.h" 14 #include "sync.h" 15 16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) 17 #include "xproto.h" 18 19 xcb_extension_t xcb_sync_id = { "SYNC", 0 }; 20 21 void 22 xcb_sync_alarm_next (xcb_sync_alarm_iterator_t *i) 23 { 24 --i->rem; 25 ++i->data; 26 i->index += sizeof(xcb_sync_alarm_t); 27 } 28 29 xcb_generic_iterator_t 30 xcb_sync_alarm_end (xcb_sync_alarm_iterator_t i) 31 { 32 xcb_generic_iterator_t ret; 33 ret.data = i.data + i.rem; 34 ret.index = i.index + ((char *) ret.data - (char *) i.data); 35 ret.rem = 0; 36 return ret; 37 } 38 39 void 40 xcb_sync_counter_next (xcb_sync_counter_iterator_t *i) 41 { 42 --i->rem; 43 ++i->data; 44 i->index += sizeof(xcb_sync_counter_t); 45 } 46 47 xcb_generic_iterator_t 48 xcb_sync_counter_end (xcb_sync_counter_iterator_t i) 49 { 50 xcb_generic_iterator_t ret; 51 ret.data = i.data + i.rem; 52 ret.index = i.index + ((char *) ret.data - (char *) i.data); 53 ret.rem = 0; 54 return ret; 55 } 56 57 void 58 xcb_sync_fence_next (xcb_sync_fence_iterator_t *i) 59 { 60 --i->rem; 61 ++i->data; 62 i->index += sizeof(xcb_sync_fence_t); 63 } 64 65 xcb_generic_iterator_t 66 xcb_sync_fence_end (xcb_sync_fence_iterator_t i) 67 { 68 xcb_generic_iterator_t ret; 69 ret.data = i.data + i.rem; 70 ret.index = i.index + ((char *) ret.data - (char *) i.data); 71 ret.rem = 0; 72 return ret; 73 } 74 75 void 76 xcb_sync_int64_next (xcb_sync_int64_iterator_t *i) 77 { 78 --i->rem; 79 ++i->data; 80 i->index += sizeof(xcb_sync_int64_t); 81 } 82 83 xcb_generic_iterator_t 84 xcb_sync_int64_end (xcb_sync_int64_iterator_t i) 85 { 86 xcb_generic_iterator_t ret; 87 ret.data = i.data + i.rem; 88 ret.index = i.index + ((char *) ret.data - (char *) i.data); 89 ret.rem = 0; 90 return ret; 91 } 92 93 int 94 xcb_sync_systemcounter_sizeof (const void *_buffer) 95 { 96 char *xcb_tmp = (char *)_buffer; 97 const xcb_sync_systemcounter_t *_aux = (xcb_sync_systemcounter_t *)_buffer; 98 unsigned int xcb_buffer_len = 0; 99 unsigned int xcb_block_len = 0; 100 unsigned int xcb_pad = 0; 101 unsigned int xcb_align_to = 0; 102 103 104 xcb_block_len += sizeof(xcb_sync_systemcounter_t); 105 xcb_tmp += xcb_block_len; 106 xcb_buffer_len += xcb_block_len; 107 xcb_block_len = 0; 108 /* name */ 109 xcb_block_len += _aux->name_len * sizeof(char); 110 xcb_tmp += xcb_block_len; 111 xcb_align_to = ALIGNOF(char); 112 xcb_align_to = 4; 113 /* insert padding */ 114 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 115 xcb_buffer_len += xcb_block_len + xcb_pad; 116 if (0 != xcb_pad) { 117 xcb_tmp += xcb_pad; 118 xcb_pad = 0; 119 } 120 xcb_block_len = 0; 121 /* insert padding */ 122 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 123 xcb_buffer_len += xcb_block_len + xcb_pad; 124 if (0 != xcb_pad) { 125 xcb_tmp += xcb_pad; 126 xcb_pad = 0; 127 } 128 xcb_block_len = 0; 129 130 return xcb_buffer_len; 131 } 132 133 char * 134 xcb_sync_systemcounter_name (const xcb_sync_systemcounter_t *R) 135 { 136 return (char *) (R + 1); 137 } 138 139 int 140 xcb_sync_systemcounter_name_length (const xcb_sync_systemcounter_t *R) 141 { 142 return R->name_len; 143 } 144 145 xcb_generic_iterator_t 146 xcb_sync_systemcounter_name_end (const xcb_sync_systemcounter_t *R) 147 { 148 xcb_generic_iterator_t i; 149 i.data = ((char *) (R + 1)) + (R->name_len); 150 i.rem = 0; 151 i.index = (char *) i.data - (char *) R; 152 return i; 153 } 154 155 void 156 xcb_sync_systemcounter_next (xcb_sync_systemcounter_iterator_t *i) 157 { 158 xcb_sync_systemcounter_t *R = i->data; 159 xcb_generic_iterator_t child; 160 child.data = (xcb_sync_systemcounter_t *)(((char *)R) + xcb_sync_systemcounter_sizeof(R)); 161 i->index = (char *) child.data - (char *) i->data; 162 --i->rem; 163 i->data = (xcb_sync_systemcounter_t *) child.data; 164 } 165 166 xcb_generic_iterator_t 167 xcb_sync_systemcounter_end (xcb_sync_systemcounter_iterator_t i) 168 { 169 xcb_generic_iterator_t ret; 170 while(i.rem > 0) 171 xcb_sync_systemcounter_next(&i); 172 ret.data = i.data; 173 ret.rem = i.rem; 174 ret.index = i.index; 175 return ret; 176 } 177 178 void 179 xcb_sync_trigger_next (xcb_sync_trigger_iterator_t *i) 180 { 181 --i->rem; 182 ++i->data; 183 i->index += sizeof(xcb_sync_trigger_t); 184 } 185 186 xcb_generic_iterator_t 187 xcb_sync_trigger_end (xcb_sync_trigger_iterator_t i) 188 { 189 xcb_generic_iterator_t ret; 190 ret.data = i.data + i.rem; 191 ret.index = i.index + ((char *) ret.data - (char *) i.data); 192 ret.rem = 0; 193 return ret; 194 } 195 196 void 197 xcb_sync_waitcondition_next (xcb_sync_waitcondition_iterator_t *i) 198 { 199 --i->rem; 200 ++i->data; 201 i->index += sizeof(xcb_sync_waitcondition_t); 202 } 203 204 xcb_generic_iterator_t 205 xcb_sync_waitcondition_end (xcb_sync_waitcondition_iterator_t i) 206 { 207 xcb_generic_iterator_t ret; 208 ret.data = i.data + i.rem; 209 ret.index = i.index + ((char *) ret.data - (char *) i.data); 210 ret.rem = 0; 211 return ret; 212 } 213 214 xcb_sync_initialize_cookie_t 215 xcb_sync_initialize (xcb_connection_t *c, 216 uint8_t desired_major_version, 217 uint8_t desired_minor_version) 218 { 219 static const xcb_protocol_request_t xcb_req = { 220 .count = 2, 221 .ext = &xcb_sync_id, 222 .opcode = XCB_SYNC_INITIALIZE, 223 .isvoid = 0 224 }; 225 226 struct iovec xcb_parts[4]; 227 xcb_sync_initialize_cookie_t xcb_ret; 228 xcb_sync_initialize_request_t xcb_out; 229 230 xcb_out.desired_major_version = desired_major_version; 231 xcb_out.desired_minor_version = desired_minor_version; 232 233 xcb_parts[2].iov_base = (char *) &xcb_out; 234 xcb_parts[2].iov_len = sizeof(xcb_out); 235 xcb_parts[3].iov_base = 0; 236 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 237 238 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 239 return xcb_ret; 240 } 241 242 xcb_sync_initialize_cookie_t 243 xcb_sync_initialize_unchecked (xcb_connection_t *c, 244 uint8_t desired_major_version, 245 uint8_t desired_minor_version) 246 { 247 static const xcb_protocol_request_t xcb_req = { 248 .count = 2, 249 .ext = &xcb_sync_id, 250 .opcode = XCB_SYNC_INITIALIZE, 251 .isvoid = 0 252 }; 253 254 struct iovec xcb_parts[4]; 255 xcb_sync_initialize_cookie_t xcb_ret; 256 xcb_sync_initialize_request_t xcb_out; 257 258 xcb_out.desired_major_version = desired_major_version; 259 xcb_out.desired_minor_version = desired_minor_version; 260 261 xcb_parts[2].iov_base = (char *) &xcb_out; 262 xcb_parts[2].iov_len = sizeof(xcb_out); 263 xcb_parts[3].iov_base = 0; 264 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 265 266 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 267 return xcb_ret; 268 } 269 270 xcb_sync_initialize_reply_t * 271 xcb_sync_initialize_reply (xcb_connection_t *c, 272 xcb_sync_initialize_cookie_t cookie /**< */, 273 xcb_generic_error_t **e) 274 { 275 return (xcb_sync_initialize_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 276 } 277 278 int 279 xcb_sync_list_system_counters_sizeof (const void *_buffer) 280 { 281 char *xcb_tmp = (char *)_buffer; 282 const xcb_sync_list_system_counters_reply_t *_aux = (xcb_sync_list_system_counters_reply_t *)_buffer; 283 unsigned int xcb_buffer_len = 0; 284 unsigned int xcb_block_len = 0; 285 unsigned int xcb_pad = 0; 286 unsigned int xcb_align_to = 0; 287 288 unsigned int i; 289 unsigned int xcb_tmp_len; 290 291 xcb_block_len += sizeof(xcb_sync_list_system_counters_reply_t); 292 xcb_tmp += xcb_block_len; 293 xcb_buffer_len += xcb_block_len; 294 xcb_block_len = 0; 295 /* counters */ 296 for(i=0; i<_aux->counters_len; i++) { 297 xcb_tmp_len = xcb_sync_systemcounter_sizeof(xcb_tmp); 298 xcb_block_len += xcb_tmp_len; 299 xcb_tmp += xcb_tmp_len; 300 } 301 xcb_align_to = ALIGNOF(xcb_sync_systemcounter_t); 302 /* insert padding */ 303 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 304 xcb_buffer_len += xcb_block_len + xcb_pad; 305 if (0 != xcb_pad) { 306 xcb_tmp += xcb_pad; 307 xcb_pad = 0; 308 } 309 xcb_block_len = 0; 310 311 return xcb_buffer_len; 312 } 313 314 xcb_sync_list_system_counters_cookie_t 315 xcb_sync_list_system_counters (xcb_connection_t *c) 316 { 317 static const xcb_protocol_request_t xcb_req = { 318 .count = 2, 319 .ext = &xcb_sync_id, 320 .opcode = XCB_SYNC_LIST_SYSTEM_COUNTERS, 321 .isvoid = 0 322 }; 323 324 struct iovec xcb_parts[4]; 325 xcb_sync_list_system_counters_cookie_t xcb_ret; 326 xcb_sync_list_system_counters_request_t xcb_out; 327 328 329 xcb_parts[2].iov_base = (char *) &xcb_out; 330 xcb_parts[2].iov_len = sizeof(xcb_out); 331 xcb_parts[3].iov_base = 0; 332 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 333 334 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 335 return xcb_ret; 336 } 337 338 xcb_sync_list_system_counters_cookie_t 339 xcb_sync_list_system_counters_unchecked (xcb_connection_t *c) 340 { 341 static const xcb_protocol_request_t xcb_req = { 342 .count = 2, 343 .ext = &xcb_sync_id, 344 .opcode = XCB_SYNC_LIST_SYSTEM_COUNTERS, 345 .isvoid = 0 346 }; 347 348 struct iovec xcb_parts[4]; 349 xcb_sync_list_system_counters_cookie_t xcb_ret; 350 xcb_sync_list_system_counters_request_t xcb_out; 351 352 353 xcb_parts[2].iov_base = (char *) &xcb_out; 354 xcb_parts[2].iov_len = sizeof(xcb_out); 355 xcb_parts[3].iov_base = 0; 356 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 357 358 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 359 return xcb_ret; 360 } 361 362 int 363 xcb_sync_list_system_counters_counters_length (const xcb_sync_list_system_counters_reply_t *R) 364 { 365 return R->counters_len; 366 } 367 368 xcb_sync_systemcounter_iterator_t 369 xcb_sync_list_system_counters_counters_iterator (const xcb_sync_list_system_counters_reply_t *R) 370 { 371 xcb_sync_systemcounter_iterator_t i; 372 i.data = (xcb_sync_systemcounter_t *) (R + 1); 373 i.rem = R->counters_len; 374 i.index = (char *) i.data - (char *) R; 375 return i; 376 } 377 378 xcb_sync_list_system_counters_reply_t * 379 xcb_sync_list_system_counters_reply (xcb_connection_t *c, 380 xcb_sync_list_system_counters_cookie_t cookie /**< */, 381 xcb_generic_error_t **e) 382 { 383 return (xcb_sync_list_system_counters_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 384 } 385 386 xcb_void_cookie_t 387 xcb_sync_create_counter_checked (xcb_connection_t *c, 388 xcb_sync_counter_t id, 389 xcb_sync_int64_t initial_value) 390 { 391 static const xcb_protocol_request_t xcb_req = { 392 .count = 2, 393 .ext = &xcb_sync_id, 394 .opcode = XCB_SYNC_CREATE_COUNTER, 395 .isvoid = 1 396 }; 397 398 struct iovec xcb_parts[4]; 399 xcb_void_cookie_t xcb_ret; 400 xcb_sync_create_counter_request_t xcb_out; 401 402 xcb_out.id = id; 403 xcb_out.initial_value = initial_value; 404 405 xcb_parts[2].iov_base = (char *) &xcb_out; 406 xcb_parts[2].iov_len = sizeof(xcb_out); 407 xcb_parts[3].iov_base = 0; 408 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 409 410 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 411 return xcb_ret; 412 } 413 414 xcb_void_cookie_t 415 xcb_sync_create_counter (xcb_connection_t *c, 416 xcb_sync_counter_t id, 417 xcb_sync_int64_t initial_value) 418 { 419 static const xcb_protocol_request_t xcb_req = { 420 .count = 2, 421 .ext = &xcb_sync_id, 422 .opcode = XCB_SYNC_CREATE_COUNTER, 423 .isvoid = 1 424 }; 425 426 struct iovec xcb_parts[4]; 427 xcb_void_cookie_t xcb_ret; 428 xcb_sync_create_counter_request_t xcb_out; 429 430 xcb_out.id = id; 431 xcb_out.initial_value = initial_value; 432 433 xcb_parts[2].iov_base = (char *) &xcb_out; 434 xcb_parts[2].iov_len = sizeof(xcb_out); 435 xcb_parts[3].iov_base = 0; 436 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 437 438 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 439 return xcb_ret; 440 } 441 442 xcb_void_cookie_t 443 xcb_sync_destroy_counter_checked (xcb_connection_t *c, 444 xcb_sync_counter_t counter) 445 { 446 static const xcb_protocol_request_t xcb_req = { 447 .count = 2, 448 .ext = &xcb_sync_id, 449 .opcode = XCB_SYNC_DESTROY_COUNTER, 450 .isvoid = 1 451 }; 452 453 struct iovec xcb_parts[4]; 454 xcb_void_cookie_t xcb_ret; 455 xcb_sync_destroy_counter_request_t xcb_out; 456 457 xcb_out.counter = counter; 458 459 xcb_parts[2].iov_base = (char *) &xcb_out; 460 xcb_parts[2].iov_len = sizeof(xcb_out); 461 xcb_parts[3].iov_base = 0; 462 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 463 464 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 465 return xcb_ret; 466 } 467 468 xcb_void_cookie_t 469 xcb_sync_destroy_counter (xcb_connection_t *c, 470 xcb_sync_counter_t counter) 471 { 472 static const xcb_protocol_request_t xcb_req = { 473 .count = 2, 474 .ext = &xcb_sync_id, 475 .opcode = XCB_SYNC_DESTROY_COUNTER, 476 .isvoid = 1 477 }; 478 479 struct iovec xcb_parts[4]; 480 xcb_void_cookie_t xcb_ret; 481 xcb_sync_destroy_counter_request_t xcb_out; 482 483 xcb_out.counter = counter; 484 485 xcb_parts[2].iov_base = (char *) &xcb_out; 486 xcb_parts[2].iov_len = sizeof(xcb_out); 487 xcb_parts[3].iov_base = 0; 488 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 489 490 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 491 return xcb_ret; 492 } 493 494 xcb_sync_query_counter_cookie_t 495 xcb_sync_query_counter (xcb_connection_t *c, 496 xcb_sync_counter_t counter) 497 { 498 static const xcb_protocol_request_t xcb_req = { 499 .count = 2, 500 .ext = &xcb_sync_id, 501 .opcode = XCB_SYNC_QUERY_COUNTER, 502 .isvoid = 0 503 }; 504 505 struct iovec xcb_parts[4]; 506 xcb_sync_query_counter_cookie_t xcb_ret; 507 xcb_sync_query_counter_request_t xcb_out; 508 509 xcb_out.counter = counter; 510 511 xcb_parts[2].iov_base = (char *) &xcb_out; 512 xcb_parts[2].iov_len = sizeof(xcb_out); 513 xcb_parts[3].iov_base = 0; 514 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 515 516 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 517 return xcb_ret; 518 } 519 520 xcb_sync_query_counter_cookie_t 521 xcb_sync_query_counter_unchecked (xcb_connection_t *c, 522 xcb_sync_counter_t counter) 523 { 524 static const xcb_protocol_request_t xcb_req = { 525 .count = 2, 526 .ext = &xcb_sync_id, 527 .opcode = XCB_SYNC_QUERY_COUNTER, 528 .isvoid = 0 529 }; 530 531 struct iovec xcb_parts[4]; 532 xcb_sync_query_counter_cookie_t xcb_ret; 533 xcb_sync_query_counter_request_t xcb_out; 534 535 xcb_out.counter = counter; 536 537 xcb_parts[2].iov_base = (char *) &xcb_out; 538 xcb_parts[2].iov_len = sizeof(xcb_out); 539 xcb_parts[3].iov_base = 0; 540 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 541 542 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 543 return xcb_ret; 544 } 545 546 xcb_sync_query_counter_reply_t * 547 xcb_sync_query_counter_reply (xcb_connection_t *c, 548 xcb_sync_query_counter_cookie_t cookie /**< */, 549 xcb_generic_error_t **e) 550 { 551 return (xcb_sync_query_counter_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 552 } 553 554 int 555 xcb_sync_await_sizeof (const void *_buffer, 556 uint32_t wait_list_len) 557 { 558 char *xcb_tmp = (char *)_buffer; 559 unsigned int xcb_buffer_len = 0; 560 unsigned int xcb_block_len = 0; 561 unsigned int xcb_pad = 0; 562 unsigned int xcb_align_to = 0; 563 564 565 xcb_block_len += sizeof(xcb_sync_await_request_t); 566 xcb_tmp += xcb_block_len; 567 xcb_buffer_len += xcb_block_len; 568 xcb_block_len = 0; 569 /* wait_list */ 570 xcb_block_len += wait_list_len * sizeof(xcb_sync_waitcondition_t); 571 xcb_tmp += xcb_block_len; 572 xcb_align_to = ALIGNOF(xcb_sync_waitcondition_t); 573 /* insert padding */ 574 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 575 xcb_buffer_len += xcb_block_len + xcb_pad; 576 if (0 != xcb_pad) { 577 xcb_tmp += xcb_pad; 578 xcb_pad = 0; 579 } 580 xcb_block_len = 0; 581 582 return xcb_buffer_len; 583 } 584 585 xcb_void_cookie_t 586 xcb_sync_await_checked (xcb_connection_t *c, 587 uint32_t wait_list_len, 588 const xcb_sync_waitcondition_t *wait_list) 589 { 590 static const xcb_protocol_request_t xcb_req = { 591 .count = 4, 592 .ext = &xcb_sync_id, 593 .opcode = XCB_SYNC_AWAIT, 594 .isvoid = 1 595 }; 596 597 struct iovec xcb_parts[6]; 598 xcb_void_cookie_t xcb_ret; 599 xcb_sync_await_request_t xcb_out; 600 601 602 xcb_parts[2].iov_base = (char *) &xcb_out; 603 xcb_parts[2].iov_len = sizeof(xcb_out); 604 xcb_parts[3].iov_base = 0; 605 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 606 /* xcb_sync_waitcondition_t wait_list */ 607 xcb_parts[4].iov_base = (char *) wait_list; 608 xcb_parts[4].iov_len = wait_list_len * sizeof(xcb_sync_waitcondition_t); 609 xcb_parts[5].iov_base = 0; 610 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 611 612 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 613 return xcb_ret; 614 } 615 616 xcb_void_cookie_t 617 xcb_sync_await (xcb_connection_t *c, 618 uint32_t wait_list_len, 619 const xcb_sync_waitcondition_t *wait_list) 620 { 621 static const xcb_protocol_request_t xcb_req = { 622 .count = 4, 623 .ext = &xcb_sync_id, 624 .opcode = XCB_SYNC_AWAIT, 625 .isvoid = 1 626 }; 627 628 struct iovec xcb_parts[6]; 629 xcb_void_cookie_t xcb_ret; 630 xcb_sync_await_request_t xcb_out; 631 632 633 xcb_parts[2].iov_base = (char *) &xcb_out; 634 xcb_parts[2].iov_len = sizeof(xcb_out); 635 xcb_parts[3].iov_base = 0; 636 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 637 /* xcb_sync_waitcondition_t wait_list */ 638 xcb_parts[4].iov_base = (char *) wait_list; 639 xcb_parts[4].iov_len = wait_list_len * sizeof(xcb_sync_waitcondition_t); 640 xcb_parts[5].iov_base = 0; 641 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 642 643 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 644 return xcb_ret; 645 } 646 647 xcb_sync_waitcondition_t * 648 xcb_sync_await_wait_list (const xcb_sync_await_request_t *R) 649 { 650 return (xcb_sync_waitcondition_t *) (R + 1); 651 } 652 653 int 654 xcb_sync_await_wait_list_length (const xcb_sync_await_request_t *R) 655 { 656 return (((R->length * 4) - sizeof(xcb_sync_await_request_t))/sizeof(xcb_sync_waitcondition_t)); 657 } 658 659 xcb_sync_waitcondition_iterator_t 660 xcb_sync_await_wait_list_iterator (const xcb_sync_await_request_t *R) 661 { 662 xcb_sync_waitcondition_iterator_t i; 663 i.data = (xcb_sync_waitcondition_t *) (R + 1); 664 i.rem = (((R->length * 4) - sizeof(xcb_sync_await_request_t))/sizeof(xcb_sync_waitcondition_t)); 665 i.index = (char *) i.data - (char *) R; 666 return i; 667 } 668 669 xcb_void_cookie_t 670 xcb_sync_change_counter_checked (xcb_connection_t *c, 671 xcb_sync_counter_t counter, 672 xcb_sync_int64_t amount) 673 { 674 static const xcb_protocol_request_t xcb_req = { 675 .count = 2, 676 .ext = &xcb_sync_id, 677 .opcode = XCB_SYNC_CHANGE_COUNTER, 678 .isvoid = 1 679 }; 680 681 struct iovec xcb_parts[4]; 682 xcb_void_cookie_t xcb_ret; 683 xcb_sync_change_counter_request_t xcb_out; 684 685 xcb_out.counter = counter; 686 xcb_out.amount = amount; 687 688 xcb_parts[2].iov_base = (char *) &xcb_out; 689 xcb_parts[2].iov_len = sizeof(xcb_out); 690 xcb_parts[3].iov_base = 0; 691 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 692 693 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 694 return xcb_ret; 695 } 696 697 xcb_void_cookie_t 698 xcb_sync_change_counter (xcb_connection_t *c, 699 xcb_sync_counter_t counter, 700 xcb_sync_int64_t amount) 701 { 702 static const xcb_protocol_request_t xcb_req = { 703 .count = 2, 704 .ext = &xcb_sync_id, 705 .opcode = XCB_SYNC_CHANGE_COUNTER, 706 .isvoid = 1 707 }; 708 709 struct iovec xcb_parts[4]; 710 xcb_void_cookie_t xcb_ret; 711 xcb_sync_change_counter_request_t xcb_out; 712 713 xcb_out.counter = counter; 714 xcb_out.amount = amount; 715 716 xcb_parts[2].iov_base = (char *) &xcb_out; 717 xcb_parts[2].iov_len = sizeof(xcb_out); 718 xcb_parts[3].iov_base = 0; 719 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 720 721 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 722 return xcb_ret; 723 } 724 725 xcb_void_cookie_t 726 xcb_sync_set_counter_checked (xcb_connection_t *c, 727 xcb_sync_counter_t counter, 728 xcb_sync_int64_t value) 729 { 730 static const xcb_protocol_request_t xcb_req = { 731 .count = 2, 732 .ext = &xcb_sync_id, 733 .opcode = XCB_SYNC_SET_COUNTER, 734 .isvoid = 1 735 }; 736 737 struct iovec xcb_parts[4]; 738 xcb_void_cookie_t xcb_ret; 739 xcb_sync_set_counter_request_t xcb_out; 740 741 xcb_out.counter = counter; 742 xcb_out.value = value; 743 744 xcb_parts[2].iov_base = (char *) &xcb_out; 745 xcb_parts[2].iov_len = sizeof(xcb_out); 746 xcb_parts[3].iov_base = 0; 747 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 748 749 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 750 return xcb_ret; 751 } 752 753 xcb_void_cookie_t 754 xcb_sync_set_counter (xcb_connection_t *c, 755 xcb_sync_counter_t counter, 756 xcb_sync_int64_t value) 757 { 758 static const xcb_protocol_request_t xcb_req = { 759 .count = 2, 760 .ext = &xcb_sync_id, 761 .opcode = XCB_SYNC_SET_COUNTER, 762 .isvoid = 1 763 }; 764 765 struct iovec xcb_parts[4]; 766 xcb_void_cookie_t xcb_ret; 767 xcb_sync_set_counter_request_t xcb_out; 768 769 xcb_out.counter = counter; 770 xcb_out.value = value; 771 772 xcb_parts[2].iov_base = (char *) &xcb_out; 773 xcb_parts[2].iov_len = sizeof(xcb_out); 774 xcb_parts[3].iov_base = 0; 775 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 776 777 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 778 return xcb_ret; 779 } 780 781 int 782 xcb_sync_create_alarm_value_list_serialize (void **_buffer, 783 uint32_t value_mask, 784 const xcb_sync_create_alarm_value_list_t *_aux) 785 { 786 char *xcb_out = *_buffer; 787 unsigned int xcb_buffer_len = 0; 788 unsigned int xcb_align_to = 0; 789 unsigned int xcb_padding_offset = 0; 790 791 unsigned int xcb_pad = 0; 792 char xcb_pad0[3] = {0, 0, 0}; 793 struct iovec xcb_parts[7]; 794 unsigned int xcb_parts_idx = 0; 795 unsigned int xcb_block_len = 0; 796 unsigned int i; 797 char *xcb_tmp; 798 799 if(value_mask & XCB_SYNC_CA_COUNTER) { 800 /* xcb_sync_create_alarm_value_list_t.counter */ 801 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->counter; 802 xcb_block_len += sizeof(xcb_sync_counter_t); 803 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_counter_t); 804 xcb_parts_idx++; 805 xcb_align_to = ALIGNOF(xcb_sync_counter_t); 806 } 807 if(value_mask & XCB_SYNC_CA_VALUE_TYPE) { 808 /* xcb_sync_create_alarm_value_list_t.valueType */ 809 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valueType; 810 xcb_block_len += sizeof(uint32_t); 811 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 812 xcb_parts_idx++; 813 xcb_align_to = ALIGNOF(uint32_t); 814 } 815 if(value_mask & XCB_SYNC_CA_VALUE) { 816 /* xcb_sync_create_alarm_value_list_t.value */ 817 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->value; 818 xcb_block_len += sizeof(xcb_sync_int64_t); 819 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t); 820 xcb_parts_idx++; 821 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 822 } 823 if(value_mask & XCB_SYNC_CA_TEST_TYPE) { 824 /* xcb_sync_create_alarm_value_list_t.testType */ 825 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->testType; 826 xcb_block_len += sizeof(uint32_t); 827 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 828 xcb_parts_idx++; 829 xcb_align_to = ALIGNOF(uint32_t); 830 } 831 if(value_mask & XCB_SYNC_CA_DELTA) { 832 /* xcb_sync_create_alarm_value_list_t.delta */ 833 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->delta; 834 xcb_block_len += sizeof(xcb_sync_int64_t); 835 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t); 836 xcb_parts_idx++; 837 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 838 } 839 if(value_mask & XCB_SYNC_CA_EVENTS) { 840 /* xcb_sync_create_alarm_value_list_t.events */ 841 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->events; 842 xcb_block_len += sizeof(uint32_t); 843 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 844 xcb_parts_idx++; 845 xcb_align_to = ALIGNOF(uint32_t); 846 } 847 /* insert padding */ 848 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); 849 xcb_buffer_len += xcb_block_len + xcb_pad; 850 if (0 != xcb_pad) { 851 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; 852 xcb_parts[xcb_parts_idx].iov_len = xcb_pad; 853 xcb_parts_idx++; 854 xcb_pad = 0; 855 } 856 xcb_block_len = 0; 857 xcb_padding_offset = 0; 858 859 if (NULL == xcb_out) { 860 /* allocate memory */ 861 xcb_out = malloc(xcb_buffer_len); 862 *_buffer = xcb_out; 863 } 864 865 xcb_tmp = xcb_out; 866 for(i=0; i<xcb_parts_idx; i++) { 867 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) 868 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); 869 if (0 != xcb_parts[i].iov_len) 870 xcb_tmp += xcb_parts[i].iov_len; 871 } 872 873 return xcb_buffer_len; 874 } 875 876 int 877 xcb_sync_create_alarm_value_list_unpack (const void *_buffer, 878 uint32_t value_mask, 879 xcb_sync_create_alarm_value_list_t *_aux) 880 { 881 char *xcb_tmp = (char *)_buffer; 882 unsigned int xcb_buffer_len = 0; 883 unsigned int xcb_block_len = 0; 884 unsigned int xcb_pad = 0; 885 unsigned int xcb_align_to = 0; 886 unsigned int xcb_padding_offset = 0; 887 888 889 if(value_mask & XCB_SYNC_CA_COUNTER) { 890 /* xcb_sync_create_alarm_value_list_t.counter */ 891 _aux->counter = *(xcb_sync_counter_t *)xcb_tmp; 892 xcb_block_len += sizeof(xcb_sync_counter_t); 893 xcb_tmp += sizeof(xcb_sync_counter_t); 894 xcb_align_to = ALIGNOF(xcb_sync_counter_t); 895 } 896 if(value_mask & XCB_SYNC_CA_VALUE_TYPE) { 897 /* xcb_sync_create_alarm_value_list_t.valueType */ 898 _aux->valueType = *(uint32_t *)xcb_tmp; 899 xcb_block_len += sizeof(uint32_t); 900 xcb_tmp += sizeof(uint32_t); 901 xcb_align_to = ALIGNOF(uint32_t); 902 } 903 if(value_mask & XCB_SYNC_CA_VALUE) { 904 /* xcb_sync_create_alarm_value_list_t.value */ 905 _aux->value = *(xcb_sync_int64_t *)xcb_tmp; 906 xcb_block_len += sizeof(xcb_sync_int64_t); 907 xcb_tmp += sizeof(xcb_sync_int64_t); 908 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 909 } 910 if(value_mask & XCB_SYNC_CA_TEST_TYPE) { 911 /* xcb_sync_create_alarm_value_list_t.testType */ 912 _aux->testType = *(uint32_t *)xcb_tmp; 913 xcb_block_len += sizeof(uint32_t); 914 xcb_tmp += sizeof(uint32_t); 915 xcb_align_to = ALIGNOF(uint32_t); 916 } 917 if(value_mask & XCB_SYNC_CA_DELTA) { 918 /* xcb_sync_create_alarm_value_list_t.delta */ 919 _aux->delta = *(xcb_sync_int64_t *)xcb_tmp; 920 xcb_block_len += sizeof(xcb_sync_int64_t); 921 xcb_tmp += sizeof(xcb_sync_int64_t); 922 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 923 } 924 if(value_mask & XCB_SYNC_CA_EVENTS) { 925 /* xcb_sync_create_alarm_value_list_t.events */ 926 _aux->events = *(uint32_t *)xcb_tmp; 927 xcb_block_len += sizeof(uint32_t); 928 xcb_tmp += sizeof(uint32_t); 929 xcb_align_to = ALIGNOF(uint32_t); 930 } 931 /* insert padding */ 932 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); 933 xcb_buffer_len += xcb_block_len + xcb_pad; 934 if (0 != xcb_pad) { 935 xcb_tmp += xcb_pad; 936 xcb_pad = 0; 937 } 938 xcb_block_len = 0; 939 xcb_padding_offset = 0; 940 941 return xcb_buffer_len; 942 } 943 944 int 945 xcb_sync_create_alarm_value_list_sizeof (const void *_buffer, 946 uint32_t value_mask) 947 { 948 xcb_sync_create_alarm_value_list_t _aux; 949 return xcb_sync_create_alarm_value_list_unpack(_buffer, value_mask, &_aux); 950 } 951 952 int 953 xcb_sync_create_alarm_sizeof (const void *_buffer) 954 { 955 char *xcb_tmp = (char *)_buffer; 956 const xcb_sync_create_alarm_request_t *_aux = (xcb_sync_create_alarm_request_t *)_buffer; 957 unsigned int xcb_buffer_len = 0; 958 unsigned int xcb_block_len = 0; 959 unsigned int xcb_pad = 0; 960 unsigned int xcb_align_to = 0; 961 962 963 xcb_block_len += sizeof(xcb_sync_create_alarm_request_t); 964 xcb_tmp += xcb_block_len; 965 xcb_buffer_len += xcb_block_len; 966 xcb_block_len = 0; 967 /* value_list */ 968 xcb_block_len += xcb_sync_create_alarm_value_list_sizeof(xcb_tmp, _aux->value_mask); 969 xcb_tmp += xcb_block_len; 970 xcb_align_to = ALIGNOF(char); 971 /* insert padding */ 972 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 973 xcb_buffer_len += xcb_block_len + xcb_pad; 974 if (0 != xcb_pad) { 975 xcb_tmp += xcb_pad; 976 xcb_pad = 0; 977 } 978 xcb_block_len = 0; 979 980 return xcb_buffer_len; 981 } 982 983 xcb_void_cookie_t 984 xcb_sync_create_alarm_checked (xcb_connection_t *c, 985 xcb_sync_alarm_t id, 986 uint32_t value_mask, 987 const void *value_list) 988 { 989 static const xcb_protocol_request_t xcb_req = { 990 .count = 3, 991 .ext = &xcb_sync_id, 992 .opcode = XCB_SYNC_CREATE_ALARM, 993 .isvoid = 1 994 }; 995 996 struct iovec xcb_parts[5]; 997 xcb_void_cookie_t xcb_ret; 998 xcb_sync_create_alarm_request_t xcb_out; 999 1000 xcb_out.id = id; 1001 xcb_out.value_mask = value_mask; 1002 1003 xcb_parts[2].iov_base = (char *) &xcb_out; 1004 xcb_parts[2].iov_len = sizeof(xcb_out); 1005 xcb_parts[3].iov_base = 0; 1006 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1007 /* xcb_sync_create_alarm_value_list_t value_list */ 1008 xcb_parts[4].iov_base = (char *) value_list; 1009 xcb_parts[4].iov_len = 1010 xcb_sync_create_alarm_value_list_sizeof (value_list, value_mask); 1011 1012 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1013 return xcb_ret; 1014 } 1015 1016 xcb_void_cookie_t 1017 xcb_sync_create_alarm (xcb_connection_t *c, 1018 xcb_sync_alarm_t id, 1019 uint32_t value_mask, 1020 const void *value_list) 1021 { 1022 static const xcb_protocol_request_t xcb_req = { 1023 .count = 3, 1024 .ext = &xcb_sync_id, 1025 .opcode = XCB_SYNC_CREATE_ALARM, 1026 .isvoid = 1 1027 }; 1028 1029 struct iovec xcb_parts[5]; 1030 xcb_void_cookie_t xcb_ret; 1031 xcb_sync_create_alarm_request_t xcb_out; 1032 1033 xcb_out.id = id; 1034 xcb_out.value_mask = value_mask; 1035 1036 xcb_parts[2].iov_base = (char *) &xcb_out; 1037 xcb_parts[2].iov_len = sizeof(xcb_out); 1038 xcb_parts[3].iov_base = 0; 1039 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1040 /* xcb_sync_create_alarm_value_list_t value_list */ 1041 xcb_parts[4].iov_base = (char *) value_list; 1042 xcb_parts[4].iov_len = 1043 xcb_sync_create_alarm_value_list_sizeof (value_list, value_mask); 1044 1045 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1046 return xcb_ret; 1047 } 1048 1049 xcb_void_cookie_t 1050 xcb_sync_create_alarm_aux_checked (xcb_connection_t *c, 1051 xcb_sync_alarm_t id, 1052 uint32_t value_mask, 1053 const xcb_sync_create_alarm_value_list_t *value_list) 1054 { 1055 static const xcb_protocol_request_t xcb_req = { 1056 .count = 3, 1057 .ext = &xcb_sync_id, 1058 .opcode = XCB_SYNC_CREATE_ALARM, 1059 .isvoid = 1 1060 }; 1061 1062 struct iovec xcb_parts[5]; 1063 xcb_void_cookie_t xcb_ret; 1064 xcb_sync_create_alarm_request_t xcb_out; 1065 void *xcb_aux0 = 0; 1066 1067 xcb_out.id = id; 1068 xcb_out.value_mask = value_mask; 1069 1070 xcb_parts[2].iov_base = (char *) &xcb_out; 1071 xcb_parts[2].iov_len = sizeof(xcb_out); 1072 xcb_parts[3].iov_base = 0; 1073 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1074 /* xcb_sync_create_alarm_value_list_t value_list */ 1075 xcb_parts[4].iov_len = 1076 xcb_sync_create_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list); 1077 xcb_parts[4].iov_base = xcb_aux0; 1078 1079 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1080 free(xcb_aux0); 1081 return xcb_ret; 1082 } 1083 1084 xcb_void_cookie_t 1085 xcb_sync_create_alarm_aux (xcb_connection_t *c, 1086 xcb_sync_alarm_t id, 1087 uint32_t value_mask, 1088 const xcb_sync_create_alarm_value_list_t *value_list) 1089 { 1090 static const xcb_protocol_request_t xcb_req = { 1091 .count = 3, 1092 .ext = &xcb_sync_id, 1093 .opcode = XCB_SYNC_CREATE_ALARM, 1094 .isvoid = 1 1095 }; 1096 1097 struct iovec xcb_parts[5]; 1098 xcb_void_cookie_t xcb_ret; 1099 xcb_sync_create_alarm_request_t xcb_out; 1100 void *xcb_aux0 = 0; 1101 1102 xcb_out.id = id; 1103 xcb_out.value_mask = value_mask; 1104 1105 xcb_parts[2].iov_base = (char *) &xcb_out; 1106 xcb_parts[2].iov_len = sizeof(xcb_out); 1107 xcb_parts[3].iov_base = 0; 1108 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1109 /* xcb_sync_create_alarm_value_list_t value_list */ 1110 xcb_parts[4].iov_len = 1111 xcb_sync_create_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list); 1112 xcb_parts[4].iov_base = xcb_aux0; 1113 1114 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1115 free(xcb_aux0); 1116 return xcb_ret; 1117 } 1118 1119 void * 1120 xcb_sync_create_alarm_value_list (const xcb_sync_create_alarm_request_t *R) 1121 { 1122 return (void *) (R + 1); 1123 } 1124 1125 int 1126 xcb_sync_change_alarm_value_list_serialize (void **_buffer, 1127 uint32_t value_mask, 1128 const xcb_sync_change_alarm_value_list_t *_aux) 1129 { 1130 char *xcb_out = *_buffer; 1131 unsigned int xcb_buffer_len = 0; 1132 unsigned int xcb_align_to = 0; 1133 unsigned int xcb_padding_offset = 0; 1134 1135 unsigned int xcb_pad = 0; 1136 char xcb_pad0[3] = {0, 0, 0}; 1137 struct iovec xcb_parts[7]; 1138 unsigned int xcb_parts_idx = 0; 1139 unsigned int xcb_block_len = 0; 1140 unsigned int i; 1141 char *xcb_tmp; 1142 1143 if(value_mask & XCB_SYNC_CA_COUNTER) { 1144 /* xcb_sync_change_alarm_value_list_t.counter */ 1145 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->counter; 1146 xcb_block_len += sizeof(xcb_sync_counter_t); 1147 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_counter_t); 1148 xcb_parts_idx++; 1149 xcb_align_to = ALIGNOF(xcb_sync_counter_t); 1150 } 1151 if(value_mask & XCB_SYNC_CA_VALUE_TYPE) { 1152 /* xcb_sync_change_alarm_value_list_t.valueType */ 1153 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->valueType; 1154 xcb_block_len += sizeof(uint32_t); 1155 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 1156 xcb_parts_idx++; 1157 xcb_align_to = ALIGNOF(uint32_t); 1158 } 1159 if(value_mask & XCB_SYNC_CA_VALUE) { 1160 /* xcb_sync_change_alarm_value_list_t.value */ 1161 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->value; 1162 xcb_block_len += sizeof(xcb_sync_int64_t); 1163 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t); 1164 xcb_parts_idx++; 1165 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 1166 } 1167 if(value_mask & XCB_SYNC_CA_TEST_TYPE) { 1168 /* xcb_sync_change_alarm_value_list_t.testType */ 1169 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->testType; 1170 xcb_block_len += sizeof(uint32_t); 1171 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 1172 xcb_parts_idx++; 1173 xcb_align_to = ALIGNOF(uint32_t); 1174 } 1175 if(value_mask & XCB_SYNC_CA_DELTA) { 1176 /* xcb_sync_change_alarm_value_list_t.delta */ 1177 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->delta; 1178 xcb_block_len += sizeof(xcb_sync_int64_t); 1179 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_sync_int64_t); 1180 xcb_parts_idx++; 1181 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 1182 } 1183 if(value_mask & XCB_SYNC_CA_EVENTS) { 1184 /* xcb_sync_change_alarm_value_list_t.events */ 1185 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->events; 1186 xcb_block_len += sizeof(uint32_t); 1187 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 1188 xcb_parts_idx++; 1189 xcb_align_to = ALIGNOF(uint32_t); 1190 } 1191 /* insert padding */ 1192 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); 1193 xcb_buffer_len += xcb_block_len + xcb_pad; 1194 if (0 != xcb_pad) { 1195 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; 1196 xcb_parts[xcb_parts_idx].iov_len = xcb_pad; 1197 xcb_parts_idx++; 1198 xcb_pad = 0; 1199 } 1200 xcb_block_len = 0; 1201 xcb_padding_offset = 0; 1202 1203 if (NULL == xcb_out) { 1204 /* allocate memory */ 1205 xcb_out = malloc(xcb_buffer_len); 1206 *_buffer = xcb_out; 1207 } 1208 1209 xcb_tmp = xcb_out; 1210 for(i=0; i<xcb_parts_idx; i++) { 1211 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) 1212 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); 1213 if (0 != xcb_parts[i].iov_len) 1214 xcb_tmp += xcb_parts[i].iov_len; 1215 } 1216 1217 return xcb_buffer_len; 1218 } 1219 1220 int 1221 xcb_sync_change_alarm_value_list_unpack (const void *_buffer, 1222 uint32_t value_mask, 1223 xcb_sync_change_alarm_value_list_t *_aux) 1224 { 1225 char *xcb_tmp = (char *)_buffer; 1226 unsigned int xcb_buffer_len = 0; 1227 unsigned int xcb_block_len = 0; 1228 unsigned int xcb_pad = 0; 1229 unsigned int xcb_align_to = 0; 1230 unsigned int xcb_padding_offset = 0; 1231 1232 1233 if(value_mask & XCB_SYNC_CA_COUNTER) { 1234 /* xcb_sync_change_alarm_value_list_t.counter */ 1235 _aux->counter = *(xcb_sync_counter_t *)xcb_tmp; 1236 xcb_block_len += sizeof(xcb_sync_counter_t); 1237 xcb_tmp += sizeof(xcb_sync_counter_t); 1238 xcb_align_to = ALIGNOF(xcb_sync_counter_t); 1239 } 1240 if(value_mask & XCB_SYNC_CA_VALUE_TYPE) { 1241 /* xcb_sync_change_alarm_value_list_t.valueType */ 1242 _aux->valueType = *(uint32_t *)xcb_tmp; 1243 xcb_block_len += sizeof(uint32_t); 1244 xcb_tmp += sizeof(uint32_t); 1245 xcb_align_to = ALIGNOF(uint32_t); 1246 } 1247 if(value_mask & XCB_SYNC_CA_VALUE) { 1248 /* xcb_sync_change_alarm_value_list_t.value */ 1249 _aux->value = *(xcb_sync_int64_t *)xcb_tmp; 1250 xcb_block_len += sizeof(xcb_sync_int64_t); 1251 xcb_tmp += sizeof(xcb_sync_int64_t); 1252 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 1253 } 1254 if(value_mask & XCB_SYNC_CA_TEST_TYPE) { 1255 /* xcb_sync_change_alarm_value_list_t.testType */ 1256 _aux->testType = *(uint32_t *)xcb_tmp; 1257 xcb_block_len += sizeof(uint32_t); 1258 xcb_tmp += sizeof(uint32_t); 1259 xcb_align_to = ALIGNOF(uint32_t); 1260 } 1261 if(value_mask & XCB_SYNC_CA_DELTA) { 1262 /* xcb_sync_change_alarm_value_list_t.delta */ 1263 _aux->delta = *(xcb_sync_int64_t *)xcb_tmp; 1264 xcb_block_len += sizeof(xcb_sync_int64_t); 1265 xcb_tmp += sizeof(xcb_sync_int64_t); 1266 xcb_align_to = ALIGNOF(xcb_sync_int64_t); 1267 } 1268 if(value_mask & XCB_SYNC_CA_EVENTS) { 1269 /* xcb_sync_change_alarm_value_list_t.events */ 1270 _aux->events = *(uint32_t *)xcb_tmp; 1271 xcb_block_len += sizeof(uint32_t); 1272 xcb_tmp += sizeof(uint32_t); 1273 xcb_align_to = ALIGNOF(uint32_t); 1274 } 1275 /* insert padding */ 1276 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); 1277 xcb_buffer_len += xcb_block_len + xcb_pad; 1278 if (0 != xcb_pad) { 1279 xcb_tmp += xcb_pad; 1280 xcb_pad = 0; 1281 } 1282 xcb_block_len = 0; 1283 xcb_padding_offset = 0; 1284 1285 return xcb_buffer_len; 1286 } 1287 1288 int 1289 xcb_sync_change_alarm_value_list_sizeof (const void *_buffer, 1290 uint32_t value_mask) 1291 { 1292 xcb_sync_change_alarm_value_list_t _aux; 1293 return xcb_sync_change_alarm_value_list_unpack(_buffer, value_mask, &_aux); 1294 } 1295 1296 int 1297 xcb_sync_change_alarm_sizeof (const void *_buffer) 1298 { 1299 char *xcb_tmp = (char *)_buffer; 1300 const xcb_sync_change_alarm_request_t *_aux = (xcb_sync_change_alarm_request_t *)_buffer; 1301 unsigned int xcb_buffer_len = 0; 1302 unsigned int xcb_block_len = 0; 1303 unsigned int xcb_pad = 0; 1304 unsigned int xcb_align_to = 0; 1305 1306 1307 xcb_block_len += sizeof(xcb_sync_change_alarm_request_t); 1308 xcb_tmp += xcb_block_len; 1309 xcb_buffer_len += xcb_block_len; 1310 xcb_block_len = 0; 1311 /* value_list */ 1312 xcb_block_len += xcb_sync_change_alarm_value_list_sizeof(xcb_tmp, _aux->value_mask); 1313 xcb_tmp += xcb_block_len; 1314 xcb_align_to = ALIGNOF(char); 1315 /* insert padding */ 1316 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1317 xcb_buffer_len += xcb_block_len + xcb_pad; 1318 if (0 != xcb_pad) { 1319 xcb_tmp += xcb_pad; 1320 xcb_pad = 0; 1321 } 1322 xcb_block_len = 0; 1323 1324 return xcb_buffer_len; 1325 } 1326 1327 xcb_void_cookie_t 1328 xcb_sync_change_alarm_checked (xcb_connection_t *c, 1329 xcb_sync_alarm_t id, 1330 uint32_t value_mask, 1331 const void *value_list) 1332 { 1333 static const xcb_protocol_request_t xcb_req = { 1334 .count = 3, 1335 .ext = &xcb_sync_id, 1336 .opcode = XCB_SYNC_CHANGE_ALARM, 1337 .isvoid = 1 1338 }; 1339 1340 struct iovec xcb_parts[5]; 1341 xcb_void_cookie_t xcb_ret; 1342 xcb_sync_change_alarm_request_t xcb_out; 1343 1344 xcb_out.id = id; 1345 xcb_out.value_mask = value_mask; 1346 1347 xcb_parts[2].iov_base = (char *) &xcb_out; 1348 xcb_parts[2].iov_len = sizeof(xcb_out); 1349 xcb_parts[3].iov_base = 0; 1350 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1351 /* xcb_sync_change_alarm_value_list_t value_list */ 1352 xcb_parts[4].iov_base = (char *) value_list; 1353 xcb_parts[4].iov_len = 1354 xcb_sync_change_alarm_value_list_sizeof (value_list, value_mask); 1355 1356 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1357 return xcb_ret; 1358 } 1359 1360 xcb_void_cookie_t 1361 xcb_sync_change_alarm (xcb_connection_t *c, 1362 xcb_sync_alarm_t id, 1363 uint32_t value_mask, 1364 const void *value_list) 1365 { 1366 static const xcb_protocol_request_t xcb_req = { 1367 .count = 3, 1368 .ext = &xcb_sync_id, 1369 .opcode = XCB_SYNC_CHANGE_ALARM, 1370 .isvoid = 1 1371 }; 1372 1373 struct iovec xcb_parts[5]; 1374 xcb_void_cookie_t xcb_ret; 1375 xcb_sync_change_alarm_request_t xcb_out; 1376 1377 xcb_out.id = id; 1378 xcb_out.value_mask = value_mask; 1379 1380 xcb_parts[2].iov_base = (char *) &xcb_out; 1381 xcb_parts[2].iov_len = sizeof(xcb_out); 1382 xcb_parts[3].iov_base = 0; 1383 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1384 /* xcb_sync_change_alarm_value_list_t value_list */ 1385 xcb_parts[4].iov_base = (char *) value_list; 1386 xcb_parts[4].iov_len = 1387 xcb_sync_change_alarm_value_list_sizeof (value_list, value_mask); 1388 1389 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1390 return xcb_ret; 1391 } 1392 1393 xcb_void_cookie_t 1394 xcb_sync_change_alarm_aux_checked (xcb_connection_t *c, 1395 xcb_sync_alarm_t id, 1396 uint32_t value_mask, 1397 const xcb_sync_change_alarm_value_list_t *value_list) 1398 { 1399 static const xcb_protocol_request_t xcb_req = { 1400 .count = 3, 1401 .ext = &xcb_sync_id, 1402 .opcode = XCB_SYNC_CHANGE_ALARM, 1403 .isvoid = 1 1404 }; 1405 1406 struct iovec xcb_parts[5]; 1407 xcb_void_cookie_t xcb_ret; 1408 xcb_sync_change_alarm_request_t xcb_out; 1409 void *xcb_aux0 = 0; 1410 1411 xcb_out.id = id; 1412 xcb_out.value_mask = value_mask; 1413 1414 xcb_parts[2].iov_base = (char *) &xcb_out; 1415 xcb_parts[2].iov_len = sizeof(xcb_out); 1416 xcb_parts[3].iov_base = 0; 1417 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1418 /* xcb_sync_change_alarm_value_list_t value_list */ 1419 xcb_parts[4].iov_len = 1420 xcb_sync_change_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list); 1421 xcb_parts[4].iov_base = xcb_aux0; 1422 1423 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1424 free(xcb_aux0); 1425 return xcb_ret; 1426 } 1427 1428 xcb_void_cookie_t 1429 xcb_sync_change_alarm_aux (xcb_connection_t *c, 1430 xcb_sync_alarm_t id, 1431 uint32_t value_mask, 1432 const xcb_sync_change_alarm_value_list_t *value_list) 1433 { 1434 static const xcb_protocol_request_t xcb_req = { 1435 .count = 3, 1436 .ext = &xcb_sync_id, 1437 .opcode = XCB_SYNC_CHANGE_ALARM, 1438 .isvoid = 1 1439 }; 1440 1441 struct iovec xcb_parts[5]; 1442 xcb_void_cookie_t xcb_ret; 1443 xcb_sync_change_alarm_request_t xcb_out; 1444 void *xcb_aux0 = 0; 1445 1446 xcb_out.id = id; 1447 xcb_out.value_mask = value_mask; 1448 1449 xcb_parts[2].iov_base = (char *) &xcb_out; 1450 xcb_parts[2].iov_len = sizeof(xcb_out); 1451 xcb_parts[3].iov_base = 0; 1452 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1453 /* xcb_sync_change_alarm_value_list_t value_list */ 1454 xcb_parts[4].iov_len = 1455 xcb_sync_change_alarm_value_list_serialize (&xcb_aux0, value_mask, value_list); 1456 xcb_parts[4].iov_base = xcb_aux0; 1457 1458 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1459 free(xcb_aux0); 1460 return xcb_ret; 1461 } 1462 1463 void * 1464 xcb_sync_change_alarm_value_list (const xcb_sync_change_alarm_request_t *R) 1465 { 1466 return (void *) (R + 1); 1467 } 1468 1469 xcb_void_cookie_t 1470 xcb_sync_destroy_alarm_checked (xcb_connection_t *c, 1471 xcb_sync_alarm_t alarm) 1472 { 1473 static const xcb_protocol_request_t xcb_req = { 1474 .count = 2, 1475 .ext = &xcb_sync_id, 1476 .opcode = XCB_SYNC_DESTROY_ALARM, 1477 .isvoid = 1 1478 }; 1479 1480 struct iovec xcb_parts[4]; 1481 xcb_void_cookie_t xcb_ret; 1482 xcb_sync_destroy_alarm_request_t xcb_out; 1483 1484 xcb_out.alarm = alarm; 1485 1486 xcb_parts[2].iov_base = (char *) &xcb_out; 1487 xcb_parts[2].iov_len = sizeof(xcb_out); 1488 xcb_parts[3].iov_base = 0; 1489 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1490 1491 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1492 return xcb_ret; 1493 } 1494 1495 xcb_void_cookie_t 1496 xcb_sync_destroy_alarm (xcb_connection_t *c, 1497 xcb_sync_alarm_t alarm) 1498 { 1499 static const xcb_protocol_request_t xcb_req = { 1500 .count = 2, 1501 .ext = &xcb_sync_id, 1502 .opcode = XCB_SYNC_DESTROY_ALARM, 1503 .isvoid = 1 1504 }; 1505 1506 struct iovec xcb_parts[4]; 1507 xcb_void_cookie_t xcb_ret; 1508 xcb_sync_destroy_alarm_request_t xcb_out; 1509 1510 xcb_out.alarm = alarm; 1511 1512 xcb_parts[2].iov_base = (char *) &xcb_out; 1513 xcb_parts[2].iov_len = sizeof(xcb_out); 1514 xcb_parts[3].iov_base = 0; 1515 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1516 1517 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1518 return xcb_ret; 1519 } 1520 1521 xcb_sync_query_alarm_cookie_t 1522 xcb_sync_query_alarm (xcb_connection_t *c, 1523 xcb_sync_alarm_t alarm) 1524 { 1525 static const xcb_protocol_request_t xcb_req = { 1526 .count = 2, 1527 .ext = &xcb_sync_id, 1528 .opcode = XCB_SYNC_QUERY_ALARM, 1529 .isvoid = 0 1530 }; 1531 1532 struct iovec xcb_parts[4]; 1533 xcb_sync_query_alarm_cookie_t xcb_ret; 1534 xcb_sync_query_alarm_request_t xcb_out; 1535 1536 xcb_out.alarm = alarm; 1537 1538 xcb_parts[2].iov_base = (char *) &xcb_out; 1539 xcb_parts[2].iov_len = sizeof(xcb_out); 1540 xcb_parts[3].iov_base = 0; 1541 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1542 1543 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1544 return xcb_ret; 1545 } 1546 1547 xcb_sync_query_alarm_cookie_t 1548 xcb_sync_query_alarm_unchecked (xcb_connection_t *c, 1549 xcb_sync_alarm_t alarm) 1550 { 1551 static const xcb_protocol_request_t xcb_req = { 1552 .count = 2, 1553 .ext = &xcb_sync_id, 1554 .opcode = XCB_SYNC_QUERY_ALARM, 1555 .isvoid = 0 1556 }; 1557 1558 struct iovec xcb_parts[4]; 1559 xcb_sync_query_alarm_cookie_t xcb_ret; 1560 xcb_sync_query_alarm_request_t xcb_out; 1561 1562 xcb_out.alarm = alarm; 1563 1564 xcb_parts[2].iov_base = (char *) &xcb_out; 1565 xcb_parts[2].iov_len = sizeof(xcb_out); 1566 xcb_parts[3].iov_base = 0; 1567 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1568 1569 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1570 return xcb_ret; 1571 } 1572 1573 xcb_sync_query_alarm_reply_t * 1574 xcb_sync_query_alarm_reply (xcb_connection_t *c, 1575 xcb_sync_query_alarm_cookie_t cookie /**< */, 1576 xcb_generic_error_t **e) 1577 { 1578 return (xcb_sync_query_alarm_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1579 } 1580 1581 xcb_void_cookie_t 1582 xcb_sync_set_priority_checked (xcb_connection_t *c, 1583 uint32_t id, 1584 int32_t priority) 1585 { 1586 static const xcb_protocol_request_t xcb_req = { 1587 .count = 2, 1588 .ext = &xcb_sync_id, 1589 .opcode = XCB_SYNC_SET_PRIORITY, 1590 .isvoid = 1 1591 }; 1592 1593 struct iovec xcb_parts[4]; 1594 xcb_void_cookie_t xcb_ret; 1595 xcb_sync_set_priority_request_t xcb_out; 1596 1597 xcb_out.id = id; 1598 xcb_out.priority = priority; 1599 1600 xcb_parts[2].iov_base = (char *) &xcb_out; 1601 xcb_parts[2].iov_len = sizeof(xcb_out); 1602 xcb_parts[3].iov_base = 0; 1603 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1604 1605 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1606 return xcb_ret; 1607 } 1608 1609 xcb_void_cookie_t 1610 xcb_sync_set_priority (xcb_connection_t *c, 1611 uint32_t id, 1612 int32_t priority) 1613 { 1614 static const xcb_protocol_request_t xcb_req = { 1615 .count = 2, 1616 .ext = &xcb_sync_id, 1617 .opcode = XCB_SYNC_SET_PRIORITY, 1618 .isvoid = 1 1619 }; 1620 1621 struct iovec xcb_parts[4]; 1622 xcb_void_cookie_t xcb_ret; 1623 xcb_sync_set_priority_request_t xcb_out; 1624 1625 xcb_out.id = id; 1626 xcb_out.priority = priority; 1627 1628 xcb_parts[2].iov_base = (char *) &xcb_out; 1629 xcb_parts[2].iov_len = sizeof(xcb_out); 1630 xcb_parts[3].iov_base = 0; 1631 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1632 1633 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1634 return xcb_ret; 1635 } 1636 1637 xcb_sync_get_priority_cookie_t 1638 xcb_sync_get_priority (xcb_connection_t *c, 1639 uint32_t id) 1640 { 1641 static const xcb_protocol_request_t xcb_req = { 1642 .count = 2, 1643 .ext = &xcb_sync_id, 1644 .opcode = XCB_SYNC_GET_PRIORITY, 1645 .isvoid = 0 1646 }; 1647 1648 struct iovec xcb_parts[4]; 1649 xcb_sync_get_priority_cookie_t xcb_ret; 1650 xcb_sync_get_priority_request_t xcb_out; 1651 1652 xcb_out.id = id; 1653 1654 xcb_parts[2].iov_base = (char *) &xcb_out; 1655 xcb_parts[2].iov_len = sizeof(xcb_out); 1656 xcb_parts[3].iov_base = 0; 1657 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1658 1659 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1660 return xcb_ret; 1661 } 1662 1663 xcb_sync_get_priority_cookie_t 1664 xcb_sync_get_priority_unchecked (xcb_connection_t *c, 1665 uint32_t id) 1666 { 1667 static const xcb_protocol_request_t xcb_req = { 1668 .count = 2, 1669 .ext = &xcb_sync_id, 1670 .opcode = XCB_SYNC_GET_PRIORITY, 1671 .isvoid = 0 1672 }; 1673 1674 struct iovec xcb_parts[4]; 1675 xcb_sync_get_priority_cookie_t xcb_ret; 1676 xcb_sync_get_priority_request_t xcb_out; 1677 1678 xcb_out.id = id; 1679 1680 xcb_parts[2].iov_base = (char *) &xcb_out; 1681 xcb_parts[2].iov_len = sizeof(xcb_out); 1682 xcb_parts[3].iov_base = 0; 1683 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1684 1685 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1686 return xcb_ret; 1687 } 1688 1689 xcb_sync_get_priority_reply_t * 1690 xcb_sync_get_priority_reply (xcb_connection_t *c, 1691 xcb_sync_get_priority_cookie_t cookie /**< */, 1692 xcb_generic_error_t **e) 1693 { 1694 return (xcb_sync_get_priority_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1695 } 1696 1697 xcb_void_cookie_t 1698 xcb_sync_create_fence_checked (xcb_connection_t *c, 1699 xcb_drawable_t drawable, 1700 xcb_sync_fence_t fence, 1701 uint8_t initially_triggered) 1702 { 1703 static const xcb_protocol_request_t xcb_req = { 1704 .count = 2, 1705 .ext = &xcb_sync_id, 1706 .opcode = XCB_SYNC_CREATE_FENCE, 1707 .isvoid = 1 1708 }; 1709 1710 struct iovec xcb_parts[4]; 1711 xcb_void_cookie_t xcb_ret; 1712 xcb_sync_create_fence_request_t xcb_out; 1713 1714 xcb_out.drawable = drawable; 1715 xcb_out.fence = fence; 1716 xcb_out.initially_triggered = initially_triggered; 1717 1718 xcb_parts[2].iov_base = (char *) &xcb_out; 1719 xcb_parts[2].iov_len = sizeof(xcb_out); 1720 xcb_parts[3].iov_base = 0; 1721 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1722 1723 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1724 return xcb_ret; 1725 } 1726 1727 xcb_void_cookie_t 1728 xcb_sync_create_fence (xcb_connection_t *c, 1729 xcb_drawable_t drawable, 1730 xcb_sync_fence_t fence, 1731 uint8_t initially_triggered) 1732 { 1733 static const xcb_protocol_request_t xcb_req = { 1734 .count = 2, 1735 .ext = &xcb_sync_id, 1736 .opcode = XCB_SYNC_CREATE_FENCE, 1737 .isvoid = 1 1738 }; 1739 1740 struct iovec xcb_parts[4]; 1741 xcb_void_cookie_t xcb_ret; 1742 xcb_sync_create_fence_request_t xcb_out; 1743 1744 xcb_out.drawable = drawable; 1745 xcb_out.fence = fence; 1746 xcb_out.initially_triggered = initially_triggered; 1747 1748 xcb_parts[2].iov_base = (char *) &xcb_out; 1749 xcb_parts[2].iov_len = sizeof(xcb_out); 1750 xcb_parts[3].iov_base = 0; 1751 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1752 1753 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1754 return xcb_ret; 1755 } 1756 1757 xcb_void_cookie_t 1758 xcb_sync_trigger_fence_checked (xcb_connection_t *c, 1759 xcb_sync_fence_t fence) 1760 { 1761 static const xcb_protocol_request_t xcb_req = { 1762 .count = 2, 1763 .ext = &xcb_sync_id, 1764 .opcode = XCB_SYNC_TRIGGER_FENCE, 1765 .isvoid = 1 1766 }; 1767 1768 struct iovec xcb_parts[4]; 1769 xcb_void_cookie_t xcb_ret; 1770 xcb_sync_trigger_fence_request_t xcb_out; 1771 1772 xcb_out.fence = fence; 1773 1774 xcb_parts[2].iov_base = (char *) &xcb_out; 1775 xcb_parts[2].iov_len = sizeof(xcb_out); 1776 xcb_parts[3].iov_base = 0; 1777 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1778 1779 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1780 return xcb_ret; 1781 } 1782 1783 xcb_void_cookie_t 1784 xcb_sync_trigger_fence (xcb_connection_t *c, 1785 xcb_sync_fence_t fence) 1786 { 1787 static const xcb_protocol_request_t xcb_req = { 1788 .count = 2, 1789 .ext = &xcb_sync_id, 1790 .opcode = XCB_SYNC_TRIGGER_FENCE, 1791 .isvoid = 1 1792 }; 1793 1794 struct iovec xcb_parts[4]; 1795 xcb_void_cookie_t xcb_ret; 1796 xcb_sync_trigger_fence_request_t xcb_out; 1797 1798 xcb_out.fence = fence; 1799 1800 xcb_parts[2].iov_base = (char *) &xcb_out; 1801 xcb_parts[2].iov_len = sizeof(xcb_out); 1802 xcb_parts[3].iov_base = 0; 1803 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1804 1805 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1806 return xcb_ret; 1807 } 1808 1809 xcb_void_cookie_t 1810 xcb_sync_reset_fence_checked (xcb_connection_t *c, 1811 xcb_sync_fence_t fence) 1812 { 1813 static const xcb_protocol_request_t xcb_req = { 1814 .count = 2, 1815 .ext = &xcb_sync_id, 1816 .opcode = XCB_SYNC_RESET_FENCE, 1817 .isvoid = 1 1818 }; 1819 1820 struct iovec xcb_parts[4]; 1821 xcb_void_cookie_t xcb_ret; 1822 xcb_sync_reset_fence_request_t xcb_out; 1823 1824 xcb_out.fence = fence; 1825 1826 xcb_parts[2].iov_base = (char *) &xcb_out; 1827 xcb_parts[2].iov_len = sizeof(xcb_out); 1828 xcb_parts[3].iov_base = 0; 1829 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1830 1831 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1832 return xcb_ret; 1833 } 1834 1835 xcb_void_cookie_t 1836 xcb_sync_reset_fence (xcb_connection_t *c, 1837 xcb_sync_fence_t fence) 1838 { 1839 static const xcb_protocol_request_t xcb_req = { 1840 .count = 2, 1841 .ext = &xcb_sync_id, 1842 .opcode = XCB_SYNC_RESET_FENCE, 1843 .isvoid = 1 1844 }; 1845 1846 struct iovec xcb_parts[4]; 1847 xcb_void_cookie_t xcb_ret; 1848 xcb_sync_reset_fence_request_t xcb_out; 1849 1850 xcb_out.fence = fence; 1851 1852 xcb_parts[2].iov_base = (char *) &xcb_out; 1853 xcb_parts[2].iov_len = sizeof(xcb_out); 1854 xcb_parts[3].iov_base = 0; 1855 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1856 1857 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1858 return xcb_ret; 1859 } 1860 1861 xcb_void_cookie_t 1862 xcb_sync_destroy_fence_checked (xcb_connection_t *c, 1863 xcb_sync_fence_t fence) 1864 { 1865 static const xcb_protocol_request_t xcb_req = { 1866 .count = 2, 1867 .ext = &xcb_sync_id, 1868 .opcode = XCB_SYNC_DESTROY_FENCE, 1869 .isvoid = 1 1870 }; 1871 1872 struct iovec xcb_parts[4]; 1873 xcb_void_cookie_t xcb_ret; 1874 xcb_sync_destroy_fence_request_t xcb_out; 1875 1876 xcb_out.fence = fence; 1877 1878 xcb_parts[2].iov_base = (char *) &xcb_out; 1879 xcb_parts[2].iov_len = sizeof(xcb_out); 1880 xcb_parts[3].iov_base = 0; 1881 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1882 1883 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1884 return xcb_ret; 1885 } 1886 1887 xcb_void_cookie_t 1888 xcb_sync_destroy_fence (xcb_connection_t *c, 1889 xcb_sync_fence_t fence) 1890 { 1891 static const xcb_protocol_request_t xcb_req = { 1892 .count = 2, 1893 .ext = &xcb_sync_id, 1894 .opcode = XCB_SYNC_DESTROY_FENCE, 1895 .isvoid = 1 1896 }; 1897 1898 struct iovec xcb_parts[4]; 1899 xcb_void_cookie_t xcb_ret; 1900 xcb_sync_destroy_fence_request_t xcb_out; 1901 1902 xcb_out.fence = fence; 1903 1904 xcb_parts[2].iov_base = (char *) &xcb_out; 1905 xcb_parts[2].iov_len = sizeof(xcb_out); 1906 xcb_parts[3].iov_base = 0; 1907 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1908 1909 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1910 return xcb_ret; 1911 } 1912 1913 xcb_sync_query_fence_cookie_t 1914 xcb_sync_query_fence (xcb_connection_t *c, 1915 xcb_sync_fence_t fence) 1916 { 1917 static const xcb_protocol_request_t xcb_req = { 1918 .count = 2, 1919 .ext = &xcb_sync_id, 1920 .opcode = XCB_SYNC_QUERY_FENCE, 1921 .isvoid = 0 1922 }; 1923 1924 struct iovec xcb_parts[4]; 1925 xcb_sync_query_fence_cookie_t xcb_ret; 1926 xcb_sync_query_fence_request_t xcb_out; 1927 1928 xcb_out.fence = fence; 1929 1930 xcb_parts[2].iov_base = (char *) &xcb_out; 1931 xcb_parts[2].iov_len = sizeof(xcb_out); 1932 xcb_parts[3].iov_base = 0; 1933 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1934 1935 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1936 return xcb_ret; 1937 } 1938 1939 xcb_sync_query_fence_cookie_t 1940 xcb_sync_query_fence_unchecked (xcb_connection_t *c, 1941 xcb_sync_fence_t fence) 1942 { 1943 static const xcb_protocol_request_t xcb_req = { 1944 .count = 2, 1945 .ext = &xcb_sync_id, 1946 .opcode = XCB_SYNC_QUERY_FENCE, 1947 .isvoid = 0 1948 }; 1949 1950 struct iovec xcb_parts[4]; 1951 xcb_sync_query_fence_cookie_t xcb_ret; 1952 xcb_sync_query_fence_request_t xcb_out; 1953 1954 xcb_out.fence = fence; 1955 1956 xcb_parts[2].iov_base = (char *) &xcb_out; 1957 xcb_parts[2].iov_len = sizeof(xcb_out); 1958 xcb_parts[3].iov_base = 0; 1959 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1960 1961 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1962 return xcb_ret; 1963 } 1964 1965 xcb_sync_query_fence_reply_t * 1966 xcb_sync_query_fence_reply (xcb_connection_t *c, 1967 xcb_sync_query_fence_cookie_t cookie /**< */, 1968 xcb_generic_error_t **e) 1969 { 1970 return (xcb_sync_query_fence_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1971 } 1972 1973 int 1974 xcb_sync_await_fence_sizeof (const void *_buffer, 1975 uint32_t fence_list_len) 1976 { 1977 char *xcb_tmp = (char *)_buffer; 1978 unsigned int xcb_buffer_len = 0; 1979 unsigned int xcb_block_len = 0; 1980 unsigned int xcb_pad = 0; 1981 unsigned int xcb_align_to = 0; 1982 1983 1984 xcb_block_len += sizeof(xcb_sync_await_fence_request_t); 1985 xcb_tmp += xcb_block_len; 1986 xcb_buffer_len += xcb_block_len; 1987 xcb_block_len = 0; 1988 /* fence_list */ 1989 xcb_block_len += fence_list_len * sizeof(xcb_sync_fence_t); 1990 xcb_tmp += xcb_block_len; 1991 xcb_align_to = ALIGNOF(xcb_sync_fence_t); 1992 /* insert padding */ 1993 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1994 xcb_buffer_len += xcb_block_len + xcb_pad; 1995 if (0 != xcb_pad) { 1996 xcb_tmp += xcb_pad; 1997 xcb_pad = 0; 1998 } 1999 xcb_block_len = 0; 2000 2001 return xcb_buffer_len; 2002 } 2003 2004 xcb_void_cookie_t 2005 xcb_sync_await_fence_checked (xcb_connection_t *c, 2006 uint32_t fence_list_len, 2007 const xcb_sync_fence_t *fence_list) 2008 { 2009 static const xcb_protocol_request_t xcb_req = { 2010 .count = 4, 2011 .ext = &xcb_sync_id, 2012 .opcode = XCB_SYNC_AWAIT_FENCE, 2013 .isvoid = 1 2014 }; 2015 2016 struct iovec xcb_parts[6]; 2017 xcb_void_cookie_t xcb_ret; 2018 xcb_sync_await_fence_request_t xcb_out; 2019 2020 2021 xcb_parts[2].iov_base = (char *) &xcb_out; 2022 xcb_parts[2].iov_len = sizeof(xcb_out); 2023 xcb_parts[3].iov_base = 0; 2024 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2025 /* xcb_sync_fence_t fence_list */ 2026 xcb_parts[4].iov_base = (char *) fence_list; 2027 xcb_parts[4].iov_len = fence_list_len * sizeof(xcb_sync_fence_t); 2028 xcb_parts[5].iov_base = 0; 2029 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2030 2031 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2032 return xcb_ret; 2033 } 2034 2035 xcb_void_cookie_t 2036 xcb_sync_await_fence (xcb_connection_t *c, 2037 uint32_t fence_list_len, 2038 const xcb_sync_fence_t *fence_list) 2039 { 2040 static const xcb_protocol_request_t xcb_req = { 2041 .count = 4, 2042 .ext = &xcb_sync_id, 2043 .opcode = XCB_SYNC_AWAIT_FENCE, 2044 .isvoid = 1 2045 }; 2046 2047 struct iovec xcb_parts[6]; 2048 xcb_void_cookie_t xcb_ret; 2049 xcb_sync_await_fence_request_t xcb_out; 2050 2051 2052 xcb_parts[2].iov_base = (char *) &xcb_out; 2053 xcb_parts[2].iov_len = sizeof(xcb_out); 2054 xcb_parts[3].iov_base = 0; 2055 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2056 /* xcb_sync_fence_t fence_list */ 2057 xcb_parts[4].iov_base = (char *) fence_list; 2058 xcb_parts[4].iov_len = fence_list_len * sizeof(xcb_sync_fence_t); 2059 xcb_parts[5].iov_base = 0; 2060 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2061 2062 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2063 return xcb_ret; 2064 } 2065 2066 xcb_sync_fence_t * 2067 xcb_sync_await_fence_fence_list (const xcb_sync_await_fence_request_t *R) 2068 { 2069 return (xcb_sync_fence_t *) (R + 1); 2070 } 2071 2072 int 2073 xcb_sync_await_fence_fence_list_length (const xcb_sync_await_fence_request_t *R) 2074 { 2075 return (((R->length * 4) - sizeof(xcb_sync_await_fence_request_t))/sizeof(xcb_sync_fence_t)); 2076 } 2077 2078 xcb_generic_iterator_t 2079 xcb_sync_await_fence_fence_list_end (const xcb_sync_await_fence_request_t *R) 2080 { 2081 xcb_generic_iterator_t i; 2082 i.data = ((xcb_sync_fence_t *) (R + 1)) + ((((R->length * 4) - sizeof(xcb_sync_await_fence_request_t))/sizeof(xcb_sync_fence_t))); 2083 i.rem = 0; 2084 i.index = (char *) i.data - (char *) R; 2085 return i; 2086 } 2087 2088
Indexes created Mon Mar 02 05:31:46 UTC 2026