src/gallium/auxiliary/rbug/rbug_context.c

   1 /*
   2  * Copyright 2009 VMware, Inc.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  19  * VMWARE AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 /*
  26  * This file holds the function implementation for one of the rbug extensions.
  27  * Prototypes and declerations of functions and structs is in the same folder
  28  * in the header file matching this file's name.
  29  *
  30  * The functions starting rbug_send_* encodes a call to the write format and
  31  * sends that to the supplied connection, while functions starting with
  32  * rbug_demarshal_* demarshal data in the wire protocol.
  33  *
  34  * Functions ending with _reply are replies to requests.
  35  */
  36
  37 #include "rbug_internal.h"
  38 #include "rbug/rbug_context.h"
  39
  40 int rbug_send_context_list(struct rbug_connection *__con,
  41                            uint32_t *__serial)
  42 {
  43         uint32_t __len = 0;
  44         uint32_t __pos = 0;
  45         uint8_t *__data = NULL;
  46         int __ret = 0;
  47
  48         LEN(8); /* header */
  49
  50         /* align */
  51         PAD(__len, 8);
  52
  53         __data = (uint8_t*)MALLOC(__len);
  54         if (!__data)
  55                 return -ENOMEM;
  56
  57         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_LIST));
  58         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  59
  60         /* final pad */
  61         PAD(__pos, 8);
  62
  63         if (__pos != __len) {
  64                 __ret = -EINVAL;
  65         } else {
  66                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_LIST, __len);
  67                 rbug_connection_write(__con, __data, __len);
  68                 __ret = rbug_connection_send_finish(__con, __serial);
  69         }
  70
  71         FREE(__data);
  72         return __ret;
  73 }
  74
  75 int rbug_send_context_info(struct rbug_connection *__con,
  76                            rbug_context_t context,
  77                            uint32_t *__serial)
  78 {
  79         uint32_t __len = 0;
  80         uint32_t __pos = 0;
  81         uint8_t *__data = NULL;
  82         int __ret = 0;
  83
  84         LEN(8); /* header */
  85         LEN(8); /* context */
  86
  87         /* align */
  88         PAD(__len, 8);
  89
  90         __data = (uint8_t*)MALLOC(__len);
  91         if (!__data)
  92                 return -ENOMEM;
  93
  94         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO));
  95         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
  96         WRITE(8, rbug_context_t, context); /* context */
  97
  98         /* final pad */
  99         PAD(__pos, 8);
 100
 101         if (__pos != __len) {
 102                 __ret = -EINVAL;
 103         } else {
 104                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_INFO, __len);
 105                 rbug_connection_write(__con, __data, __len);
 106                 __ret = rbug_connection_send_finish(__con, __serial);
 107         }
 108
 109         FREE(__data);
 110         return __ret;
 111 }
 112
 113 int rbug_send_context_draw_block(struct rbug_connection *__con,
 114                                  rbug_context_t context,
 115                                  rbug_block_t block,
 116                                  uint32_t *__serial)
 117 {
 118         uint32_t __len = 0;
 119         uint32_t __pos = 0;
 120         uint8_t *__data = NULL;
 121         int __ret = 0;
 122
 123         LEN(8); /* header */
 124         LEN(8); /* context */
 125         LEN(4); /* block */
 126
 127         /* align */
 128         PAD(__len, 8);
 129
 130         __data = (uint8_t*)MALLOC(__len);
 131         if (!__data)
 132                 return -ENOMEM;
 133
 134         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_BLOCK));
 135         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 136         WRITE(8, rbug_context_t, context); /* context */
 137         WRITE(4, rbug_block_t, block); /* block */
 138
 139         /* final pad */
 140         PAD(__pos, 8);
 141
 142         if (__pos != __len) {
 143                 __ret = -EINVAL;
 144         } else {
 145                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_BLOCK, __len);
 146                 rbug_connection_write(__con, __data, __len);
 147                 __ret = rbug_connection_send_finish(__con, __serial);
 148         }
 149
 150         FREE(__data);
 151         return __ret;
 152 }
 153
 154 int rbug_send_context_draw_step(struct rbug_connection *__con,
 155                                 rbug_context_t context,
 156                                 rbug_block_t step,
 157                                 uint32_t *__serial)
 158 {
 159         uint32_t __len = 0;
 160         uint32_t __pos = 0;
 161         uint8_t *__data = NULL;
 162         int __ret = 0;
 163
 164         LEN(8); /* header */
 165         LEN(8); /* context */
 166         LEN(4); /* step */
 167
 168         /* align */
 169         PAD(__len, 8);
 170
 171         __data = (uint8_t*)MALLOC(__len);
 172         if (!__data)
 173                 return -ENOMEM;
 174
 175         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_STEP));
 176         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 177         WRITE(8, rbug_context_t, context); /* context */
 178         WRITE(4, rbug_block_t, step); /* step */
 179
 180         /* final pad */
 181         PAD(__pos, 8);
 182
 183         if (__pos != __len) {
 184                 __ret = -EINVAL;
 185         } else {
 186                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_STEP, __len);
 187                 rbug_connection_write(__con, __data, __len);
 188                 __ret = rbug_connection_send_finish(__con, __serial);
 189         }
 190
 191         FREE(__data);
 192         return __ret;
 193 }
 194
 195 int rbug_send_context_draw_unblock(struct rbug_connection *__con,
 196                                    rbug_context_t context,
 197                                    rbug_block_t unblock,
 198                                    uint32_t *__serial)
 199 {
 200         uint32_t __len = 0;
 201         uint32_t __pos = 0;
 202         uint8_t *__data = NULL;
 203         int __ret = 0;
 204
 205         LEN(8); /* header */
 206         LEN(8); /* context */
 207         LEN(4); /* unblock */
 208
 209         /* align */
 210         PAD(__len, 8);
 211
 212         __data = (uint8_t*)MALLOC(__len);
 213         if (!__data)
 214                 return -ENOMEM;
 215
 216         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_UNBLOCK));
 217         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 218         WRITE(8, rbug_context_t, context); /* context */
 219         WRITE(4, rbug_block_t, unblock); /* unblock */
 220
 221         /* final pad */
 222         PAD(__pos, 8);
 223
 224         if (__pos != __len) {
 225                 __ret = -EINVAL;
 226         } else {
 227                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_UNBLOCK, __len);
 228                 rbug_connection_write(__con, __data, __len);
 229                 __ret = rbug_connection_send_finish(__con, __serial);
 230         }
 231
 232         FREE(__data);
 233         return __ret;
 234 }
 235
 236 int rbug_send_context_flush(struct rbug_connection *__con,
 237                             rbug_context_t context,
 238                             int32_t flags,
 239                             uint32_t *__serial)
 240 {
 241         uint32_t __len = 0;
 242         uint32_t __pos = 0;
 243         uint8_t *__data = NULL;
 244         int __ret = 0;
 245
 246         LEN(8); /* header */
 247         LEN(8); /* context */
 248         LEN(4); /* flags */
 249
 250         /* align */
 251         PAD(__len, 8);
 252
 253         __data = (uint8_t*)MALLOC(__len);
 254         if (!__data)
 255                 return -ENOMEM;
 256
 257         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_FLUSH));
 258         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 259         WRITE(8, rbug_context_t, context); /* context */
 260         WRITE(4, int32_t, flags); /* flags */
 261
 262         /* final pad */
 263         PAD(__pos, 8);
 264
 265         if (__pos != __len) {
 266                 __ret = -EINVAL;
 267         } else {
 268                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_FLUSH, __len);
 269                 rbug_connection_write(__con, __data, __len);
 270                 __ret = rbug_connection_send_finish(__con, __serial);
 271         }
 272
 273         FREE(__data);
 274         return __ret;
 275 }
 276
 277 int rbug_send_context_list_reply(struct rbug_connection *__con,
 278                                  uint32_t serial,
 279                                  rbug_context_t *contexts,
 280                                  uint32_t contexts_len,
 281                                  uint32_t *__serial)
 282 {
 283         uint32_t __len = 0;
 284         uint32_t __pos = 0;
 285         uint8_t *__data = NULL;
 286         int __ret = 0;
 287
 288         LEN(8); /* header */
 289         LEN(4); /* serial */
 290         LEN_ARRAY(8, contexts); /* contexts */
 291
 292         /* align */
 293         PAD(__len, 8);
 294
 295         __data = (uint8_t*)MALLOC(__len);
 296         if (!__data)
 297                 return -ENOMEM;
 298
 299         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_LIST_REPLY));
 300         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 301         WRITE(4, uint32_t, serial); /* serial */
 302         WRITE_ARRAY(8, rbug_context_t, contexts); /* contexts */
 303
 304         /* final pad */
 305         PAD(__pos, 8);
 306
 307         if (__pos != __len) {
 308                 __ret = -EINVAL;
 309         } else {
 310                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_LIST_REPLY, __len);
 311                 rbug_connection_write(__con, __data, __len);
 312                 __ret = rbug_connection_send_finish(__con, __serial);
 313         }
 314
 315         FREE(__data);
 316         return __ret;
 317 }
 318
 319 int rbug_send_context_info_reply(struct rbug_connection *__con,
 320                                  uint32_t serial,
 321                                  rbug_shader_t vertex,
 322                                  rbug_shader_t fragment,
 323                                  rbug_texture_t *cbufs,
 324                                  uint32_t cbufs_len,
 325                                  rbug_texture_t zsbuf,
 326                                  rbug_block_t blocker,
 327                                  rbug_block_t blocked,
 328                                  uint32_t *__serial)
 329 {
 330         uint32_t __len = 0;
 331         uint32_t __pos = 0;
 332         uint8_t *__data = NULL;
 333         int __ret = 0;
 334
 335         LEN(8); /* header */
 336         LEN(4); /* serial */
 337         LEN(8); /* vertex */
 338         LEN(8); /* fragment */
 339         LEN_ARRAY(8, cbufs); /* cbufs */
 340         LEN(8); /* zsbuf */
 341         LEN(4); /* blocker */
 342         LEN(4); /* blocked */
 343
 344         /* align */
 345         PAD(__len, 8);
 346
 347         __data = (uint8_t*)MALLOC(__len);
 348         if (!__data)
 349                 return -ENOMEM;
 350
 351         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_INFO_REPLY));
 352         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 353         WRITE(4, uint32_t, serial); /* serial */
 354         WRITE(8, rbug_shader_t, vertex); /* vertex */
 355         WRITE(8, rbug_shader_t, fragment); /* fragment */
 356         WRITE_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */
 357         WRITE(8, rbug_texture_t, zsbuf); /* zsbuf */
 358         WRITE(4, rbug_block_t, blocker); /* blocker */
 359         WRITE(4, rbug_block_t, blocked); /* blocked */
 360
 361         /* final pad */
 362         PAD(__pos, 8);
 363
 364         if (__pos != __len) {
 365                 __ret = -EINVAL;
 366         } else {
 367                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_INFO_REPLY, __len);
 368                 rbug_connection_write(__con, __data, __len);
 369                 __ret = rbug_connection_send_finish(__con, __serial);
 370         }
 371
 372         FREE(__data);
 373         return __ret;
 374 }
 375
 376 int rbug_send_context_draw_blocked(struct rbug_connection *__con,
 377                                    rbug_context_t context,
 378                                    rbug_block_t block,
 379                                    uint32_t *__serial)
 380 {
 381         uint32_t __len = 0;
 382         uint32_t __pos = 0;
 383         uint8_t *__data = NULL;
 384         int __ret = 0;
 385
 386         LEN(8); /* header */
 387         LEN(8); /* context */
 388         LEN(4); /* block */
 389
 390         /* align */
 391         PAD(__len, 8);
 392
 393         __data = (uint8_t*)MALLOC(__len);
 394         if (!__data)
 395                 return -ENOMEM;
 396
 397         WRITE(4, int32_t, ((int32_t)RBUG_OP_CONTEXT_DRAW_BLOCKED));
 398         WRITE(4, uint32_t, ((uint32_t)(__len / 4)));
 399         WRITE(8, rbug_context_t, context); /* context */
 400         WRITE(4, rbug_block_t, block); /* block */
 401
 402         /* final pad */
 403         PAD(__pos, 8);
 404
 405         if (__pos != __len) {
 406                 __ret = -EINVAL;
 407         } else {
 408                 rbug_connection_send_start(__con, RBUG_OP_CONTEXT_DRAW_BLOCKED, __len);
 409                 rbug_connection_write(__con, __data, __len);
 410                 __ret = rbug_connection_send_finish(__con, __serial);
 411         }
 412
 413         FREE(__data);
 414         return __ret;
 415 }
 416
 417 struct rbug_proto_context_list * rbug_demarshal_context_list(struct rbug_proto_header *header)
 418 {
 419         uint32_t len = 0;
 420         uint32_t pos = 0;
 421         uint8_t *data =  NULL;
 422         struct rbug_proto_context_list *ret;
 423
 424         if (!header)
 425                 return NULL;
 426         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_LIST)
 427                 return NULL;
 428
 429         pos = 0;
 430         len = header->length * 4;
 431         data = (uint8_t*)&header[1];
 432         ret = MALLOC(sizeof(*ret));
 433         if (!ret)
 434                 return NULL;
 435
 436         ret->header.__message = header;
 437         ret->header.opcode = header->opcode;
 438
 439
 440         return ret;
 441 }
 442
 443 struct rbug_proto_context_info * rbug_demarshal_context_info(struct rbug_proto_header *header)
 444 {
 445         uint32_t len = 0;
 446         uint32_t pos = 0;
 447         uint8_t *data =  NULL;
 448         struct rbug_proto_context_info *ret;
 449
 450         if (!header)
 451                 return NULL;
 452         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_INFO)
 453                 return NULL;
 454
 455         pos = 0;
 456         len = header->length * 4;
 457         data = (uint8_t*)&header[1];
 458         ret = MALLOC(sizeof(*ret));
 459         if (!ret)
 460                 return NULL;
 461
 462         ret->header.__message = header;
 463         ret->header.opcode = header->opcode;
 464
 465         READ(8, rbug_context_t, context); /* context */
 466
 467         return ret;
 468 }
 469
 470 struct rbug_proto_context_draw_block * rbug_demarshal_context_draw_block(struct rbug_proto_header *header)
 471 {
 472         uint32_t len = 0;
 473         uint32_t pos = 0;
 474         uint8_t *data =  NULL;
 475         struct rbug_proto_context_draw_block *ret;
 476
 477         if (!header)
 478                 return NULL;
 479         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_BLOCK)
 480                 return NULL;
 481
 482         pos = 0;
 483         len = header->length * 4;
 484         data = (uint8_t*)&header[1];
 485         ret = MALLOC(sizeof(*ret));
 486         if (!ret)
 487                 return NULL;
 488
 489         ret->header.__message = header;
 490         ret->header.opcode = header->opcode;
 491
 492         READ(8, rbug_context_t, context); /* context */
 493         READ(4, rbug_block_t, block); /* block */
 494
 495         return ret;
 496 }
 497
 498 struct rbug_proto_context_draw_step * rbug_demarshal_context_draw_step(struct rbug_proto_header *header)
 499 {
 500         uint32_t len = 0;
 501         uint32_t pos = 0;
 502         uint8_t *data =  NULL;
 503         struct rbug_proto_context_draw_step *ret;
 504
 505         if (!header)
 506                 return NULL;
 507         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_STEP)
 508                 return NULL;
 509
 510         pos = 0;
 511         len = header->length * 4;
 512         data = (uint8_t*)&header[1];
 513         ret = MALLOC(sizeof(*ret));
 514         if (!ret)
 515                 return NULL;
 516
 517         ret->header.__message = header;
 518         ret->header.opcode = header->opcode;
 519
 520         READ(8, rbug_context_t, context); /* context */
 521         READ(4, rbug_block_t, step); /* step */
 522
 523         return ret;
 524 }
 525
 526 struct rbug_proto_context_draw_unblock * rbug_demarshal_context_draw_unblock(struct rbug_proto_header *header)
 527 {
 528         uint32_t len = 0;
 529         uint32_t pos = 0;
 530         uint8_t *data =  NULL;
 531         struct rbug_proto_context_draw_unblock *ret;
 532
 533         if (!header)
 534                 return NULL;
 535         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_UNBLOCK)
 536                 return NULL;
 537
 538         pos = 0;
 539         len = header->length * 4;
 540         data = (uint8_t*)&header[1];
 541         ret = MALLOC(sizeof(*ret));
 542         if (!ret)
 543                 return NULL;
 544
 545         ret->header.__message = header;
 546         ret->header.opcode = header->opcode;
 547
 548         READ(8, rbug_context_t, context); /* context */
 549         READ(4, rbug_block_t, unblock); /* unblock */
 550
 551         return ret;
 552 }
 553
 554 struct rbug_proto_context_flush * rbug_demarshal_context_flush(struct rbug_proto_header *header)
 555 {
 556         uint32_t len = 0;
 557         uint32_t pos = 0;
 558         uint8_t *data =  NULL;
 559         struct rbug_proto_context_flush *ret;
 560
 561         if (!header)
 562                 return NULL;
 563         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_FLUSH)
 564                 return NULL;
 565
 566         pos = 0;
 567         len = header->length * 4;
 568         data = (uint8_t*)&header[1];
 569         ret = MALLOC(sizeof(*ret));
 570         if (!ret)
 571                 return NULL;
 572
 573         ret->header.__message = header;
 574         ret->header.opcode = header->opcode;
 575
 576         READ(8, rbug_context_t, context); /* context */
 577         READ(4, int32_t, flags); /* flags */
 578
 579         return ret;
 580 }
 581
 582 struct rbug_proto_context_list_reply * rbug_demarshal_context_list_reply(struct rbug_proto_header *header)
 583 {
 584         uint32_t len = 0;
 585         uint32_t pos = 0;
 586         uint8_t *data =  NULL;
 587         struct rbug_proto_context_list_reply *ret;
 588
 589         if (!header)
 590                 return NULL;
 591         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_LIST_REPLY)
 592                 return NULL;
 593
 594         pos = 0;
 595         len = header->length * 4;
 596         data = (uint8_t*)&header[1];
 597         ret = MALLOC(sizeof(*ret));
 598         if (!ret)
 599                 return NULL;
 600
 601         ret->header.__message = header;
 602         ret->header.opcode = header->opcode;
 603
 604         READ(4, uint32_t, serial); /* serial */
 605         READ_ARRAY(8, rbug_context_t, contexts); /* contexts */
 606
 607         return ret;
 608 }
 609
 610 struct rbug_proto_context_info_reply * rbug_demarshal_context_info_reply(struct rbug_proto_header *header)
 611 {
 612         uint32_t len = 0;
 613         uint32_t pos = 0;
 614         uint8_t *data =  NULL;
 615         struct rbug_proto_context_info_reply *ret;
 616
 617         if (!header)
 618                 return NULL;
 619         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_INFO_REPLY)
 620                 return NULL;
 621
 622         pos = 0;
 623         len = header->length * 4;
 624         data = (uint8_t*)&header[1];
 625         ret = MALLOC(sizeof(*ret));
 626         if (!ret)
 627                 return NULL;
 628
 629         ret->header.__message = header;
 630         ret->header.opcode = header->opcode;
 631
 632         READ(4, uint32_t, serial); /* serial */
 633         READ(8, rbug_shader_t, vertex); /* vertex */
 634         READ(8, rbug_shader_t, fragment); /* fragment */
 635         READ_ARRAY(8, rbug_texture_t, cbufs); /* cbufs */
 636         READ(8, rbug_texture_t, zsbuf); /* zsbuf */
 637         READ(4, rbug_block_t, blocker); /* blocker */
 638         READ(4, rbug_block_t, blocked); /* blocked */
 639
 640         return ret;
 641 }
 642
 643 struct rbug_proto_context_draw_blocked * rbug_demarshal_context_draw_blocked(struct rbug_proto_header *header)
 644 {
 645         uint32_t len = 0;
 646         uint32_t pos = 0;
 647         uint8_t *data =  NULL;
 648         struct rbug_proto_context_draw_blocked *ret;
 649
 650         if (!header)
 651                 return NULL;
 652         if (header->opcode != (int16_t)RBUG_OP_CONTEXT_DRAW_BLOCKED)
 653                 return NULL;
 654
 655         pos = 0;
 656         len = header->length * 4;
 657         data = (uint8_t*)&header[1];
 658         ret = MALLOC(sizeof(*ret));
 659         if (!ret)
 660                 return NULL;
 661
 662         ret->header.__message = header;
 663         ret->header.opcode = header->opcode;
 664
 665         READ(8, rbug_context_t, context); /* context */
 666         READ(4, rbug_block_t, block); /* block */
 667
 668         return ret;
 669 }