github.com/castai/kvisor@v1.7.1-0.20240516114728-b3572a2607b5/pkg/ebpftracer/decoder/args_decoder.go (about) 1 // Code generated by tools/codegen; DO NOT EDIT. 2 3 package decoder 4 5 import ( 6 "errors" 7 8 "github.com/castai/kvisor/pkg/ebpftracer/events" 9 "github.com/castai/kvisor/pkg/ebpftracer/types" 10 ) 11 12 var ( 13 ErrUnknownArgsType error = errors.New("unknown args type") 14 ) 15 16 // eventMaxByteSliceBufferSize is used to determine the max slice size allowed for different 17 // event types. For example, most events have a max size of 4096, but for network related events 18 // there is no max size (this is represented as -1). 19 func eventMaxByteSliceBufferSize(id events.ID) int { 20 // For non network event, we have a max byte slice size of 4096 21 if id < events.NetPacketBase || id > events.MaxNetID { 22 return 4096 23 } 24 25 // Network events do not have a max buffer size. 26 return -1 27 } 28 29 func ParseReadArgs(decoder *Decoder) (types.ReadArgs, error) { 30 var result types.ReadArgs 31 var err error 32 33 var numArgs uint8 34 err = decoder.DecodeUint8(&numArgs) 35 if err != nil { 36 return types.ReadArgs{}, err 37 } 38 39 for arg := 0; arg < int(numArgs); arg++ { 40 var currArg uint8 41 err = decoder.DecodeUint8(&currArg) 42 if err != nil { 43 return types.ReadArgs{}, err 44 } 45 46 switch currArg { 47 case 0: 48 err = decoder.DecodeInt32(&result.Fd) 49 if err != nil { 50 return types.ReadArgs{}, err 51 } 52 case 1: 53 var dataBuf uint64 54 err = decoder.DecodeUint64(&dataBuf) 55 if err != nil { 56 return types.ReadArgs{}, err 57 } 58 result.Buf = uintptr(dataBuf) 59 case 2: 60 err = decoder.DecodeUint64(&result.Count) 61 if err != nil { 62 return types.ReadArgs{}, err 63 } 64 } 65 } 66 return result, nil 67 } 68 69 func ParseWriteArgs(decoder *Decoder) (types.WriteArgs, error) { 70 var result types.WriteArgs 71 var err error 72 73 var numArgs uint8 74 err = decoder.DecodeUint8(&numArgs) 75 if err != nil { 76 return types.WriteArgs{}, err 77 } 78 79 for arg := 0; arg < int(numArgs); arg++ { 80 var currArg uint8 81 err = decoder.DecodeUint8(&currArg) 82 if err != nil { 83 return types.WriteArgs{}, err 84 } 85 86 switch currArg { 87 case 0: 88 err = decoder.DecodeInt32(&result.Fd) 89 if err != nil { 90 return types.WriteArgs{}, err 91 } 92 case 1: 93 var dataBuf uint64 94 err = decoder.DecodeUint64(&dataBuf) 95 if err != nil { 96 return types.WriteArgs{}, err 97 } 98 result.Buf = uintptr(dataBuf) 99 case 2: 100 err = decoder.DecodeUint64(&result.Count) 101 if err != nil { 102 return types.WriteArgs{}, err 103 } 104 } 105 } 106 return result, nil 107 } 108 109 func ParseOpenArgs(decoder *Decoder) (types.OpenArgs, error) { 110 var result types.OpenArgs 111 var err error 112 113 var numArgs uint8 114 err = decoder.DecodeUint8(&numArgs) 115 if err != nil { 116 return types.OpenArgs{}, err 117 } 118 119 for arg := 0; arg < int(numArgs); arg++ { 120 var currArg uint8 121 err = decoder.DecodeUint8(&currArg) 122 if err != nil { 123 return types.OpenArgs{}, err 124 } 125 126 switch currArg { 127 case 0: 128 result.Pathname, err = decoder.ReadStringFromBuff() 129 if err != nil { 130 return types.OpenArgs{}, err 131 } 132 case 1: 133 err = decoder.DecodeInt32(&result.Flags) 134 if err != nil { 135 return types.OpenArgs{}, err 136 } 137 case 2: 138 err = decoder.DecodeUint32(&result.Mode) 139 if err != nil { 140 return types.OpenArgs{}, err 141 } 142 } 143 } 144 return result, nil 145 } 146 147 func ParseCloseArgs(decoder *Decoder) (types.CloseArgs, error) { 148 var result types.CloseArgs 149 var err error 150 151 var numArgs uint8 152 err = decoder.DecodeUint8(&numArgs) 153 if err != nil { 154 return types.CloseArgs{}, err 155 } 156 157 for arg := 0; arg < int(numArgs); arg++ { 158 var currArg uint8 159 err = decoder.DecodeUint8(&currArg) 160 if err != nil { 161 return types.CloseArgs{}, err 162 } 163 164 switch currArg { 165 case 0: 166 err = decoder.DecodeInt32(&result.Fd) 167 if err != nil { 168 return types.CloseArgs{}, err 169 } 170 } 171 } 172 return result, nil 173 } 174 175 func ParseStatArgs(decoder *Decoder) (types.StatArgs, error) { 176 var result types.StatArgs 177 var err error 178 179 var numArgs uint8 180 err = decoder.DecodeUint8(&numArgs) 181 if err != nil { 182 return types.StatArgs{}, err 183 } 184 185 for arg := 0; arg < int(numArgs); arg++ { 186 var currArg uint8 187 err = decoder.DecodeUint8(&currArg) 188 if err != nil { 189 return types.StatArgs{}, err 190 } 191 192 switch currArg { 193 case 0: 194 result.Pathname, err = decoder.ReadStringFromBuff() 195 if err != nil { 196 return types.StatArgs{}, err 197 } 198 case 1: 199 var dataStatbuf uint64 200 err = decoder.DecodeUint64(&dataStatbuf) 201 if err != nil { 202 return types.StatArgs{}, err 203 } 204 result.Statbuf = uintptr(dataStatbuf) 205 } 206 } 207 return result, nil 208 } 209 210 func ParseFstatArgs(decoder *Decoder) (types.FstatArgs, error) { 211 var result types.FstatArgs 212 var err error 213 214 var numArgs uint8 215 err = decoder.DecodeUint8(&numArgs) 216 if err != nil { 217 return types.FstatArgs{}, err 218 } 219 220 for arg := 0; arg < int(numArgs); arg++ { 221 var currArg uint8 222 err = decoder.DecodeUint8(&currArg) 223 if err != nil { 224 return types.FstatArgs{}, err 225 } 226 227 switch currArg { 228 case 0: 229 err = decoder.DecodeInt32(&result.Fd) 230 if err != nil { 231 return types.FstatArgs{}, err 232 } 233 case 1: 234 var dataStatbuf uint64 235 err = decoder.DecodeUint64(&dataStatbuf) 236 if err != nil { 237 return types.FstatArgs{}, err 238 } 239 result.Statbuf = uintptr(dataStatbuf) 240 } 241 } 242 return result, nil 243 } 244 245 func ParseLstatArgs(decoder *Decoder) (types.LstatArgs, error) { 246 var result types.LstatArgs 247 var err error 248 249 var numArgs uint8 250 err = decoder.DecodeUint8(&numArgs) 251 if err != nil { 252 return types.LstatArgs{}, err 253 } 254 255 for arg := 0; arg < int(numArgs); arg++ { 256 var currArg uint8 257 err = decoder.DecodeUint8(&currArg) 258 if err != nil { 259 return types.LstatArgs{}, err 260 } 261 262 switch currArg { 263 case 0: 264 result.Pathname, err = decoder.ReadStringFromBuff() 265 if err != nil { 266 return types.LstatArgs{}, err 267 } 268 case 1: 269 var dataStatbuf uint64 270 err = decoder.DecodeUint64(&dataStatbuf) 271 if err != nil { 272 return types.LstatArgs{}, err 273 } 274 result.Statbuf = uintptr(dataStatbuf) 275 } 276 } 277 return result, nil 278 } 279 280 func ParsePollArgs(decoder *Decoder) (types.PollArgs, error) { 281 var result types.PollArgs 282 var err error 283 284 var numArgs uint8 285 err = decoder.DecodeUint8(&numArgs) 286 if err != nil { 287 return types.PollArgs{}, err 288 } 289 290 for arg := 0; arg < int(numArgs); arg++ { 291 var currArg uint8 292 err = decoder.DecodeUint8(&currArg) 293 if err != nil { 294 return types.PollArgs{}, err 295 } 296 297 switch currArg { 298 case 0: 299 var dataFds uint64 300 err = decoder.DecodeUint64(&dataFds) 301 if err != nil { 302 return types.PollArgs{}, err 303 } 304 result.Fds = uintptr(dataFds) 305 case 1: 306 err = decoder.DecodeUint32(&result.Nfds) 307 if err != nil { 308 return types.PollArgs{}, err 309 } 310 case 2: 311 err = decoder.DecodeInt32(&result.Timeout) 312 if err != nil { 313 return types.PollArgs{}, err 314 } 315 } 316 } 317 return result, nil 318 } 319 320 func ParseLseekArgs(decoder *Decoder) (types.LseekArgs, error) { 321 var result types.LseekArgs 322 var err error 323 324 var numArgs uint8 325 err = decoder.DecodeUint8(&numArgs) 326 if err != nil { 327 return types.LseekArgs{}, err 328 } 329 330 for arg := 0; arg < int(numArgs); arg++ { 331 var currArg uint8 332 err = decoder.DecodeUint8(&currArg) 333 if err != nil { 334 return types.LseekArgs{}, err 335 } 336 337 switch currArg { 338 case 0: 339 err = decoder.DecodeInt32(&result.Fd) 340 if err != nil { 341 return types.LseekArgs{}, err 342 } 343 case 1: 344 err = decoder.DecodeUint64(&result.Offset) 345 if err != nil { 346 return types.LseekArgs{}, err 347 } 348 case 2: 349 err = decoder.DecodeUint32(&result.Whence) 350 if err != nil { 351 return types.LseekArgs{}, err 352 } 353 } 354 } 355 return result, nil 356 } 357 358 func ParseMmapArgs(decoder *Decoder) (types.MmapArgs, error) { 359 var result types.MmapArgs 360 var err error 361 362 var numArgs uint8 363 err = decoder.DecodeUint8(&numArgs) 364 if err != nil { 365 return types.MmapArgs{}, err 366 } 367 368 for arg := 0; arg < int(numArgs); arg++ { 369 var currArg uint8 370 err = decoder.DecodeUint8(&currArg) 371 if err != nil { 372 return types.MmapArgs{}, err 373 } 374 375 switch currArg { 376 case 0: 377 var dataAddr uint64 378 err = decoder.DecodeUint64(&dataAddr) 379 if err != nil { 380 return types.MmapArgs{}, err 381 } 382 result.Addr = uintptr(dataAddr) 383 case 1: 384 err = decoder.DecodeUint64(&result.Length) 385 if err != nil { 386 return types.MmapArgs{}, err 387 } 388 case 2: 389 err = decoder.DecodeInt32(&result.Prot) 390 if err != nil { 391 return types.MmapArgs{}, err 392 } 393 case 3: 394 err = decoder.DecodeInt32(&result.Flags) 395 if err != nil { 396 return types.MmapArgs{}, err 397 } 398 case 4: 399 err = decoder.DecodeInt32(&result.Fd) 400 if err != nil { 401 return types.MmapArgs{}, err 402 } 403 case 5: 404 err = decoder.DecodeUint64(&result.Off) 405 if err != nil { 406 return types.MmapArgs{}, err 407 } 408 } 409 } 410 return result, nil 411 } 412 413 func ParseMprotectArgs(decoder *Decoder) (types.MprotectArgs, error) { 414 var result types.MprotectArgs 415 var err error 416 417 var numArgs uint8 418 err = decoder.DecodeUint8(&numArgs) 419 if err != nil { 420 return types.MprotectArgs{}, err 421 } 422 423 for arg := 0; arg < int(numArgs); arg++ { 424 var currArg uint8 425 err = decoder.DecodeUint8(&currArg) 426 if err != nil { 427 return types.MprotectArgs{}, err 428 } 429 430 switch currArg { 431 case 0: 432 var dataAddr uint64 433 err = decoder.DecodeUint64(&dataAddr) 434 if err != nil { 435 return types.MprotectArgs{}, err 436 } 437 result.Addr = uintptr(dataAddr) 438 case 1: 439 err = decoder.DecodeUint64(&result.Len) 440 if err != nil { 441 return types.MprotectArgs{}, err 442 } 443 case 2: 444 err = decoder.DecodeInt32(&result.Prot) 445 if err != nil { 446 return types.MprotectArgs{}, err 447 } 448 } 449 } 450 return result, nil 451 } 452 453 func ParseMunmapArgs(decoder *Decoder) (types.MunmapArgs, error) { 454 var result types.MunmapArgs 455 var err error 456 457 var numArgs uint8 458 err = decoder.DecodeUint8(&numArgs) 459 if err != nil { 460 return types.MunmapArgs{}, err 461 } 462 463 for arg := 0; arg < int(numArgs); arg++ { 464 var currArg uint8 465 err = decoder.DecodeUint8(&currArg) 466 if err != nil { 467 return types.MunmapArgs{}, err 468 } 469 470 switch currArg { 471 case 0: 472 var dataAddr uint64 473 err = decoder.DecodeUint64(&dataAddr) 474 if err != nil { 475 return types.MunmapArgs{}, err 476 } 477 result.Addr = uintptr(dataAddr) 478 case 1: 479 err = decoder.DecodeUint64(&result.Length) 480 if err != nil { 481 return types.MunmapArgs{}, err 482 } 483 } 484 } 485 return result, nil 486 } 487 488 func ParseBrkArgs(decoder *Decoder) (types.BrkArgs, error) { 489 var result types.BrkArgs 490 var err error 491 492 var numArgs uint8 493 err = decoder.DecodeUint8(&numArgs) 494 if err != nil { 495 return types.BrkArgs{}, err 496 } 497 498 for arg := 0; arg < int(numArgs); arg++ { 499 var currArg uint8 500 err = decoder.DecodeUint8(&currArg) 501 if err != nil { 502 return types.BrkArgs{}, err 503 } 504 505 switch currArg { 506 case 0: 507 var dataAddr uint64 508 err = decoder.DecodeUint64(&dataAddr) 509 if err != nil { 510 return types.BrkArgs{}, err 511 } 512 result.Addr = uintptr(dataAddr) 513 } 514 } 515 return result, nil 516 } 517 518 func ParseRtSigactionArgs(decoder *Decoder) (types.RtSigactionArgs, error) { 519 var result types.RtSigactionArgs 520 var err error 521 522 var numArgs uint8 523 err = decoder.DecodeUint8(&numArgs) 524 if err != nil { 525 return types.RtSigactionArgs{}, err 526 } 527 528 for arg := 0; arg < int(numArgs); arg++ { 529 var currArg uint8 530 err = decoder.DecodeUint8(&currArg) 531 if err != nil { 532 return types.RtSigactionArgs{}, err 533 } 534 535 switch currArg { 536 case 0: 537 err = decoder.DecodeInt32(&result.Signum) 538 if err != nil { 539 return types.RtSigactionArgs{}, err 540 } 541 case 1: 542 var dataAct uint64 543 err = decoder.DecodeUint64(&dataAct) 544 if err != nil { 545 return types.RtSigactionArgs{}, err 546 } 547 result.Act = uintptr(dataAct) 548 case 2: 549 var dataOldact uint64 550 err = decoder.DecodeUint64(&dataOldact) 551 if err != nil { 552 return types.RtSigactionArgs{}, err 553 } 554 result.Oldact = uintptr(dataOldact) 555 case 3: 556 err = decoder.DecodeUint64(&result.Sigsetsize) 557 if err != nil { 558 return types.RtSigactionArgs{}, err 559 } 560 } 561 } 562 return result, nil 563 } 564 565 func ParseRtSigprocmaskArgs(decoder *Decoder) (types.RtSigprocmaskArgs, error) { 566 var result types.RtSigprocmaskArgs 567 var err error 568 569 var numArgs uint8 570 err = decoder.DecodeUint8(&numArgs) 571 if err != nil { 572 return types.RtSigprocmaskArgs{}, err 573 } 574 575 for arg := 0; arg < int(numArgs); arg++ { 576 var currArg uint8 577 err = decoder.DecodeUint8(&currArg) 578 if err != nil { 579 return types.RtSigprocmaskArgs{}, err 580 } 581 582 switch currArg { 583 case 0: 584 err = decoder.DecodeInt32(&result.How) 585 if err != nil { 586 return types.RtSigprocmaskArgs{}, err 587 } 588 case 1: 589 var dataSet uint64 590 err = decoder.DecodeUint64(&dataSet) 591 if err != nil { 592 return types.RtSigprocmaskArgs{}, err 593 } 594 result.Set = uintptr(dataSet) 595 case 2: 596 var dataOldset uint64 597 err = decoder.DecodeUint64(&dataOldset) 598 if err != nil { 599 return types.RtSigprocmaskArgs{}, err 600 } 601 result.Oldset = uintptr(dataOldset) 602 case 3: 603 err = decoder.DecodeUint64(&result.Sigsetsize) 604 if err != nil { 605 return types.RtSigprocmaskArgs{}, err 606 } 607 } 608 } 609 return result, nil 610 } 611 612 func ParseRtSigreturnArgs(decoder *Decoder) (types.RtSigreturnArgs, error) { 613 return types.RtSigreturnArgs{}, nil 614 } 615 616 func ParseIoctlArgs(decoder *Decoder) (types.IoctlArgs, error) { 617 var result types.IoctlArgs 618 var err error 619 620 var numArgs uint8 621 err = decoder.DecodeUint8(&numArgs) 622 if err != nil { 623 return types.IoctlArgs{}, err 624 } 625 626 for arg := 0; arg < int(numArgs); arg++ { 627 var currArg uint8 628 err = decoder.DecodeUint8(&currArg) 629 if err != nil { 630 return types.IoctlArgs{}, err 631 } 632 633 switch currArg { 634 case 0: 635 err = decoder.DecodeInt32(&result.Fd) 636 if err != nil { 637 return types.IoctlArgs{}, err 638 } 639 case 1: 640 err = decoder.DecodeUint64(&result.Request) 641 if err != nil { 642 return types.IoctlArgs{}, err 643 } 644 case 2: 645 err = decoder.DecodeUint64(&result.Arg) 646 if err != nil { 647 return types.IoctlArgs{}, err 648 } 649 } 650 } 651 return result, nil 652 } 653 654 func ParsePread64Args(decoder *Decoder) (types.Pread64Args, error) { 655 var result types.Pread64Args 656 var err error 657 658 var numArgs uint8 659 err = decoder.DecodeUint8(&numArgs) 660 if err != nil { 661 return types.Pread64Args{}, err 662 } 663 664 for arg := 0; arg < int(numArgs); arg++ { 665 var currArg uint8 666 err = decoder.DecodeUint8(&currArg) 667 if err != nil { 668 return types.Pread64Args{}, err 669 } 670 671 switch currArg { 672 case 0: 673 err = decoder.DecodeInt32(&result.Fd) 674 if err != nil { 675 return types.Pread64Args{}, err 676 } 677 case 1: 678 var dataBuf uint64 679 err = decoder.DecodeUint64(&dataBuf) 680 if err != nil { 681 return types.Pread64Args{}, err 682 } 683 result.Buf = uintptr(dataBuf) 684 case 2: 685 err = decoder.DecodeUint64(&result.Count) 686 if err != nil { 687 return types.Pread64Args{}, err 688 } 689 case 3: 690 err = decoder.DecodeUint64(&result.Offset) 691 if err != nil { 692 return types.Pread64Args{}, err 693 } 694 } 695 } 696 return result, nil 697 } 698 699 func ParsePwrite64Args(decoder *Decoder) (types.Pwrite64Args, error) { 700 var result types.Pwrite64Args 701 var err error 702 703 var numArgs uint8 704 err = decoder.DecodeUint8(&numArgs) 705 if err != nil { 706 return types.Pwrite64Args{}, err 707 } 708 709 for arg := 0; arg < int(numArgs); arg++ { 710 var currArg uint8 711 err = decoder.DecodeUint8(&currArg) 712 if err != nil { 713 return types.Pwrite64Args{}, err 714 } 715 716 switch currArg { 717 case 0: 718 err = decoder.DecodeInt32(&result.Fd) 719 if err != nil { 720 return types.Pwrite64Args{}, err 721 } 722 case 1: 723 var dataBuf uint64 724 err = decoder.DecodeUint64(&dataBuf) 725 if err != nil { 726 return types.Pwrite64Args{}, err 727 } 728 result.Buf = uintptr(dataBuf) 729 case 2: 730 err = decoder.DecodeUint64(&result.Count) 731 if err != nil { 732 return types.Pwrite64Args{}, err 733 } 734 case 3: 735 err = decoder.DecodeUint64(&result.Offset) 736 if err != nil { 737 return types.Pwrite64Args{}, err 738 } 739 } 740 } 741 return result, nil 742 } 743 744 func ParseReadvArgs(decoder *Decoder) (types.ReadvArgs, error) { 745 var result types.ReadvArgs 746 var err error 747 748 var numArgs uint8 749 err = decoder.DecodeUint8(&numArgs) 750 if err != nil { 751 return types.ReadvArgs{}, err 752 } 753 754 for arg := 0; arg < int(numArgs); arg++ { 755 var currArg uint8 756 err = decoder.DecodeUint8(&currArg) 757 if err != nil { 758 return types.ReadvArgs{}, err 759 } 760 761 switch currArg { 762 case 0: 763 err = decoder.DecodeInt32(&result.Fd) 764 if err != nil { 765 return types.ReadvArgs{}, err 766 } 767 case 1: 768 var dataIov uint64 769 err = decoder.DecodeUint64(&dataIov) 770 if err != nil { 771 return types.ReadvArgs{}, err 772 } 773 result.Iov = uintptr(dataIov) 774 case 2: 775 err = decoder.DecodeInt32(&result.Iovcnt) 776 if err != nil { 777 return types.ReadvArgs{}, err 778 } 779 } 780 } 781 return result, nil 782 } 783 784 func ParseWritevArgs(decoder *Decoder) (types.WritevArgs, error) { 785 var result types.WritevArgs 786 var err error 787 788 var numArgs uint8 789 err = decoder.DecodeUint8(&numArgs) 790 if err != nil { 791 return types.WritevArgs{}, err 792 } 793 794 for arg := 0; arg < int(numArgs); arg++ { 795 var currArg uint8 796 err = decoder.DecodeUint8(&currArg) 797 if err != nil { 798 return types.WritevArgs{}, err 799 } 800 801 switch currArg { 802 case 0: 803 err = decoder.DecodeInt32(&result.Fd) 804 if err != nil { 805 return types.WritevArgs{}, err 806 } 807 case 1: 808 var dataIov uint64 809 err = decoder.DecodeUint64(&dataIov) 810 if err != nil { 811 return types.WritevArgs{}, err 812 } 813 result.Iov = uintptr(dataIov) 814 case 2: 815 err = decoder.DecodeInt32(&result.Iovcnt) 816 if err != nil { 817 return types.WritevArgs{}, err 818 } 819 } 820 } 821 return result, nil 822 } 823 824 func ParseAccessArgs(decoder *Decoder) (types.AccessArgs, error) { 825 var result types.AccessArgs 826 var err error 827 828 var numArgs uint8 829 err = decoder.DecodeUint8(&numArgs) 830 if err != nil { 831 return types.AccessArgs{}, err 832 } 833 834 for arg := 0; arg < int(numArgs); arg++ { 835 var currArg uint8 836 err = decoder.DecodeUint8(&currArg) 837 if err != nil { 838 return types.AccessArgs{}, err 839 } 840 841 switch currArg { 842 case 0: 843 result.Pathname, err = decoder.ReadStringFromBuff() 844 if err != nil { 845 return types.AccessArgs{}, err 846 } 847 case 1: 848 err = decoder.DecodeInt32(&result.Mode) 849 if err != nil { 850 return types.AccessArgs{}, err 851 } 852 } 853 } 854 return result, nil 855 } 856 857 func ParsePipeArgs(decoder *Decoder) (types.PipeArgs, error) { 858 var result types.PipeArgs 859 var err error 860 861 var numArgs uint8 862 err = decoder.DecodeUint8(&numArgs) 863 if err != nil { 864 return types.PipeArgs{}, err 865 } 866 867 for arg := 0; arg < int(numArgs); arg++ { 868 var currArg uint8 869 err = decoder.DecodeUint8(&currArg) 870 if err != nil { 871 return types.PipeArgs{}, err 872 } 873 874 switch currArg { 875 case 0: 876 err = decoder.DecodeIntArray(result.Pipefd[:], 2) 877 if err != nil { 878 return types.PipeArgs{}, err 879 } 880 } 881 } 882 return result, nil 883 } 884 885 func ParseSelectArgs(decoder *Decoder) (types.SelectArgs, error) { 886 var result types.SelectArgs 887 var err error 888 889 var numArgs uint8 890 err = decoder.DecodeUint8(&numArgs) 891 if err != nil { 892 return types.SelectArgs{}, err 893 } 894 895 for arg := 0; arg < int(numArgs); arg++ { 896 var currArg uint8 897 err = decoder.DecodeUint8(&currArg) 898 if err != nil { 899 return types.SelectArgs{}, err 900 } 901 902 switch currArg { 903 case 0: 904 err = decoder.DecodeInt32(&result.Nfds) 905 if err != nil { 906 return types.SelectArgs{}, err 907 } 908 case 1: 909 var dataReadfds uint64 910 err = decoder.DecodeUint64(&dataReadfds) 911 if err != nil { 912 return types.SelectArgs{}, err 913 } 914 result.Readfds = uintptr(dataReadfds) 915 case 2: 916 var dataWritefds uint64 917 err = decoder.DecodeUint64(&dataWritefds) 918 if err != nil { 919 return types.SelectArgs{}, err 920 } 921 result.Writefds = uintptr(dataWritefds) 922 case 3: 923 var dataExceptfds uint64 924 err = decoder.DecodeUint64(&dataExceptfds) 925 if err != nil { 926 return types.SelectArgs{}, err 927 } 928 result.Exceptfds = uintptr(dataExceptfds) 929 case 4: 930 var dataTimeout uint64 931 err = decoder.DecodeUint64(&dataTimeout) 932 if err != nil { 933 return types.SelectArgs{}, err 934 } 935 result.Timeout = uintptr(dataTimeout) 936 } 937 } 938 return result, nil 939 } 940 941 func ParseSchedYieldArgs(decoder *Decoder) (types.SchedYieldArgs, error) { 942 return types.SchedYieldArgs{}, nil 943 } 944 945 func ParseMremapArgs(decoder *Decoder) (types.MremapArgs, error) { 946 var result types.MremapArgs 947 var err error 948 949 var numArgs uint8 950 err = decoder.DecodeUint8(&numArgs) 951 if err != nil { 952 return types.MremapArgs{}, err 953 } 954 955 for arg := 0; arg < int(numArgs); arg++ { 956 var currArg uint8 957 err = decoder.DecodeUint8(&currArg) 958 if err != nil { 959 return types.MremapArgs{}, err 960 } 961 962 switch currArg { 963 case 0: 964 var dataOldAddress uint64 965 err = decoder.DecodeUint64(&dataOldAddress) 966 if err != nil { 967 return types.MremapArgs{}, err 968 } 969 result.OldAddress = uintptr(dataOldAddress) 970 case 1: 971 err = decoder.DecodeUint64(&result.OldSize) 972 if err != nil { 973 return types.MremapArgs{}, err 974 } 975 case 2: 976 err = decoder.DecodeUint64(&result.NewSize) 977 if err != nil { 978 return types.MremapArgs{}, err 979 } 980 case 3: 981 err = decoder.DecodeInt32(&result.Flags) 982 if err != nil { 983 return types.MremapArgs{}, err 984 } 985 case 4: 986 var dataNewAddress uint64 987 err = decoder.DecodeUint64(&dataNewAddress) 988 if err != nil { 989 return types.MremapArgs{}, err 990 } 991 result.NewAddress = uintptr(dataNewAddress) 992 } 993 } 994 return result, nil 995 } 996 997 func ParseMsyncArgs(decoder *Decoder) (types.MsyncArgs, error) { 998 var result types.MsyncArgs 999 var err error 1000 1001 var numArgs uint8 1002 err = decoder.DecodeUint8(&numArgs) 1003 if err != nil { 1004 return types.MsyncArgs{}, err 1005 } 1006 1007 for arg := 0; arg < int(numArgs); arg++ { 1008 var currArg uint8 1009 err = decoder.DecodeUint8(&currArg) 1010 if err != nil { 1011 return types.MsyncArgs{}, err 1012 } 1013 1014 switch currArg { 1015 case 0: 1016 var dataAddr uint64 1017 err = decoder.DecodeUint64(&dataAddr) 1018 if err != nil { 1019 return types.MsyncArgs{}, err 1020 } 1021 result.Addr = uintptr(dataAddr) 1022 case 1: 1023 err = decoder.DecodeUint64(&result.Length) 1024 if err != nil { 1025 return types.MsyncArgs{}, err 1026 } 1027 case 2: 1028 err = decoder.DecodeInt32(&result.Flags) 1029 if err != nil { 1030 return types.MsyncArgs{}, err 1031 } 1032 } 1033 } 1034 return result, nil 1035 } 1036 1037 func ParseMincoreArgs(decoder *Decoder) (types.MincoreArgs, error) { 1038 var result types.MincoreArgs 1039 var err error 1040 1041 var numArgs uint8 1042 err = decoder.DecodeUint8(&numArgs) 1043 if err != nil { 1044 return types.MincoreArgs{}, err 1045 } 1046 1047 for arg := 0; arg < int(numArgs); arg++ { 1048 var currArg uint8 1049 err = decoder.DecodeUint8(&currArg) 1050 if err != nil { 1051 return types.MincoreArgs{}, err 1052 } 1053 1054 switch currArg { 1055 case 0: 1056 var dataAddr uint64 1057 err = decoder.DecodeUint64(&dataAddr) 1058 if err != nil { 1059 return types.MincoreArgs{}, err 1060 } 1061 result.Addr = uintptr(dataAddr) 1062 case 1: 1063 err = decoder.DecodeUint64(&result.Length) 1064 if err != nil { 1065 return types.MincoreArgs{}, err 1066 } 1067 case 2: 1068 var dataVec uint64 1069 err = decoder.DecodeUint64(&dataVec) 1070 if err != nil { 1071 return types.MincoreArgs{}, err 1072 } 1073 result.Vec = uintptr(dataVec) 1074 } 1075 } 1076 return result, nil 1077 } 1078 1079 func ParseMadviseArgs(decoder *Decoder) (types.MadviseArgs, error) { 1080 var result types.MadviseArgs 1081 var err error 1082 1083 var numArgs uint8 1084 err = decoder.DecodeUint8(&numArgs) 1085 if err != nil { 1086 return types.MadviseArgs{}, err 1087 } 1088 1089 for arg := 0; arg < int(numArgs); arg++ { 1090 var currArg uint8 1091 err = decoder.DecodeUint8(&currArg) 1092 if err != nil { 1093 return types.MadviseArgs{}, err 1094 } 1095 1096 switch currArg { 1097 case 0: 1098 var dataAddr uint64 1099 err = decoder.DecodeUint64(&dataAddr) 1100 if err != nil { 1101 return types.MadviseArgs{}, err 1102 } 1103 result.Addr = uintptr(dataAddr) 1104 case 1: 1105 err = decoder.DecodeUint64(&result.Length) 1106 if err != nil { 1107 return types.MadviseArgs{}, err 1108 } 1109 case 2: 1110 err = decoder.DecodeInt32(&result.Advice) 1111 if err != nil { 1112 return types.MadviseArgs{}, err 1113 } 1114 } 1115 } 1116 return result, nil 1117 } 1118 1119 func ParseShmgetArgs(decoder *Decoder) (types.ShmgetArgs, error) { 1120 var result types.ShmgetArgs 1121 var err error 1122 1123 var numArgs uint8 1124 err = decoder.DecodeUint8(&numArgs) 1125 if err != nil { 1126 return types.ShmgetArgs{}, err 1127 } 1128 1129 for arg := 0; arg < int(numArgs); arg++ { 1130 var currArg uint8 1131 err = decoder.DecodeUint8(&currArg) 1132 if err != nil { 1133 return types.ShmgetArgs{}, err 1134 } 1135 1136 switch currArg { 1137 case 0: 1138 err = decoder.DecodeInt32(&result.Key) 1139 if err != nil { 1140 return types.ShmgetArgs{}, err 1141 } 1142 case 1: 1143 err = decoder.DecodeUint64(&result.Size) 1144 if err != nil { 1145 return types.ShmgetArgs{}, err 1146 } 1147 case 2: 1148 err = decoder.DecodeInt32(&result.Shmflg) 1149 if err != nil { 1150 return types.ShmgetArgs{}, err 1151 } 1152 } 1153 } 1154 return result, nil 1155 } 1156 1157 func ParseShmatArgs(decoder *Decoder) (types.ShmatArgs, error) { 1158 var result types.ShmatArgs 1159 var err error 1160 1161 var numArgs uint8 1162 err = decoder.DecodeUint8(&numArgs) 1163 if err != nil { 1164 return types.ShmatArgs{}, err 1165 } 1166 1167 for arg := 0; arg < int(numArgs); arg++ { 1168 var currArg uint8 1169 err = decoder.DecodeUint8(&currArg) 1170 if err != nil { 1171 return types.ShmatArgs{}, err 1172 } 1173 1174 switch currArg { 1175 case 0: 1176 err = decoder.DecodeInt32(&result.Shmid) 1177 if err != nil { 1178 return types.ShmatArgs{}, err 1179 } 1180 case 1: 1181 var dataShmaddr uint64 1182 err = decoder.DecodeUint64(&dataShmaddr) 1183 if err != nil { 1184 return types.ShmatArgs{}, err 1185 } 1186 result.Shmaddr = uintptr(dataShmaddr) 1187 case 2: 1188 err = decoder.DecodeInt32(&result.Shmflg) 1189 if err != nil { 1190 return types.ShmatArgs{}, err 1191 } 1192 } 1193 } 1194 return result, nil 1195 } 1196 1197 func ParseShmctlArgs(decoder *Decoder) (types.ShmctlArgs, error) { 1198 var result types.ShmctlArgs 1199 var err error 1200 1201 var numArgs uint8 1202 err = decoder.DecodeUint8(&numArgs) 1203 if err != nil { 1204 return types.ShmctlArgs{}, err 1205 } 1206 1207 for arg := 0; arg < int(numArgs); arg++ { 1208 var currArg uint8 1209 err = decoder.DecodeUint8(&currArg) 1210 if err != nil { 1211 return types.ShmctlArgs{}, err 1212 } 1213 1214 switch currArg { 1215 case 0: 1216 err = decoder.DecodeInt32(&result.Shmid) 1217 if err != nil { 1218 return types.ShmctlArgs{}, err 1219 } 1220 case 1: 1221 err = decoder.DecodeInt32(&result.Cmd) 1222 if err != nil { 1223 return types.ShmctlArgs{}, err 1224 } 1225 case 2: 1226 var dataBuf uint64 1227 err = decoder.DecodeUint64(&dataBuf) 1228 if err != nil { 1229 return types.ShmctlArgs{}, err 1230 } 1231 result.Buf = uintptr(dataBuf) 1232 } 1233 } 1234 return result, nil 1235 } 1236 1237 func ParseDupArgs(decoder *Decoder) (types.DupArgs, error) { 1238 var result types.DupArgs 1239 var err error 1240 1241 var numArgs uint8 1242 err = decoder.DecodeUint8(&numArgs) 1243 if err != nil { 1244 return types.DupArgs{}, err 1245 } 1246 1247 for arg := 0; arg < int(numArgs); arg++ { 1248 var currArg uint8 1249 err = decoder.DecodeUint8(&currArg) 1250 if err != nil { 1251 return types.DupArgs{}, err 1252 } 1253 1254 switch currArg { 1255 case 0: 1256 err = decoder.DecodeInt32(&result.Oldfd) 1257 if err != nil { 1258 return types.DupArgs{}, err 1259 } 1260 } 1261 } 1262 return result, nil 1263 } 1264 1265 func ParseDup2Args(decoder *Decoder) (types.Dup2Args, error) { 1266 var result types.Dup2Args 1267 var err error 1268 1269 var numArgs uint8 1270 err = decoder.DecodeUint8(&numArgs) 1271 if err != nil { 1272 return types.Dup2Args{}, err 1273 } 1274 1275 for arg := 0; arg < int(numArgs); arg++ { 1276 var currArg uint8 1277 err = decoder.DecodeUint8(&currArg) 1278 if err != nil { 1279 return types.Dup2Args{}, err 1280 } 1281 1282 switch currArg { 1283 case 0: 1284 err = decoder.DecodeInt32(&result.Oldfd) 1285 if err != nil { 1286 return types.Dup2Args{}, err 1287 } 1288 case 1: 1289 err = decoder.DecodeInt32(&result.Newfd) 1290 if err != nil { 1291 return types.Dup2Args{}, err 1292 } 1293 } 1294 } 1295 return result, nil 1296 } 1297 1298 func ParsePauseArgs(decoder *Decoder) (types.PauseArgs, error) { 1299 return types.PauseArgs{}, nil 1300 } 1301 1302 func ParseNanosleepArgs(decoder *Decoder) (types.NanosleepArgs, error) { 1303 var result types.NanosleepArgs 1304 var err error 1305 1306 var numArgs uint8 1307 err = decoder.DecodeUint8(&numArgs) 1308 if err != nil { 1309 return types.NanosleepArgs{}, err 1310 } 1311 1312 for arg := 0; arg < int(numArgs); arg++ { 1313 var currArg uint8 1314 err = decoder.DecodeUint8(&currArg) 1315 if err != nil { 1316 return types.NanosleepArgs{}, err 1317 } 1318 1319 switch currArg { 1320 case 0: 1321 result.Req, err = decoder.ReadTimespec() 1322 if err != nil { 1323 return types.NanosleepArgs{}, err 1324 } 1325 case 1: 1326 result.Rem, err = decoder.ReadTimespec() 1327 if err != nil { 1328 return types.NanosleepArgs{}, err 1329 } 1330 } 1331 } 1332 return result, nil 1333 } 1334 1335 func ParseGetitimerArgs(decoder *Decoder) (types.GetitimerArgs, error) { 1336 var result types.GetitimerArgs 1337 var err error 1338 1339 var numArgs uint8 1340 err = decoder.DecodeUint8(&numArgs) 1341 if err != nil { 1342 return types.GetitimerArgs{}, err 1343 } 1344 1345 for arg := 0; arg < int(numArgs); arg++ { 1346 var currArg uint8 1347 err = decoder.DecodeUint8(&currArg) 1348 if err != nil { 1349 return types.GetitimerArgs{}, err 1350 } 1351 1352 switch currArg { 1353 case 0: 1354 err = decoder.DecodeInt32(&result.Which) 1355 if err != nil { 1356 return types.GetitimerArgs{}, err 1357 } 1358 case 1: 1359 var dataCurrValue uint64 1360 err = decoder.DecodeUint64(&dataCurrValue) 1361 if err != nil { 1362 return types.GetitimerArgs{}, err 1363 } 1364 result.CurrValue = uintptr(dataCurrValue) 1365 } 1366 } 1367 return result, nil 1368 } 1369 1370 func ParseAlarmArgs(decoder *Decoder) (types.AlarmArgs, error) { 1371 var result types.AlarmArgs 1372 var err error 1373 1374 var numArgs uint8 1375 err = decoder.DecodeUint8(&numArgs) 1376 if err != nil { 1377 return types.AlarmArgs{}, err 1378 } 1379 1380 for arg := 0; arg < int(numArgs); arg++ { 1381 var currArg uint8 1382 err = decoder.DecodeUint8(&currArg) 1383 if err != nil { 1384 return types.AlarmArgs{}, err 1385 } 1386 1387 switch currArg { 1388 case 0: 1389 err = decoder.DecodeUint32(&result.Seconds) 1390 if err != nil { 1391 return types.AlarmArgs{}, err 1392 } 1393 } 1394 } 1395 return result, nil 1396 } 1397 1398 func ParseSetitimerArgs(decoder *Decoder) (types.SetitimerArgs, error) { 1399 var result types.SetitimerArgs 1400 var err error 1401 1402 var numArgs uint8 1403 err = decoder.DecodeUint8(&numArgs) 1404 if err != nil { 1405 return types.SetitimerArgs{}, err 1406 } 1407 1408 for arg := 0; arg < int(numArgs); arg++ { 1409 var currArg uint8 1410 err = decoder.DecodeUint8(&currArg) 1411 if err != nil { 1412 return types.SetitimerArgs{}, err 1413 } 1414 1415 switch currArg { 1416 case 0: 1417 err = decoder.DecodeInt32(&result.Which) 1418 if err != nil { 1419 return types.SetitimerArgs{}, err 1420 } 1421 case 1: 1422 var dataNewValue uint64 1423 err = decoder.DecodeUint64(&dataNewValue) 1424 if err != nil { 1425 return types.SetitimerArgs{}, err 1426 } 1427 result.NewValue = uintptr(dataNewValue) 1428 case 2: 1429 var dataOldValue uint64 1430 err = decoder.DecodeUint64(&dataOldValue) 1431 if err != nil { 1432 return types.SetitimerArgs{}, err 1433 } 1434 result.OldValue = uintptr(dataOldValue) 1435 } 1436 } 1437 return result, nil 1438 } 1439 1440 func ParseGetpidArgs(decoder *Decoder) (types.GetpidArgs, error) { 1441 return types.GetpidArgs{}, nil 1442 } 1443 1444 func ParseSendfileArgs(decoder *Decoder) (types.SendfileArgs, error) { 1445 var result types.SendfileArgs 1446 var err error 1447 1448 var numArgs uint8 1449 err = decoder.DecodeUint8(&numArgs) 1450 if err != nil { 1451 return types.SendfileArgs{}, err 1452 } 1453 1454 for arg := 0; arg < int(numArgs); arg++ { 1455 var currArg uint8 1456 err = decoder.DecodeUint8(&currArg) 1457 if err != nil { 1458 return types.SendfileArgs{}, err 1459 } 1460 1461 switch currArg { 1462 case 0: 1463 err = decoder.DecodeInt32(&result.OutFd) 1464 if err != nil { 1465 return types.SendfileArgs{}, err 1466 } 1467 case 1: 1468 err = decoder.DecodeInt32(&result.InFd) 1469 if err != nil { 1470 return types.SendfileArgs{}, err 1471 } 1472 case 2: 1473 var dataOffset uint64 1474 err = decoder.DecodeUint64(&dataOffset) 1475 if err != nil { 1476 return types.SendfileArgs{}, err 1477 } 1478 result.Offset = uintptr(dataOffset) 1479 case 3: 1480 err = decoder.DecodeUint64(&result.Count) 1481 if err != nil { 1482 return types.SendfileArgs{}, err 1483 } 1484 } 1485 } 1486 return result, nil 1487 } 1488 1489 func ParseSocketArgs(decoder *Decoder) (types.SocketArgs, error) { 1490 var result types.SocketArgs 1491 var err error 1492 1493 var numArgs uint8 1494 err = decoder.DecodeUint8(&numArgs) 1495 if err != nil { 1496 return types.SocketArgs{}, err 1497 } 1498 1499 for arg := 0; arg < int(numArgs); arg++ { 1500 var currArg uint8 1501 err = decoder.DecodeUint8(&currArg) 1502 if err != nil { 1503 return types.SocketArgs{}, err 1504 } 1505 1506 switch currArg { 1507 case 0: 1508 err = decoder.DecodeInt32(&result.Domain) 1509 if err != nil { 1510 return types.SocketArgs{}, err 1511 } 1512 case 1: 1513 err = decoder.DecodeInt32(&result.Type) 1514 if err != nil { 1515 return types.SocketArgs{}, err 1516 } 1517 case 2: 1518 err = decoder.DecodeInt32(&result.Protocol) 1519 if err != nil { 1520 return types.SocketArgs{}, err 1521 } 1522 } 1523 } 1524 return result, nil 1525 } 1526 1527 func ParseConnectArgs(decoder *Decoder) (types.ConnectArgs, error) { 1528 var result types.ConnectArgs 1529 var err error 1530 1531 var numArgs uint8 1532 err = decoder.DecodeUint8(&numArgs) 1533 if err != nil { 1534 return types.ConnectArgs{}, err 1535 } 1536 1537 for arg := 0; arg < int(numArgs); arg++ { 1538 var currArg uint8 1539 err = decoder.DecodeUint8(&currArg) 1540 if err != nil { 1541 return types.ConnectArgs{}, err 1542 } 1543 1544 switch currArg { 1545 case 0: 1546 err = decoder.DecodeInt32(&result.Sockfd) 1547 if err != nil { 1548 return types.ConnectArgs{}, err 1549 } 1550 case 1: 1551 result.Addr, err = decoder.ReadSockaddrFromBuff() 1552 if err != nil { 1553 return types.ConnectArgs{}, err 1554 } 1555 case 2: 1556 err = decoder.DecodeInt32(&result.Addrlen) 1557 if err != nil { 1558 return types.ConnectArgs{}, err 1559 } 1560 } 1561 } 1562 return result, nil 1563 } 1564 1565 func ParseAcceptArgs(decoder *Decoder) (types.AcceptArgs, error) { 1566 var result types.AcceptArgs 1567 var err error 1568 1569 var numArgs uint8 1570 err = decoder.DecodeUint8(&numArgs) 1571 if err != nil { 1572 return types.AcceptArgs{}, err 1573 } 1574 1575 for arg := 0; arg < int(numArgs); arg++ { 1576 var currArg uint8 1577 err = decoder.DecodeUint8(&currArg) 1578 if err != nil { 1579 return types.AcceptArgs{}, err 1580 } 1581 1582 switch currArg { 1583 case 0: 1584 err = decoder.DecodeInt32(&result.Sockfd) 1585 if err != nil { 1586 return types.AcceptArgs{}, err 1587 } 1588 case 1: 1589 result.Addr, err = decoder.ReadSockaddrFromBuff() 1590 if err != nil { 1591 return types.AcceptArgs{}, err 1592 } 1593 case 2: 1594 var dataAddrlen uint64 1595 err = decoder.DecodeUint64(&dataAddrlen) 1596 if err != nil { 1597 return types.AcceptArgs{}, err 1598 } 1599 result.Addrlen = uintptr(dataAddrlen) 1600 } 1601 } 1602 return result, nil 1603 } 1604 1605 func ParseSendtoArgs(decoder *Decoder) (types.SendtoArgs, error) { 1606 var result types.SendtoArgs 1607 var err error 1608 1609 var numArgs uint8 1610 err = decoder.DecodeUint8(&numArgs) 1611 if err != nil { 1612 return types.SendtoArgs{}, err 1613 } 1614 1615 for arg := 0; arg < int(numArgs); arg++ { 1616 var currArg uint8 1617 err = decoder.DecodeUint8(&currArg) 1618 if err != nil { 1619 return types.SendtoArgs{}, err 1620 } 1621 1622 switch currArg { 1623 case 0: 1624 err = decoder.DecodeInt32(&result.Sockfd) 1625 if err != nil { 1626 return types.SendtoArgs{}, err 1627 } 1628 case 1: 1629 var dataBuf uint64 1630 err = decoder.DecodeUint64(&dataBuf) 1631 if err != nil { 1632 return types.SendtoArgs{}, err 1633 } 1634 result.Buf = uintptr(dataBuf) 1635 case 2: 1636 err = decoder.DecodeUint64(&result.Len) 1637 if err != nil { 1638 return types.SendtoArgs{}, err 1639 } 1640 case 3: 1641 err = decoder.DecodeInt32(&result.Flags) 1642 if err != nil { 1643 return types.SendtoArgs{}, err 1644 } 1645 case 4: 1646 result.DestAddr, err = decoder.ReadSockaddrFromBuff() 1647 if err != nil { 1648 return types.SendtoArgs{}, err 1649 } 1650 case 5: 1651 err = decoder.DecodeInt32(&result.Addrlen) 1652 if err != nil { 1653 return types.SendtoArgs{}, err 1654 } 1655 } 1656 } 1657 return result, nil 1658 } 1659 1660 func ParseRecvfromArgs(decoder *Decoder) (types.RecvfromArgs, error) { 1661 var result types.RecvfromArgs 1662 var err error 1663 1664 var numArgs uint8 1665 err = decoder.DecodeUint8(&numArgs) 1666 if err != nil { 1667 return types.RecvfromArgs{}, err 1668 } 1669 1670 for arg := 0; arg < int(numArgs); arg++ { 1671 var currArg uint8 1672 err = decoder.DecodeUint8(&currArg) 1673 if err != nil { 1674 return types.RecvfromArgs{}, err 1675 } 1676 1677 switch currArg { 1678 case 0: 1679 err = decoder.DecodeInt32(&result.Sockfd) 1680 if err != nil { 1681 return types.RecvfromArgs{}, err 1682 } 1683 case 1: 1684 var dataBuf uint64 1685 err = decoder.DecodeUint64(&dataBuf) 1686 if err != nil { 1687 return types.RecvfromArgs{}, err 1688 } 1689 result.Buf = uintptr(dataBuf) 1690 case 2: 1691 err = decoder.DecodeUint64(&result.Len) 1692 if err != nil { 1693 return types.RecvfromArgs{}, err 1694 } 1695 case 3: 1696 err = decoder.DecodeInt32(&result.Flags) 1697 if err != nil { 1698 return types.RecvfromArgs{}, err 1699 } 1700 case 4: 1701 result.SrcAddr, err = decoder.ReadSockaddrFromBuff() 1702 if err != nil { 1703 return types.RecvfromArgs{}, err 1704 } 1705 case 5: 1706 var dataAddrlen uint64 1707 err = decoder.DecodeUint64(&dataAddrlen) 1708 if err != nil { 1709 return types.RecvfromArgs{}, err 1710 } 1711 result.Addrlen = uintptr(dataAddrlen) 1712 } 1713 } 1714 return result, nil 1715 } 1716 1717 func ParseSendmsgArgs(decoder *Decoder) (types.SendmsgArgs, error) { 1718 var result types.SendmsgArgs 1719 var err error 1720 1721 var numArgs uint8 1722 err = decoder.DecodeUint8(&numArgs) 1723 if err != nil { 1724 return types.SendmsgArgs{}, err 1725 } 1726 1727 for arg := 0; arg < int(numArgs); arg++ { 1728 var currArg uint8 1729 err = decoder.DecodeUint8(&currArg) 1730 if err != nil { 1731 return types.SendmsgArgs{}, err 1732 } 1733 1734 switch currArg { 1735 case 0: 1736 err = decoder.DecodeInt32(&result.Sockfd) 1737 if err != nil { 1738 return types.SendmsgArgs{}, err 1739 } 1740 case 1: 1741 var dataMsg uint64 1742 err = decoder.DecodeUint64(&dataMsg) 1743 if err != nil { 1744 return types.SendmsgArgs{}, err 1745 } 1746 result.Msg = uintptr(dataMsg) 1747 case 2: 1748 err = decoder.DecodeInt32(&result.Flags) 1749 if err != nil { 1750 return types.SendmsgArgs{}, err 1751 } 1752 } 1753 } 1754 return result, nil 1755 } 1756 1757 func ParseRecvmsgArgs(decoder *Decoder) (types.RecvmsgArgs, error) { 1758 var result types.RecvmsgArgs 1759 var err error 1760 1761 var numArgs uint8 1762 err = decoder.DecodeUint8(&numArgs) 1763 if err != nil { 1764 return types.RecvmsgArgs{}, err 1765 } 1766 1767 for arg := 0; arg < int(numArgs); arg++ { 1768 var currArg uint8 1769 err = decoder.DecodeUint8(&currArg) 1770 if err != nil { 1771 return types.RecvmsgArgs{}, err 1772 } 1773 1774 switch currArg { 1775 case 0: 1776 err = decoder.DecodeInt32(&result.Sockfd) 1777 if err != nil { 1778 return types.RecvmsgArgs{}, err 1779 } 1780 case 1: 1781 var dataMsg uint64 1782 err = decoder.DecodeUint64(&dataMsg) 1783 if err != nil { 1784 return types.RecvmsgArgs{}, err 1785 } 1786 result.Msg = uintptr(dataMsg) 1787 case 2: 1788 err = decoder.DecodeInt32(&result.Flags) 1789 if err != nil { 1790 return types.RecvmsgArgs{}, err 1791 } 1792 } 1793 } 1794 return result, nil 1795 } 1796 1797 func ParseShutdownArgs(decoder *Decoder) (types.ShutdownArgs, error) { 1798 var result types.ShutdownArgs 1799 var err error 1800 1801 var numArgs uint8 1802 err = decoder.DecodeUint8(&numArgs) 1803 if err != nil { 1804 return types.ShutdownArgs{}, err 1805 } 1806 1807 for arg := 0; arg < int(numArgs); arg++ { 1808 var currArg uint8 1809 err = decoder.DecodeUint8(&currArg) 1810 if err != nil { 1811 return types.ShutdownArgs{}, err 1812 } 1813 1814 switch currArg { 1815 case 0: 1816 err = decoder.DecodeInt32(&result.Sockfd) 1817 if err != nil { 1818 return types.ShutdownArgs{}, err 1819 } 1820 case 1: 1821 err = decoder.DecodeInt32(&result.How) 1822 if err != nil { 1823 return types.ShutdownArgs{}, err 1824 } 1825 } 1826 } 1827 return result, nil 1828 } 1829 1830 func ParseBindArgs(decoder *Decoder) (types.BindArgs, error) { 1831 var result types.BindArgs 1832 var err error 1833 1834 var numArgs uint8 1835 err = decoder.DecodeUint8(&numArgs) 1836 if err != nil { 1837 return types.BindArgs{}, err 1838 } 1839 1840 for arg := 0; arg < int(numArgs); arg++ { 1841 var currArg uint8 1842 err = decoder.DecodeUint8(&currArg) 1843 if err != nil { 1844 return types.BindArgs{}, err 1845 } 1846 1847 switch currArg { 1848 case 0: 1849 err = decoder.DecodeInt32(&result.Sockfd) 1850 if err != nil { 1851 return types.BindArgs{}, err 1852 } 1853 case 1: 1854 result.Addr, err = decoder.ReadSockaddrFromBuff() 1855 if err != nil { 1856 return types.BindArgs{}, err 1857 } 1858 case 2: 1859 err = decoder.DecodeInt32(&result.Addrlen) 1860 if err != nil { 1861 return types.BindArgs{}, err 1862 } 1863 } 1864 } 1865 return result, nil 1866 } 1867 1868 func ParseListenArgs(decoder *Decoder) (types.ListenArgs, error) { 1869 var result types.ListenArgs 1870 var err error 1871 1872 var numArgs uint8 1873 err = decoder.DecodeUint8(&numArgs) 1874 if err != nil { 1875 return types.ListenArgs{}, err 1876 } 1877 1878 for arg := 0; arg < int(numArgs); arg++ { 1879 var currArg uint8 1880 err = decoder.DecodeUint8(&currArg) 1881 if err != nil { 1882 return types.ListenArgs{}, err 1883 } 1884 1885 switch currArg { 1886 case 0: 1887 err = decoder.DecodeInt32(&result.Sockfd) 1888 if err != nil { 1889 return types.ListenArgs{}, err 1890 } 1891 case 1: 1892 err = decoder.DecodeInt32(&result.Backlog) 1893 if err != nil { 1894 return types.ListenArgs{}, err 1895 } 1896 } 1897 } 1898 return result, nil 1899 } 1900 1901 func ParseGetsocknameArgs(decoder *Decoder) (types.GetsocknameArgs, error) { 1902 var result types.GetsocknameArgs 1903 var err error 1904 1905 var numArgs uint8 1906 err = decoder.DecodeUint8(&numArgs) 1907 if err != nil { 1908 return types.GetsocknameArgs{}, err 1909 } 1910 1911 for arg := 0; arg < int(numArgs); arg++ { 1912 var currArg uint8 1913 err = decoder.DecodeUint8(&currArg) 1914 if err != nil { 1915 return types.GetsocknameArgs{}, err 1916 } 1917 1918 switch currArg { 1919 case 0: 1920 err = decoder.DecodeInt32(&result.Sockfd) 1921 if err != nil { 1922 return types.GetsocknameArgs{}, err 1923 } 1924 case 1: 1925 result.Addr, err = decoder.ReadSockaddrFromBuff() 1926 if err != nil { 1927 return types.GetsocknameArgs{}, err 1928 } 1929 case 2: 1930 var dataAddrlen uint64 1931 err = decoder.DecodeUint64(&dataAddrlen) 1932 if err != nil { 1933 return types.GetsocknameArgs{}, err 1934 } 1935 result.Addrlen = uintptr(dataAddrlen) 1936 } 1937 } 1938 return result, nil 1939 } 1940 1941 func ParseGetpeernameArgs(decoder *Decoder) (types.GetpeernameArgs, error) { 1942 var result types.GetpeernameArgs 1943 var err error 1944 1945 var numArgs uint8 1946 err = decoder.DecodeUint8(&numArgs) 1947 if err != nil { 1948 return types.GetpeernameArgs{}, err 1949 } 1950 1951 for arg := 0; arg < int(numArgs); arg++ { 1952 var currArg uint8 1953 err = decoder.DecodeUint8(&currArg) 1954 if err != nil { 1955 return types.GetpeernameArgs{}, err 1956 } 1957 1958 switch currArg { 1959 case 0: 1960 err = decoder.DecodeInt32(&result.Sockfd) 1961 if err != nil { 1962 return types.GetpeernameArgs{}, err 1963 } 1964 case 1: 1965 result.Addr, err = decoder.ReadSockaddrFromBuff() 1966 if err != nil { 1967 return types.GetpeernameArgs{}, err 1968 } 1969 case 2: 1970 var dataAddrlen uint64 1971 err = decoder.DecodeUint64(&dataAddrlen) 1972 if err != nil { 1973 return types.GetpeernameArgs{}, err 1974 } 1975 result.Addrlen = uintptr(dataAddrlen) 1976 } 1977 } 1978 return result, nil 1979 } 1980 1981 func ParseSocketpairArgs(decoder *Decoder) (types.SocketpairArgs, error) { 1982 var result types.SocketpairArgs 1983 var err error 1984 1985 var numArgs uint8 1986 err = decoder.DecodeUint8(&numArgs) 1987 if err != nil { 1988 return types.SocketpairArgs{}, err 1989 } 1990 1991 for arg := 0; arg < int(numArgs); arg++ { 1992 var currArg uint8 1993 err = decoder.DecodeUint8(&currArg) 1994 if err != nil { 1995 return types.SocketpairArgs{}, err 1996 } 1997 1998 switch currArg { 1999 case 0: 2000 err = decoder.DecodeInt32(&result.Domain) 2001 if err != nil { 2002 return types.SocketpairArgs{}, err 2003 } 2004 case 1: 2005 err = decoder.DecodeInt32(&result.Type) 2006 if err != nil { 2007 return types.SocketpairArgs{}, err 2008 } 2009 case 2: 2010 err = decoder.DecodeInt32(&result.Protocol) 2011 if err != nil { 2012 return types.SocketpairArgs{}, err 2013 } 2014 case 3: 2015 err = decoder.DecodeIntArray(result.Sv[:], 2) 2016 if err != nil { 2017 return types.SocketpairArgs{}, err 2018 } 2019 } 2020 } 2021 return result, nil 2022 } 2023 2024 func ParseSetsockoptArgs(decoder *Decoder) (types.SetsockoptArgs, error) { 2025 var result types.SetsockoptArgs 2026 var err error 2027 2028 var numArgs uint8 2029 err = decoder.DecodeUint8(&numArgs) 2030 if err != nil { 2031 return types.SetsockoptArgs{}, err 2032 } 2033 2034 for arg := 0; arg < int(numArgs); arg++ { 2035 var currArg uint8 2036 err = decoder.DecodeUint8(&currArg) 2037 if err != nil { 2038 return types.SetsockoptArgs{}, err 2039 } 2040 2041 switch currArg { 2042 case 0: 2043 err = decoder.DecodeInt32(&result.Sockfd) 2044 if err != nil { 2045 return types.SetsockoptArgs{}, err 2046 } 2047 case 1: 2048 err = decoder.DecodeInt32(&result.Level) 2049 if err != nil { 2050 return types.SetsockoptArgs{}, err 2051 } 2052 case 2: 2053 err = decoder.DecodeInt32(&result.Optname) 2054 if err != nil { 2055 return types.SetsockoptArgs{}, err 2056 } 2057 case 3: 2058 var dataOptval uint64 2059 err = decoder.DecodeUint64(&dataOptval) 2060 if err != nil { 2061 return types.SetsockoptArgs{}, err 2062 } 2063 result.Optval = uintptr(dataOptval) 2064 case 4: 2065 err = decoder.DecodeInt32(&result.Optlen) 2066 if err != nil { 2067 return types.SetsockoptArgs{}, err 2068 } 2069 } 2070 } 2071 return result, nil 2072 } 2073 2074 func ParseGetsockoptArgs(decoder *Decoder) (types.GetsockoptArgs, error) { 2075 var result types.GetsockoptArgs 2076 var err error 2077 2078 var numArgs uint8 2079 err = decoder.DecodeUint8(&numArgs) 2080 if err != nil { 2081 return types.GetsockoptArgs{}, err 2082 } 2083 2084 for arg := 0; arg < int(numArgs); arg++ { 2085 var currArg uint8 2086 err = decoder.DecodeUint8(&currArg) 2087 if err != nil { 2088 return types.GetsockoptArgs{}, err 2089 } 2090 2091 switch currArg { 2092 case 0: 2093 err = decoder.DecodeInt32(&result.Sockfd) 2094 if err != nil { 2095 return types.GetsockoptArgs{}, err 2096 } 2097 case 1: 2098 err = decoder.DecodeInt32(&result.Level) 2099 if err != nil { 2100 return types.GetsockoptArgs{}, err 2101 } 2102 case 2: 2103 err = decoder.DecodeInt32(&result.Optname) 2104 if err != nil { 2105 return types.GetsockoptArgs{}, err 2106 } 2107 case 3: 2108 var dataOptval uint64 2109 err = decoder.DecodeUint64(&dataOptval) 2110 if err != nil { 2111 return types.GetsockoptArgs{}, err 2112 } 2113 result.Optval = uintptr(dataOptval) 2114 case 4: 2115 var dataOptlen uint64 2116 err = decoder.DecodeUint64(&dataOptlen) 2117 if err != nil { 2118 return types.GetsockoptArgs{}, err 2119 } 2120 result.Optlen = uintptr(dataOptlen) 2121 } 2122 } 2123 return result, nil 2124 } 2125 2126 func ParseCloneArgs(decoder *Decoder) (types.CloneArgs, error) { 2127 var result types.CloneArgs 2128 var err error 2129 2130 var numArgs uint8 2131 err = decoder.DecodeUint8(&numArgs) 2132 if err != nil { 2133 return types.CloneArgs{}, err 2134 } 2135 2136 for arg := 0; arg < int(numArgs); arg++ { 2137 var currArg uint8 2138 err = decoder.DecodeUint8(&currArg) 2139 if err != nil { 2140 return types.CloneArgs{}, err 2141 } 2142 2143 switch currArg { 2144 case 0: 2145 err = decoder.DecodeUint64(&result.Flags) 2146 if err != nil { 2147 return types.CloneArgs{}, err 2148 } 2149 case 1: 2150 var dataStack uint64 2151 err = decoder.DecodeUint64(&dataStack) 2152 if err != nil { 2153 return types.CloneArgs{}, err 2154 } 2155 result.Stack = uintptr(dataStack) 2156 case 2: 2157 var dataParentTid uint64 2158 err = decoder.DecodeUint64(&dataParentTid) 2159 if err != nil { 2160 return types.CloneArgs{}, err 2161 } 2162 result.ParentTid = uintptr(dataParentTid) 2163 case 3: 2164 var dataChildTid uint64 2165 err = decoder.DecodeUint64(&dataChildTid) 2166 if err != nil { 2167 return types.CloneArgs{}, err 2168 } 2169 result.ChildTid = uintptr(dataChildTid) 2170 case 4: 2171 err = decoder.DecodeUint64(&result.Tls) 2172 if err != nil { 2173 return types.CloneArgs{}, err 2174 } 2175 } 2176 } 2177 return result, nil 2178 } 2179 2180 func ParseForkArgs(decoder *Decoder) (types.ForkArgs, error) { 2181 return types.ForkArgs{}, nil 2182 } 2183 2184 func ParseVforkArgs(decoder *Decoder) (types.VforkArgs, error) { 2185 return types.VforkArgs{}, nil 2186 } 2187 2188 func ParseExecveArgs(decoder *Decoder) (types.ExecveArgs, error) { 2189 var result types.ExecveArgs 2190 var err error 2191 2192 var numArgs uint8 2193 err = decoder.DecodeUint8(&numArgs) 2194 if err != nil { 2195 return types.ExecveArgs{}, err 2196 } 2197 2198 for arg := 0; arg < int(numArgs); arg++ { 2199 var currArg uint8 2200 err = decoder.DecodeUint8(&currArg) 2201 if err != nil { 2202 return types.ExecveArgs{}, err 2203 } 2204 2205 switch currArg { 2206 case 0: 2207 result.Pathname, err = decoder.ReadStringFromBuff() 2208 if err != nil { 2209 return types.ExecveArgs{}, err 2210 } 2211 case 1: 2212 result.Argv, err = decoder.ReadStringArrayFromBuff() 2213 if err != nil { 2214 return types.ExecveArgs{}, err 2215 } 2216 case 2: 2217 result.Envp, err = decoder.ReadStringArrayFromBuff() 2218 if err != nil { 2219 return types.ExecveArgs{}, err 2220 } 2221 } 2222 } 2223 return result, nil 2224 } 2225 2226 func ParseExitArgs(decoder *Decoder) (types.ExitArgs, error) { 2227 var result types.ExitArgs 2228 var err error 2229 2230 var numArgs uint8 2231 err = decoder.DecodeUint8(&numArgs) 2232 if err != nil { 2233 return types.ExitArgs{}, err 2234 } 2235 2236 for arg := 0; arg < int(numArgs); arg++ { 2237 var currArg uint8 2238 err = decoder.DecodeUint8(&currArg) 2239 if err != nil { 2240 return types.ExitArgs{}, err 2241 } 2242 2243 switch currArg { 2244 case 0: 2245 err = decoder.DecodeInt32(&result.Status) 2246 if err != nil { 2247 return types.ExitArgs{}, err 2248 } 2249 } 2250 } 2251 return result, nil 2252 } 2253 2254 func ParseWait4Args(decoder *Decoder) (types.Wait4Args, error) { 2255 var result types.Wait4Args 2256 var err error 2257 2258 var numArgs uint8 2259 err = decoder.DecodeUint8(&numArgs) 2260 if err != nil { 2261 return types.Wait4Args{}, err 2262 } 2263 2264 for arg := 0; arg < int(numArgs); arg++ { 2265 var currArg uint8 2266 err = decoder.DecodeUint8(&currArg) 2267 if err != nil { 2268 return types.Wait4Args{}, err 2269 } 2270 2271 switch currArg { 2272 case 0: 2273 err = decoder.DecodeInt32(&result.Pid) 2274 if err != nil { 2275 return types.Wait4Args{}, err 2276 } 2277 case 1: 2278 var dataWstatus uint64 2279 err = decoder.DecodeUint64(&dataWstatus) 2280 if err != nil { 2281 return types.Wait4Args{}, err 2282 } 2283 result.Wstatus = uintptr(dataWstatus) 2284 case 2: 2285 err = decoder.DecodeInt32(&result.Options) 2286 if err != nil { 2287 return types.Wait4Args{}, err 2288 } 2289 case 3: 2290 var dataRusage uint64 2291 err = decoder.DecodeUint64(&dataRusage) 2292 if err != nil { 2293 return types.Wait4Args{}, err 2294 } 2295 result.Rusage = uintptr(dataRusage) 2296 } 2297 } 2298 return result, nil 2299 } 2300 2301 func ParseKillArgs(decoder *Decoder) (types.KillArgs, error) { 2302 var result types.KillArgs 2303 var err error 2304 2305 var numArgs uint8 2306 err = decoder.DecodeUint8(&numArgs) 2307 if err != nil { 2308 return types.KillArgs{}, err 2309 } 2310 2311 for arg := 0; arg < int(numArgs); arg++ { 2312 var currArg uint8 2313 err = decoder.DecodeUint8(&currArg) 2314 if err != nil { 2315 return types.KillArgs{}, err 2316 } 2317 2318 switch currArg { 2319 case 0: 2320 err = decoder.DecodeInt32(&result.Pid) 2321 if err != nil { 2322 return types.KillArgs{}, err 2323 } 2324 case 1: 2325 err = decoder.DecodeInt32(&result.Sig) 2326 if err != nil { 2327 return types.KillArgs{}, err 2328 } 2329 } 2330 } 2331 return result, nil 2332 } 2333 2334 func ParseUnameArgs(decoder *Decoder) (types.UnameArgs, error) { 2335 var result types.UnameArgs 2336 var err error 2337 2338 var numArgs uint8 2339 err = decoder.DecodeUint8(&numArgs) 2340 if err != nil { 2341 return types.UnameArgs{}, err 2342 } 2343 2344 for arg := 0; arg < int(numArgs); arg++ { 2345 var currArg uint8 2346 err = decoder.DecodeUint8(&currArg) 2347 if err != nil { 2348 return types.UnameArgs{}, err 2349 } 2350 2351 switch currArg { 2352 case 0: 2353 var dataBuf uint64 2354 err = decoder.DecodeUint64(&dataBuf) 2355 if err != nil { 2356 return types.UnameArgs{}, err 2357 } 2358 result.Buf = uintptr(dataBuf) 2359 } 2360 } 2361 return result, nil 2362 } 2363 2364 func ParseSemgetArgs(decoder *Decoder) (types.SemgetArgs, error) { 2365 var result types.SemgetArgs 2366 var err error 2367 2368 var numArgs uint8 2369 err = decoder.DecodeUint8(&numArgs) 2370 if err != nil { 2371 return types.SemgetArgs{}, err 2372 } 2373 2374 for arg := 0; arg < int(numArgs); arg++ { 2375 var currArg uint8 2376 err = decoder.DecodeUint8(&currArg) 2377 if err != nil { 2378 return types.SemgetArgs{}, err 2379 } 2380 2381 switch currArg { 2382 case 0: 2383 err = decoder.DecodeInt32(&result.Key) 2384 if err != nil { 2385 return types.SemgetArgs{}, err 2386 } 2387 case 1: 2388 err = decoder.DecodeInt32(&result.Nsems) 2389 if err != nil { 2390 return types.SemgetArgs{}, err 2391 } 2392 case 2: 2393 err = decoder.DecodeInt32(&result.Semflg) 2394 if err != nil { 2395 return types.SemgetArgs{}, err 2396 } 2397 } 2398 } 2399 return result, nil 2400 } 2401 2402 func ParseSemopArgs(decoder *Decoder) (types.SemopArgs, error) { 2403 var result types.SemopArgs 2404 var err error 2405 2406 var numArgs uint8 2407 err = decoder.DecodeUint8(&numArgs) 2408 if err != nil { 2409 return types.SemopArgs{}, err 2410 } 2411 2412 for arg := 0; arg < int(numArgs); arg++ { 2413 var currArg uint8 2414 err = decoder.DecodeUint8(&currArg) 2415 if err != nil { 2416 return types.SemopArgs{}, err 2417 } 2418 2419 switch currArg { 2420 case 0: 2421 err = decoder.DecodeInt32(&result.Semid) 2422 if err != nil { 2423 return types.SemopArgs{}, err 2424 } 2425 case 1: 2426 var dataSops uint64 2427 err = decoder.DecodeUint64(&dataSops) 2428 if err != nil { 2429 return types.SemopArgs{}, err 2430 } 2431 result.Sops = uintptr(dataSops) 2432 case 2: 2433 err = decoder.DecodeUint64(&result.Nsops) 2434 if err != nil { 2435 return types.SemopArgs{}, err 2436 } 2437 } 2438 } 2439 return result, nil 2440 } 2441 2442 func ParseSemctlArgs(decoder *Decoder) (types.SemctlArgs, error) { 2443 var result types.SemctlArgs 2444 var err error 2445 2446 var numArgs uint8 2447 err = decoder.DecodeUint8(&numArgs) 2448 if err != nil { 2449 return types.SemctlArgs{}, err 2450 } 2451 2452 for arg := 0; arg < int(numArgs); arg++ { 2453 var currArg uint8 2454 err = decoder.DecodeUint8(&currArg) 2455 if err != nil { 2456 return types.SemctlArgs{}, err 2457 } 2458 2459 switch currArg { 2460 case 0: 2461 err = decoder.DecodeInt32(&result.Semid) 2462 if err != nil { 2463 return types.SemctlArgs{}, err 2464 } 2465 case 1: 2466 err = decoder.DecodeInt32(&result.Semnum) 2467 if err != nil { 2468 return types.SemctlArgs{}, err 2469 } 2470 case 2: 2471 err = decoder.DecodeInt32(&result.Cmd) 2472 if err != nil { 2473 return types.SemctlArgs{}, err 2474 } 2475 case 3: 2476 err = decoder.DecodeUint64(&result.Arg) 2477 if err != nil { 2478 return types.SemctlArgs{}, err 2479 } 2480 } 2481 } 2482 return result, nil 2483 } 2484 2485 func ParseShmdtArgs(decoder *Decoder) (types.ShmdtArgs, error) { 2486 var result types.ShmdtArgs 2487 var err error 2488 2489 var numArgs uint8 2490 err = decoder.DecodeUint8(&numArgs) 2491 if err != nil { 2492 return types.ShmdtArgs{}, err 2493 } 2494 2495 for arg := 0; arg < int(numArgs); arg++ { 2496 var currArg uint8 2497 err = decoder.DecodeUint8(&currArg) 2498 if err != nil { 2499 return types.ShmdtArgs{}, err 2500 } 2501 2502 switch currArg { 2503 case 0: 2504 var dataShmaddr uint64 2505 err = decoder.DecodeUint64(&dataShmaddr) 2506 if err != nil { 2507 return types.ShmdtArgs{}, err 2508 } 2509 result.Shmaddr = uintptr(dataShmaddr) 2510 } 2511 } 2512 return result, nil 2513 } 2514 2515 func ParseMsggetArgs(decoder *Decoder) (types.MsggetArgs, error) { 2516 var result types.MsggetArgs 2517 var err error 2518 2519 var numArgs uint8 2520 err = decoder.DecodeUint8(&numArgs) 2521 if err != nil { 2522 return types.MsggetArgs{}, err 2523 } 2524 2525 for arg := 0; arg < int(numArgs); arg++ { 2526 var currArg uint8 2527 err = decoder.DecodeUint8(&currArg) 2528 if err != nil { 2529 return types.MsggetArgs{}, err 2530 } 2531 2532 switch currArg { 2533 case 0: 2534 err = decoder.DecodeInt32(&result.Key) 2535 if err != nil { 2536 return types.MsggetArgs{}, err 2537 } 2538 case 1: 2539 err = decoder.DecodeInt32(&result.Msgflg) 2540 if err != nil { 2541 return types.MsggetArgs{}, err 2542 } 2543 } 2544 } 2545 return result, nil 2546 } 2547 2548 func ParseMsgsndArgs(decoder *Decoder) (types.MsgsndArgs, error) { 2549 var result types.MsgsndArgs 2550 var err error 2551 2552 var numArgs uint8 2553 err = decoder.DecodeUint8(&numArgs) 2554 if err != nil { 2555 return types.MsgsndArgs{}, err 2556 } 2557 2558 for arg := 0; arg < int(numArgs); arg++ { 2559 var currArg uint8 2560 err = decoder.DecodeUint8(&currArg) 2561 if err != nil { 2562 return types.MsgsndArgs{}, err 2563 } 2564 2565 switch currArg { 2566 case 0: 2567 err = decoder.DecodeInt32(&result.Msqid) 2568 if err != nil { 2569 return types.MsgsndArgs{}, err 2570 } 2571 case 1: 2572 var dataMsgp uint64 2573 err = decoder.DecodeUint64(&dataMsgp) 2574 if err != nil { 2575 return types.MsgsndArgs{}, err 2576 } 2577 result.Msgp = uintptr(dataMsgp) 2578 case 2: 2579 err = decoder.DecodeUint64(&result.Msgsz) 2580 if err != nil { 2581 return types.MsgsndArgs{}, err 2582 } 2583 case 3: 2584 err = decoder.DecodeInt32(&result.Msgflg) 2585 if err != nil { 2586 return types.MsgsndArgs{}, err 2587 } 2588 } 2589 } 2590 return result, nil 2591 } 2592 2593 func ParseMsgrcvArgs(decoder *Decoder) (types.MsgrcvArgs, error) { 2594 var result types.MsgrcvArgs 2595 var err error 2596 2597 var numArgs uint8 2598 err = decoder.DecodeUint8(&numArgs) 2599 if err != nil { 2600 return types.MsgrcvArgs{}, err 2601 } 2602 2603 for arg := 0; arg < int(numArgs); arg++ { 2604 var currArg uint8 2605 err = decoder.DecodeUint8(&currArg) 2606 if err != nil { 2607 return types.MsgrcvArgs{}, err 2608 } 2609 2610 switch currArg { 2611 case 0: 2612 err = decoder.DecodeInt32(&result.Msqid) 2613 if err != nil { 2614 return types.MsgrcvArgs{}, err 2615 } 2616 case 1: 2617 var dataMsgp uint64 2618 err = decoder.DecodeUint64(&dataMsgp) 2619 if err != nil { 2620 return types.MsgrcvArgs{}, err 2621 } 2622 result.Msgp = uintptr(dataMsgp) 2623 case 2: 2624 err = decoder.DecodeUint64(&result.Msgsz) 2625 if err != nil { 2626 return types.MsgrcvArgs{}, err 2627 } 2628 case 3: 2629 err = decoder.DecodeInt64(&result.Msgtyp) 2630 if err != nil { 2631 return types.MsgrcvArgs{}, err 2632 } 2633 case 4: 2634 err = decoder.DecodeInt32(&result.Msgflg) 2635 if err != nil { 2636 return types.MsgrcvArgs{}, err 2637 } 2638 } 2639 } 2640 return result, nil 2641 } 2642 2643 func ParseMsgctlArgs(decoder *Decoder) (types.MsgctlArgs, error) { 2644 var result types.MsgctlArgs 2645 var err error 2646 2647 var numArgs uint8 2648 err = decoder.DecodeUint8(&numArgs) 2649 if err != nil { 2650 return types.MsgctlArgs{}, err 2651 } 2652 2653 for arg := 0; arg < int(numArgs); arg++ { 2654 var currArg uint8 2655 err = decoder.DecodeUint8(&currArg) 2656 if err != nil { 2657 return types.MsgctlArgs{}, err 2658 } 2659 2660 switch currArg { 2661 case 0: 2662 err = decoder.DecodeInt32(&result.Msqid) 2663 if err != nil { 2664 return types.MsgctlArgs{}, err 2665 } 2666 case 1: 2667 err = decoder.DecodeInt32(&result.Cmd) 2668 if err != nil { 2669 return types.MsgctlArgs{}, err 2670 } 2671 case 2: 2672 var dataBuf uint64 2673 err = decoder.DecodeUint64(&dataBuf) 2674 if err != nil { 2675 return types.MsgctlArgs{}, err 2676 } 2677 result.Buf = uintptr(dataBuf) 2678 } 2679 } 2680 return result, nil 2681 } 2682 2683 func ParseFcntlArgs(decoder *Decoder) (types.FcntlArgs, error) { 2684 var result types.FcntlArgs 2685 var err error 2686 2687 var numArgs uint8 2688 err = decoder.DecodeUint8(&numArgs) 2689 if err != nil { 2690 return types.FcntlArgs{}, err 2691 } 2692 2693 for arg := 0; arg < int(numArgs); arg++ { 2694 var currArg uint8 2695 err = decoder.DecodeUint8(&currArg) 2696 if err != nil { 2697 return types.FcntlArgs{}, err 2698 } 2699 2700 switch currArg { 2701 case 0: 2702 err = decoder.DecodeInt32(&result.Fd) 2703 if err != nil { 2704 return types.FcntlArgs{}, err 2705 } 2706 case 1: 2707 err = decoder.DecodeInt32(&result.Cmd) 2708 if err != nil { 2709 return types.FcntlArgs{}, err 2710 } 2711 case 2: 2712 err = decoder.DecodeUint64(&result.Arg) 2713 if err != nil { 2714 return types.FcntlArgs{}, err 2715 } 2716 } 2717 } 2718 return result, nil 2719 } 2720 2721 func ParseFlockArgs(decoder *Decoder) (types.FlockArgs, error) { 2722 var result types.FlockArgs 2723 var err error 2724 2725 var numArgs uint8 2726 err = decoder.DecodeUint8(&numArgs) 2727 if err != nil { 2728 return types.FlockArgs{}, err 2729 } 2730 2731 for arg := 0; arg < int(numArgs); arg++ { 2732 var currArg uint8 2733 err = decoder.DecodeUint8(&currArg) 2734 if err != nil { 2735 return types.FlockArgs{}, err 2736 } 2737 2738 switch currArg { 2739 case 0: 2740 err = decoder.DecodeInt32(&result.Fd) 2741 if err != nil { 2742 return types.FlockArgs{}, err 2743 } 2744 case 1: 2745 err = decoder.DecodeInt32(&result.Operation) 2746 if err != nil { 2747 return types.FlockArgs{}, err 2748 } 2749 } 2750 } 2751 return result, nil 2752 } 2753 2754 func ParseFsyncArgs(decoder *Decoder) (types.FsyncArgs, error) { 2755 var result types.FsyncArgs 2756 var err error 2757 2758 var numArgs uint8 2759 err = decoder.DecodeUint8(&numArgs) 2760 if err != nil { 2761 return types.FsyncArgs{}, err 2762 } 2763 2764 for arg := 0; arg < int(numArgs); arg++ { 2765 var currArg uint8 2766 err = decoder.DecodeUint8(&currArg) 2767 if err != nil { 2768 return types.FsyncArgs{}, err 2769 } 2770 2771 switch currArg { 2772 case 0: 2773 err = decoder.DecodeInt32(&result.Fd) 2774 if err != nil { 2775 return types.FsyncArgs{}, err 2776 } 2777 } 2778 } 2779 return result, nil 2780 } 2781 2782 func ParseFdatasyncArgs(decoder *Decoder) (types.FdatasyncArgs, error) { 2783 var result types.FdatasyncArgs 2784 var err error 2785 2786 var numArgs uint8 2787 err = decoder.DecodeUint8(&numArgs) 2788 if err != nil { 2789 return types.FdatasyncArgs{}, err 2790 } 2791 2792 for arg := 0; arg < int(numArgs); arg++ { 2793 var currArg uint8 2794 err = decoder.DecodeUint8(&currArg) 2795 if err != nil { 2796 return types.FdatasyncArgs{}, err 2797 } 2798 2799 switch currArg { 2800 case 0: 2801 err = decoder.DecodeInt32(&result.Fd) 2802 if err != nil { 2803 return types.FdatasyncArgs{}, err 2804 } 2805 } 2806 } 2807 return result, nil 2808 } 2809 2810 func ParseTruncateArgs(decoder *Decoder) (types.TruncateArgs, error) { 2811 var result types.TruncateArgs 2812 var err error 2813 2814 var numArgs uint8 2815 err = decoder.DecodeUint8(&numArgs) 2816 if err != nil { 2817 return types.TruncateArgs{}, err 2818 } 2819 2820 for arg := 0; arg < int(numArgs); arg++ { 2821 var currArg uint8 2822 err = decoder.DecodeUint8(&currArg) 2823 if err != nil { 2824 return types.TruncateArgs{}, err 2825 } 2826 2827 switch currArg { 2828 case 0: 2829 result.Path, err = decoder.ReadStringFromBuff() 2830 if err != nil { 2831 return types.TruncateArgs{}, err 2832 } 2833 case 1: 2834 err = decoder.DecodeUint64(&result.Length) 2835 if err != nil { 2836 return types.TruncateArgs{}, err 2837 } 2838 } 2839 } 2840 return result, nil 2841 } 2842 2843 func ParseFtruncateArgs(decoder *Decoder) (types.FtruncateArgs, error) { 2844 var result types.FtruncateArgs 2845 var err error 2846 2847 var numArgs uint8 2848 err = decoder.DecodeUint8(&numArgs) 2849 if err != nil { 2850 return types.FtruncateArgs{}, err 2851 } 2852 2853 for arg := 0; arg < int(numArgs); arg++ { 2854 var currArg uint8 2855 err = decoder.DecodeUint8(&currArg) 2856 if err != nil { 2857 return types.FtruncateArgs{}, err 2858 } 2859 2860 switch currArg { 2861 case 0: 2862 err = decoder.DecodeInt32(&result.Fd) 2863 if err != nil { 2864 return types.FtruncateArgs{}, err 2865 } 2866 case 1: 2867 err = decoder.DecodeUint64(&result.Length) 2868 if err != nil { 2869 return types.FtruncateArgs{}, err 2870 } 2871 } 2872 } 2873 return result, nil 2874 } 2875 2876 func ParseGetdentsArgs(decoder *Decoder) (types.GetdentsArgs, error) { 2877 var result types.GetdentsArgs 2878 var err error 2879 2880 var numArgs uint8 2881 err = decoder.DecodeUint8(&numArgs) 2882 if err != nil { 2883 return types.GetdentsArgs{}, err 2884 } 2885 2886 for arg := 0; arg < int(numArgs); arg++ { 2887 var currArg uint8 2888 err = decoder.DecodeUint8(&currArg) 2889 if err != nil { 2890 return types.GetdentsArgs{}, err 2891 } 2892 2893 switch currArg { 2894 case 0: 2895 err = decoder.DecodeInt32(&result.Fd) 2896 if err != nil { 2897 return types.GetdentsArgs{}, err 2898 } 2899 case 1: 2900 var dataDirp uint64 2901 err = decoder.DecodeUint64(&dataDirp) 2902 if err != nil { 2903 return types.GetdentsArgs{}, err 2904 } 2905 result.Dirp = uintptr(dataDirp) 2906 case 2: 2907 err = decoder.DecodeUint32(&result.Count) 2908 if err != nil { 2909 return types.GetdentsArgs{}, err 2910 } 2911 } 2912 } 2913 return result, nil 2914 } 2915 2916 func ParseGetcwdArgs(decoder *Decoder) (types.GetcwdArgs, error) { 2917 var result types.GetcwdArgs 2918 var err error 2919 2920 var numArgs uint8 2921 err = decoder.DecodeUint8(&numArgs) 2922 if err != nil { 2923 return types.GetcwdArgs{}, err 2924 } 2925 2926 for arg := 0; arg < int(numArgs); arg++ { 2927 var currArg uint8 2928 err = decoder.DecodeUint8(&currArg) 2929 if err != nil { 2930 return types.GetcwdArgs{}, err 2931 } 2932 2933 switch currArg { 2934 case 0: 2935 result.Buf, err = decoder.ReadStringFromBuff() 2936 if err != nil { 2937 return types.GetcwdArgs{}, err 2938 } 2939 case 1: 2940 err = decoder.DecodeUint64(&result.Size) 2941 if err != nil { 2942 return types.GetcwdArgs{}, err 2943 } 2944 } 2945 } 2946 return result, nil 2947 } 2948 2949 func ParseChdirArgs(decoder *Decoder) (types.ChdirArgs, error) { 2950 var result types.ChdirArgs 2951 var err error 2952 2953 var numArgs uint8 2954 err = decoder.DecodeUint8(&numArgs) 2955 if err != nil { 2956 return types.ChdirArgs{}, err 2957 } 2958 2959 for arg := 0; arg < int(numArgs); arg++ { 2960 var currArg uint8 2961 err = decoder.DecodeUint8(&currArg) 2962 if err != nil { 2963 return types.ChdirArgs{}, err 2964 } 2965 2966 switch currArg { 2967 case 0: 2968 result.Path, err = decoder.ReadStringFromBuff() 2969 if err != nil { 2970 return types.ChdirArgs{}, err 2971 } 2972 } 2973 } 2974 return result, nil 2975 } 2976 2977 func ParseFchdirArgs(decoder *Decoder) (types.FchdirArgs, error) { 2978 var result types.FchdirArgs 2979 var err error 2980 2981 var numArgs uint8 2982 err = decoder.DecodeUint8(&numArgs) 2983 if err != nil { 2984 return types.FchdirArgs{}, err 2985 } 2986 2987 for arg := 0; arg < int(numArgs); arg++ { 2988 var currArg uint8 2989 err = decoder.DecodeUint8(&currArg) 2990 if err != nil { 2991 return types.FchdirArgs{}, err 2992 } 2993 2994 switch currArg { 2995 case 0: 2996 err = decoder.DecodeInt32(&result.Fd) 2997 if err != nil { 2998 return types.FchdirArgs{}, err 2999 } 3000 } 3001 } 3002 return result, nil 3003 } 3004 3005 func ParseRenameArgs(decoder *Decoder) (types.RenameArgs, error) { 3006 var result types.RenameArgs 3007 var err error 3008 3009 var numArgs uint8 3010 err = decoder.DecodeUint8(&numArgs) 3011 if err != nil { 3012 return types.RenameArgs{}, err 3013 } 3014 3015 for arg := 0; arg < int(numArgs); arg++ { 3016 var currArg uint8 3017 err = decoder.DecodeUint8(&currArg) 3018 if err != nil { 3019 return types.RenameArgs{}, err 3020 } 3021 3022 switch currArg { 3023 case 0: 3024 result.Oldpath, err = decoder.ReadStringFromBuff() 3025 if err != nil { 3026 return types.RenameArgs{}, err 3027 } 3028 case 1: 3029 result.Newpath, err = decoder.ReadStringFromBuff() 3030 if err != nil { 3031 return types.RenameArgs{}, err 3032 } 3033 } 3034 } 3035 return result, nil 3036 } 3037 3038 func ParseMkdirArgs(decoder *Decoder) (types.MkdirArgs, error) { 3039 var result types.MkdirArgs 3040 var err error 3041 3042 var numArgs uint8 3043 err = decoder.DecodeUint8(&numArgs) 3044 if err != nil { 3045 return types.MkdirArgs{}, err 3046 } 3047 3048 for arg := 0; arg < int(numArgs); arg++ { 3049 var currArg uint8 3050 err = decoder.DecodeUint8(&currArg) 3051 if err != nil { 3052 return types.MkdirArgs{}, err 3053 } 3054 3055 switch currArg { 3056 case 0: 3057 result.Pathname, err = decoder.ReadStringFromBuff() 3058 if err != nil { 3059 return types.MkdirArgs{}, err 3060 } 3061 case 1: 3062 err = decoder.DecodeUint32(&result.Mode) 3063 if err != nil { 3064 return types.MkdirArgs{}, err 3065 } 3066 } 3067 } 3068 return result, nil 3069 } 3070 3071 func ParseRmdirArgs(decoder *Decoder) (types.RmdirArgs, error) { 3072 var result types.RmdirArgs 3073 var err error 3074 3075 var numArgs uint8 3076 err = decoder.DecodeUint8(&numArgs) 3077 if err != nil { 3078 return types.RmdirArgs{}, err 3079 } 3080 3081 for arg := 0; arg < int(numArgs); arg++ { 3082 var currArg uint8 3083 err = decoder.DecodeUint8(&currArg) 3084 if err != nil { 3085 return types.RmdirArgs{}, err 3086 } 3087 3088 switch currArg { 3089 case 0: 3090 result.Pathname, err = decoder.ReadStringFromBuff() 3091 if err != nil { 3092 return types.RmdirArgs{}, err 3093 } 3094 } 3095 } 3096 return result, nil 3097 } 3098 3099 func ParseCreatArgs(decoder *Decoder) (types.CreatArgs, error) { 3100 var result types.CreatArgs 3101 var err error 3102 3103 var numArgs uint8 3104 err = decoder.DecodeUint8(&numArgs) 3105 if err != nil { 3106 return types.CreatArgs{}, err 3107 } 3108 3109 for arg := 0; arg < int(numArgs); arg++ { 3110 var currArg uint8 3111 err = decoder.DecodeUint8(&currArg) 3112 if err != nil { 3113 return types.CreatArgs{}, err 3114 } 3115 3116 switch currArg { 3117 case 0: 3118 result.Pathname, err = decoder.ReadStringFromBuff() 3119 if err != nil { 3120 return types.CreatArgs{}, err 3121 } 3122 case 1: 3123 err = decoder.DecodeUint32(&result.Mode) 3124 if err != nil { 3125 return types.CreatArgs{}, err 3126 } 3127 } 3128 } 3129 return result, nil 3130 } 3131 3132 func ParseLinkArgs(decoder *Decoder) (types.LinkArgs, error) { 3133 var result types.LinkArgs 3134 var err error 3135 3136 var numArgs uint8 3137 err = decoder.DecodeUint8(&numArgs) 3138 if err != nil { 3139 return types.LinkArgs{}, err 3140 } 3141 3142 for arg := 0; arg < int(numArgs); arg++ { 3143 var currArg uint8 3144 err = decoder.DecodeUint8(&currArg) 3145 if err != nil { 3146 return types.LinkArgs{}, err 3147 } 3148 3149 switch currArg { 3150 case 0: 3151 result.Oldpath, err = decoder.ReadStringFromBuff() 3152 if err != nil { 3153 return types.LinkArgs{}, err 3154 } 3155 case 1: 3156 result.Newpath, err = decoder.ReadStringFromBuff() 3157 if err != nil { 3158 return types.LinkArgs{}, err 3159 } 3160 } 3161 } 3162 return result, nil 3163 } 3164 3165 func ParseUnlinkArgs(decoder *Decoder) (types.UnlinkArgs, error) { 3166 var result types.UnlinkArgs 3167 var err error 3168 3169 var numArgs uint8 3170 err = decoder.DecodeUint8(&numArgs) 3171 if err != nil { 3172 return types.UnlinkArgs{}, err 3173 } 3174 3175 for arg := 0; arg < int(numArgs); arg++ { 3176 var currArg uint8 3177 err = decoder.DecodeUint8(&currArg) 3178 if err != nil { 3179 return types.UnlinkArgs{}, err 3180 } 3181 3182 switch currArg { 3183 case 0: 3184 result.Pathname, err = decoder.ReadStringFromBuff() 3185 if err != nil { 3186 return types.UnlinkArgs{}, err 3187 } 3188 } 3189 } 3190 return result, nil 3191 } 3192 3193 func ParseSymlinkArgs(decoder *Decoder) (types.SymlinkArgs, error) { 3194 var result types.SymlinkArgs 3195 var err error 3196 3197 var numArgs uint8 3198 err = decoder.DecodeUint8(&numArgs) 3199 if err != nil { 3200 return types.SymlinkArgs{}, err 3201 } 3202 3203 for arg := 0; arg < int(numArgs); arg++ { 3204 var currArg uint8 3205 err = decoder.DecodeUint8(&currArg) 3206 if err != nil { 3207 return types.SymlinkArgs{}, err 3208 } 3209 3210 switch currArg { 3211 case 0: 3212 result.Target, err = decoder.ReadStringFromBuff() 3213 if err != nil { 3214 return types.SymlinkArgs{}, err 3215 } 3216 case 1: 3217 result.Linkpath, err = decoder.ReadStringFromBuff() 3218 if err != nil { 3219 return types.SymlinkArgs{}, err 3220 } 3221 } 3222 } 3223 return result, nil 3224 } 3225 3226 func ParseReadlinkArgs(decoder *Decoder) (types.ReadlinkArgs, error) { 3227 var result types.ReadlinkArgs 3228 var err error 3229 3230 var numArgs uint8 3231 err = decoder.DecodeUint8(&numArgs) 3232 if err != nil { 3233 return types.ReadlinkArgs{}, err 3234 } 3235 3236 for arg := 0; arg < int(numArgs); arg++ { 3237 var currArg uint8 3238 err = decoder.DecodeUint8(&currArg) 3239 if err != nil { 3240 return types.ReadlinkArgs{}, err 3241 } 3242 3243 switch currArg { 3244 case 0: 3245 result.Pathname, err = decoder.ReadStringFromBuff() 3246 if err != nil { 3247 return types.ReadlinkArgs{}, err 3248 } 3249 case 1: 3250 result.Buf, err = decoder.ReadStringFromBuff() 3251 if err != nil { 3252 return types.ReadlinkArgs{}, err 3253 } 3254 case 2: 3255 err = decoder.DecodeUint64(&result.Bufsiz) 3256 if err != nil { 3257 return types.ReadlinkArgs{}, err 3258 } 3259 } 3260 } 3261 return result, nil 3262 } 3263 3264 func ParseChmodArgs(decoder *Decoder) (types.ChmodArgs, error) { 3265 var result types.ChmodArgs 3266 var err error 3267 3268 var numArgs uint8 3269 err = decoder.DecodeUint8(&numArgs) 3270 if err != nil { 3271 return types.ChmodArgs{}, err 3272 } 3273 3274 for arg := 0; arg < int(numArgs); arg++ { 3275 var currArg uint8 3276 err = decoder.DecodeUint8(&currArg) 3277 if err != nil { 3278 return types.ChmodArgs{}, err 3279 } 3280 3281 switch currArg { 3282 case 0: 3283 result.Pathname, err = decoder.ReadStringFromBuff() 3284 if err != nil { 3285 return types.ChmodArgs{}, err 3286 } 3287 case 1: 3288 err = decoder.DecodeUint32(&result.Mode) 3289 if err != nil { 3290 return types.ChmodArgs{}, err 3291 } 3292 } 3293 } 3294 return result, nil 3295 } 3296 3297 func ParseFchmodArgs(decoder *Decoder) (types.FchmodArgs, error) { 3298 var result types.FchmodArgs 3299 var err error 3300 3301 var numArgs uint8 3302 err = decoder.DecodeUint8(&numArgs) 3303 if err != nil { 3304 return types.FchmodArgs{}, err 3305 } 3306 3307 for arg := 0; arg < int(numArgs); arg++ { 3308 var currArg uint8 3309 err = decoder.DecodeUint8(&currArg) 3310 if err != nil { 3311 return types.FchmodArgs{}, err 3312 } 3313 3314 switch currArg { 3315 case 0: 3316 err = decoder.DecodeInt32(&result.Fd) 3317 if err != nil { 3318 return types.FchmodArgs{}, err 3319 } 3320 case 1: 3321 err = decoder.DecodeUint32(&result.Mode) 3322 if err != nil { 3323 return types.FchmodArgs{}, err 3324 } 3325 } 3326 } 3327 return result, nil 3328 } 3329 3330 func ParseChownArgs(decoder *Decoder) (types.ChownArgs, error) { 3331 var result types.ChownArgs 3332 var err error 3333 3334 var numArgs uint8 3335 err = decoder.DecodeUint8(&numArgs) 3336 if err != nil { 3337 return types.ChownArgs{}, err 3338 } 3339 3340 for arg := 0; arg < int(numArgs); arg++ { 3341 var currArg uint8 3342 err = decoder.DecodeUint8(&currArg) 3343 if err != nil { 3344 return types.ChownArgs{}, err 3345 } 3346 3347 switch currArg { 3348 case 0: 3349 result.Pathname, err = decoder.ReadStringFromBuff() 3350 if err != nil { 3351 return types.ChownArgs{}, err 3352 } 3353 case 1: 3354 err = decoder.DecodeInt32(&result.Owner) 3355 if err != nil { 3356 return types.ChownArgs{}, err 3357 } 3358 case 2: 3359 err = decoder.DecodeInt32(&result.Group) 3360 if err != nil { 3361 return types.ChownArgs{}, err 3362 } 3363 } 3364 } 3365 return result, nil 3366 } 3367 3368 func ParseFchownArgs(decoder *Decoder) (types.FchownArgs, error) { 3369 var result types.FchownArgs 3370 var err error 3371 3372 var numArgs uint8 3373 err = decoder.DecodeUint8(&numArgs) 3374 if err != nil { 3375 return types.FchownArgs{}, err 3376 } 3377 3378 for arg := 0; arg < int(numArgs); arg++ { 3379 var currArg uint8 3380 err = decoder.DecodeUint8(&currArg) 3381 if err != nil { 3382 return types.FchownArgs{}, err 3383 } 3384 3385 switch currArg { 3386 case 0: 3387 err = decoder.DecodeInt32(&result.Fd) 3388 if err != nil { 3389 return types.FchownArgs{}, err 3390 } 3391 case 1: 3392 err = decoder.DecodeInt32(&result.Owner) 3393 if err != nil { 3394 return types.FchownArgs{}, err 3395 } 3396 case 2: 3397 err = decoder.DecodeInt32(&result.Group) 3398 if err != nil { 3399 return types.FchownArgs{}, err 3400 } 3401 } 3402 } 3403 return result, nil 3404 } 3405 3406 func ParseLchownArgs(decoder *Decoder) (types.LchownArgs, error) { 3407 var result types.LchownArgs 3408 var err error 3409 3410 var numArgs uint8 3411 err = decoder.DecodeUint8(&numArgs) 3412 if err != nil { 3413 return types.LchownArgs{}, err 3414 } 3415 3416 for arg := 0; arg < int(numArgs); arg++ { 3417 var currArg uint8 3418 err = decoder.DecodeUint8(&currArg) 3419 if err != nil { 3420 return types.LchownArgs{}, err 3421 } 3422 3423 switch currArg { 3424 case 0: 3425 result.Pathname, err = decoder.ReadStringFromBuff() 3426 if err != nil { 3427 return types.LchownArgs{}, err 3428 } 3429 case 1: 3430 err = decoder.DecodeInt32(&result.Owner) 3431 if err != nil { 3432 return types.LchownArgs{}, err 3433 } 3434 case 2: 3435 err = decoder.DecodeInt32(&result.Group) 3436 if err != nil { 3437 return types.LchownArgs{}, err 3438 } 3439 } 3440 } 3441 return result, nil 3442 } 3443 3444 func ParseUmaskArgs(decoder *Decoder) (types.UmaskArgs, error) { 3445 var result types.UmaskArgs 3446 var err error 3447 3448 var numArgs uint8 3449 err = decoder.DecodeUint8(&numArgs) 3450 if err != nil { 3451 return types.UmaskArgs{}, err 3452 } 3453 3454 for arg := 0; arg < int(numArgs); arg++ { 3455 var currArg uint8 3456 err = decoder.DecodeUint8(&currArg) 3457 if err != nil { 3458 return types.UmaskArgs{}, err 3459 } 3460 3461 switch currArg { 3462 case 0: 3463 err = decoder.DecodeUint32(&result.Mask) 3464 if err != nil { 3465 return types.UmaskArgs{}, err 3466 } 3467 } 3468 } 3469 return result, nil 3470 } 3471 3472 func ParseGettimeofdayArgs(decoder *Decoder) (types.GettimeofdayArgs, error) { 3473 var result types.GettimeofdayArgs 3474 var err error 3475 3476 var numArgs uint8 3477 err = decoder.DecodeUint8(&numArgs) 3478 if err != nil { 3479 return types.GettimeofdayArgs{}, err 3480 } 3481 3482 for arg := 0; arg < int(numArgs); arg++ { 3483 var currArg uint8 3484 err = decoder.DecodeUint8(&currArg) 3485 if err != nil { 3486 return types.GettimeofdayArgs{}, err 3487 } 3488 3489 switch currArg { 3490 case 0: 3491 var dataTv uint64 3492 err = decoder.DecodeUint64(&dataTv) 3493 if err != nil { 3494 return types.GettimeofdayArgs{}, err 3495 } 3496 result.Tv = uintptr(dataTv) 3497 case 1: 3498 var dataTz uint64 3499 err = decoder.DecodeUint64(&dataTz) 3500 if err != nil { 3501 return types.GettimeofdayArgs{}, err 3502 } 3503 result.Tz = uintptr(dataTz) 3504 } 3505 } 3506 return result, nil 3507 } 3508 3509 func ParseGetrlimitArgs(decoder *Decoder) (types.GetrlimitArgs, error) { 3510 var result types.GetrlimitArgs 3511 var err error 3512 3513 var numArgs uint8 3514 err = decoder.DecodeUint8(&numArgs) 3515 if err != nil { 3516 return types.GetrlimitArgs{}, err 3517 } 3518 3519 for arg := 0; arg < int(numArgs); arg++ { 3520 var currArg uint8 3521 err = decoder.DecodeUint8(&currArg) 3522 if err != nil { 3523 return types.GetrlimitArgs{}, err 3524 } 3525 3526 switch currArg { 3527 case 0: 3528 err = decoder.DecodeInt32(&result.Resource) 3529 if err != nil { 3530 return types.GetrlimitArgs{}, err 3531 } 3532 case 1: 3533 var dataRlim uint64 3534 err = decoder.DecodeUint64(&dataRlim) 3535 if err != nil { 3536 return types.GetrlimitArgs{}, err 3537 } 3538 result.Rlim = uintptr(dataRlim) 3539 } 3540 } 3541 return result, nil 3542 } 3543 3544 func ParseGetrusageArgs(decoder *Decoder) (types.GetrusageArgs, error) { 3545 var result types.GetrusageArgs 3546 var err error 3547 3548 var numArgs uint8 3549 err = decoder.DecodeUint8(&numArgs) 3550 if err != nil { 3551 return types.GetrusageArgs{}, err 3552 } 3553 3554 for arg := 0; arg < int(numArgs); arg++ { 3555 var currArg uint8 3556 err = decoder.DecodeUint8(&currArg) 3557 if err != nil { 3558 return types.GetrusageArgs{}, err 3559 } 3560 3561 switch currArg { 3562 case 0: 3563 err = decoder.DecodeInt32(&result.Who) 3564 if err != nil { 3565 return types.GetrusageArgs{}, err 3566 } 3567 case 1: 3568 var dataUsage uint64 3569 err = decoder.DecodeUint64(&dataUsage) 3570 if err != nil { 3571 return types.GetrusageArgs{}, err 3572 } 3573 result.Usage = uintptr(dataUsage) 3574 } 3575 } 3576 return result, nil 3577 } 3578 3579 func ParseSysinfoArgs(decoder *Decoder) (types.SysinfoArgs, error) { 3580 var result types.SysinfoArgs 3581 var err error 3582 3583 var numArgs uint8 3584 err = decoder.DecodeUint8(&numArgs) 3585 if err != nil { 3586 return types.SysinfoArgs{}, err 3587 } 3588 3589 for arg := 0; arg < int(numArgs); arg++ { 3590 var currArg uint8 3591 err = decoder.DecodeUint8(&currArg) 3592 if err != nil { 3593 return types.SysinfoArgs{}, err 3594 } 3595 3596 switch currArg { 3597 case 0: 3598 var dataInfo uint64 3599 err = decoder.DecodeUint64(&dataInfo) 3600 if err != nil { 3601 return types.SysinfoArgs{}, err 3602 } 3603 result.Info = uintptr(dataInfo) 3604 } 3605 } 3606 return result, nil 3607 } 3608 3609 func ParseTimesArgs(decoder *Decoder) (types.TimesArgs, error) { 3610 var result types.TimesArgs 3611 var err error 3612 3613 var numArgs uint8 3614 err = decoder.DecodeUint8(&numArgs) 3615 if err != nil { 3616 return types.TimesArgs{}, err 3617 } 3618 3619 for arg := 0; arg < int(numArgs); arg++ { 3620 var currArg uint8 3621 err = decoder.DecodeUint8(&currArg) 3622 if err != nil { 3623 return types.TimesArgs{}, err 3624 } 3625 3626 switch currArg { 3627 case 0: 3628 var dataBuf uint64 3629 err = decoder.DecodeUint64(&dataBuf) 3630 if err != nil { 3631 return types.TimesArgs{}, err 3632 } 3633 result.Buf = uintptr(dataBuf) 3634 } 3635 } 3636 return result, nil 3637 } 3638 3639 func ParsePtraceArgs(decoder *Decoder) (types.PtraceArgs, error) { 3640 var result types.PtraceArgs 3641 var err error 3642 3643 var numArgs uint8 3644 err = decoder.DecodeUint8(&numArgs) 3645 if err != nil { 3646 return types.PtraceArgs{}, err 3647 } 3648 3649 for arg := 0; arg < int(numArgs); arg++ { 3650 var currArg uint8 3651 err = decoder.DecodeUint8(&currArg) 3652 if err != nil { 3653 return types.PtraceArgs{}, err 3654 } 3655 3656 switch currArg { 3657 case 0: 3658 err = decoder.DecodeInt64(&result.Request) 3659 if err != nil { 3660 return types.PtraceArgs{}, err 3661 } 3662 case 1: 3663 err = decoder.DecodeInt32(&result.Pid) 3664 if err != nil { 3665 return types.PtraceArgs{}, err 3666 } 3667 case 2: 3668 var dataAddr uint64 3669 err = decoder.DecodeUint64(&dataAddr) 3670 if err != nil { 3671 return types.PtraceArgs{}, err 3672 } 3673 result.Addr = uintptr(dataAddr) 3674 case 3: 3675 var dataData uint64 3676 err = decoder.DecodeUint64(&dataData) 3677 if err != nil { 3678 return types.PtraceArgs{}, err 3679 } 3680 result.Data = uintptr(dataData) 3681 } 3682 } 3683 return result, nil 3684 } 3685 3686 func ParseGetuidArgs(decoder *Decoder) (types.GetuidArgs, error) { 3687 return types.GetuidArgs{}, nil 3688 } 3689 3690 func ParseSyslogArgs(decoder *Decoder) (types.SyslogArgs, error) { 3691 var result types.SyslogArgs 3692 var err error 3693 3694 var numArgs uint8 3695 err = decoder.DecodeUint8(&numArgs) 3696 if err != nil { 3697 return types.SyslogArgs{}, err 3698 } 3699 3700 for arg := 0; arg < int(numArgs); arg++ { 3701 var currArg uint8 3702 err = decoder.DecodeUint8(&currArg) 3703 if err != nil { 3704 return types.SyslogArgs{}, err 3705 } 3706 3707 switch currArg { 3708 case 0: 3709 err = decoder.DecodeInt32(&result.Type) 3710 if err != nil { 3711 return types.SyslogArgs{}, err 3712 } 3713 case 1: 3714 result.Bufp, err = decoder.ReadStringFromBuff() 3715 if err != nil { 3716 return types.SyslogArgs{}, err 3717 } 3718 case 2: 3719 err = decoder.DecodeInt32(&result.Len) 3720 if err != nil { 3721 return types.SyslogArgs{}, err 3722 } 3723 } 3724 } 3725 return result, nil 3726 } 3727 3728 func ParseGetgidArgs(decoder *Decoder) (types.GetgidArgs, error) { 3729 return types.GetgidArgs{}, nil 3730 } 3731 3732 func ParseSetuidArgs(decoder *Decoder) (types.SetuidArgs, error) { 3733 var result types.SetuidArgs 3734 var err error 3735 3736 var numArgs uint8 3737 err = decoder.DecodeUint8(&numArgs) 3738 if err != nil { 3739 return types.SetuidArgs{}, err 3740 } 3741 3742 for arg := 0; arg < int(numArgs); arg++ { 3743 var currArg uint8 3744 err = decoder.DecodeUint8(&currArg) 3745 if err != nil { 3746 return types.SetuidArgs{}, err 3747 } 3748 3749 switch currArg { 3750 case 0: 3751 err = decoder.DecodeInt32(&result.Uid) 3752 if err != nil { 3753 return types.SetuidArgs{}, err 3754 } 3755 } 3756 } 3757 return result, nil 3758 } 3759 3760 func ParseSetgidArgs(decoder *Decoder) (types.SetgidArgs, error) { 3761 var result types.SetgidArgs 3762 var err error 3763 3764 var numArgs uint8 3765 err = decoder.DecodeUint8(&numArgs) 3766 if err != nil { 3767 return types.SetgidArgs{}, err 3768 } 3769 3770 for arg := 0; arg < int(numArgs); arg++ { 3771 var currArg uint8 3772 err = decoder.DecodeUint8(&currArg) 3773 if err != nil { 3774 return types.SetgidArgs{}, err 3775 } 3776 3777 switch currArg { 3778 case 0: 3779 err = decoder.DecodeInt32(&result.Gid) 3780 if err != nil { 3781 return types.SetgidArgs{}, err 3782 } 3783 } 3784 } 3785 return result, nil 3786 } 3787 3788 func ParseGeteuidArgs(decoder *Decoder) (types.GeteuidArgs, error) { 3789 return types.GeteuidArgs{}, nil 3790 } 3791 3792 func ParseGetegidArgs(decoder *Decoder) (types.GetegidArgs, error) { 3793 return types.GetegidArgs{}, nil 3794 } 3795 3796 func ParseSetpgidArgs(decoder *Decoder) (types.SetpgidArgs, error) { 3797 var result types.SetpgidArgs 3798 var err error 3799 3800 var numArgs uint8 3801 err = decoder.DecodeUint8(&numArgs) 3802 if err != nil { 3803 return types.SetpgidArgs{}, err 3804 } 3805 3806 for arg := 0; arg < int(numArgs); arg++ { 3807 var currArg uint8 3808 err = decoder.DecodeUint8(&currArg) 3809 if err != nil { 3810 return types.SetpgidArgs{}, err 3811 } 3812 3813 switch currArg { 3814 case 0: 3815 err = decoder.DecodeInt32(&result.Pid) 3816 if err != nil { 3817 return types.SetpgidArgs{}, err 3818 } 3819 case 1: 3820 err = decoder.DecodeInt32(&result.Pgid) 3821 if err != nil { 3822 return types.SetpgidArgs{}, err 3823 } 3824 } 3825 } 3826 return result, nil 3827 } 3828 3829 func ParseGetppidArgs(decoder *Decoder) (types.GetppidArgs, error) { 3830 return types.GetppidArgs{}, nil 3831 } 3832 3833 func ParseGetpgrpArgs(decoder *Decoder) (types.GetpgrpArgs, error) { 3834 return types.GetpgrpArgs{}, nil 3835 } 3836 3837 func ParseSetsidArgs(decoder *Decoder) (types.SetsidArgs, error) { 3838 return types.SetsidArgs{}, nil 3839 } 3840 3841 func ParseSetreuidArgs(decoder *Decoder) (types.SetreuidArgs, error) { 3842 var result types.SetreuidArgs 3843 var err error 3844 3845 var numArgs uint8 3846 err = decoder.DecodeUint8(&numArgs) 3847 if err != nil { 3848 return types.SetreuidArgs{}, err 3849 } 3850 3851 for arg := 0; arg < int(numArgs); arg++ { 3852 var currArg uint8 3853 err = decoder.DecodeUint8(&currArg) 3854 if err != nil { 3855 return types.SetreuidArgs{}, err 3856 } 3857 3858 switch currArg { 3859 case 0: 3860 err = decoder.DecodeInt32(&result.Ruid) 3861 if err != nil { 3862 return types.SetreuidArgs{}, err 3863 } 3864 case 1: 3865 err = decoder.DecodeInt32(&result.Euid) 3866 if err != nil { 3867 return types.SetreuidArgs{}, err 3868 } 3869 } 3870 } 3871 return result, nil 3872 } 3873 3874 func ParseSetregidArgs(decoder *Decoder) (types.SetregidArgs, error) { 3875 var result types.SetregidArgs 3876 var err error 3877 3878 var numArgs uint8 3879 err = decoder.DecodeUint8(&numArgs) 3880 if err != nil { 3881 return types.SetregidArgs{}, err 3882 } 3883 3884 for arg := 0; arg < int(numArgs); arg++ { 3885 var currArg uint8 3886 err = decoder.DecodeUint8(&currArg) 3887 if err != nil { 3888 return types.SetregidArgs{}, err 3889 } 3890 3891 switch currArg { 3892 case 0: 3893 err = decoder.DecodeInt32(&result.Rgid) 3894 if err != nil { 3895 return types.SetregidArgs{}, err 3896 } 3897 case 1: 3898 err = decoder.DecodeInt32(&result.Egid) 3899 if err != nil { 3900 return types.SetregidArgs{}, err 3901 } 3902 } 3903 } 3904 return result, nil 3905 } 3906 3907 func ParseGetgroupsArgs(decoder *Decoder) (types.GetgroupsArgs, error) { 3908 var result types.GetgroupsArgs 3909 var err error 3910 3911 var numArgs uint8 3912 err = decoder.DecodeUint8(&numArgs) 3913 if err != nil { 3914 return types.GetgroupsArgs{}, err 3915 } 3916 3917 for arg := 0; arg < int(numArgs); arg++ { 3918 var currArg uint8 3919 err = decoder.DecodeUint8(&currArg) 3920 if err != nil { 3921 return types.GetgroupsArgs{}, err 3922 } 3923 3924 switch currArg { 3925 case 0: 3926 err = decoder.DecodeInt32(&result.Size) 3927 if err != nil { 3928 return types.GetgroupsArgs{}, err 3929 } 3930 case 1: 3931 var dataList uint64 3932 err = decoder.DecodeUint64(&dataList) 3933 if err != nil { 3934 return types.GetgroupsArgs{}, err 3935 } 3936 result.List = uintptr(dataList) 3937 } 3938 } 3939 return result, nil 3940 } 3941 3942 func ParseSetgroupsArgs(decoder *Decoder) (types.SetgroupsArgs, error) { 3943 var result types.SetgroupsArgs 3944 var err error 3945 3946 var numArgs uint8 3947 err = decoder.DecodeUint8(&numArgs) 3948 if err != nil { 3949 return types.SetgroupsArgs{}, err 3950 } 3951 3952 for arg := 0; arg < int(numArgs); arg++ { 3953 var currArg uint8 3954 err = decoder.DecodeUint8(&currArg) 3955 if err != nil { 3956 return types.SetgroupsArgs{}, err 3957 } 3958 3959 switch currArg { 3960 case 0: 3961 err = decoder.DecodeInt32(&result.Size) 3962 if err != nil { 3963 return types.SetgroupsArgs{}, err 3964 } 3965 case 1: 3966 var dataList uint64 3967 err = decoder.DecodeUint64(&dataList) 3968 if err != nil { 3969 return types.SetgroupsArgs{}, err 3970 } 3971 result.List = uintptr(dataList) 3972 } 3973 } 3974 return result, nil 3975 } 3976 3977 func ParseSetresuidArgs(decoder *Decoder) (types.SetresuidArgs, error) { 3978 var result types.SetresuidArgs 3979 var err error 3980 3981 var numArgs uint8 3982 err = decoder.DecodeUint8(&numArgs) 3983 if err != nil { 3984 return types.SetresuidArgs{}, err 3985 } 3986 3987 for arg := 0; arg < int(numArgs); arg++ { 3988 var currArg uint8 3989 err = decoder.DecodeUint8(&currArg) 3990 if err != nil { 3991 return types.SetresuidArgs{}, err 3992 } 3993 3994 switch currArg { 3995 case 0: 3996 err = decoder.DecodeInt32(&result.Ruid) 3997 if err != nil { 3998 return types.SetresuidArgs{}, err 3999 } 4000 case 1: 4001 err = decoder.DecodeInt32(&result.Euid) 4002 if err != nil { 4003 return types.SetresuidArgs{}, err 4004 } 4005 case 2: 4006 err = decoder.DecodeInt32(&result.Suid) 4007 if err != nil { 4008 return types.SetresuidArgs{}, err 4009 } 4010 } 4011 } 4012 return result, nil 4013 } 4014 4015 func ParseGetresuidArgs(decoder *Decoder) (types.GetresuidArgs, error) { 4016 var result types.GetresuidArgs 4017 var err error 4018 4019 var numArgs uint8 4020 err = decoder.DecodeUint8(&numArgs) 4021 if err != nil { 4022 return types.GetresuidArgs{}, err 4023 } 4024 4025 for arg := 0; arg < int(numArgs); arg++ { 4026 var currArg uint8 4027 err = decoder.DecodeUint8(&currArg) 4028 if err != nil { 4029 return types.GetresuidArgs{}, err 4030 } 4031 4032 switch currArg { 4033 case 0: 4034 var dataRuid uint64 4035 err = decoder.DecodeUint64(&dataRuid) 4036 if err != nil { 4037 return types.GetresuidArgs{}, err 4038 } 4039 result.Ruid = uintptr(dataRuid) 4040 case 1: 4041 var dataEuid uint64 4042 err = decoder.DecodeUint64(&dataEuid) 4043 if err != nil { 4044 return types.GetresuidArgs{}, err 4045 } 4046 result.Euid = uintptr(dataEuid) 4047 case 2: 4048 var dataSuid uint64 4049 err = decoder.DecodeUint64(&dataSuid) 4050 if err != nil { 4051 return types.GetresuidArgs{}, err 4052 } 4053 result.Suid = uintptr(dataSuid) 4054 } 4055 } 4056 return result, nil 4057 } 4058 4059 func ParseSetresgidArgs(decoder *Decoder) (types.SetresgidArgs, error) { 4060 var result types.SetresgidArgs 4061 var err error 4062 4063 var numArgs uint8 4064 err = decoder.DecodeUint8(&numArgs) 4065 if err != nil { 4066 return types.SetresgidArgs{}, err 4067 } 4068 4069 for arg := 0; arg < int(numArgs); arg++ { 4070 var currArg uint8 4071 err = decoder.DecodeUint8(&currArg) 4072 if err != nil { 4073 return types.SetresgidArgs{}, err 4074 } 4075 4076 switch currArg { 4077 case 0: 4078 err = decoder.DecodeInt32(&result.Rgid) 4079 if err != nil { 4080 return types.SetresgidArgs{}, err 4081 } 4082 case 1: 4083 err = decoder.DecodeInt32(&result.Egid) 4084 if err != nil { 4085 return types.SetresgidArgs{}, err 4086 } 4087 case 2: 4088 err = decoder.DecodeInt32(&result.Sgid) 4089 if err != nil { 4090 return types.SetresgidArgs{}, err 4091 } 4092 } 4093 } 4094 return result, nil 4095 } 4096 4097 func ParseGetresgidArgs(decoder *Decoder) (types.GetresgidArgs, error) { 4098 var result types.GetresgidArgs 4099 var err error 4100 4101 var numArgs uint8 4102 err = decoder.DecodeUint8(&numArgs) 4103 if err != nil { 4104 return types.GetresgidArgs{}, err 4105 } 4106 4107 for arg := 0; arg < int(numArgs); arg++ { 4108 var currArg uint8 4109 err = decoder.DecodeUint8(&currArg) 4110 if err != nil { 4111 return types.GetresgidArgs{}, err 4112 } 4113 4114 switch currArg { 4115 case 0: 4116 var dataRgid uint64 4117 err = decoder.DecodeUint64(&dataRgid) 4118 if err != nil { 4119 return types.GetresgidArgs{}, err 4120 } 4121 result.Rgid = uintptr(dataRgid) 4122 case 1: 4123 var dataEgid uint64 4124 err = decoder.DecodeUint64(&dataEgid) 4125 if err != nil { 4126 return types.GetresgidArgs{}, err 4127 } 4128 result.Egid = uintptr(dataEgid) 4129 case 2: 4130 var dataSgid uint64 4131 err = decoder.DecodeUint64(&dataSgid) 4132 if err != nil { 4133 return types.GetresgidArgs{}, err 4134 } 4135 result.Sgid = uintptr(dataSgid) 4136 } 4137 } 4138 return result, nil 4139 } 4140 4141 func ParseGetpgidArgs(decoder *Decoder) (types.GetpgidArgs, error) { 4142 var result types.GetpgidArgs 4143 var err error 4144 4145 var numArgs uint8 4146 err = decoder.DecodeUint8(&numArgs) 4147 if err != nil { 4148 return types.GetpgidArgs{}, err 4149 } 4150 4151 for arg := 0; arg < int(numArgs); arg++ { 4152 var currArg uint8 4153 err = decoder.DecodeUint8(&currArg) 4154 if err != nil { 4155 return types.GetpgidArgs{}, err 4156 } 4157 4158 switch currArg { 4159 case 0: 4160 err = decoder.DecodeInt32(&result.Pid) 4161 if err != nil { 4162 return types.GetpgidArgs{}, err 4163 } 4164 } 4165 } 4166 return result, nil 4167 } 4168 4169 func ParseSetfsuidArgs(decoder *Decoder) (types.SetfsuidArgs, error) { 4170 var result types.SetfsuidArgs 4171 var err error 4172 4173 var numArgs uint8 4174 err = decoder.DecodeUint8(&numArgs) 4175 if err != nil { 4176 return types.SetfsuidArgs{}, err 4177 } 4178 4179 for arg := 0; arg < int(numArgs); arg++ { 4180 var currArg uint8 4181 err = decoder.DecodeUint8(&currArg) 4182 if err != nil { 4183 return types.SetfsuidArgs{}, err 4184 } 4185 4186 switch currArg { 4187 case 0: 4188 err = decoder.DecodeInt32(&result.Fsuid) 4189 if err != nil { 4190 return types.SetfsuidArgs{}, err 4191 } 4192 } 4193 } 4194 return result, nil 4195 } 4196 4197 func ParseSetfsgidArgs(decoder *Decoder) (types.SetfsgidArgs, error) { 4198 var result types.SetfsgidArgs 4199 var err error 4200 4201 var numArgs uint8 4202 err = decoder.DecodeUint8(&numArgs) 4203 if err != nil { 4204 return types.SetfsgidArgs{}, err 4205 } 4206 4207 for arg := 0; arg < int(numArgs); arg++ { 4208 var currArg uint8 4209 err = decoder.DecodeUint8(&currArg) 4210 if err != nil { 4211 return types.SetfsgidArgs{}, err 4212 } 4213 4214 switch currArg { 4215 case 0: 4216 err = decoder.DecodeInt32(&result.Fsgid) 4217 if err != nil { 4218 return types.SetfsgidArgs{}, err 4219 } 4220 } 4221 } 4222 return result, nil 4223 } 4224 4225 func ParseGetsidArgs(decoder *Decoder) (types.GetsidArgs, error) { 4226 var result types.GetsidArgs 4227 var err error 4228 4229 var numArgs uint8 4230 err = decoder.DecodeUint8(&numArgs) 4231 if err != nil { 4232 return types.GetsidArgs{}, err 4233 } 4234 4235 for arg := 0; arg < int(numArgs); arg++ { 4236 var currArg uint8 4237 err = decoder.DecodeUint8(&currArg) 4238 if err != nil { 4239 return types.GetsidArgs{}, err 4240 } 4241 4242 switch currArg { 4243 case 0: 4244 err = decoder.DecodeInt32(&result.Pid) 4245 if err != nil { 4246 return types.GetsidArgs{}, err 4247 } 4248 } 4249 } 4250 return result, nil 4251 } 4252 4253 func ParseCapgetArgs(decoder *Decoder) (types.CapgetArgs, error) { 4254 var result types.CapgetArgs 4255 var err error 4256 4257 var numArgs uint8 4258 err = decoder.DecodeUint8(&numArgs) 4259 if err != nil { 4260 return types.CapgetArgs{}, err 4261 } 4262 4263 for arg := 0; arg < int(numArgs); arg++ { 4264 var currArg uint8 4265 err = decoder.DecodeUint8(&currArg) 4266 if err != nil { 4267 return types.CapgetArgs{}, err 4268 } 4269 4270 switch currArg { 4271 case 0: 4272 var dataHdrp uint64 4273 err = decoder.DecodeUint64(&dataHdrp) 4274 if err != nil { 4275 return types.CapgetArgs{}, err 4276 } 4277 result.Hdrp = uintptr(dataHdrp) 4278 case 1: 4279 var dataDatap uint64 4280 err = decoder.DecodeUint64(&dataDatap) 4281 if err != nil { 4282 return types.CapgetArgs{}, err 4283 } 4284 result.Datap = uintptr(dataDatap) 4285 } 4286 } 4287 return result, nil 4288 } 4289 4290 func ParseCapsetArgs(decoder *Decoder) (types.CapsetArgs, error) { 4291 var result types.CapsetArgs 4292 var err error 4293 4294 var numArgs uint8 4295 err = decoder.DecodeUint8(&numArgs) 4296 if err != nil { 4297 return types.CapsetArgs{}, err 4298 } 4299 4300 for arg := 0; arg < int(numArgs); arg++ { 4301 var currArg uint8 4302 err = decoder.DecodeUint8(&currArg) 4303 if err != nil { 4304 return types.CapsetArgs{}, err 4305 } 4306 4307 switch currArg { 4308 case 0: 4309 var dataHdrp uint64 4310 err = decoder.DecodeUint64(&dataHdrp) 4311 if err != nil { 4312 return types.CapsetArgs{}, err 4313 } 4314 result.Hdrp = uintptr(dataHdrp) 4315 case 1: 4316 var dataDatap uint64 4317 err = decoder.DecodeUint64(&dataDatap) 4318 if err != nil { 4319 return types.CapsetArgs{}, err 4320 } 4321 result.Datap = uintptr(dataDatap) 4322 } 4323 } 4324 return result, nil 4325 } 4326 4327 func ParseRtSigpendingArgs(decoder *Decoder) (types.RtSigpendingArgs, error) { 4328 var result types.RtSigpendingArgs 4329 var err error 4330 4331 var numArgs uint8 4332 err = decoder.DecodeUint8(&numArgs) 4333 if err != nil { 4334 return types.RtSigpendingArgs{}, err 4335 } 4336 4337 for arg := 0; arg < int(numArgs); arg++ { 4338 var currArg uint8 4339 err = decoder.DecodeUint8(&currArg) 4340 if err != nil { 4341 return types.RtSigpendingArgs{}, err 4342 } 4343 4344 switch currArg { 4345 case 0: 4346 var dataSet uint64 4347 err = decoder.DecodeUint64(&dataSet) 4348 if err != nil { 4349 return types.RtSigpendingArgs{}, err 4350 } 4351 result.Set = uintptr(dataSet) 4352 case 1: 4353 err = decoder.DecodeUint64(&result.Sigsetsize) 4354 if err != nil { 4355 return types.RtSigpendingArgs{}, err 4356 } 4357 } 4358 } 4359 return result, nil 4360 } 4361 4362 func ParseRtSigtimedwaitArgs(decoder *Decoder) (types.RtSigtimedwaitArgs, error) { 4363 var result types.RtSigtimedwaitArgs 4364 var err error 4365 4366 var numArgs uint8 4367 err = decoder.DecodeUint8(&numArgs) 4368 if err != nil { 4369 return types.RtSigtimedwaitArgs{}, err 4370 } 4371 4372 for arg := 0; arg < int(numArgs); arg++ { 4373 var currArg uint8 4374 err = decoder.DecodeUint8(&currArg) 4375 if err != nil { 4376 return types.RtSigtimedwaitArgs{}, err 4377 } 4378 4379 switch currArg { 4380 case 0: 4381 var dataSet uint64 4382 err = decoder.DecodeUint64(&dataSet) 4383 if err != nil { 4384 return types.RtSigtimedwaitArgs{}, err 4385 } 4386 result.Set = uintptr(dataSet) 4387 case 1: 4388 var dataInfo uint64 4389 err = decoder.DecodeUint64(&dataInfo) 4390 if err != nil { 4391 return types.RtSigtimedwaitArgs{}, err 4392 } 4393 result.Info = uintptr(dataInfo) 4394 case 2: 4395 result.Timeout, err = decoder.ReadTimespec() 4396 if err != nil { 4397 return types.RtSigtimedwaitArgs{}, err 4398 } 4399 case 3: 4400 err = decoder.DecodeUint64(&result.Sigsetsize) 4401 if err != nil { 4402 return types.RtSigtimedwaitArgs{}, err 4403 } 4404 } 4405 } 4406 return result, nil 4407 } 4408 4409 func ParseRtSigqueueinfoArgs(decoder *Decoder) (types.RtSigqueueinfoArgs, error) { 4410 var result types.RtSigqueueinfoArgs 4411 var err error 4412 4413 var numArgs uint8 4414 err = decoder.DecodeUint8(&numArgs) 4415 if err != nil { 4416 return types.RtSigqueueinfoArgs{}, err 4417 } 4418 4419 for arg := 0; arg < int(numArgs); arg++ { 4420 var currArg uint8 4421 err = decoder.DecodeUint8(&currArg) 4422 if err != nil { 4423 return types.RtSigqueueinfoArgs{}, err 4424 } 4425 4426 switch currArg { 4427 case 0: 4428 err = decoder.DecodeInt32(&result.Tgid) 4429 if err != nil { 4430 return types.RtSigqueueinfoArgs{}, err 4431 } 4432 case 1: 4433 err = decoder.DecodeInt32(&result.Sig) 4434 if err != nil { 4435 return types.RtSigqueueinfoArgs{}, err 4436 } 4437 case 2: 4438 var dataInfo uint64 4439 err = decoder.DecodeUint64(&dataInfo) 4440 if err != nil { 4441 return types.RtSigqueueinfoArgs{}, err 4442 } 4443 result.Info = uintptr(dataInfo) 4444 } 4445 } 4446 return result, nil 4447 } 4448 4449 func ParseRtSigsuspendArgs(decoder *Decoder) (types.RtSigsuspendArgs, error) { 4450 var result types.RtSigsuspendArgs 4451 var err error 4452 4453 var numArgs uint8 4454 err = decoder.DecodeUint8(&numArgs) 4455 if err != nil { 4456 return types.RtSigsuspendArgs{}, err 4457 } 4458 4459 for arg := 0; arg < int(numArgs); arg++ { 4460 var currArg uint8 4461 err = decoder.DecodeUint8(&currArg) 4462 if err != nil { 4463 return types.RtSigsuspendArgs{}, err 4464 } 4465 4466 switch currArg { 4467 case 0: 4468 var dataMask uint64 4469 err = decoder.DecodeUint64(&dataMask) 4470 if err != nil { 4471 return types.RtSigsuspendArgs{}, err 4472 } 4473 result.Mask = uintptr(dataMask) 4474 case 1: 4475 err = decoder.DecodeUint64(&result.Sigsetsize) 4476 if err != nil { 4477 return types.RtSigsuspendArgs{}, err 4478 } 4479 } 4480 } 4481 return result, nil 4482 } 4483 4484 func ParseSigaltstackArgs(decoder *Decoder) (types.SigaltstackArgs, error) { 4485 var result types.SigaltstackArgs 4486 var err error 4487 4488 var numArgs uint8 4489 err = decoder.DecodeUint8(&numArgs) 4490 if err != nil { 4491 return types.SigaltstackArgs{}, err 4492 } 4493 4494 for arg := 0; arg < int(numArgs); arg++ { 4495 var currArg uint8 4496 err = decoder.DecodeUint8(&currArg) 4497 if err != nil { 4498 return types.SigaltstackArgs{}, err 4499 } 4500 4501 switch currArg { 4502 case 0: 4503 var dataSs uint64 4504 err = decoder.DecodeUint64(&dataSs) 4505 if err != nil { 4506 return types.SigaltstackArgs{}, err 4507 } 4508 result.Ss = uintptr(dataSs) 4509 case 1: 4510 var dataOldSs uint64 4511 err = decoder.DecodeUint64(&dataOldSs) 4512 if err != nil { 4513 return types.SigaltstackArgs{}, err 4514 } 4515 result.OldSs = uintptr(dataOldSs) 4516 } 4517 } 4518 return result, nil 4519 } 4520 4521 func ParseUtimeArgs(decoder *Decoder) (types.UtimeArgs, error) { 4522 var result types.UtimeArgs 4523 var err error 4524 4525 var numArgs uint8 4526 err = decoder.DecodeUint8(&numArgs) 4527 if err != nil { 4528 return types.UtimeArgs{}, err 4529 } 4530 4531 for arg := 0; arg < int(numArgs); arg++ { 4532 var currArg uint8 4533 err = decoder.DecodeUint8(&currArg) 4534 if err != nil { 4535 return types.UtimeArgs{}, err 4536 } 4537 4538 switch currArg { 4539 case 0: 4540 result.Filename, err = decoder.ReadStringFromBuff() 4541 if err != nil { 4542 return types.UtimeArgs{}, err 4543 } 4544 case 1: 4545 var dataTimes uint64 4546 err = decoder.DecodeUint64(&dataTimes) 4547 if err != nil { 4548 return types.UtimeArgs{}, err 4549 } 4550 result.Times = uintptr(dataTimes) 4551 } 4552 } 4553 return result, nil 4554 } 4555 4556 func ParseMknodArgs(decoder *Decoder) (types.MknodArgs, error) { 4557 var result types.MknodArgs 4558 var err error 4559 4560 var numArgs uint8 4561 err = decoder.DecodeUint8(&numArgs) 4562 if err != nil { 4563 return types.MknodArgs{}, err 4564 } 4565 4566 for arg := 0; arg < int(numArgs); arg++ { 4567 var currArg uint8 4568 err = decoder.DecodeUint8(&currArg) 4569 if err != nil { 4570 return types.MknodArgs{}, err 4571 } 4572 4573 switch currArg { 4574 case 0: 4575 result.Pathname, err = decoder.ReadStringFromBuff() 4576 if err != nil { 4577 return types.MknodArgs{}, err 4578 } 4579 case 1: 4580 err = decoder.DecodeUint32(&result.Mode) 4581 if err != nil { 4582 return types.MknodArgs{}, err 4583 } 4584 case 2: 4585 err = decoder.DecodeUint32(&result.Dev) 4586 if err != nil { 4587 return types.MknodArgs{}, err 4588 } 4589 } 4590 } 4591 return result, nil 4592 } 4593 4594 func ParseUselibArgs(decoder *Decoder) (types.UselibArgs, error) { 4595 var result types.UselibArgs 4596 var err error 4597 4598 var numArgs uint8 4599 err = decoder.DecodeUint8(&numArgs) 4600 if err != nil { 4601 return types.UselibArgs{}, err 4602 } 4603 4604 for arg := 0; arg < int(numArgs); arg++ { 4605 var currArg uint8 4606 err = decoder.DecodeUint8(&currArg) 4607 if err != nil { 4608 return types.UselibArgs{}, err 4609 } 4610 4611 switch currArg { 4612 case 0: 4613 result.Library, err = decoder.ReadStringFromBuff() 4614 if err != nil { 4615 return types.UselibArgs{}, err 4616 } 4617 } 4618 } 4619 return result, nil 4620 } 4621 4622 func ParsePersonalityArgs(decoder *Decoder) (types.PersonalityArgs, error) { 4623 var result types.PersonalityArgs 4624 var err error 4625 4626 var numArgs uint8 4627 err = decoder.DecodeUint8(&numArgs) 4628 if err != nil { 4629 return types.PersonalityArgs{}, err 4630 } 4631 4632 for arg := 0; arg < int(numArgs); arg++ { 4633 var currArg uint8 4634 err = decoder.DecodeUint8(&currArg) 4635 if err != nil { 4636 return types.PersonalityArgs{}, err 4637 } 4638 4639 switch currArg { 4640 case 0: 4641 err = decoder.DecodeUint64(&result.Persona) 4642 if err != nil { 4643 return types.PersonalityArgs{}, err 4644 } 4645 } 4646 } 4647 return result, nil 4648 } 4649 4650 func ParseUstatArgs(decoder *Decoder) (types.UstatArgs, error) { 4651 var result types.UstatArgs 4652 var err error 4653 4654 var numArgs uint8 4655 err = decoder.DecodeUint8(&numArgs) 4656 if err != nil { 4657 return types.UstatArgs{}, err 4658 } 4659 4660 for arg := 0; arg < int(numArgs); arg++ { 4661 var currArg uint8 4662 err = decoder.DecodeUint8(&currArg) 4663 if err != nil { 4664 return types.UstatArgs{}, err 4665 } 4666 4667 switch currArg { 4668 case 0: 4669 err = decoder.DecodeUint32(&result.Dev) 4670 if err != nil { 4671 return types.UstatArgs{}, err 4672 } 4673 case 1: 4674 var dataUbuf uint64 4675 err = decoder.DecodeUint64(&dataUbuf) 4676 if err != nil { 4677 return types.UstatArgs{}, err 4678 } 4679 result.Ubuf = uintptr(dataUbuf) 4680 } 4681 } 4682 return result, nil 4683 } 4684 4685 func ParseStatfsArgs(decoder *Decoder) (types.StatfsArgs, error) { 4686 var result types.StatfsArgs 4687 var err error 4688 4689 var numArgs uint8 4690 err = decoder.DecodeUint8(&numArgs) 4691 if err != nil { 4692 return types.StatfsArgs{}, err 4693 } 4694 4695 for arg := 0; arg < int(numArgs); arg++ { 4696 var currArg uint8 4697 err = decoder.DecodeUint8(&currArg) 4698 if err != nil { 4699 return types.StatfsArgs{}, err 4700 } 4701 4702 switch currArg { 4703 case 0: 4704 result.Path, err = decoder.ReadStringFromBuff() 4705 if err != nil { 4706 return types.StatfsArgs{}, err 4707 } 4708 case 1: 4709 var dataBuf uint64 4710 err = decoder.DecodeUint64(&dataBuf) 4711 if err != nil { 4712 return types.StatfsArgs{}, err 4713 } 4714 result.Buf = uintptr(dataBuf) 4715 } 4716 } 4717 return result, nil 4718 } 4719 4720 func ParseFstatfsArgs(decoder *Decoder) (types.FstatfsArgs, error) { 4721 var result types.FstatfsArgs 4722 var err error 4723 4724 var numArgs uint8 4725 err = decoder.DecodeUint8(&numArgs) 4726 if err != nil { 4727 return types.FstatfsArgs{}, err 4728 } 4729 4730 for arg := 0; arg < int(numArgs); arg++ { 4731 var currArg uint8 4732 err = decoder.DecodeUint8(&currArg) 4733 if err != nil { 4734 return types.FstatfsArgs{}, err 4735 } 4736 4737 switch currArg { 4738 case 0: 4739 err = decoder.DecodeInt32(&result.Fd) 4740 if err != nil { 4741 return types.FstatfsArgs{}, err 4742 } 4743 case 1: 4744 var dataBuf uint64 4745 err = decoder.DecodeUint64(&dataBuf) 4746 if err != nil { 4747 return types.FstatfsArgs{}, err 4748 } 4749 result.Buf = uintptr(dataBuf) 4750 } 4751 } 4752 return result, nil 4753 } 4754 4755 func ParseSysfsArgs(decoder *Decoder) (types.SysfsArgs, error) { 4756 var result types.SysfsArgs 4757 var err error 4758 4759 var numArgs uint8 4760 err = decoder.DecodeUint8(&numArgs) 4761 if err != nil { 4762 return types.SysfsArgs{}, err 4763 } 4764 4765 for arg := 0; arg < int(numArgs); arg++ { 4766 var currArg uint8 4767 err = decoder.DecodeUint8(&currArg) 4768 if err != nil { 4769 return types.SysfsArgs{}, err 4770 } 4771 4772 switch currArg { 4773 case 0: 4774 err = decoder.DecodeInt32(&result.Option) 4775 if err != nil { 4776 return types.SysfsArgs{}, err 4777 } 4778 } 4779 } 4780 return result, nil 4781 } 4782 4783 func ParseGetpriorityArgs(decoder *Decoder) (types.GetpriorityArgs, error) { 4784 var result types.GetpriorityArgs 4785 var err error 4786 4787 var numArgs uint8 4788 err = decoder.DecodeUint8(&numArgs) 4789 if err != nil { 4790 return types.GetpriorityArgs{}, err 4791 } 4792 4793 for arg := 0; arg < int(numArgs); arg++ { 4794 var currArg uint8 4795 err = decoder.DecodeUint8(&currArg) 4796 if err != nil { 4797 return types.GetpriorityArgs{}, err 4798 } 4799 4800 switch currArg { 4801 case 0: 4802 err = decoder.DecodeInt32(&result.Which) 4803 if err != nil { 4804 return types.GetpriorityArgs{}, err 4805 } 4806 case 1: 4807 err = decoder.DecodeInt32(&result.Who) 4808 if err != nil { 4809 return types.GetpriorityArgs{}, err 4810 } 4811 } 4812 } 4813 return result, nil 4814 } 4815 4816 func ParseSetpriorityArgs(decoder *Decoder) (types.SetpriorityArgs, error) { 4817 var result types.SetpriorityArgs 4818 var err error 4819 4820 var numArgs uint8 4821 err = decoder.DecodeUint8(&numArgs) 4822 if err != nil { 4823 return types.SetpriorityArgs{}, err 4824 } 4825 4826 for arg := 0; arg < int(numArgs); arg++ { 4827 var currArg uint8 4828 err = decoder.DecodeUint8(&currArg) 4829 if err != nil { 4830 return types.SetpriorityArgs{}, err 4831 } 4832 4833 switch currArg { 4834 case 0: 4835 err = decoder.DecodeInt32(&result.Which) 4836 if err != nil { 4837 return types.SetpriorityArgs{}, err 4838 } 4839 case 1: 4840 err = decoder.DecodeInt32(&result.Who) 4841 if err != nil { 4842 return types.SetpriorityArgs{}, err 4843 } 4844 case 2: 4845 err = decoder.DecodeInt32(&result.Prio) 4846 if err != nil { 4847 return types.SetpriorityArgs{}, err 4848 } 4849 } 4850 } 4851 return result, nil 4852 } 4853 4854 func ParseSchedSetparamArgs(decoder *Decoder) (types.SchedSetparamArgs, error) { 4855 var result types.SchedSetparamArgs 4856 var err error 4857 4858 var numArgs uint8 4859 err = decoder.DecodeUint8(&numArgs) 4860 if err != nil { 4861 return types.SchedSetparamArgs{}, err 4862 } 4863 4864 for arg := 0; arg < int(numArgs); arg++ { 4865 var currArg uint8 4866 err = decoder.DecodeUint8(&currArg) 4867 if err != nil { 4868 return types.SchedSetparamArgs{}, err 4869 } 4870 4871 switch currArg { 4872 case 0: 4873 err = decoder.DecodeInt32(&result.Pid) 4874 if err != nil { 4875 return types.SchedSetparamArgs{}, err 4876 } 4877 case 1: 4878 var dataParam uint64 4879 err = decoder.DecodeUint64(&dataParam) 4880 if err != nil { 4881 return types.SchedSetparamArgs{}, err 4882 } 4883 result.Param = uintptr(dataParam) 4884 } 4885 } 4886 return result, nil 4887 } 4888 4889 func ParseSchedGetparamArgs(decoder *Decoder) (types.SchedGetparamArgs, error) { 4890 var result types.SchedGetparamArgs 4891 var err error 4892 4893 var numArgs uint8 4894 err = decoder.DecodeUint8(&numArgs) 4895 if err != nil { 4896 return types.SchedGetparamArgs{}, err 4897 } 4898 4899 for arg := 0; arg < int(numArgs); arg++ { 4900 var currArg uint8 4901 err = decoder.DecodeUint8(&currArg) 4902 if err != nil { 4903 return types.SchedGetparamArgs{}, err 4904 } 4905 4906 switch currArg { 4907 case 0: 4908 err = decoder.DecodeInt32(&result.Pid) 4909 if err != nil { 4910 return types.SchedGetparamArgs{}, err 4911 } 4912 case 1: 4913 var dataParam uint64 4914 err = decoder.DecodeUint64(&dataParam) 4915 if err != nil { 4916 return types.SchedGetparamArgs{}, err 4917 } 4918 result.Param = uintptr(dataParam) 4919 } 4920 } 4921 return result, nil 4922 } 4923 4924 func ParseSchedSetschedulerArgs(decoder *Decoder) (types.SchedSetschedulerArgs, error) { 4925 var result types.SchedSetschedulerArgs 4926 var err error 4927 4928 var numArgs uint8 4929 err = decoder.DecodeUint8(&numArgs) 4930 if err != nil { 4931 return types.SchedSetschedulerArgs{}, err 4932 } 4933 4934 for arg := 0; arg < int(numArgs); arg++ { 4935 var currArg uint8 4936 err = decoder.DecodeUint8(&currArg) 4937 if err != nil { 4938 return types.SchedSetschedulerArgs{}, err 4939 } 4940 4941 switch currArg { 4942 case 0: 4943 err = decoder.DecodeInt32(&result.Pid) 4944 if err != nil { 4945 return types.SchedSetschedulerArgs{}, err 4946 } 4947 case 1: 4948 err = decoder.DecodeInt32(&result.Policy) 4949 if err != nil { 4950 return types.SchedSetschedulerArgs{}, err 4951 } 4952 case 2: 4953 var dataParam uint64 4954 err = decoder.DecodeUint64(&dataParam) 4955 if err != nil { 4956 return types.SchedSetschedulerArgs{}, err 4957 } 4958 result.Param = uintptr(dataParam) 4959 } 4960 } 4961 return result, nil 4962 } 4963 4964 func ParseSchedGetschedulerArgs(decoder *Decoder) (types.SchedGetschedulerArgs, error) { 4965 var result types.SchedGetschedulerArgs 4966 var err error 4967 4968 var numArgs uint8 4969 err = decoder.DecodeUint8(&numArgs) 4970 if err != nil { 4971 return types.SchedGetschedulerArgs{}, err 4972 } 4973 4974 for arg := 0; arg < int(numArgs); arg++ { 4975 var currArg uint8 4976 err = decoder.DecodeUint8(&currArg) 4977 if err != nil { 4978 return types.SchedGetschedulerArgs{}, err 4979 } 4980 4981 switch currArg { 4982 case 0: 4983 err = decoder.DecodeInt32(&result.Pid) 4984 if err != nil { 4985 return types.SchedGetschedulerArgs{}, err 4986 } 4987 } 4988 } 4989 return result, nil 4990 } 4991 4992 func ParseSchedGetPriorityMaxArgs(decoder *Decoder) (types.SchedGetPriorityMaxArgs, error) { 4993 var result types.SchedGetPriorityMaxArgs 4994 var err error 4995 4996 var numArgs uint8 4997 err = decoder.DecodeUint8(&numArgs) 4998 if err != nil { 4999 return types.SchedGetPriorityMaxArgs{}, err 5000 } 5001 5002 for arg := 0; arg < int(numArgs); arg++ { 5003 var currArg uint8 5004 err = decoder.DecodeUint8(&currArg) 5005 if err != nil { 5006 return types.SchedGetPriorityMaxArgs{}, err 5007 } 5008 5009 switch currArg { 5010 case 0: 5011 err = decoder.DecodeInt32(&result.Policy) 5012 if err != nil { 5013 return types.SchedGetPriorityMaxArgs{}, err 5014 } 5015 } 5016 } 5017 return result, nil 5018 } 5019 5020 func ParseSchedGetPriorityMinArgs(decoder *Decoder) (types.SchedGetPriorityMinArgs, error) { 5021 var result types.SchedGetPriorityMinArgs 5022 var err error 5023 5024 var numArgs uint8 5025 err = decoder.DecodeUint8(&numArgs) 5026 if err != nil { 5027 return types.SchedGetPriorityMinArgs{}, err 5028 } 5029 5030 for arg := 0; arg < int(numArgs); arg++ { 5031 var currArg uint8 5032 err = decoder.DecodeUint8(&currArg) 5033 if err != nil { 5034 return types.SchedGetPriorityMinArgs{}, err 5035 } 5036 5037 switch currArg { 5038 case 0: 5039 err = decoder.DecodeInt32(&result.Policy) 5040 if err != nil { 5041 return types.SchedGetPriorityMinArgs{}, err 5042 } 5043 } 5044 } 5045 return result, nil 5046 } 5047 5048 func ParseSchedRrGetIntervalArgs(decoder *Decoder) (types.SchedRrGetIntervalArgs, error) { 5049 var result types.SchedRrGetIntervalArgs 5050 var err error 5051 5052 var numArgs uint8 5053 err = decoder.DecodeUint8(&numArgs) 5054 if err != nil { 5055 return types.SchedRrGetIntervalArgs{}, err 5056 } 5057 5058 for arg := 0; arg < int(numArgs); arg++ { 5059 var currArg uint8 5060 err = decoder.DecodeUint8(&currArg) 5061 if err != nil { 5062 return types.SchedRrGetIntervalArgs{}, err 5063 } 5064 5065 switch currArg { 5066 case 0: 5067 err = decoder.DecodeInt32(&result.Pid) 5068 if err != nil { 5069 return types.SchedRrGetIntervalArgs{}, err 5070 } 5071 case 1: 5072 result.Tp, err = decoder.ReadTimespec() 5073 if err != nil { 5074 return types.SchedRrGetIntervalArgs{}, err 5075 } 5076 } 5077 } 5078 return result, nil 5079 } 5080 5081 func ParseMlockArgs(decoder *Decoder) (types.MlockArgs, error) { 5082 var result types.MlockArgs 5083 var err error 5084 5085 var numArgs uint8 5086 err = decoder.DecodeUint8(&numArgs) 5087 if err != nil { 5088 return types.MlockArgs{}, err 5089 } 5090 5091 for arg := 0; arg < int(numArgs); arg++ { 5092 var currArg uint8 5093 err = decoder.DecodeUint8(&currArg) 5094 if err != nil { 5095 return types.MlockArgs{}, err 5096 } 5097 5098 switch currArg { 5099 case 0: 5100 var dataAddr uint64 5101 err = decoder.DecodeUint64(&dataAddr) 5102 if err != nil { 5103 return types.MlockArgs{}, err 5104 } 5105 result.Addr = uintptr(dataAddr) 5106 case 1: 5107 err = decoder.DecodeUint64(&result.Len) 5108 if err != nil { 5109 return types.MlockArgs{}, err 5110 } 5111 } 5112 } 5113 return result, nil 5114 } 5115 5116 func ParseMunlockArgs(decoder *Decoder) (types.MunlockArgs, error) { 5117 var result types.MunlockArgs 5118 var err error 5119 5120 var numArgs uint8 5121 err = decoder.DecodeUint8(&numArgs) 5122 if err != nil { 5123 return types.MunlockArgs{}, err 5124 } 5125 5126 for arg := 0; arg < int(numArgs); arg++ { 5127 var currArg uint8 5128 err = decoder.DecodeUint8(&currArg) 5129 if err != nil { 5130 return types.MunlockArgs{}, err 5131 } 5132 5133 switch currArg { 5134 case 0: 5135 var dataAddr uint64 5136 err = decoder.DecodeUint64(&dataAddr) 5137 if err != nil { 5138 return types.MunlockArgs{}, err 5139 } 5140 result.Addr = uintptr(dataAddr) 5141 case 1: 5142 err = decoder.DecodeUint64(&result.Len) 5143 if err != nil { 5144 return types.MunlockArgs{}, err 5145 } 5146 } 5147 } 5148 return result, nil 5149 } 5150 5151 func ParseMlockallArgs(decoder *Decoder) (types.MlockallArgs, error) { 5152 var result types.MlockallArgs 5153 var err error 5154 5155 var numArgs uint8 5156 err = decoder.DecodeUint8(&numArgs) 5157 if err != nil { 5158 return types.MlockallArgs{}, err 5159 } 5160 5161 for arg := 0; arg < int(numArgs); arg++ { 5162 var currArg uint8 5163 err = decoder.DecodeUint8(&currArg) 5164 if err != nil { 5165 return types.MlockallArgs{}, err 5166 } 5167 5168 switch currArg { 5169 case 0: 5170 err = decoder.DecodeInt32(&result.Flags) 5171 if err != nil { 5172 return types.MlockallArgs{}, err 5173 } 5174 } 5175 } 5176 return result, nil 5177 } 5178 5179 func ParseMunlockallArgs(decoder *Decoder) (types.MunlockallArgs, error) { 5180 return types.MunlockallArgs{}, nil 5181 } 5182 5183 func ParseVhangupArgs(decoder *Decoder) (types.VhangupArgs, error) { 5184 return types.VhangupArgs{}, nil 5185 } 5186 5187 func ParseModifyLdtArgs(decoder *Decoder) (types.ModifyLdtArgs, error) { 5188 var result types.ModifyLdtArgs 5189 var err error 5190 5191 var numArgs uint8 5192 err = decoder.DecodeUint8(&numArgs) 5193 if err != nil { 5194 return types.ModifyLdtArgs{}, err 5195 } 5196 5197 for arg := 0; arg < int(numArgs); arg++ { 5198 var currArg uint8 5199 err = decoder.DecodeUint8(&currArg) 5200 if err != nil { 5201 return types.ModifyLdtArgs{}, err 5202 } 5203 5204 switch currArg { 5205 case 0: 5206 err = decoder.DecodeInt32(&result.Func) 5207 if err != nil { 5208 return types.ModifyLdtArgs{}, err 5209 } 5210 case 1: 5211 var dataPtr uint64 5212 err = decoder.DecodeUint64(&dataPtr) 5213 if err != nil { 5214 return types.ModifyLdtArgs{}, err 5215 } 5216 result.Ptr = uintptr(dataPtr) 5217 case 2: 5218 err = decoder.DecodeUint64(&result.Bytecount) 5219 if err != nil { 5220 return types.ModifyLdtArgs{}, err 5221 } 5222 } 5223 } 5224 return result, nil 5225 } 5226 5227 func ParsePivotRootArgs(decoder *Decoder) (types.PivotRootArgs, error) { 5228 var result types.PivotRootArgs 5229 var err error 5230 5231 var numArgs uint8 5232 err = decoder.DecodeUint8(&numArgs) 5233 if err != nil { 5234 return types.PivotRootArgs{}, err 5235 } 5236 5237 for arg := 0; arg < int(numArgs); arg++ { 5238 var currArg uint8 5239 err = decoder.DecodeUint8(&currArg) 5240 if err != nil { 5241 return types.PivotRootArgs{}, err 5242 } 5243 5244 switch currArg { 5245 case 0: 5246 result.NewRoot, err = decoder.ReadStringFromBuff() 5247 if err != nil { 5248 return types.PivotRootArgs{}, err 5249 } 5250 case 1: 5251 result.PutOld, err = decoder.ReadStringFromBuff() 5252 if err != nil { 5253 return types.PivotRootArgs{}, err 5254 } 5255 } 5256 } 5257 return result, nil 5258 } 5259 5260 func ParseSysctlArgs(decoder *Decoder) (types.SysctlArgs, error) { 5261 var result types.SysctlArgs 5262 var err error 5263 5264 var numArgs uint8 5265 err = decoder.DecodeUint8(&numArgs) 5266 if err != nil { 5267 return types.SysctlArgs{}, err 5268 } 5269 5270 for arg := 0; arg < int(numArgs); arg++ { 5271 var currArg uint8 5272 err = decoder.DecodeUint8(&currArg) 5273 if err != nil { 5274 return types.SysctlArgs{}, err 5275 } 5276 5277 switch currArg { 5278 case 0: 5279 var dataArgs uint64 5280 err = decoder.DecodeUint64(&dataArgs) 5281 if err != nil { 5282 return types.SysctlArgs{}, err 5283 } 5284 result.Args = uintptr(dataArgs) 5285 } 5286 } 5287 return result, nil 5288 } 5289 5290 func ParsePrctlArgs(decoder *Decoder) (types.PrctlArgs, error) { 5291 var result types.PrctlArgs 5292 var err error 5293 5294 var numArgs uint8 5295 err = decoder.DecodeUint8(&numArgs) 5296 if err != nil { 5297 return types.PrctlArgs{}, err 5298 } 5299 5300 for arg := 0; arg < int(numArgs); arg++ { 5301 var currArg uint8 5302 err = decoder.DecodeUint8(&currArg) 5303 if err != nil { 5304 return types.PrctlArgs{}, err 5305 } 5306 5307 switch currArg { 5308 case 0: 5309 err = decoder.DecodeInt32(&result.Option) 5310 if err != nil { 5311 return types.PrctlArgs{}, err 5312 } 5313 case 1: 5314 err = decoder.DecodeUint64(&result.Arg2) 5315 if err != nil { 5316 return types.PrctlArgs{}, err 5317 } 5318 case 2: 5319 err = decoder.DecodeUint64(&result.Arg3) 5320 if err != nil { 5321 return types.PrctlArgs{}, err 5322 } 5323 case 3: 5324 err = decoder.DecodeUint64(&result.Arg4) 5325 if err != nil { 5326 return types.PrctlArgs{}, err 5327 } 5328 case 4: 5329 err = decoder.DecodeUint64(&result.Arg5) 5330 if err != nil { 5331 return types.PrctlArgs{}, err 5332 } 5333 } 5334 } 5335 return result, nil 5336 } 5337 5338 func ParseArchPrctlArgs(decoder *Decoder) (types.ArchPrctlArgs, error) { 5339 var result types.ArchPrctlArgs 5340 var err error 5341 5342 var numArgs uint8 5343 err = decoder.DecodeUint8(&numArgs) 5344 if err != nil { 5345 return types.ArchPrctlArgs{}, err 5346 } 5347 5348 for arg := 0; arg < int(numArgs); arg++ { 5349 var currArg uint8 5350 err = decoder.DecodeUint8(&currArg) 5351 if err != nil { 5352 return types.ArchPrctlArgs{}, err 5353 } 5354 5355 switch currArg { 5356 case 0: 5357 err = decoder.DecodeInt32(&result.Option) 5358 if err != nil { 5359 return types.ArchPrctlArgs{}, err 5360 } 5361 case 1: 5362 err = decoder.DecodeUint64(&result.Addr) 5363 if err != nil { 5364 return types.ArchPrctlArgs{}, err 5365 } 5366 } 5367 } 5368 return result, nil 5369 } 5370 5371 func ParseAdjtimexArgs(decoder *Decoder) (types.AdjtimexArgs, error) { 5372 var result types.AdjtimexArgs 5373 var err error 5374 5375 var numArgs uint8 5376 err = decoder.DecodeUint8(&numArgs) 5377 if err != nil { 5378 return types.AdjtimexArgs{}, err 5379 } 5380 5381 for arg := 0; arg < int(numArgs); arg++ { 5382 var currArg uint8 5383 err = decoder.DecodeUint8(&currArg) 5384 if err != nil { 5385 return types.AdjtimexArgs{}, err 5386 } 5387 5388 switch currArg { 5389 case 0: 5390 var dataBuf uint64 5391 err = decoder.DecodeUint64(&dataBuf) 5392 if err != nil { 5393 return types.AdjtimexArgs{}, err 5394 } 5395 result.Buf = uintptr(dataBuf) 5396 } 5397 } 5398 return result, nil 5399 } 5400 5401 func ParseSetrlimitArgs(decoder *Decoder) (types.SetrlimitArgs, error) { 5402 var result types.SetrlimitArgs 5403 var err error 5404 5405 var numArgs uint8 5406 err = decoder.DecodeUint8(&numArgs) 5407 if err != nil { 5408 return types.SetrlimitArgs{}, err 5409 } 5410 5411 for arg := 0; arg < int(numArgs); arg++ { 5412 var currArg uint8 5413 err = decoder.DecodeUint8(&currArg) 5414 if err != nil { 5415 return types.SetrlimitArgs{}, err 5416 } 5417 5418 switch currArg { 5419 case 0: 5420 err = decoder.DecodeInt32(&result.Resource) 5421 if err != nil { 5422 return types.SetrlimitArgs{}, err 5423 } 5424 case 1: 5425 var dataRlim uint64 5426 err = decoder.DecodeUint64(&dataRlim) 5427 if err != nil { 5428 return types.SetrlimitArgs{}, err 5429 } 5430 result.Rlim = uintptr(dataRlim) 5431 } 5432 } 5433 return result, nil 5434 } 5435 5436 func ParseChrootArgs(decoder *Decoder) (types.ChrootArgs, error) { 5437 var result types.ChrootArgs 5438 var err error 5439 5440 var numArgs uint8 5441 err = decoder.DecodeUint8(&numArgs) 5442 if err != nil { 5443 return types.ChrootArgs{}, err 5444 } 5445 5446 for arg := 0; arg < int(numArgs); arg++ { 5447 var currArg uint8 5448 err = decoder.DecodeUint8(&currArg) 5449 if err != nil { 5450 return types.ChrootArgs{}, err 5451 } 5452 5453 switch currArg { 5454 case 0: 5455 result.Path, err = decoder.ReadStringFromBuff() 5456 if err != nil { 5457 return types.ChrootArgs{}, err 5458 } 5459 } 5460 } 5461 return result, nil 5462 } 5463 5464 func ParseSyncArgs(decoder *Decoder) (types.SyncArgs, error) { 5465 return types.SyncArgs{}, nil 5466 } 5467 5468 func ParseAcctArgs(decoder *Decoder) (types.AcctArgs, error) { 5469 var result types.AcctArgs 5470 var err error 5471 5472 var numArgs uint8 5473 err = decoder.DecodeUint8(&numArgs) 5474 if err != nil { 5475 return types.AcctArgs{}, err 5476 } 5477 5478 for arg := 0; arg < int(numArgs); arg++ { 5479 var currArg uint8 5480 err = decoder.DecodeUint8(&currArg) 5481 if err != nil { 5482 return types.AcctArgs{}, err 5483 } 5484 5485 switch currArg { 5486 case 0: 5487 result.Filename, err = decoder.ReadStringFromBuff() 5488 if err != nil { 5489 return types.AcctArgs{}, err 5490 } 5491 } 5492 } 5493 return result, nil 5494 } 5495 5496 func ParseSettimeofdayArgs(decoder *Decoder) (types.SettimeofdayArgs, error) { 5497 var result types.SettimeofdayArgs 5498 var err error 5499 5500 var numArgs uint8 5501 err = decoder.DecodeUint8(&numArgs) 5502 if err != nil { 5503 return types.SettimeofdayArgs{}, err 5504 } 5505 5506 for arg := 0; arg < int(numArgs); arg++ { 5507 var currArg uint8 5508 err = decoder.DecodeUint8(&currArg) 5509 if err != nil { 5510 return types.SettimeofdayArgs{}, err 5511 } 5512 5513 switch currArg { 5514 case 0: 5515 var dataTv uint64 5516 err = decoder.DecodeUint64(&dataTv) 5517 if err != nil { 5518 return types.SettimeofdayArgs{}, err 5519 } 5520 result.Tv = uintptr(dataTv) 5521 case 1: 5522 var dataTz uint64 5523 err = decoder.DecodeUint64(&dataTz) 5524 if err != nil { 5525 return types.SettimeofdayArgs{}, err 5526 } 5527 result.Tz = uintptr(dataTz) 5528 } 5529 } 5530 return result, nil 5531 } 5532 5533 func ParseMountArgs(decoder *Decoder) (types.MountArgs, error) { 5534 var result types.MountArgs 5535 var err error 5536 5537 var numArgs uint8 5538 err = decoder.DecodeUint8(&numArgs) 5539 if err != nil { 5540 return types.MountArgs{}, err 5541 } 5542 5543 for arg := 0; arg < int(numArgs); arg++ { 5544 var currArg uint8 5545 err = decoder.DecodeUint8(&currArg) 5546 if err != nil { 5547 return types.MountArgs{}, err 5548 } 5549 5550 switch currArg { 5551 case 0: 5552 result.Source, err = decoder.ReadStringFromBuff() 5553 if err != nil { 5554 return types.MountArgs{}, err 5555 } 5556 case 1: 5557 result.Target, err = decoder.ReadStringFromBuff() 5558 if err != nil { 5559 return types.MountArgs{}, err 5560 } 5561 case 2: 5562 result.Filesystemtype, err = decoder.ReadStringFromBuff() 5563 if err != nil { 5564 return types.MountArgs{}, err 5565 } 5566 case 3: 5567 err = decoder.DecodeUint64(&result.Mountflags) 5568 if err != nil { 5569 return types.MountArgs{}, err 5570 } 5571 case 4: 5572 var dataData uint64 5573 err = decoder.DecodeUint64(&dataData) 5574 if err != nil { 5575 return types.MountArgs{}, err 5576 } 5577 result.Data = uintptr(dataData) 5578 } 5579 } 5580 return result, nil 5581 } 5582 5583 func ParseUmount2Args(decoder *Decoder) (types.Umount2Args, error) { 5584 var result types.Umount2Args 5585 var err error 5586 5587 var numArgs uint8 5588 err = decoder.DecodeUint8(&numArgs) 5589 if err != nil { 5590 return types.Umount2Args{}, err 5591 } 5592 5593 for arg := 0; arg < int(numArgs); arg++ { 5594 var currArg uint8 5595 err = decoder.DecodeUint8(&currArg) 5596 if err != nil { 5597 return types.Umount2Args{}, err 5598 } 5599 5600 switch currArg { 5601 case 0: 5602 result.Target, err = decoder.ReadStringFromBuff() 5603 if err != nil { 5604 return types.Umount2Args{}, err 5605 } 5606 case 1: 5607 err = decoder.DecodeInt32(&result.Flags) 5608 if err != nil { 5609 return types.Umount2Args{}, err 5610 } 5611 } 5612 } 5613 return result, nil 5614 } 5615 5616 func ParseSwaponArgs(decoder *Decoder) (types.SwaponArgs, error) { 5617 var result types.SwaponArgs 5618 var err error 5619 5620 var numArgs uint8 5621 err = decoder.DecodeUint8(&numArgs) 5622 if err != nil { 5623 return types.SwaponArgs{}, err 5624 } 5625 5626 for arg := 0; arg < int(numArgs); arg++ { 5627 var currArg uint8 5628 err = decoder.DecodeUint8(&currArg) 5629 if err != nil { 5630 return types.SwaponArgs{}, err 5631 } 5632 5633 switch currArg { 5634 case 0: 5635 result.Path, err = decoder.ReadStringFromBuff() 5636 if err != nil { 5637 return types.SwaponArgs{}, err 5638 } 5639 case 1: 5640 err = decoder.DecodeInt32(&result.Swapflags) 5641 if err != nil { 5642 return types.SwaponArgs{}, err 5643 } 5644 } 5645 } 5646 return result, nil 5647 } 5648 5649 func ParseSwapoffArgs(decoder *Decoder) (types.SwapoffArgs, error) { 5650 var result types.SwapoffArgs 5651 var err error 5652 5653 var numArgs uint8 5654 err = decoder.DecodeUint8(&numArgs) 5655 if err != nil { 5656 return types.SwapoffArgs{}, err 5657 } 5658 5659 for arg := 0; arg < int(numArgs); arg++ { 5660 var currArg uint8 5661 err = decoder.DecodeUint8(&currArg) 5662 if err != nil { 5663 return types.SwapoffArgs{}, err 5664 } 5665 5666 switch currArg { 5667 case 0: 5668 result.Path, err = decoder.ReadStringFromBuff() 5669 if err != nil { 5670 return types.SwapoffArgs{}, err 5671 } 5672 } 5673 } 5674 return result, nil 5675 } 5676 5677 func ParseRebootArgs(decoder *Decoder) (types.RebootArgs, error) { 5678 var result types.RebootArgs 5679 var err error 5680 5681 var numArgs uint8 5682 err = decoder.DecodeUint8(&numArgs) 5683 if err != nil { 5684 return types.RebootArgs{}, err 5685 } 5686 5687 for arg := 0; arg < int(numArgs); arg++ { 5688 var currArg uint8 5689 err = decoder.DecodeUint8(&currArg) 5690 if err != nil { 5691 return types.RebootArgs{}, err 5692 } 5693 5694 switch currArg { 5695 case 0: 5696 err = decoder.DecodeInt32(&result.Magic) 5697 if err != nil { 5698 return types.RebootArgs{}, err 5699 } 5700 case 1: 5701 err = decoder.DecodeInt32(&result.Magic2) 5702 if err != nil { 5703 return types.RebootArgs{}, err 5704 } 5705 case 2: 5706 err = decoder.DecodeInt32(&result.Cmd) 5707 if err != nil { 5708 return types.RebootArgs{}, err 5709 } 5710 case 3: 5711 var dataArg uint64 5712 err = decoder.DecodeUint64(&dataArg) 5713 if err != nil { 5714 return types.RebootArgs{}, err 5715 } 5716 result.Arg = uintptr(dataArg) 5717 } 5718 } 5719 return result, nil 5720 } 5721 5722 func ParseSethostnameArgs(decoder *Decoder) (types.SethostnameArgs, error) { 5723 var result types.SethostnameArgs 5724 var err error 5725 5726 var numArgs uint8 5727 err = decoder.DecodeUint8(&numArgs) 5728 if err != nil { 5729 return types.SethostnameArgs{}, err 5730 } 5731 5732 for arg := 0; arg < int(numArgs); arg++ { 5733 var currArg uint8 5734 err = decoder.DecodeUint8(&currArg) 5735 if err != nil { 5736 return types.SethostnameArgs{}, err 5737 } 5738 5739 switch currArg { 5740 case 0: 5741 result.Name, err = decoder.ReadStringFromBuff() 5742 if err != nil { 5743 return types.SethostnameArgs{}, err 5744 } 5745 case 1: 5746 err = decoder.DecodeUint64(&result.Len) 5747 if err != nil { 5748 return types.SethostnameArgs{}, err 5749 } 5750 } 5751 } 5752 return result, nil 5753 } 5754 5755 func ParseSetdomainnameArgs(decoder *Decoder) (types.SetdomainnameArgs, error) { 5756 var result types.SetdomainnameArgs 5757 var err error 5758 5759 var numArgs uint8 5760 err = decoder.DecodeUint8(&numArgs) 5761 if err != nil { 5762 return types.SetdomainnameArgs{}, err 5763 } 5764 5765 for arg := 0; arg < int(numArgs); arg++ { 5766 var currArg uint8 5767 err = decoder.DecodeUint8(&currArg) 5768 if err != nil { 5769 return types.SetdomainnameArgs{}, err 5770 } 5771 5772 switch currArg { 5773 case 0: 5774 result.Name, err = decoder.ReadStringFromBuff() 5775 if err != nil { 5776 return types.SetdomainnameArgs{}, err 5777 } 5778 case 1: 5779 err = decoder.DecodeUint64(&result.Len) 5780 if err != nil { 5781 return types.SetdomainnameArgs{}, err 5782 } 5783 } 5784 } 5785 return result, nil 5786 } 5787 5788 func ParseIoplArgs(decoder *Decoder) (types.IoplArgs, error) { 5789 var result types.IoplArgs 5790 var err error 5791 5792 var numArgs uint8 5793 err = decoder.DecodeUint8(&numArgs) 5794 if err != nil { 5795 return types.IoplArgs{}, err 5796 } 5797 5798 for arg := 0; arg < int(numArgs); arg++ { 5799 var currArg uint8 5800 err = decoder.DecodeUint8(&currArg) 5801 if err != nil { 5802 return types.IoplArgs{}, err 5803 } 5804 5805 switch currArg { 5806 case 0: 5807 err = decoder.DecodeInt32(&result.Level) 5808 if err != nil { 5809 return types.IoplArgs{}, err 5810 } 5811 } 5812 } 5813 return result, nil 5814 } 5815 5816 func ParseIopermArgs(decoder *Decoder) (types.IopermArgs, error) { 5817 var result types.IopermArgs 5818 var err error 5819 5820 var numArgs uint8 5821 err = decoder.DecodeUint8(&numArgs) 5822 if err != nil { 5823 return types.IopermArgs{}, err 5824 } 5825 5826 for arg := 0; arg < int(numArgs); arg++ { 5827 var currArg uint8 5828 err = decoder.DecodeUint8(&currArg) 5829 if err != nil { 5830 return types.IopermArgs{}, err 5831 } 5832 5833 switch currArg { 5834 case 0: 5835 err = decoder.DecodeUint64(&result.From) 5836 if err != nil { 5837 return types.IopermArgs{}, err 5838 } 5839 case 1: 5840 err = decoder.DecodeUint64(&result.Num) 5841 if err != nil { 5842 return types.IopermArgs{}, err 5843 } 5844 case 2: 5845 err = decoder.DecodeInt32(&result.TurnOn) 5846 if err != nil { 5847 return types.IopermArgs{}, err 5848 } 5849 } 5850 } 5851 return result, nil 5852 } 5853 5854 func ParseCreateModuleArgs(decoder *Decoder) (types.CreateModuleArgs, error) { 5855 return types.CreateModuleArgs{}, nil 5856 } 5857 5858 func ParseInitModuleArgs(decoder *Decoder) (types.InitModuleArgs, error) { 5859 var result types.InitModuleArgs 5860 var err error 5861 5862 var numArgs uint8 5863 err = decoder.DecodeUint8(&numArgs) 5864 if err != nil { 5865 return types.InitModuleArgs{}, err 5866 } 5867 5868 for arg := 0; arg < int(numArgs); arg++ { 5869 var currArg uint8 5870 err = decoder.DecodeUint8(&currArg) 5871 if err != nil { 5872 return types.InitModuleArgs{}, err 5873 } 5874 5875 switch currArg { 5876 case 0: 5877 var dataModuleImage uint64 5878 err = decoder.DecodeUint64(&dataModuleImage) 5879 if err != nil { 5880 return types.InitModuleArgs{}, err 5881 } 5882 result.ModuleImage = uintptr(dataModuleImage) 5883 case 1: 5884 err = decoder.DecodeUint64(&result.Len) 5885 if err != nil { 5886 return types.InitModuleArgs{}, err 5887 } 5888 case 2: 5889 result.ParamValues, err = decoder.ReadStringFromBuff() 5890 if err != nil { 5891 return types.InitModuleArgs{}, err 5892 } 5893 } 5894 } 5895 return result, nil 5896 } 5897 5898 func ParseDeleteModuleArgs(decoder *Decoder) (types.DeleteModuleArgs, error) { 5899 var result types.DeleteModuleArgs 5900 var err error 5901 5902 var numArgs uint8 5903 err = decoder.DecodeUint8(&numArgs) 5904 if err != nil { 5905 return types.DeleteModuleArgs{}, err 5906 } 5907 5908 for arg := 0; arg < int(numArgs); arg++ { 5909 var currArg uint8 5910 err = decoder.DecodeUint8(&currArg) 5911 if err != nil { 5912 return types.DeleteModuleArgs{}, err 5913 } 5914 5915 switch currArg { 5916 case 0: 5917 result.Name, err = decoder.ReadStringFromBuff() 5918 if err != nil { 5919 return types.DeleteModuleArgs{}, err 5920 } 5921 case 1: 5922 err = decoder.DecodeInt32(&result.Flags) 5923 if err != nil { 5924 return types.DeleteModuleArgs{}, err 5925 } 5926 } 5927 } 5928 return result, nil 5929 } 5930 5931 func ParseGetKernelSymsArgs(decoder *Decoder) (types.GetKernelSymsArgs, error) { 5932 return types.GetKernelSymsArgs{}, nil 5933 } 5934 5935 func ParseQueryModuleArgs(decoder *Decoder) (types.QueryModuleArgs, error) { 5936 return types.QueryModuleArgs{}, nil 5937 } 5938 5939 func ParseQuotactlArgs(decoder *Decoder) (types.QuotactlArgs, error) { 5940 var result types.QuotactlArgs 5941 var err error 5942 5943 var numArgs uint8 5944 err = decoder.DecodeUint8(&numArgs) 5945 if err != nil { 5946 return types.QuotactlArgs{}, err 5947 } 5948 5949 for arg := 0; arg < int(numArgs); arg++ { 5950 var currArg uint8 5951 err = decoder.DecodeUint8(&currArg) 5952 if err != nil { 5953 return types.QuotactlArgs{}, err 5954 } 5955 5956 switch currArg { 5957 case 0: 5958 err = decoder.DecodeInt32(&result.Cmd) 5959 if err != nil { 5960 return types.QuotactlArgs{}, err 5961 } 5962 case 1: 5963 result.Special, err = decoder.ReadStringFromBuff() 5964 if err != nil { 5965 return types.QuotactlArgs{}, err 5966 } 5967 case 2: 5968 err = decoder.DecodeInt32(&result.Id) 5969 if err != nil { 5970 return types.QuotactlArgs{}, err 5971 } 5972 case 3: 5973 var dataAddr uint64 5974 err = decoder.DecodeUint64(&dataAddr) 5975 if err != nil { 5976 return types.QuotactlArgs{}, err 5977 } 5978 result.Addr = uintptr(dataAddr) 5979 } 5980 } 5981 return result, nil 5982 } 5983 5984 func ParseNfsservctlArgs(decoder *Decoder) (types.NfsservctlArgs, error) { 5985 return types.NfsservctlArgs{}, nil 5986 } 5987 5988 func ParseGetpmsgArgs(decoder *Decoder) (types.GetpmsgArgs, error) { 5989 return types.GetpmsgArgs{}, nil 5990 } 5991 5992 func ParsePutpmsgArgs(decoder *Decoder) (types.PutpmsgArgs, error) { 5993 return types.PutpmsgArgs{}, nil 5994 } 5995 5996 func ParseAfsArgs(decoder *Decoder) (types.AfsArgs, error) { 5997 return types.AfsArgs{}, nil 5998 } 5999 6000 func ParseTuxcallArgs(decoder *Decoder) (types.TuxcallArgs, error) { 6001 return types.TuxcallArgs{}, nil 6002 } 6003 6004 func ParseSecurityArgs(decoder *Decoder) (types.SecurityArgs, error) { 6005 return types.SecurityArgs{}, nil 6006 } 6007 6008 func ParseGettidArgs(decoder *Decoder) (types.GettidArgs, error) { 6009 return types.GettidArgs{}, nil 6010 } 6011 6012 func ParseReadaheadArgs(decoder *Decoder) (types.ReadaheadArgs, error) { 6013 var result types.ReadaheadArgs 6014 var err error 6015 6016 var numArgs uint8 6017 err = decoder.DecodeUint8(&numArgs) 6018 if err != nil { 6019 return types.ReadaheadArgs{}, err 6020 } 6021 6022 for arg := 0; arg < int(numArgs); arg++ { 6023 var currArg uint8 6024 err = decoder.DecodeUint8(&currArg) 6025 if err != nil { 6026 return types.ReadaheadArgs{}, err 6027 } 6028 6029 switch currArg { 6030 case 0: 6031 err = decoder.DecodeInt32(&result.Fd) 6032 if err != nil { 6033 return types.ReadaheadArgs{}, err 6034 } 6035 case 1: 6036 err = decoder.DecodeUint64(&result.Offset) 6037 if err != nil { 6038 return types.ReadaheadArgs{}, err 6039 } 6040 case 2: 6041 err = decoder.DecodeUint64(&result.Count) 6042 if err != nil { 6043 return types.ReadaheadArgs{}, err 6044 } 6045 } 6046 } 6047 return result, nil 6048 } 6049 6050 func ParseSetxattrArgs(decoder *Decoder) (types.SetxattrArgs, error) { 6051 var result types.SetxattrArgs 6052 var err error 6053 6054 var numArgs uint8 6055 err = decoder.DecodeUint8(&numArgs) 6056 if err != nil { 6057 return types.SetxattrArgs{}, err 6058 } 6059 6060 for arg := 0; arg < int(numArgs); arg++ { 6061 var currArg uint8 6062 err = decoder.DecodeUint8(&currArg) 6063 if err != nil { 6064 return types.SetxattrArgs{}, err 6065 } 6066 6067 switch currArg { 6068 case 0: 6069 result.Path, err = decoder.ReadStringFromBuff() 6070 if err != nil { 6071 return types.SetxattrArgs{}, err 6072 } 6073 case 1: 6074 result.Name, err = decoder.ReadStringFromBuff() 6075 if err != nil { 6076 return types.SetxattrArgs{}, err 6077 } 6078 case 2: 6079 var dataValue uint64 6080 err = decoder.DecodeUint64(&dataValue) 6081 if err != nil { 6082 return types.SetxattrArgs{}, err 6083 } 6084 result.Value = uintptr(dataValue) 6085 case 3: 6086 err = decoder.DecodeUint64(&result.Size) 6087 if err != nil { 6088 return types.SetxattrArgs{}, err 6089 } 6090 case 4: 6091 err = decoder.DecodeInt32(&result.Flags) 6092 if err != nil { 6093 return types.SetxattrArgs{}, err 6094 } 6095 } 6096 } 6097 return result, nil 6098 } 6099 6100 func ParseLsetxattrArgs(decoder *Decoder) (types.LsetxattrArgs, error) { 6101 var result types.LsetxattrArgs 6102 var err error 6103 6104 var numArgs uint8 6105 err = decoder.DecodeUint8(&numArgs) 6106 if err != nil { 6107 return types.LsetxattrArgs{}, err 6108 } 6109 6110 for arg := 0; arg < int(numArgs); arg++ { 6111 var currArg uint8 6112 err = decoder.DecodeUint8(&currArg) 6113 if err != nil { 6114 return types.LsetxattrArgs{}, err 6115 } 6116 6117 switch currArg { 6118 case 0: 6119 result.Path, err = decoder.ReadStringFromBuff() 6120 if err != nil { 6121 return types.LsetxattrArgs{}, err 6122 } 6123 case 1: 6124 result.Name, err = decoder.ReadStringFromBuff() 6125 if err != nil { 6126 return types.LsetxattrArgs{}, err 6127 } 6128 case 2: 6129 var dataValue uint64 6130 err = decoder.DecodeUint64(&dataValue) 6131 if err != nil { 6132 return types.LsetxattrArgs{}, err 6133 } 6134 result.Value = uintptr(dataValue) 6135 case 3: 6136 err = decoder.DecodeUint64(&result.Size) 6137 if err != nil { 6138 return types.LsetxattrArgs{}, err 6139 } 6140 case 4: 6141 err = decoder.DecodeInt32(&result.Flags) 6142 if err != nil { 6143 return types.LsetxattrArgs{}, err 6144 } 6145 } 6146 } 6147 return result, nil 6148 } 6149 6150 func ParseFsetxattrArgs(decoder *Decoder) (types.FsetxattrArgs, error) { 6151 var result types.FsetxattrArgs 6152 var err error 6153 6154 var numArgs uint8 6155 err = decoder.DecodeUint8(&numArgs) 6156 if err != nil { 6157 return types.FsetxattrArgs{}, err 6158 } 6159 6160 for arg := 0; arg < int(numArgs); arg++ { 6161 var currArg uint8 6162 err = decoder.DecodeUint8(&currArg) 6163 if err != nil { 6164 return types.FsetxattrArgs{}, err 6165 } 6166 6167 switch currArg { 6168 case 0: 6169 err = decoder.DecodeInt32(&result.Fd) 6170 if err != nil { 6171 return types.FsetxattrArgs{}, err 6172 } 6173 case 1: 6174 result.Name, err = decoder.ReadStringFromBuff() 6175 if err != nil { 6176 return types.FsetxattrArgs{}, err 6177 } 6178 case 2: 6179 var dataValue uint64 6180 err = decoder.DecodeUint64(&dataValue) 6181 if err != nil { 6182 return types.FsetxattrArgs{}, err 6183 } 6184 result.Value = uintptr(dataValue) 6185 case 3: 6186 err = decoder.DecodeUint64(&result.Size) 6187 if err != nil { 6188 return types.FsetxattrArgs{}, err 6189 } 6190 case 4: 6191 err = decoder.DecodeInt32(&result.Flags) 6192 if err != nil { 6193 return types.FsetxattrArgs{}, err 6194 } 6195 } 6196 } 6197 return result, nil 6198 } 6199 6200 func ParseGetxattrArgs(decoder *Decoder) (types.GetxattrArgs, error) { 6201 var result types.GetxattrArgs 6202 var err error 6203 6204 var numArgs uint8 6205 err = decoder.DecodeUint8(&numArgs) 6206 if err != nil { 6207 return types.GetxattrArgs{}, err 6208 } 6209 6210 for arg := 0; arg < int(numArgs); arg++ { 6211 var currArg uint8 6212 err = decoder.DecodeUint8(&currArg) 6213 if err != nil { 6214 return types.GetxattrArgs{}, err 6215 } 6216 6217 switch currArg { 6218 case 0: 6219 result.Path, err = decoder.ReadStringFromBuff() 6220 if err != nil { 6221 return types.GetxattrArgs{}, err 6222 } 6223 case 1: 6224 result.Name, err = decoder.ReadStringFromBuff() 6225 if err != nil { 6226 return types.GetxattrArgs{}, err 6227 } 6228 case 2: 6229 var dataValue uint64 6230 err = decoder.DecodeUint64(&dataValue) 6231 if err != nil { 6232 return types.GetxattrArgs{}, err 6233 } 6234 result.Value = uintptr(dataValue) 6235 case 3: 6236 err = decoder.DecodeUint64(&result.Size) 6237 if err != nil { 6238 return types.GetxattrArgs{}, err 6239 } 6240 } 6241 } 6242 return result, nil 6243 } 6244 6245 func ParseLgetxattrArgs(decoder *Decoder) (types.LgetxattrArgs, error) { 6246 var result types.LgetxattrArgs 6247 var err error 6248 6249 var numArgs uint8 6250 err = decoder.DecodeUint8(&numArgs) 6251 if err != nil { 6252 return types.LgetxattrArgs{}, err 6253 } 6254 6255 for arg := 0; arg < int(numArgs); arg++ { 6256 var currArg uint8 6257 err = decoder.DecodeUint8(&currArg) 6258 if err != nil { 6259 return types.LgetxattrArgs{}, err 6260 } 6261 6262 switch currArg { 6263 case 0: 6264 result.Path, err = decoder.ReadStringFromBuff() 6265 if err != nil { 6266 return types.LgetxattrArgs{}, err 6267 } 6268 case 1: 6269 result.Name, err = decoder.ReadStringFromBuff() 6270 if err != nil { 6271 return types.LgetxattrArgs{}, err 6272 } 6273 case 2: 6274 var dataValue uint64 6275 err = decoder.DecodeUint64(&dataValue) 6276 if err != nil { 6277 return types.LgetxattrArgs{}, err 6278 } 6279 result.Value = uintptr(dataValue) 6280 case 3: 6281 err = decoder.DecodeUint64(&result.Size) 6282 if err != nil { 6283 return types.LgetxattrArgs{}, err 6284 } 6285 } 6286 } 6287 return result, nil 6288 } 6289 6290 func ParseFgetxattrArgs(decoder *Decoder) (types.FgetxattrArgs, error) { 6291 var result types.FgetxattrArgs 6292 var err error 6293 6294 var numArgs uint8 6295 err = decoder.DecodeUint8(&numArgs) 6296 if err != nil { 6297 return types.FgetxattrArgs{}, err 6298 } 6299 6300 for arg := 0; arg < int(numArgs); arg++ { 6301 var currArg uint8 6302 err = decoder.DecodeUint8(&currArg) 6303 if err != nil { 6304 return types.FgetxattrArgs{}, err 6305 } 6306 6307 switch currArg { 6308 case 0: 6309 err = decoder.DecodeInt32(&result.Fd) 6310 if err != nil { 6311 return types.FgetxattrArgs{}, err 6312 } 6313 case 1: 6314 result.Name, err = decoder.ReadStringFromBuff() 6315 if err != nil { 6316 return types.FgetxattrArgs{}, err 6317 } 6318 case 2: 6319 var dataValue uint64 6320 err = decoder.DecodeUint64(&dataValue) 6321 if err != nil { 6322 return types.FgetxattrArgs{}, err 6323 } 6324 result.Value = uintptr(dataValue) 6325 case 3: 6326 err = decoder.DecodeUint64(&result.Size) 6327 if err != nil { 6328 return types.FgetxattrArgs{}, err 6329 } 6330 } 6331 } 6332 return result, nil 6333 } 6334 6335 func ParseListxattrArgs(decoder *Decoder) (types.ListxattrArgs, error) { 6336 var result types.ListxattrArgs 6337 var err error 6338 6339 var numArgs uint8 6340 err = decoder.DecodeUint8(&numArgs) 6341 if err != nil { 6342 return types.ListxattrArgs{}, err 6343 } 6344 6345 for arg := 0; arg < int(numArgs); arg++ { 6346 var currArg uint8 6347 err = decoder.DecodeUint8(&currArg) 6348 if err != nil { 6349 return types.ListxattrArgs{}, err 6350 } 6351 6352 switch currArg { 6353 case 0: 6354 result.Path, err = decoder.ReadStringFromBuff() 6355 if err != nil { 6356 return types.ListxattrArgs{}, err 6357 } 6358 case 1: 6359 result.List, err = decoder.ReadStringFromBuff() 6360 if err != nil { 6361 return types.ListxattrArgs{}, err 6362 } 6363 case 2: 6364 err = decoder.DecodeUint64(&result.Size) 6365 if err != nil { 6366 return types.ListxattrArgs{}, err 6367 } 6368 } 6369 } 6370 return result, nil 6371 } 6372 6373 func ParseLlistxattrArgs(decoder *Decoder) (types.LlistxattrArgs, error) { 6374 var result types.LlistxattrArgs 6375 var err error 6376 6377 var numArgs uint8 6378 err = decoder.DecodeUint8(&numArgs) 6379 if err != nil { 6380 return types.LlistxattrArgs{}, err 6381 } 6382 6383 for arg := 0; arg < int(numArgs); arg++ { 6384 var currArg uint8 6385 err = decoder.DecodeUint8(&currArg) 6386 if err != nil { 6387 return types.LlistxattrArgs{}, err 6388 } 6389 6390 switch currArg { 6391 case 0: 6392 result.Path, err = decoder.ReadStringFromBuff() 6393 if err != nil { 6394 return types.LlistxattrArgs{}, err 6395 } 6396 case 1: 6397 result.List, err = decoder.ReadStringFromBuff() 6398 if err != nil { 6399 return types.LlistxattrArgs{}, err 6400 } 6401 case 2: 6402 err = decoder.DecodeUint64(&result.Size) 6403 if err != nil { 6404 return types.LlistxattrArgs{}, err 6405 } 6406 } 6407 } 6408 return result, nil 6409 } 6410 6411 func ParseFlistxattrArgs(decoder *Decoder) (types.FlistxattrArgs, error) { 6412 var result types.FlistxattrArgs 6413 var err error 6414 6415 var numArgs uint8 6416 err = decoder.DecodeUint8(&numArgs) 6417 if err != nil { 6418 return types.FlistxattrArgs{}, err 6419 } 6420 6421 for arg := 0; arg < int(numArgs); arg++ { 6422 var currArg uint8 6423 err = decoder.DecodeUint8(&currArg) 6424 if err != nil { 6425 return types.FlistxattrArgs{}, err 6426 } 6427 6428 switch currArg { 6429 case 0: 6430 err = decoder.DecodeInt32(&result.Fd) 6431 if err != nil { 6432 return types.FlistxattrArgs{}, err 6433 } 6434 case 1: 6435 result.List, err = decoder.ReadStringFromBuff() 6436 if err != nil { 6437 return types.FlistxattrArgs{}, err 6438 } 6439 case 2: 6440 err = decoder.DecodeUint64(&result.Size) 6441 if err != nil { 6442 return types.FlistxattrArgs{}, err 6443 } 6444 } 6445 } 6446 return result, nil 6447 } 6448 6449 func ParseRemovexattrArgs(decoder *Decoder) (types.RemovexattrArgs, error) { 6450 var result types.RemovexattrArgs 6451 var err error 6452 6453 var numArgs uint8 6454 err = decoder.DecodeUint8(&numArgs) 6455 if err != nil { 6456 return types.RemovexattrArgs{}, err 6457 } 6458 6459 for arg := 0; arg < int(numArgs); arg++ { 6460 var currArg uint8 6461 err = decoder.DecodeUint8(&currArg) 6462 if err != nil { 6463 return types.RemovexattrArgs{}, err 6464 } 6465 6466 switch currArg { 6467 case 0: 6468 result.Path, err = decoder.ReadStringFromBuff() 6469 if err != nil { 6470 return types.RemovexattrArgs{}, err 6471 } 6472 case 1: 6473 result.Name, err = decoder.ReadStringFromBuff() 6474 if err != nil { 6475 return types.RemovexattrArgs{}, err 6476 } 6477 } 6478 } 6479 return result, nil 6480 } 6481 6482 func ParseLremovexattrArgs(decoder *Decoder) (types.LremovexattrArgs, error) { 6483 var result types.LremovexattrArgs 6484 var err error 6485 6486 var numArgs uint8 6487 err = decoder.DecodeUint8(&numArgs) 6488 if err != nil { 6489 return types.LremovexattrArgs{}, err 6490 } 6491 6492 for arg := 0; arg < int(numArgs); arg++ { 6493 var currArg uint8 6494 err = decoder.DecodeUint8(&currArg) 6495 if err != nil { 6496 return types.LremovexattrArgs{}, err 6497 } 6498 6499 switch currArg { 6500 case 0: 6501 result.Path, err = decoder.ReadStringFromBuff() 6502 if err != nil { 6503 return types.LremovexattrArgs{}, err 6504 } 6505 case 1: 6506 result.Name, err = decoder.ReadStringFromBuff() 6507 if err != nil { 6508 return types.LremovexattrArgs{}, err 6509 } 6510 } 6511 } 6512 return result, nil 6513 } 6514 6515 func ParseFremovexattrArgs(decoder *Decoder) (types.FremovexattrArgs, error) { 6516 var result types.FremovexattrArgs 6517 var err error 6518 6519 var numArgs uint8 6520 err = decoder.DecodeUint8(&numArgs) 6521 if err != nil { 6522 return types.FremovexattrArgs{}, err 6523 } 6524 6525 for arg := 0; arg < int(numArgs); arg++ { 6526 var currArg uint8 6527 err = decoder.DecodeUint8(&currArg) 6528 if err != nil { 6529 return types.FremovexattrArgs{}, err 6530 } 6531 6532 switch currArg { 6533 case 0: 6534 err = decoder.DecodeInt32(&result.Fd) 6535 if err != nil { 6536 return types.FremovexattrArgs{}, err 6537 } 6538 case 1: 6539 result.Name, err = decoder.ReadStringFromBuff() 6540 if err != nil { 6541 return types.FremovexattrArgs{}, err 6542 } 6543 } 6544 } 6545 return result, nil 6546 } 6547 6548 func ParseTkillArgs(decoder *Decoder) (types.TkillArgs, error) { 6549 var result types.TkillArgs 6550 var err error 6551 6552 var numArgs uint8 6553 err = decoder.DecodeUint8(&numArgs) 6554 if err != nil { 6555 return types.TkillArgs{}, err 6556 } 6557 6558 for arg := 0; arg < int(numArgs); arg++ { 6559 var currArg uint8 6560 err = decoder.DecodeUint8(&currArg) 6561 if err != nil { 6562 return types.TkillArgs{}, err 6563 } 6564 6565 switch currArg { 6566 case 0: 6567 err = decoder.DecodeInt32(&result.Tid) 6568 if err != nil { 6569 return types.TkillArgs{}, err 6570 } 6571 case 1: 6572 err = decoder.DecodeInt32(&result.Sig) 6573 if err != nil { 6574 return types.TkillArgs{}, err 6575 } 6576 } 6577 } 6578 return result, nil 6579 } 6580 6581 func ParseTimeArgs(decoder *Decoder) (types.TimeArgs, error) { 6582 var result types.TimeArgs 6583 var err error 6584 6585 var numArgs uint8 6586 err = decoder.DecodeUint8(&numArgs) 6587 if err != nil { 6588 return types.TimeArgs{}, err 6589 } 6590 6591 for arg := 0; arg < int(numArgs); arg++ { 6592 var currArg uint8 6593 err = decoder.DecodeUint8(&currArg) 6594 if err != nil { 6595 return types.TimeArgs{}, err 6596 } 6597 6598 switch currArg { 6599 case 0: 6600 var dataTloc uint64 6601 err = decoder.DecodeUint64(&dataTloc) 6602 if err != nil { 6603 return types.TimeArgs{}, err 6604 } 6605 result.Tloc = uintptr(dataTloc) 6606 } 6607 } 6608 return result, nil 6609 } 6610 6611 func ParseFutexArgs(decoder *Decoder) (types.FutexArgs, error) { 6612 var result types.FutexArgs 6613 var err error 6614 6615 var numArgs uint8 6616 err = decoder.DecodeUint8(&numArgs) 6617 if err != nil { 6618 return types.FutexArgs{}, err 6619 } 6620 6621 for arg := 0; arg < int(numArgs); arg++ { 6622 var currArg uint8 6623 err = decoder.DecodeUint8(&currArg) 6624 if err != nil { 6625 return types.FutexArgs{}, err 6626 } 6627 6628 switch currArg { 6629 case 0: 6630 var dataUaddr uint64 6631 err = decoder.DecodeUint64(&dataUaddr) 6632 if err != nil { 6633 return types.FutexArgs{}, err 6634 } 6635 result.Uaddr = uintptr(dataUaddr) 6636 case 1: 6637 err = decoder.DecodeInt32(&result.FutexOp) 6638 if err != nil { 6639 return types.FutexArgs{}, err 6640 } 6641 case 2: 6642 err = decoder.DecodeInt32(&result.Val) 6643 if err != nil { 6644 return types.FutexArgs{}, err 6645 } 6646 case 3: 6647 result.Timeout, err = decoder.ReadTimespec() 6648 if err != nil { 6649 return types.FutexArgs{}, err 6650 } 6651 case 4: 6652 var dataUaddr2 uint64 6653 err = decoder.DecodeUint64(&dataUaddr2) 6654 if err != nil { 6655 return types.FutexArgs{}, err 6656 } 6657 result.Uaddr2 = uintptr(dataUaddr2) 6658 case 5: 6659 err = decoder.DecodeInt32(&result.Val3) 6660 if err != nil { 6661 return types.FutexArgs{}, err 6662 } 6663 } 6664 } 6665 return result, nil 6666 } 6667 6668 func ParseSchedSetaffinityArgs(decoder *Decoder) (types.SchedSetaffinityArgs, error) { 6669 var result types.SchedSetaffinityArgs 6670 var err error 6671 6672 var numArgs uint8 6673 err = decoder.DecodeUint8(&numArgs) 6674 if err != nil { 6675 return types.SchedSetaffinityArgs{}, err 6676 } 6677 6678 for arg := 0; arg < int(numArgs); arg++ { 6679 var currArg uint8 6680 err = decoder.DecodeUint8(&currArg) 6681 if err != nil { 6682 return types.SchedSetaffinityArgs{}, err 6683 } 6684 6685 switch currArg { 6686 case 0: 6687 err = decoder.DecodeInt32(&result.Pid) 6688 if err != nil { 6689 return types.SchedSetaffinityArgs{}, err 6690 } 6691 case 1: 6692 err = decoder.DecodeUint64(&result.Cpusetsize) 6693 if err != nil { 6694 return types.SchedSetaffinityArgs{}, err 6695 } 6696 case 2: 6697 var dataMask uint64 6698 err = decoder.DecodeUint64(&dataMask) 6699 if err != nil { 6700 return types.SchedSetaffinityArgs{}, err 6701 } 6702 result.Mask = uintptr(dataMask) 6703 } 6704 } 6705 return result, nil 6706 } 6707 6708 func ParseSchedGetaffinityArgs(decoder *Decoder) (types.SchedGetaffinityArgs, error) { 6709 var result types.SchedGetaffinityArgs 6710 var err error 6711 6712 var numArgs uint8 6713 err = decoder.DecodeUint8(&numArgs) 6714 if err != nil { 6715 return types.SchedGetaffinityArgs{}, err 6716 } 6717 6718 for arg := 0; arg < int(numArgs); arg++ { 6719 var currArg uint8 6720 err = decoder.DecodeUint8(&currArg) 6721 if err != nil { 6722 return types.SchedGetaffinityArgs{}, err 6723 } 6724 6725 switch currArg { 6726 case 0: 6727 err = decoder.DecodeInt32(&result.Pid) 6728 if err != nil { 6729 return types.SchedGetaffinityArgs{}, err 6730 } 6731 case 1: 6732 err = decoder.DecodeUint64(&result.Cpusetsize) 6733 if err != nil { 6734 return types.SchedGetaffinityArgs{}, err 6735 } 6736 case 2: 6737 var dataMask uint64 6738 err = decoder.DecodeUint64(&dataMask) 6739 if err != nil { 6740 return types.SchedGetaffinityArgs{}, err 6741 } 6742 result.Mask = uintptr(dataMask) 6743 } 6744 } 6745 return result, nil 6746 } 6747 6748 func ParseSetThreadAreaArgs(decoder *Decoder) (types.SetThreadAreaArgs, error) { 6749 var result types.SetThreadAreaArgs 6750 var err error 6751 6752 var numArgs uint8 6753 err = decoder.DecodeUint8(&numArgs) 6754 if err != nil { 6755 return types.SetThreadAreaArgs{}, err 6756 } 6757 6758 for arg := 0; arg < int(numArgs); arg++ { 6759 var currArg uint8 6760 err = decoder.DecodeUint8(&currArg) 6761 if err != nil { 6762 return types.SetThreadAreaArgs{}, err 6763 } 6764 6765 switch currArg { 6766 case 0: 6767 var dataUInfo uint64 6768 err = decoder.DecodeUint64(&dataUInfo) 6769 if err != nil { 6770 return types.SetThreadAreaArgs{}, err 6771 } 6772 result.UInfo = uintptr(dataUInfo) 6773 } 6774 } 6775 return result, nil 6776 } 6777 6778 func ParseIoSetupArgs(decoder *Decoder) (types.IoSetupArgs, error) { 6779 var result types.IoSetupArgs 6780 var err error 6781 6782 var numArgs uint8 6783 err = decoder.DecodeUint8(&numArgs) 6784 if err != nil { 6785 return types.IoSetupArgs{}, err 6786 } 6787 6788 for arg := 0; arg < int(numArgs); arg++ { 6789 var currArg uint8 6790 err = decoder.DecodeUint8(&currArg) 6791 if err != nil { 6792 return types.IoSetupArgs{}, err 6793 } 6794 6795 switch currArg { 6796 case 0: 6797 err = decoder.DecodeUint32(&result.NrEvents) 6798 if err != nil { 6799 return types.IoSetupArgs{}, err 6800 } 6801 case 1: 6802 var dataCtxIdp uint64 6803 err = decoder.DecodeUint64(&dataCtxIdp) 6804 if err != nil { 6805 return types.IoSetupArgs{}, err 6806 } 6807 result.CtxIdp = uintptr(dataCtxIdp) 6808 } 6809 } 6810 return result, nil 6811 } 6812 6813 func ParseIoDestroyArgs(decoder *Decoder) (types.IoDestroyArgs, error) { 6814 var result types.IoDestroyArgs 6815 var err error 6816 6817 var numArgs uint8 6818 err = decoder.DecodeUint8(&numArgs) 6819 if err != nil { 6820 return types.IoDestroyArgs{}, err 6821 } 6822 6823 for arg := 0; arg < int(numArgs); arg++ { 6824 var currArg uint8 6825 err = decoder.DecodeUint8(&currArg) 6826 if err != nil { 6827 return types.IoDestroyArgs{}, err 6828 } 6829 6830 switch currArg { 6831 case 0: 6832 var dataCtxId uint64 6833 err = decoder.DecodeUint64(&dataCtxId) 6834 if err != nil { 6835 return types.IoDestroyArgs{}, err 6836 } 6837 result.CtxId = uintptr(dataCtxId) 6838 } 6839 } 6840 return result, nil 6841 } 6842 6843 func ParseIoGeteventsArgs(decoder *Decoder) (types.IoGeteventsArgs, error) { 6844 var result types.IoGeteventsArgs 6845 var err error 6846 6847 var numArgs uint8 6848 err = decoder.DecodeUint8(&numArgs) 6849 if err != nil { 6850 return types.IoGeteventsArgs{}, err 6851 } 6852 6853 for arg := 0; arg < int(numArgs); arg++ { 6854 var currArg uint8 6855 err = decoder.DecodeUint8(&currArg) 6856 if err != nil { 6857 return types.IoGeteventsArgs{}, err 6858 } 6859 6860 switch currArg { 6861 case 0: 6862 var dataCtxId uint64 6863 err = decoder.DecodeUint64(&dataCtxId) 6864 if err != nil { 6865 return types.IoGeteventsArgs{}, err 6866 } 6867 result.CtxId = uintptr(dataCtxId) 6868 case 1: 6869 err = decoder.DecodeInt64(&result.MinNr) 6870 if err != nil { 6871 return types.IoGeteventsArgs{}, err 6872 } 6873 case 2: 6874 err = decoder.DecodeInt64(&result.Nr) 6875 if err != nil { 6876 return types.IoGeteventsArgs{}, err 6877 } 6878 case 3: 6879 var dataEvents uint64 6880 err = decoder.DecodeUint64(&dataEvents) 6881 if err != nil { 6882 return types.IoGeteventsArgs{}, err 6883 } 6884 result.Events = uintptr(dataEvents) 6885 case 4: 6886 result.Timeout, err = decoder.ReadTimespec() 6887 if err != nil { 6888 return types.IoGeteventsArgs{}, err 6889 } 6890 } 6891 } 6892 return result, nil 6893 } 6894 6895 func ParseIoSubmitArgs(decoder *Decoder) (types.IoSubmitArgs, error) { 6896 var result types.IoSubmitArgs 6897 var err error 6898 6899 var numArgs uint8 6900 err = decoder.DecodeUint8(&numArgs) 6901 if err != nil { 6902 return types.IoSubmitArgs{}, err 6903 } 6904 6905 for arg := 0; arg < int(numArgs); arg++ { 6906 var currArg uint8 6907 err = decoder.DecodeUint8(&currArg) 6908 if err != nil { 6909 return types.IoSubmitArgs{}, err 6910 } 6911 6912 switch currArg { 6913 case 0: 6914 var dataCtxId uint64 6915 err = decoder.DecodeUint64(&dataCtxId) 6916 if err != nil { 6917 return types.IoSubmitArgs{}, err 6918 } 6919 result.CtxId = uintptr(dataCtxId) 6920 case 1: 6921 err = decoder.DecodeInt64(&result.Nr) 6922 if err != nil { 6923 return types.IoSubmitArgs{}, err 6924 } 6925 case 2: 6926 var dataIocbpp uint64 6927 err = decoder.DecodeUint64(&dataIocbpp) 6928 if err != nil { 6929 return types.IoSubmitArgs{}, err 6930 } 6931 result.Iocbpp = uintptr(dataIocbpp) 6932 } 6933 } 6934 return result, nil 6935 } 6936 6937 func ParseIoCancelArgs(decoder *Decoder) (types.IoCancelArgs, error) { 6938 var result types.IoCancelArgs 6939 var err error 6940 6941 var numArgs uint8 6942 err = decoder.DecodeUint8(&numArgs) 6943 if err != nil { 6944 return types.IoCancelArgs{}, err 6945 } 6946 6947 for arg := 0; arg < int(numArgs); arg++ { 6948 var currArg uint8 6949 err = decoder.DecodeUint8(&currArg) 6950 if err != nil { 6951 return types.IoCancelArgs{}, err 6952 } 6953 6954 switch currArg { 6955 case 0: 6956 var dataCtxId uint64 6957 err = decoder.DecodeUint64(&dataCtxId) 6958 if err != nil { 6959 return types.IoCancelArgs{}, err 6960 } 6961 result.CtxId = uintptr(dataCtxId) 6962 case 1: 6963 var dataIocb uint64 6964 err = decoder.DecodeUint64(&dataIocb) 6965 if err != nil { 6966 return types.IoCancelArgs{}, err 6967 } 6968 result.Iocb = uintptr(dataIocb) 6969 case 2: 6970 var dataResult uint64 6971 err = decoder.DecodeUint64(&dataResult) 6972 if err != nil { 6973 return types.IoCancelArgs{}, err 6974 } 6975 result.Result = uintptr(dataResult) 6976 } 6977 } 6978 return result, nil 6979 } 6980 6981 func ParseGetThreadAreaArgs(decoder *Decoder) (types.GetThreadAreaArgs, error) { 6982 var result types.GetThreadAreaArgs 6983 var err error 6984 6985 var numArgs uint8 6986 err = decoder.DecodeUint8(&numArgs) 6987 if err != nil { 6988 return types.GetThreadAreaArgs{}, err 6989 } 6990 6991 for arg := 0; arg < int(numArgs); arg++ { 6992 var currArg uint8 6993 err = decoder.DecodeUint8(&currArg) 6994 if err != nil { 6995 return types.GetThreadAreaArgs{}, err 6996 } 6997 6998 switch currArg { 6999 case 0: 7000 var dataUInfo uint64 7001 err = decoder.DecodeUint64(&dataUInfo) 7002 if err != nil { 7003 return types.GetThreadAreaArgs{}, err 7004 } 7005 result.UInfo = uintptr(dataUInfo) 7006 } 7007 } 7008 return result, nil 7009 } 7010 7011 func ParseLookupDcookieArgs(decoder *Decoder) (types.LookupDcookieArgs, error) { 7012 var result types.LookupDcookieArgs 7013 var err error 7014 7015 var numArgs uint8 7016 err = decoder.DecodeUint8(&numArgs) 7017 if err != nil { 7018 return types.LookupDcookieArgs{}, err 7019 } 7020 7021 for arg := 0; arg < int(numArgs); arg++ { 7022 var currArg uint8 7023 err = decoder.DecodeUint8(&currArg) 7024 if err != nil { 7025 return types.LookupDcookieArgs{}, err 7026 } 7027 7028 switch currArg { 7029 case 0: 7030 err = decoder.DecodeUint64(&result.Cookie) 7031 if err != nil { 7032 return types.LookupDcookieArgs{}, err 7033 } 7034 case 1: 7035 result.Buffer, err = decoder.ReadStringFromBuff() 7036 if err != nil { 7037 return types.LookupDcookieArgs{}, err 7038 } 7039 case 2: 7040 err = decoder.DecodeUint64(&result.Len) 7041 if err != nil { 7042 return types.LookupDcookieArgs{}, err 7043 } 7044 } 7045 } 7046 return result, nil 7047 } 7048 7049 func ParseEpollCreateArgs(decoder *Decoder) (types.EpollCreateArgs, error) { 7050 var result types.EpollCreateArgs 7051 var err error 7052 7053 var numArgs uint8 7054 err = decoder.DecodeUint8(&numArgs) 7055 if err != nil { 7056 return types.EpollCreateArgs{}, err 7057 } 7058 7059 for arg := 0; arg < int(numArgs); arg++ { 7060 var currArg uint8 7061 err = decoder.DecodeUint8(&currArg) 7062 if err != nil { 7063 return types.EpollCreateArgs{}, err 7064 } 7065 7066 switch currArg { 7067 case 0: 7068 err = decoder.DecodeInt32(&result.Size) 7069 if err != nil { 7070 return types.EpollCreateArgs{}, err 7071 } 7072 } 7073 } 7074 return result, nil 7075 } 7076 7077 func ParseEpollCtlOldArgs(decoder *Decoder) (types.EpollCtlOldArgs, error) { 7078 return types.EpollCtlOldArgs{}, nil 7079 } 7080 7081 func ParseEpollWaitOldArgs(decoder *Decoder) (types.EpollWaitOldArgs, error) { 7082 return types.EpollWaitOldArgs{}, nil 7083 } 7084 7085 func ParseRemapFilePagesArgs(decoder *Decoder) (types.RemapFilePagesArgs, error) { 7086 var result types.RemapFilePagesArgs 7087 var err error 7088 7089 var numArgs uint8 7090 err = decoder.DecodeUint8(&numArgs) 7091 if err != nil { 7092 return types.RemapFilePagesArgs{}, err 7093 } 7094 7095 for arg := 0; arg < int(numArgs); arg++ { 7096 var currArg uint8 7097 err = decoder.DecodeUint8(&currArg) 7098 if err != nil { 7099 return types.RemapFilePagesArgs{}, err 7100 } 7101 7102 switch currArg { 7103 case 0: 7104 var dataAddr uint64 7105 err = decoder.DecodeUint64(&dataAddr) 7106 if err != nil { 7107 return types.RemapFilePagesArgs{}, err 7108 } 7109 result.Addr = uintptr(dataAddr) 7110 case 1: 7111 err = decoder.DecodeUint64(&result.Size) 7112 if err != nil { 7113 return types.RemapFilePagesArgs{}, err 7114 } 7115 case 2: 7116 err = decoder.DecodeInt32(&result.Prot) 7117 if err != nil { 7118 return types.RemapFilePagesArgs{}, err 7119 } 7120 case 3: 7121 err = decoder.DecodeUint64(&result.Pgoff) 7122 if err != nil { 7123 return types.RemapFilePagesArgs{}, err 7124 } 7125 case 4: 7126 err = decoder.DecodeInt32(&result.Flags) 7127 if err != nil { 7128 return types.RemapFilePagesArgs{}, err 7129 } 7130 } 7131 } 7132 return result, nil 7133 } 7134 7135 func ParseGetdents64Args(decoder *Decoder) (types.Getdents64Args, error) { 7136 var result types.Getdents64Args 7137 var err error 7138 7139 var numArgs uint8 7140 err = decoder.DecodeUint8(&numArgs) 7141 if err != nil { 7142 return types.Getdents64Args{}, err 7143 } 7144 7145 for arg := 0; arg < int(numArgs); arg++ { 7146 var currArg uint8 7147 err = decoder.DecodeUint8(&currArg) 7148 if err != nil { 7149 return types.Getdents64Args{}, err 7150 } 7151 7152 switch currArg { 7153 case 0: 7154 err = decoder.DecodeUint32(&result.Fd) 7155 if err != nil { 7156 return types.Getdents64Args{}, err 7157 } 7158 case 1: 7159 var dataDirp uint64 7160 err = decoder.DecodeUint64(&dataDirp) 7161 if err != nil { 7162 return types.Getdents64Args{}, err 7163 } 7164 result.Dirp = uintptr(dataDirp) 7165 case 2: 7166 err = decoder.DecodeUint32(&result.Count) 7167 if err != nil { 7168 return types.Getdents64Args{}, err 7169 } 7170 } 7171 } 7172 return result, nil 7173 } 7174 7175 func ParseSetTidAddressArgs(decoder *Decoder) (types.SetTidAddressArgs, error) { 7176 var result types.SetTidAddressArgs 7177 var err error 7178 7179 var numArgs uint8 7180 err = decoder.DecodeUint8(&numArgs) 7181 if err != nil { 7182 return types.SetTidAddressArgs{}, err 7183 } 7184 7185 for arg := 0; arg < int(numArgs); arg++ { 7186 var currArg uint8 7187 err = decoder.DecodeUint8(&currArg) 7188 if err != nil { 7189 return types.SetTidAddressArgs{}, err 7190 } 7191 7192 switch currArg { 7193 case 0: 7194 var dataTidptr uint64 7195 err = decoder.DecodeUint64(&dataTidptr) 7196 if err != nil { 7197 return types.SetTidAddressArgs{}, err 7198 } 7199 result.Tidptr = uintptr(dataTidptr) 7200 } 7201 } 7202 return result, nil 7203 } 7204 7205 func ParseRestartSyscallArgs(decoder *Decoder) (types.RestartSyscallArgs, error) { 7206 return types.RestartSyscallArgs{}, nil 7207 } 7208 7209 func ParseSemtimedopArgs(decoder *Decoder) (types.SemtimedopArgs, error) { 7210 var result types.SemtimedopArgs 7211 var err error 7212 7213 var numArgs uint8 7214 err = decoder.DecodeUint8(&numArgs) 7215 if err != nil { 7216 return types.SemtimedopArgs{}, err 7217 } 7218 7219 for arg := 0; arg < int(numArgs); arg++ { 7220 var currArg uint8 7221 err = decoder.DecodeUint8(&currArg) 7222 if err != nil { 7223 return types.SemtimedopArgs{}, err 7224 } 7225 7226 switch currArg { 7227 case 0: 7228 err = decoder.DecodeInt32(&result.Semid) 7229 if err != nil { 7230 return types.SemtimedopArgs{}, err 7231 } 7232 case 1: 7233 var dataSops uint64 7234 err = decoder.DecodeUint64(&dataSops) 7235 if err != nil { 7236 return types.SemtimedopArgs{}, err 7237 } 7238 result.Sops = uintptr(dataSops) 7239 case 2: 7240 err = decoder.DecodeUint64(&result.Nsops) 7241 if err != nil { 7242 return types.SemtimedopArgs{}, err 7243 } 7244 case 3: 7245 result.Timeout, err = decoder.ReadTimespec() 7246 if err != nil { 7247 return types.SemtimedopArgs{}, err 7248 } 7249 } 7250 } 7251 return result, nil 7252 } 7253 7254 func ParseFadvise64Args(decoder *Decoder) (types.Fadvise64Args, error) { 7255 var result types.Fadvise64Args 7256 var err error 7257 7258 var numArgs uint8 7259 err = decoder.DecodeUint8(&numArgs) 7260 if err != nil { 7261 return types.Fadvise64Args{}, err 7262 } 7263 7264 for arg := 0; arg < int(numArgs); arg++ { 7265 var currArg uint8 7266 err = decoder.DecodeUint8(&currArg) 7267 if err != nil { 7268 return types.Fadvise64Args{}, err 7269 } 7270 7271 switch currArg { 7272 case 0: 7273 err = decoder.DecodeInt32(&result.Fd) 7274 if err != nil { 7275 return types.Fadvise64Args{}, err 7276 } 7277 case 1: 7278 err = decoder.DecodeUint64(&result.Offset) 7279 if err != nil { 7280 return types.Fadvise64Args{}, err 7281 } 7282 case 2: 7283 err = decoder.DecodeUint64(&result.Len) 7284 if err != nil { 7285 return types.Fadvise64Args{}, err 7286 } 7287 case 3: 7288 err = decoder.DecodeInt32(&result.Advice) 7289 if err != nil { 7290 return types.Fadvise64Args{}, err 7291 } 7292 } 7293 } 7294 return result, nil 7295 } 7296 7297 func ParseTimerCreateArgs(decoder *Decoder) (types.TimerCreateArgs, error) { 7298 var result types.TimerCreateArgs 7299 var err error 7300 7301 var numArgs uint8 7302 err = decoder.DecodeUint8(&numArgs) 7303 if err != nil { 7304 return types.TimerCreateArgs{}, err 7305 } 7306 7307 for arg := 0; arg < int(numArgs); arg++ { 7308 var currArg uint8 7309 err = decoder.DecodeUint8(&currArg) 7310 if err != nil { 7311 return types.TimerCreateArgs{}, err 7312 } 7313 7314 switch currArg { 7315 case 0: 7316 err = decoder.DecodeInt32(&result.Clockid) 7317 if err != nil { 7318 return types.TimerCreateArgs{}, err 7319 } 7320 case 1: 7321 var dataSevp uint64 7322 err = decoder.DecodeUint64(&dataSevp) 7323 if err != nil { 7324 return types.TimerCreateArgs{}, err 7325 } 7326 result.Sevp = uintptr(dataSevp) 7327 case 2: 7328 var dataTimerId uint64 7329 err = decoder.DecodeUint64(&dataTimerId) 7330 if err != nil { 7331 return types.TimerCreateArgs{}, err 7332 } 7333 result.TimerId = uintptr(dataTimerId) 7334 } 7335 } 7336 return result, nil 7337 } 7338 7339 func ParseTimerSettimeArgs(decoder *Decoder) (types.TimerSettimeArgs, error) { 7340 var result types.TimerSettimeArgs 7341 var err error 7342 7343 var numArgs uint8 7344 err = decoder.DecodeUint8(&numArgs) 7345 if err != nil { 7346 return types.TimerSettimeArgs{}, err 7347 } 7348 7349 for arg := 0; arg < int(numArgs); arg++ { 7350 var currArg uint8 7351 err = decoder.DecodeUint8(&currArg) 7352 if err != nil { 7353 return types.TimerSettimeArgs{}, err 7354 } 7355 7356 switch currArg { 7357 case 0: 7358 err = decoder.DecodeInt32(&result.TimerId) 7359 if err != nil { 7360 return types.TimerSettimeArgs{}, err 7361 } 7362 case 1: 7363 err = decoder.DecodeInt32(&result.Flags) 7364 if err != nil { 7365 return types.TimerSettimeArgs{}, err 7366 } 7367 case 2: 7368 var dataNewValue uint64 7369 err = decoder.DecodeUint64(&dataNewValue) 7370 if err != nil { 7371 return types.TimerSettimeArgs{}, err 7372 } 7373 result.NewValue = uintptr(dataNewValue) 7374 case 3: 7375 var dataOldValue uint64 7376 err = decoder.DecodeUint64(&dataOldValue) 7377 if err != nil { 7378 return types.TimerSettimeArgs{}, err 7379 } 7380 result.OldValue = uintptr(dataOldValue) 7381 } 7382 } 7383 return result, nil 7384 } 7385 7386 func ParseTimerGettimeArgs(decoder *Decoder) (types.TimerGettimeArgs, error) { 7387 var result types.TimerGettimeArgs 7388 var err error 7389 7390 var numArgs uint8 7391 err = decoder.DecodeUint8(&numArgs) 7392 if err != nil { 7393 return types.TimerGettimeArgs{}, err 7394 } 7395 7396 for arg := 0; arg < int(numArgs); arg++ { 7397 var currArg uint8 7398 err = decoder.DecodeUint8(&currArg) 7399 if err != nil { 7400 return types.TimerGettimeArgs{}, err 7401 } 7402 7403 switch currArg { 7404 case 0: 7405 err = decoder.DecodeInt32(&result.TimerId) 7406 if err != nil { 7407 return types.TimerGettimeArgs{}, err 7408 } 7409 case 1: 7410 var dataCurrValue uint64 7411 err = decoder.DecodeUint64(&dataCurrValue) 7412 if err != nil { 7413 return types.TimerGettimeArgs{}, err 7414 } 7415 result.CurrValue = uintptr(dataCurrValue) 7416 } 7417 } 7418 return result, nil 7419 } 7420 7421 func ParseTimerGetoverrunArgs(decoder *Decoder) (types.TimerGetoverrunArgs, error) { 7422 var result types.TimerGetoverrunArgs 7423 var err error 7424 7425 var numArgs uint8 7426 err = decoder.DecodeUint8(&numArgs) 7427 if err != nil { 7428 return types.TimerGetoverrunArgs{}, err 7429 } 7430 7431 for arg := 0; arg < int(numArgs); arg++ { 7432 var currArg uint8 7433 err = decoder.DecodeUint8(&currArg) 7434 if err != nil { 7435 return types.TimerGetoverrunArgs{}, err 7436 } 7437 7438 switch currArg { 7439 case 0: 7440 err = decoder.DecodeInt32(&result.TimerId) 7441 if err != nil { 7442 return types.TimerGetoverrunArgs{}, err 7443 } 7444 } 7445 } 7446 return result, nil 7447 } 7448 7449 func ParseTimerDeleteArgs(decoder *Decoder) (types.TimerDeleteArgs, error) { 7450 var result types.TimerDeleteArgs 7451 var err error 7452 7453 var numArgs uint8 7454 err = decoder.DecodeUint8(&numArgs) 7455 if err != nil { 7456 return types.TimerDeleteArgs{}, err 7457 } 7458 7459 for arg := 0; arg < int(numArgs); arg++ { 7460 var currArg uint8 7461 err = decoder.DecodeUint8(&currArg) 7462 if err != nil { 7463 return types.TimerDeleteArgs{}, err 7464 } 7465 7466 switch currArg { 7467 case 0: 7468 err = decoder.DecodeInt32(&result.TimerId) 7469 if err != nil { 7470 return types.TimerDeleteArgs{}, err 7471 } 7472 } 7473 } 7474 return result, nil 7475 } 7476 7477 func ParseClockSettimeArgs(decoder *Decoder) (types.ClockSettimeArgs, error) { 7478 var result types.ClockSettimeArgs 7479 var err error 7480 7481 var numArgs uint8 7482 err = decoder.DecodeUint8(&numArgs) 7483 if err != nil { 7484 return types.ClockSettimeArgs{}, err 7485 } 7486 7487 for arg := 0; arg < int(numArgs); arg++ { 7488 var currArg uint8 7489 err = decoder.DecodeUint8(&currArg) 7490 if err != nil { 7491 return types.ClockSettimeArgs{}, err 7492 } 7493 7494 switch currArg { 7495 case 0: 7496 err = decoder.DecodeInt32(&result.Clockid) 7497 if err != nil { 7498 return types.ClockSettimeArgs{}, err 7499 } 7500 case 1: 7501 result.Tp, err = decoder.ReadTimespec() 7502 if err != nil { 7503 return types.ClockSettimeArgs{}, err 7504 } 7505 } 7506 } 7507 return result, nil 7508 } 7509 7510 func ParseClockGettimeArgs(decoder *Decoder) (types.ClockGettimeArgs, error) { 7511 var result types.ClockGettimeArgs 7512 var err error 7513 7514 var numArgs uint8 7515 err = decoder.DecodeUint8(&numArgs) 7516 if err != nil { 7517 return types.ClockGettimeArgs{}, err 7518 } 7519 7520 for arg := 0; arg < int(numArgs); arg++ { 7521 var currArg uint8 7522 err = decoder.DecodeUint8(&currArg) 7523 if err != nil { 7524 return types.ClockGettimeArgs{}, err 7525 } 7526 7527 switch currArg { 7528 case 0: 7529 err = decoder.DecodeInt32(&result.Clockid) 7530 if err != nil { 7531 return types.ClockGettimeArgs{}, err 7532 } 7533 case 1: 7534 result.Tp, err = decoder.ReadTimespec() 7535 if err != nil { 7536 return types.ClockGettimeArgs{}, err 7537 } 7538 } 7539 } 7540 return result, nil 7541 } 7542 7543 func ParseClockGetresArgs(decoder *Decoder) (types.ClockGetresArgs, error) { 7544 var result types.ClockGetresArgs 7545 var err error 7546 7547 var numArgs uint8 7548 err = decoder.DecodeUint8(&numArgs) 7549 if err != nil { 7550 return types.ClockGetresArgs{}, err 7551 } 7552 7553 for arg := 0; arg < int(numArgs); arg++ { 7554 var currArg uint8 7555 err = decoder.DecodeUint8(&currArg) 7556 if err != nil { 7557 return types.ClockGetresArgs{}, err 7558 } 7559 7560 switch currArg { 7561 case 0: 7562 err = decoder.DecodeInt32(&result.Clockid) 7563 if err != nil { 7564 return types.ClockGetresArgs{}, err 7565 } 7566 case 1: 7567 result.Res, err = decoder.ReadTimespec() 7568 if err != nil { 7569 return types.ClockGetresArgs{}, err 7570 } 7571 } 7572 } 7573 return result, nil 7574 } 7575 7576 func ParseClockNanosleepArgs(decoder *Decoder) (types.ClockNanosleepArgs, error) { 7577 var result types.ClockNanosleepArgs 7578 var err error 7579 7580 var numArgs uint8 7581 err = decoder.DecodeUint8(&numArgs) 7582 if err != nil { 7583 return types.ClockNanosleepArgs{}, err 7584 } 7585 7586 for arg := 0; arg < int(numArgs); arg++ { 7587 var currArg uint8 7588 err = decoder.DecodeUint8(&currArg) 7589 if err != nil { 7590 return types.ClockNanosleepArgs{}, err 7591 } 7592 7593 switch currArg { 7594 case 0: 7595 err = decoder.DecodeInt32(&result.Clockid) 7596 if err != nil { 7597 return types.ClockNanosleepArgs{}, err 7598 } 7599 case 1: 7600 err = decoder.DecodeInt32(&result.Flags) 7601 if err != nil { 7602 return types.ClockNanosleepArgs{}, err 7603 } 7604 case 2: 7605 result.Request, err = decoder.ReadTimespec() 7606 if err != nil { 7607 return types.ClockNanosleepArgs{}, err 7608 } 7609 case 3: 7610 result.Remain, err = decoder.ReadTimespec() 7611 if err != nil { 7612 return types.ClockNanosleepArgs{}, err 7613 } 7614 } 7615 } 7616 return result, nil 7617 } 7618 7619 func ParseExitGroupArgs(decoder *Decoder) (types.ExitGroupArgs, error) { 7620 var result types.ExitGroupArgs 7621 var err error 7622 7623 var numArgs uint8 7624 err = decoder.DecodeUint8(&numArgs) 7625 if err != nil { 7626 return types.ExitGroupArgs{}, err 7627 } 7628 7629 for arg := 0; arg < int(numArgs); arg++ { 7630 var currArg uint8 7631 err = decoder.DecodeUint8(&currArg) 7632 if err != nil { 7633 return types.ExitGroupArgs{}, err 7634 } 7635 7636 switch currArg { 7637 case 0: 7638 err = decoder.DecodeInt32(&result.Status) 7639 if err != nil { 7640 return types.ExitGroupArgs{}, err 7641 } 7642 } 7643 } 7644 return result, nil 7645 } 7646 7647 func ParseEpollWaitArgs(decoder *Decoder) (types.EpollWaitArgs, error) { 7648 var result types.EpollWaitArgs 7649 var err error 7650 7651 var numArgs uint8 7652 err = decoder.DecodeUint8(&numArgs) 7653 if err != nil { 7654 return types.EpollWaitArgs{}, err 7655 } 7656 7657 for arg := 0; arg < int(numArgs); arg++ { 7658 var currArg uint8 7659 err = decoder.DecodeUint8(&currArg) 7660 if err != nil { 7661 return types.EpollWaitArgs{}, err 7662 } 7663 7664 switch currArg { 7665 case 0: 7666 err = decoder.DecodeInt32(&result.Epfd) 7667 if err != nil { 7668 return types.EpollWaitArgs{}, err 7669 } 7670 case 1: 7671 var dataEvents uint64 7672 err = decoder.DecodeUint64(&dataEvents) 7673 if err != nil { 7674 return types.EpollWaitArgs{}, err 7675 } 7676 result.Events = uintptr(dataEvents) 7677 case 2: 7678 err = decoder.DecodeInt32(&result.Maxevents) 7679 if err != nil { 7680 return types.EpollWaitArgs{}, err 7681 } 7682 case 3: 7683 err = decoder.DecodeInt32(&result.Timeout) 7684 if err != nil { 7685 return types.EpollWaitArgs{}, err 7686 } 7687 } 7688 } 7689 return result, nil 7690 } 7691 7692 func ParseEpollCtlArgs(decoder *Decoder) (types.EpollCtlArgs, error) { 7693 var result types.EpollCtlArgs 7694 var err error 7695 7696 var numArgs uint8 7697 err = decoder.DecodeUint8(&numArgs) 7698 if err != nil { 7699 return types.EpollCtlArgs{}, err 7700 } 7701 7702 for arg := 0; arg < int(numArgs); arg++ { 7703 var currArg uint8 7704 err = decoder.DecodeUint8(&currArg) 7705 if err != nil { 7706 return types.EpollCtlArgs{}, err 7707 } 7708 7709 switch currArg { 7710 case 0: 7711 err = decoder.DecodeInt32(&result.Epfd) 7712 if err != nil { 7713 return types.EpollCtlArgs{}, err 7714 } 7715 case 1: 7716 err = decoder.DecodeInt32(&result.Op) 7717 if err != nil { 7718 return types.EpollCtlArgs{}, err 7719 } 7720 case 2: 7721 err = decoder.DecodeInt32(&result.Fd) 7722 if err != nil { 7723 return types.EpollCtlArgs{}, err 7724 } 7725 case 3: 7726 var dataEvent uint64 7727 err = decoder.DecodeUint64(&dataEvent) 7728 if err != nil { 7729 return types.EpollCtlArgs{}, err 7730 } 7731 result.Event = uintptr(dataEvent) 7732 } 7733 } 7734 return result, nil 7735 } 7736 7737 func ParseTgkillArgs(decoder *Decoder) (types.TgkillArgs, error) { 7738 var result types.TgkillArgs 7739 var err error 7740 7741 var numArgs uint8 7742 err = decoder.DecodeUint8(&numArgs) 7743 if err != nil { 7744 return types.TgkillArgs{}, err 7745 } 7746 7747 for arg := 0; arg < int(numArgs); arg++ { 7748 var currArg uint8 7749 err = decoder.DecodeUint8(&currArg) 7750 if err != nil { 7751 return types.TgkillArgs{}, err 7752 } 7753 7754 switch currArg { 7755 case 0: 7756 err = decoder.DecodeInt32(&result.Tgid) 7757 if err != nil { 7758 return types.TgkillArgs{}, err 7759 } 7760 case 1: 7761 err = decoder.DecodeInt32(&result.Tid) 7762 if err != nil { 7763 return types.TgkillArgs{}, err 7764 } 7765 case 2: 7766 err = decoder.DecodeInt32(&result.Sig) 7767 if err != nil { 7768 return types.TgkillArgs{}, err 7769 } 7770 } 7771 } 7772 return result, nil 7773 } 7774 7775 func ParseUtimesArgs(decoder *Decoder) (types.UtimesArgs, error) { 7776 var result types.UtimesArgs 7777 var err error 7778 7779 var numArgs uint8 7780 err = decoder.DecodeUint8(&numArgs) 7781 if err != nil { 7782 return types.UtimesArgs{}, err 7783 } 7784 7785 for arg := 0; arg < int(numArgs); arg++ { 7786 var currArg uint8 7787 err = decoder.DecodeUint8(&currArg) 7788 if err != nil { 7789 return types.UtimesArgs{}, err 7790 } 7791 7792 switch currArg { 7793 case 0: 7794 result.Filename, err = decoder.ReadStringFromBuff() 7795 if err != nil { 7796 return types.UtimesArgs{}, err 7797 } 7798 case 1: 7799 var dataTimes uint64 7800 err = decoder.DecodeUint64(&dataTimes) 7801 if err != nil { 7802 return types.UtimesArgs{}, err 7803 } 7804 result.Times = uintptr(dataTimes) 7805 } 7806 } 7807 return result, nil 7808 } 7809 7810 func ParseVserverArgs(decoder *Decoder) (types.VserverArgs, error) { 7811 return types.VserverArgs{}, nil 7812 } 7813 7814 func ParseMbindArgs(decoder *Decoder) (types.MbindArgs, error) { 7815 var result types.MbindArgs 7816 var err error 7817 7818 var numArgs uint8 7819 err = decoder.DecodeUint8(&numArgs) 7820 if err != nil { 7821 return types.MbindArgs{}, err 7822 } 7823 7824 for arg := 0; arg < int(numArgs); arg++ { 7825 var currArg uint8 7826 err = decoder.DecodeUint8(&currArg) 7827 if err != nil { 7828 return types.MbindArgs{}, err 7829 } 7830 7831 switch currArg { 7832 case 0: 7833 var dataAddr uint64 7834 err = decoder.DecodeUint64(&dataAddr) 7835 if err != nil { 7836 return types.MbindArgs{}, err 7837 } 7838 result.Addr = uintptr(dataAddr) 7839 case 1: 7840 err = decoder.DecodeUint64(&result.Len) 7841 if err != nil { 7842 return types.MbindArgs{}, err 7843 } 7844 case 2: 7845 err = decoder.DecodeInt32(&result.Mode) 7846 if err != nil { 7847 return types.MbindArgs{}, err 7848 } 7849 case 3: 7850 var dataNodemask uint64 7851 err = decoder.DecodeUint64(&dataNodemask) 7852 if err != nil { 7853 return types.MbindArgs{}, err 7854 } 7855 result.Nodemask = uintptr(dataNodemask) 7856 case 4: 7857 err = decoder.DecodeUint64(&result.Maxnode) 7858 if err != nil { 7859 return types.MbindArgs{}, err 7860 } 7861 case 5: 7862 err = decoder.DecodeUint32(&result.Flags) 7863 if err != nil { 7864 return types.MbindArgs{}, err 7865 } 7866 } 7867 } 7868 return result, nil 7869 } 7870 7871 func ParseSetMempolicyArgs(decoder *Decoder) (types.SetMempolicyArgs, error) { 7872 var result types.SetMempolicyArgs 7873 var err error 7874 7875 var numArgs uint8 7876 err = decoder.DecodeUint8(&numArgs) 7877 if err != nil { 7878 return types.SetMempolicyArgs{}, err 7879 } 7880 7881 for arg := 0; arg < int(numArgs); arg++ { 7882 var currArg uint8 7883 err = decoder.DecodeUint8(&currArg) 7884 if err != nil { 7885 return types.SetMempolicyArgs{}, err 7886 } 7887 7888 switch currArg { 7889 case 0: 7890 err = decoder.DecodeInt32(&result.Mode) 7891 if err != nil { 7892 return types.SetMempolicyArgs{}, err 7893 } 7894 case 1: 7895 var dataNodemask uint64 7896 err = decoder.DecodeUint64(&dataNodemask) 7897 if err != nil { 7898 return types.SetMempolicyArgs{}, err 7899 } 7900 result.Nodemask = uintptr(dataNodemask) 7901 case 2: 7902 err = decoder.DecodeUint64(&result.Maxnode) 7903 if err != nil { 7904 return types.SetMempolicyArgs{}, err 7905 } 7906 } 7907 } 7908 return result, nil 7909 } 7910 7911 func ParseGetMempolicyArgs(decoder *Decoder) (types.GetMempolicyArgs, error) { 7912 var result types.GetMempolicyArgs 7913 var err error 7914 7915 var numArgs uint8 7916 err = decoder.DecodeUint8(&numArgs) 7917 if err != nil { 7918 return types.GetMempolicyArgs{}, err 7919 } 7920 7921 for arg := 0; arg < int(numArgs); arg++ { 7922 var currArg uint8 7923 err = decoder.DecodeUint8(&currArg) 7924 if err != nil { 7925 return types.GetMempolicyArgs{}, err 7926 } 7927 7928 switch currArg { 7929 case 0: 7930 var dataMode uint64 7931 err = decoder.DecodeUint64(&dataMode) 7932 if err != nil { 7933 return types.GetMempolicyArgs{}, err 7934 } 7935 result.Mode = uintptr(dataMode) 7936 case 1: 7937 var dataNodemask uint64 7938 err = decoder.DecodeUint64(&dataNodemask) 7939 if err != nil { 7940 return types.GetMempolicyArgs{}, err 7941 } 7942 result.Nodemask = uintptr(dataNodemask) 7943 case 2: 7944 err = decoder.DecodeUint64(&result.Maxnode) 7945 if err != nil { 7946 return types.GetMempolicyArgs{}, err 7947 } 7948 case 3: 7949 var dataAddr uint64 7950 err = decoder.DecodeUint64(&dataAddr) 7951 if err != nil { 7952 return types.GetMempolicyArgs{}, err 7953 } 7954 result.Addr = uintptr(dataAddr) 7955 case 4: 7956 err = decoder.DecodeUint64(&result.Flags) 7957 if err != nil { 7958 return types.GetMempolicyArgs{}, err 7959 } 7960 } 7961 } 7962 return result, nil 7963 } 7964 7965 func ParseMqOpenArgs(decoder *Decoder) (types.MqOpenArgs, error) { 7966 var result types.MqOpenArgs 7967 var err error 7968 7969 var numArgs uint8 7970 err = decoder.DecodeUint8(&numArgs) 7971 if err != nil { 7972 return types.MqOpenArgs{}, err 7973 } 7974 7975 for arg := 0; arg < int(numArgs); arg++ { 7976 var currArg uint8 7977 err = decoder.DecodeUint8(&currArg) 7978 if err != nil { 7979 return types.MqOpenArgs{}, err 7980 } 7981 7982 switch currArg { 7983 case 0: 7984 result.Name, err = decoder.ReadStringFromBuff() 7985 if err != nil { 7986 return types.MqOpenArgs{}, err 7987 } 7988 case 1: 7989 err = decoder.DecodeInt32(&result.Oflag) 7990 if err != nil { 7991 return types.MqOpenArgs{}, err 7992 } 7993 case 2: 7994 err = decoder.DecodeUint32(&result.Mode) 7995 if err != nil { 7996 return types.MqOpenArgs{}, err 7997 } 7998 case 3: 7999 var dataAttr uint64 8000 err = decoder.DecodeUint64(&dataAttr) 8001 if err != nil { 8002 return types.MqOpenArgs{}, err 8003 } 8004 result.Attr = uintptr(dataAttr) 8005 } 8006 } 8007 return result, nil 8008 } 8009 8010 func ParseMqUnlinkArgs(decoder *Decoder) (types.MqUnlinkArgs, error) { 8011 var result types.MqUnlinkArgs 8012 var err error 8013 8014 var numArgs uint8 8015 err = decoder.DecodeUint8(&numArgs) 8016 if err != nil { 8017 return types.MqUnlinkArgs{}, err 8018 } 8019 8020 for arg := 0; arg < int(numArgs); arg++ { 8021 var currArg uint8 8022 err = decoder.DecodeUint8(&currArg) 8023 if err != nil { 8024 return types.MqUnlinkArgs{}, err 8025 } 8026 8027 switch currArg { 8028 case 0: 8029 result.Name, err = decoder.ReadStringFromBuff() 8030 if err != nil { 8031 return types.MqUnlinkArgs{}, err 8032 } 8033 } 8034 } 8035 return result, nil 8036 } 8037 8038 func ParseMqTimedsendArgs(decoder *Decoder) (types.MqTimedsendArgs, error) { 8039 var result types.MqTimedsendArgs 8040 var err error 8041 8042 var numArgs uint8 8043 err = decoder.DecodeUint8(&numArgs) 8044 if err != nil { 8045 return types.MqTimedsendArgs{}, err 8046 } 8047 8048 for arg := 0; arg < int(numArgs); arg++ { 8049 var currArg uint8 8050 err = decoder.DecodeUint8(&currArg) 8051 if err != nil { 8052 return types.MqTimedsendArgs{}, err 8053 } 8054 8055 switch currArg { 8056 case 0: 8057 err = decoder.DecodeInt32(&result.Mqdes) 8058 if err != nil { 8059 return types.MqTimedsendArgs{}, err 8060 } 8061 case 1: 8062 result.MsgPtr, err = decoder.ReadStringFromBuff() 8063 if err != nil { 8064 return types.MqTimedsendArgs{}, err 8065 } 8066 case 2: 8067 err = decoder.DecodeUint64(&result.MsgLen) 8068 if err != nil { 8069 return types.MqTimedsendArgs{}, err 8070 } 8071 case 3: 8072 err = decoder.DecodeUint32(&result.MsgPrio) 8073 if err != nil { 8074 return types.MqTimedsendArgs{}, err 8075 } 8076 case 4: 8077 result.AbsTimeout, err = decoder.ReadTimespec() 8078 if err != nil { 8079 return types.MqTimedsendArgs{}, err 8080 } 8081 } 8082 } 8083 return result, nil 8084 } 8085 8086 func ParseMqTimedreceiveArgs(decoder *Decoder) (types.MqTimedreceiveArgs, error) { 8087 var result types.MqTimedreceiveArgs 8088 var err error 8089 8090 var numArgs uint8 8091 err = decoder.DecodeUint8(&numArgs) 8092 if err != nil { 8093 return types.MqTimedreceiveArgs{}, err 8094 } 8095 8096 for arg := 0; arg < int(numArgs); arg++ { 8097 var currArg uint8 8098 err = decoder.DecodeUint8(&currArg) 8099 if err != nil { 8100 return types.MqTimedreceiveArgs{}, err 8101 } 8102 8103 switch currArg { 8104 case 0: 8105 err = decoder.DecodeInt32(&result.Mqdes) 8106 if err != nil { 8107 return types.MqTimedreceiveArgs{}, err 8108 } 8109 case 1: 8110 result.MsgPtr, err = decoder.ReadStringFromBuff() 8111 if err != nil { 8112 return types.MqTimedreceiveArgs{}, err 8113 } 8114 case 2: 8115 err = decoder.DecodeUint64(&result.MsgLen) 8116 if err != nil { 8117 return types.MqTimedreceiveArgs{}, err 8118 } 8119 case 3: 8120 var dataMsgPrio uint64 8121 err = decoder.DecodeUint64(&dataMsgPrio) 8122 if err != nil { 8123 return types.MqTimedreceiveArgs{}, err 8124 } 8125 result.MsgPrio = uintptr(dataMsgPrio) 8126 case 4: 8127 result.AbsTimeout, err = decoder.ReadTimespec() 8128 if err != nil { 8129 return types.MqTimedreceiveArgs{}, err 8130 } 8131 } 8132 } 8133 return result, nil 8134 } 8135 8136 func ParseMqNotifyArgs(decoder *Decoder) (types.MqNotifyArgs, error) { 8137 var result types.MqNotifyArgs 8138 var err error 8139 8140 var numArgs uint8 8141 err = decoder.DecodeUint8(&numArgs) 8142 if err != nil { 8143 return types.MqNotifyArgs{}, err 8144 } 8145 8146 for arg := 0; arg < int(numArgs); arg++ { 8147 var currArg uint8 8148 err = decoder.DecodeUint8(&currArg) 8149 if err != nil { 8150 return types.MqNotifyArgs{}, err 8151 } 8152 8153 switch currArg { 8154 case 0: 8155 err = decoder.DecodeInt32(&result.Mqdes) 8156 if err != nil { 8157 return types.MqNotifyArgs{}, err 8158 } 8159 case 1: 8160 var dataSevp uint64 8161 err = decoder.DecodeUint64(&dataSevp) 8162 if err != nil { 8163 return types.MqNotifyArgs{}, err 8164 } 8165 result.Sevp = uintptr(dataSevp) 8166 } 8167 } 8168 return result, nil 8169 } 8170 8171 func ParseMqGetsetattrArgs(decoder *Decoder) (types.MqGetsetattrArgs, error) { 8172 var result types.MqGetsetattrArgs 8173 var err error 8174 8175 var numArgs uint8 8176 err = decoder.DecodeUint8(&numArgs) 8177 if err != nil { 8178 return types.MqGetsetattrArgs{}, err 8179 } 8180 8181 for arg := 0; arg < int(numArgs); arg++ { 8182 var currArg uint8 8183 err = decoder.DecodeUint8(&currArg) 8184 if err != nil { 8185 return types.MqGetsetattrArgs{}, err 8186 } 8187 8188 switch currArg { 8189 case 0: 8190 err = decoder.DecodeInt32(&result.Mqdes) 8191 if err != nil { 8192 return types.MqGetsetattrArgs{}, err 8193 } 8194 case 1: 8195 var dataNewattr uint64 8196 err = decoder.DecodeUint64(&dataNewattr) 8197 if err != nil { 8198 return types.MqGetsetattrArgs{}, err 8199 } 8200 result.Newattr = uintptr(dataNewattr) 8201 case 2: 8202 var dataOldattr uint64 8203 err = decoder.DecodeUint64(&dataOldattr) 8204 if err != nil { 8205 return types.MqGetsetattrArgs{}, err 8206 } 8207 result.Oldattr = uintptr(dataOldattr) 8208 } 8209 } 8210 return result, nil 8211 } 8212 8213 func ParseKexecLoadArgs(decoder *Decoder) (types.KexecLoadArgs, error) { 8214 var result types.KexecLoadArgs 8215 var err error 8216 8217 var numArgs uint8 8218 err = decoder.DecodeUint8(&numArgs) 8219 if err != nil { 8220 return types.KexecLoadArgs{}, err 8221 } 8222 8223 for arg := 0; arg < int(numArgs); arg++ { 8224 var currArg uint8 8225 err = decoder.DecodeUint8(&currArg) 8226 if err != nil { 8227 return types.KexecLoadArgs{}, err 8228 } 8229 8230 switch currArg { 8231 case 0: 8232 err = decoder.DecodeUint64(&result.Entry) 8233 if err != nil { 8234 return types.KexecLoadArgs{}, err 8235 } 8236 case 1: 8237 err = decoder.DecodeUint64(&result.NrSegments) 8238 if err != nil { 8239 return types.KexecLoadArgs{}, err 8240 } 8241 case 2: 8242 var dataSegments uint64 8243 err = decoder.DecodeUint64(&dataSegments) 8244 if err != nil { 8245 return types.KexecLoadArgs{}, err 8246 } 8247 result.Segments = uintptr(dataSegments) 8248 case 3: 8249 err = decoder.DecodeUint64(&result.Flags) 8250 if err != nil { 8251 return types.KexecLoadArgs{}, err 8252 } 8253 } 8254 } 8255 return result, nil 8256 } 8257 8258 func ParseWaitidArgs(decoder *Decoder) (types.WaitidArgs, error) { 8259 var result types.WaitidArgs 8260 var err error 8261 8262 var numArgs uint8 8263 err = decoder.DecodeUint8(&numArgs) 8264 if err != nil { 8265 return types.WaitidArgs{}, err 8266 } 8267 8268 for arg := 0; arg < int(numArgs); arg++ { 8269 var currArg uint8 8270 err = decoder.DecodeUint8(&currArg) 8271 if err != nil { 8272 return types.WaitidArgs{}, err 8273 } 8274 8275 switch currArg { 8276 case 0: 8277 err = decoder.DecodeInt32(&result.Idtype) 8278 if err != nil { 8279 return types.WaitidArgs{}, err 8280 } 8281 case 1: 8282 err = decoder.DecodeInt32(&result.Id) 8283 if err != nil { 8284 return types.WaitidArgs{}, err 8285 } 8286 case 2: 8287 var dataInfop uint64 8288 err = decoder.DecodeUint64(&dataInfop) 8289 if err != nil { 8290 return types.WaitidArgs{}, err 8291 } 8292 result.Infop = uintptr(dataInfop) 8293 case 3: 8294 err = decoder.DecodeInt32(&result.Options) 8295 if err != nil { 8296 return types.WaitidArgs{}, err 8297 } 8298 case 4: 8299 var dataRusage uint64 8300 err = decoder.DecodeUint64(&dataRusage) 8301 if err != nil { 8302 return types.WaitidArgs{}, err 8303 } 8304 result.Rusage = uintptr(dataRusage) 8305 } 8306 } 8307 return result, nil 8308 } 8309 8310 func ParseAddKeyArgs(decoder *Decoder) (types.AddKeyArgs, error) { 8311 var result types.AddKeyArgs 8312 var err error 8313 8314 var numArgs uint8 8315 err = decoder.DecodeUint8(&numArgs) 8316 if err != nil { 8317 return types.AddKeyArgs{}, err 8318 } 8319 8320 for arg := 0; arg < int(numArgs); arg++ { 8321 var currArg uint8 8322 err = decoder.DecodeUint8(&currArg) 8323 if err != nil { 8324 return types.AddKeyArgs{}, err 8325 } 8326 8327 switch currArg { 8328 case 0: 8329 result.Type, err = decoder.ReadStringFromBuff() 8330 if err != nil { 8331 return types.AddKeyArgs{}, err 8332 } 8333 case 1: 8334 result.Description, err = decoder.ReadStringFromBuff() 8335 if err != nil { 8336 return types.AddKeyArgs{}, err 8337 } 8338 case 2: 8339 var dataPayload uint64 8340 err = decoder.DecodeUint64(&dataPayload) 8341 if err != nil { 8342 return types.AddKeyArgs{}, err 8343 } 8344 result.Payload = uintptr(dataPayload) 8345 case 3: 8346 err = decoder.DecodeUint64(&result.Plen) 8347 if err != nil { 8348 return types.AddKeyArgs{}, err 8349 } 8350 case 4: 8351 err = decoder.DecodeInt32(&result.Keyring) 8352 if err != nil { 8353 return types.AddKeyArgs{}, err 8354 } 8355 } 8356 } 8357 return result, nil 8358 } 8359 8360 func ParseRequestKeyArgs(decoder *Decoder) (types.RequestKeyArgs, error) { 8361 var result types.RequestKeyArgs 8362 var err error 8363 8364 var numArgs uint8 8365 err = decoder.DecodeUint8(&numArgs) 8366 if err != nil { 8367 return types.RequestKeyArgs{}, err 8368 } 8369 8370 for arg := 0; arg < int(numArgs); arg++ { 8371 var currArg uint8 8372 err = decoder.DecodeUint8(&currArg) 8373 if err != nil { 8374 return types.RequestKeyArgs{}, err 8375 } 8376 8377 switch currArg { 8378 case 0: 8379 result.Type, err = decoder.ReadStringFromBuff() 8380 if err != nil { 8381 return types.RequestKeyArgs{}, err 8382 } 8383 case 1: 8384 result.Description, err = decoder.ReadStringFromBuff() 8385 if err != nil { 8386 return types.RequestKeyArgs{}, err 8387 } 8388 case 2: 8389 result.CalloutInfo, err = decoder.ReadStringFromBuff() 8390 if err != nil { 8391 return types.RequestKeyArgs{}, err 8392 } 8393 case 3: 8394 err = decoder.DecodeInt32(&result.DestKeyring) 8395 if err != nil { 8396 return types.RequestKeyArgs{}, err 8397 } 8398 } 8399 } 8400 return result, nil 8401 } 8402 8403 func ParseKeyctlArgs(decoder *Decoder) (types.KeyctlArgs, error) { 8404 var result types.KeyctlArgs 8405 var err error 8406 8407 var numArgs uint8 8408 err = decoder.DecodeUint8(&numArgs) 8409 if err != nil { 8410 return types.KeyctlArgs{}, err 8411 } 8412 8413 for arg := 0; arg < int(numArgs); arg++ { 8414 var currArg uint8 8415 err = decoder.DecodeUint8(&currArg) 8416 if err != nil { 8417 return types.KeyctlArgs{}, err 8418 } 8419 8420 switch currArg { 8421 case 0: 8422 err = decoder.DecodeInt32(&result.Operation) 8423 if err != nil { 8424 return types.KeyctlArgs{}, err 8425 } 8426 case 1: 8427 err = decoder.DecodeUint64(&result.Arg2) 8428 if err != nil { 8429 return types.KeyctlArgs{}, err 8430 } 8431 case 2: 8432 err = decoder.DecodeUint64(&result.Arg3) 8433 if err != nil { 8434 return types.KeyctlArgs{}, err 8435 } 8436 case 3: 8437 err = decoder.DecodeUint64(&result.Arg4) 8438 if err != nil { 8439 return types.KeyctlArgs{}, err 8440 } 8441 case 4: 8442 err = decoder.DecodeUint64(&result.Arg5) 8443 if err != nil { 8444 return types.KeyctlArgs{}, err 8445 } 8446 } 8447 } 8448 return result, nil 8449 } 8450 8451 func ParseIoprioSetArgs(decoder *Decoder) (types.IoprioSetArgs, error) { 8452 var result types.IoprioSetArgs 8453 var err error 8454 8455 var numArgs uint8 8456 err = decoder.DecodeUint8(&numArgs) 8457 if err != nil { 8458 return types.IoprioSetArgs{}, err 8459 } 8460 8461 for arg := 0; arg < int(numArgs); arg++ { 8462 var currArg uint8 8463 err = decoder.DecodeUint8(&currArg) 8464 if err != nil { 8465 return types.IoprioSetArgs{}, err 8466 } 8467 8468 switch currArg { 8469 case 0: 8470 err = decoder.DecodeInt32(&result.Which) 8471 if err != nil { 8472 return types.IoprioSetArgs{}, err 8473 } 8474 case 1: 8475 err = decoder.DecodeInt32(&result.Who) 8476 if err != nil { 8477 return types.IoprioSetArgs{}, err 8478 } 8479 case 2: 8480 err = decoder.DecodeInt32(&result.Ioprio) 8481 if err != nil { 8482 return types.IoprioSetArgs{}, err 8483 } 8484 } 8485 } 8486 return result, nil 8487 } 8488 8489 func ParseIoprioGetArgs(decoder *Decoder) (types.IoprioGetArgs, error) { 8490 var result types.IoprioGetArgs 8491 var err error 8492 8493 var numArgs uint8 8494 err = decoder.DecodeUint8(&numArgs) 8495 if err != nil { 8496 return types.IoprioGetArgs{}, err 8497 } 8498 8499 for arg := 0; arg < int(numArgs); arg++ { 8500 var currArg uint8 8501 err = decoder.DecodeUint8(&currArg) 8502 if err != nil { 8503 return types.IoprioGetArgs{}, err 8504 } 8505 8506 switch currArg { 8507 case 0: 8508 err = decoder.DecodeInt32(&result.Which) 8509 if err != nil { 8510 return types.IoprioGetArgs{}, err 8511 } 8512 case 1: 8513 err = decoder.DecodeInt32(&result.Who) 8514 if err != nil { 8515 return types.IoprioGetArgs{}, err 8516 } 8517 } 8518 } 8519 return result, nil 8520 } 8521 8522 func ParseInotifyInitArgs(decoder *Decoder) (types.InotifyInitArgs, error) { 8523 return types.InotifyInitArgs{}, nil 8524 } 8525 8526 func ParseInotifyAddWatchArgs(decoder *Decoder) (types.InotifyAddWatchArgs, error) { 8527 var result types.InotifyAddWatchArgs 8528 var err error 8529 8530 var numArgs uint8 8531 err = decoder.DecodeUint8(&numArgs) 8532 if err != nil { 8533 return types.InotifyAddWatchArgs{}, err 8534 } 8535 8536 for arg := 0; arg < int(numArgs); arg++ { 8537 var currArg uint8 8538 err = decoder.DecodeUint8(&currArg) 8539 if err != nil { 8540 return types.InotifyAddWatchArgs{}, err 8541 } 8542 8543 switch currArg { 8544 case 0: 8545 err = decoder.DecodeInt32(&result.Fd) 8546 if err != nil { 8547 return types.InotifyAddWatchArgs{}, err 8548 } 8549 case 1: 8550 result.Pathname, err = decoder.ReadStringFromBuff() 8551 if err != nil { 8552 return types.InotifyAddWatchArgs{}, err 8553 } 8554 case 2: 8555 err = decoder.DecodeUint32(&result.Mask) 8556 if err != nil { 8557 return types.InotifyAddWatchArgs{}, err 8558 } 8559 } 8560 } 8561 return result, nil 8562 } 8563 8564 func ParseInotifyRmWatchArgs(decoder *Decoder) (types.InotifyRmWatchArgs, error) { 8565 var result types.InotifyRmWatchArgs 8566 var err error 8567 8568 var numArgs uint8 8569 err = decoder.DecodeUint8(&numArgs) 8570 if err != nil { 8571 return types.InotifyRmWatchArgs{}, err 8572 } 8573 8574 for arg := 0; arg < int(numArgs); arg++ { 8575 var currArg uint8 8576 err = decoder.DecodeUint8(&currArg) 8577 if err != nil { 8578 return types.InotifyRmWatchArgs{}, err 8579 } 8580 8581 switch currArg { 8582 case 0: 8583 err = decoder.DecodeInt32(&result.Fd) 8584 if err != nil { 8585 return types.InotifyRmWatchArgs{}, err 8586 } 8587 case 1: 8588 err = decoder.DecodeInt32(&result.Wd) 8589 if err != nil { 8590 return types.InotifyRmWatchArgs{}, err 8591 } 8592 } 8593 } 8594 return result, nil 8595 } 8596 8597 func ParseMigratePagesArgs(decoder *Decoder) (types.MigratePagesArgs, error) { 8598 var result types.MigratePagesArgs 8599 var err error 8600 8601 var numArgs uint8 8602 err = decoder.DecodeUint8(&numArgs) 8603 if err != nil { 8604 return types.MigratePagesArgs{}, err 8605 } 8606 8607 for arg := 0; arg < int(numArgs); arg++ { 8608 var currArg uint8 8609 err = decoder.DecodeUint8(&currArg) 8610 if err != nil { 8611 return types.MigratePagesArgs{}, err 8612 } 8613 8614 switch currArg { 8615 case 0: 8616 err = decoder.DecodeInt32(&result.Pid) 8617 if err != nil { 8618 return types.MigratePagesArgs{}, err 8619 } 8620 case 1: 8621 err = decoder.DecodeUint64(&result.Maxnode) 8622 if err != nil { 8623 return types.MigratePagesArgs{}, err 8624 } 8625 case 2: 8626 var dataOldNodes uint64 8627 err = decoder.DecodeUint64(&dataOldNodes) 8628 if err != nil { 8629 return types.MigratePagesArgs{}, err 8630 } 8631 result.OldNodes = uintptr(dataOldNodes) 8632 case 3: 8633 var dataNewNodes uint64 8634 err = decoder.DecodeUint64(&dataNewNodes) 8635 if err != nil { 8636 return types.MigratePagesArgs{}, err 8637 } 8638 result.NewNodes = uintptr(dataNewNodes) 8639 } 8640 } 8641 return result, nil 8642 } 8643 8644 func ParseOpenatArgs(decoder *Decoder) (types.OpenatArgs, error) { 8645 var result types.OpenatArgs 8646 var err error 8647 8648 var numArgs uint8 8649 err = decoder.DecodeUint8(&numArgs) 8650 if err != nil { 8651 return types.OpenatArgs{}, err 8652 } 8653 8654 for arg := 0; arg < int(numArgs); arg++ { 8655 var currArg uint8 8656 err = decoder.DecodeUint8(&currArg) 8657 if err != nil { 8658 return types.OpenatArgs{}, err 8659 } 8660 8661 switch currArg { 8662 case 0: 8663 err = decoder.DecodeInt32(&result.Dirfd) 8664 if err != nil { 8665 return types.OpenatArgs{}, err 8666 } 8667 case 1: 8668 result.Pathname, err = decoder.ReadStringFromBuff() 8669 if err != nil { 8670 return types.OpenatArgs{}, err 8671 } 8672 case 2: 8673 err = decoder.DecodeInt32(&result.Flags) 8674 if err != nil { 8675 return types.OpenatArgs{}, err 8676 } 8677 case 3: 8678 err = decoder.DecodeUint32(&result.Mode) 8679 if err != nil { 8680 return types.OpenatArgs{}, err 8681 } 8682 } 8683 } 8684 return result, nil 8685 } 8686 8687 func ParseMkdiratArgs(decoder *Decoder) (types.MkdiratArgs, error) { 8688 var result types.MkdiratArgs 8689 var err error 8690 8691 var numArgs uint8 8692 err = decoder.DecodeUint8(&numArgs) 8693 if err != nil { 8694 return types.MkdiratArgs{}, err 8695 } 8696 8697 for arg := 0; arg < int(numArgs); arg++ { 8698 var currArg uint8 8699 err = decoder.DecodeUint8(&currArg) 8700 if err != nil { 8701 return types.MkdiratArgs{}, err 8702 } 8703 8704 switch currArg { 8705 case 0: 8706 err = decoder.DecodeInt32(&result.Dirfd) 8707 if err != nil { 8708 return types.MkdiratArgs{}, err 8709 } 8710 case 1: 8711 result.Pathname, err = decoder.ReadStringFromBuff() 8712 if err != nil { 8713 return types.MkdiratArgs{}, err 8714 } 8715 case 2: 8716 err = decoder.DecodeUint32(&result.Mode) 8717 if err != nil { 8718 return types.MkdiratArgs{}, err 8719 } 8720 } 8721 } 8722 return result, nil 8723 } 8724 8725 func ParseMknodatArgs(decoder *Decoder) (types.MknodatArgs, error) { 8726 var result types.MknodatArgs 8727 var err error 8728 8729 var numArgs uint8 8730 err = decoder.DecodeUint8(&numArgs) 8731 if err != nil { 8732 return types.MknodatArgs{}, err 8733 } 8734 8735 for arg := 0; arg < int(numArgs); arg++ { 8736 var currArg uint8 8737 err = decoder.DecodeUint8(&currArg) 8738 if err != nil { 8739 return types.MknodatArgs{}, err 8740 } 8741 8742 switch currArg { 8743 case 0: 8744 err = decoder.DecodeInt32(&result.Dirfd) 8745 if err != nil { 8746 return types.MknodatArgs{}, err 8747 } 8748 case 1: 8749 result.Pathname, err = decoder.ReadStringFromBuff() 8750 if err != nil { 8751 return types.MknodatArgs{}, err 8752 } 8753 case 2: 8754 err = decoder.DecodeUint32(&result.Mode) 8755 if err != nil { 8756 return types.MknodatArgs{}, err 8757 } 8758 case 3: 8759 err = decoder.DecodeUint32(&result.Dev) 8760 if err != nil { 8761 return types.MknodatArgs{}, err 8762 } 8763 } 8764 } 8765 return result, nil 8766 } 8767 8768 func ParseFchownatArgs(decoder *Decoder) (types.FchownatArgs, error) { 8769 var result types.FchownatArgs 8770 var err error 8771 8772 var numArgs uint8 8773 err = decoder.DecodeUint8(&numArgs) 8774 if err != nil { 8775 return types.FchownatArgs{}, err 8776 } 8777 8778 for arg := 0; arg < int(numArgs); arg++ { 8779 var currArg uint8 8780 err = decoder.DecodeUint8(&currArg) 8781 if err != nil { 8782 return types.FchownatArgs{}, err 8783 } 8784 8785 switch currArg { 8786 case 0: 8787 err = decoder.DecodeInt32(&result.Dirfd) 8788 if err != nil { 8789 return types.FchownatArgs{}, err 8790 } 8791 case 1: 8792 result.Pathname, err = decoder.ReadStringFromBuff() 8793 if err != nil { 8794 return types.FchownatArgs{}, err 8795 } 8796 case 2: 8797 err = decoder.DecodeInt32(&result.Owner) 8798 if err != nil { 8799 return types.FchownatArgs{}, err 8800 } 8801 case 3: 8802 err = decoder.DecodeInt32(&result.Group) 8803 if err != nil { 8804 return types.FchownatArgs{}, err 8805 } 8806 case 4: 8807 err = decoder.DecodeInt32(&result.Flags) 8808 if err != nil { 8809 return types.FchownatArgs{}, err 8810 } 8811 } 8812 } 8813 return result, nil 8814 } 8815 8816 func ParseFutimesatArgs(decoder *Decoder) (types.FutimesatArgs, error) { 8817 var result types.FutimesatArgs 8818 var err error 8819 8820 var numArgs uint8 8821 err = decoder.DecodeUint8(&numArgs) 8822 if err != nil { 8823 return types.FutimesatArgs{}, err 8824 } 8825 8826 for arg := 0; arg < int(numArgs); arg++ { 8827 var currArg uint8 8828 err = decoder.DecodeUint8(&currArg) 8829 if err != nil { 8830 return types.FutimesatArgs{}, err 8831 } 8832 8833 switch currArg { 8834 case 0: 8835 err = decoder.DecodeInt32(&result.Dirfd) 8836 if err != nil { 8837 return types.FutimesatArgs{}, err 8838 } 8839 case 1: 8840 result.Pathname, err = decoder.ReadStringFromBuff() 8841 if err != nil { 8842 return types.FutimesatArgs{}, err 8843 } 8844 case 2: 8845 var dataTimes uint64 8846 err = decoder.DecodeUint64(&dataTimes) 8847 if err != nil { 8848 return types.FutimesatArgs{}, err 8849 } 8850 result.Times = uintptr(dataTimes) 8851 } 8852 } 8853 return result, nil 8854 } 8855 8856 func ParseNewfstatatArgs(decoder *Decoder) (types.NewfstatatArgs, error) { 8857 var result types.NewfstatatArgs 8858 var err error 8859 8860 var numArgs uint8 8861 err = decoder.DecodeUint8(&numArgs) 8862 if err != nil { 8863 return types.NewfstatatArgs{}, err 8864 } 8865 8866 for arg := 0; arg < int(numArgs); arg++ { 8867 var currArg uint8 8868 err = decoder.DecodeUint8(&currArg) 8869 if err != nil { 8870 return types.NewfstatatArgs{}, err 8871 } 8872 8873 switch currArg { 8874 case 0: 8875 err = decoder.DecodeInt32(&result.Dirfd) 8876 if err != nil { 8877 return types.NewfstatatArgs{}, err 8878 } 8879 case 1: 8880 result.Pathname, err = decoder.ReadStringFromBuff() 8881 if err != nil { 8882 return types.NewfstatatArgs{}, err 8883 } 8884 case 2: 8885 var dataStatbuf uint64 8886 err = decoder.DecodeUint64(&dataStatbuf) 8887 if err != nil { 8888 return types.NewfstatatArgs{}, err 8889 } 8890 result.Statbuf = uintptr(dataStatbuf) 8891 case 3: 8892 err = decoder.DecodeInt32(&result.Flags) 8893 if err != nil { 8894 return types.NewfstatatArgs{}, err 8895 } 8896 } 8897 } 8898 return result, nil 8899 } 8900 8901 func ParseUnlinkatArgs(decoder *Decoder) (types.UnlinkatArgs, error) { 8902 var result types.UnlinkatArgs 8903 var err error 8904 8905 var numArgs uint8 8906 err = decoder.DecodeUint8(&numArgs) 8907 if err != nil { 8908 return types.UnlinkatArgs{}, err 8909 } 8910 8911 for arg := 0; arg < int(numArgs); arg++ { 8912 var currArg uint8 8913 err = decoder.DecodeUint8(&currArg) 8914 if err != nil { 8915 return types.UnlinkatArgs{}, err 8916 } 8917 8918 switch currArg { 8919 case 0: 8920 err = decoder.DecodeInt32(&result.Dirfd) 8921 if err != nil { 8922 return types.UnlinkatArgs{}, err 8923 } 8924 case 1: 8925 result.Pathname, err = decoder.ReadStringFromBuff() 8926 if err != nil { 8927 return types.UnlinkatArgs{}, err 8928 } 8929 case 2: 8930 err = decoder.DecodeInt32(&result.Flags) 8931 if err != nil { 8932 return types.UnlinkatArgs{}, err 8933 } 8934 } 8935 } 8936 return result, nil 8937 } 8938 8939 func ParseRenameatArgs(decoder *Decoder) (types.RenameatArgs, error) { 8940 var result types.RenameatArgs 8941 var err error 8942 8943 var numArgs uint8 8944 err = decoder.DecodeUint8(&numArgs) 8945 if err != nil { 8946 return types.RenameatArgs{}, err 8947 } 8948 8949 for arg := 0; arg < int(numArgs); arg++ { 8950 var currArg uint8 8951 err = decoder.DecodeUint8(&currArg) 8952 if err != nil { 8953 return types.RenameatArgs{}, err 8954 } 8955 8956 switch currArg { 8957 case 0: 8958 err = decoder.DecodeInt32(&result.Olddirfd) 8959 if err != nil { 8960 return types.RenameatArgs{}, err 8961 } 8962 case 1: 8963 result.Oldpath, err = decoder.ReadStringFromBuff() 8964 if err != nil { 8965 return types.RenameatArgs{}, err 8966 } 8967 case 2: 8968 err = decoder.DecodeInt32(&result.Newdirfd) 8969 if err != nil { 8970 return types.RenameatArgs{}, err 8971 } 8972 case 3: 8973 result.Newpath, err = decoder.ReadStringFromBuff() 8974 if err != nil { 8975 return types.RenameatArgs{}, err 8976 } 8977 } 8978 } 8979 return result, nil 8980 } 8981 8982 func ParseLinkatArgs(decoder *Decoder) (types.LinkatArgs, error) { 8983 var result types.LinkatArgs 8984 var err error 8985 8986 var numArgs uint8 8987 err = decoder.DecodeUint8(&numArgs) 8988 if err != nil { 8989 return types.LinkatArgs{}, err 8990 } 8991 8992 for arg := 0; arg < int(numArgs); arg++ { 8993 var currArg uint8 8994 err = decoder.DecodeUint8(&currArg) 8995 if err != nil { 8996 return types.LinkatArgs{}, err 8997 } 8998 8999 switch currArg { 9000 case 0: 9001 err = decoder.DecodeInt32(&result.Olddirfd) 9002 if err != nil { 9003 return types.LinkatArgs{}, err 9004 } 9005 case 1: 9006 result.Oldpath, err = decoder.ReadStringFromBuff() 9007 if err != nil { 9008 return types.LinkatArgs{}, err 9009 } 9010 case 2: 9011 err = decoder.DecodeInt32(&result.Newdirfd) 9012 if err != nil { 9013 return types.LinkatArgs{}, err 9014 } 9015 case 3: 9016 result.Newpath, err = decoder.ReadStringFromBuff() 9017 if err != nil { 9018 return types.LinkatArgs{}, err 9019 } 9020 case 4: 9021 err = decoder.DecodeUint32(&result.Flags) 9022 if err != nil { 9023 return types.LinkatArgs{}, err 9024 } 9025 } 9026 } 9027 return result, nil 9028 } 9029 9030 func ParseSymlinkatArgs(decoder *Decoder) (types.SymlinkatArgs, error) { 9031 var result types.SymlinkatArgs 9032 var err error 9033 9034 var numArgs uint8 9035 err = decoder.DecodeUint8(&numArgs) 9036 if err != nil { 9037 return types.SymlinkatArgs{}, err 9038 } 9039 9040 for arg := 0; arg < int(numArgs); arg++ { 9041 var currArg uint8 9042 err = decoder.DecodeUint8(&currArg) 9043 if err != nil { 9044 return types.SymlinkatArgs{}, err 9045 } 9046 9047 switch currArg { 9048 case 0: 9049 result.Target, err = decoder.ReadStringFromBuff() 9050 if err != nil { 9051 return types.SymlinkatArgs{}, err 9052 } 9053 case 1: 9054 err = decoder.DecodeInt32(&result.Newdirfd) 9055 if err != nil { 9056 return types.SymlinkatArgs{}, err 9057 } 9058 case 2: 9059 result.Linkpath, err = decoder.ReadStringFromBuff() 9060 if err != nil { 9061 return types.SymlinkatArgs{}, err 9062 } 9063 } 9064 } 9065 return result, nil 9066 } 9067 9068 func ParseReadlinkatArgs(decoder *Decoder) (types.ReadlinkatArgs, error) { 9069 var result types.ReadlinkatArgs 9070 var err error 9071 9072 var numArgs uint8 9073 err = decoder.DecodeUint8(&numArgs) 9074 if err != nil { 9075 return types.ReadlinkatArgs{}, err 9076 } 9077 9078 for arg := 0; arg < int(numArgs); arg++ { 9079 var currArg uint8 9080 err = decoder.DecodeUint8(&currArg) 9081 if err != nil { 9082 return types.ReadlinkatArgs{}, err 9083 } 9084 9085 switch currArg { 9086 case 0: 9087 err = decoder.DecodeInt32(&result.Dirfd) 9088 if err != nil { 9089 return types.ReadlinkatArgs{}, err 9090 } 9091 case 1: 9092 result.Pathname, err = decoder.ReadStringFromBuff() 9093 if err != nil { 9094 return types.ReadlinkatArgs{}, err 9095 } 9096 case 2: 9097 result.Buf, err = decoder.ReadStringFromBuff() 9098 if err != nil { 9099 return types.ReadlinkatArgs{}, err 9100 } 9101 case 3: 9102 err = decoder.DecodeInt32(&result.Bufsiz) 9103 if err != nil { 9104 return types.ReadlinkatArgs{}, err 9105 } 9106 } 9107 } 9108 return result, nil 9109 } 9110 9111 func ParseFchmodatArgs(decoder *Decoder) (types.FchmodatArgs, error) { 9112 var result types.FchmodatArgs 9113 var err error 9114 9115 var numArgs uint8 9116 err = decoder.DecodeUint8(&numArgs) 9117 if err != nil { 9118 return types.FchmodatArgs{}, err 9119 } 9120 9121 for arg := 0; arg < int(numArgs); arg++ { 9122 var currArg uint8 9123 err = decoder.DecodeUint8(&currArg) 9124 if err != nil { 9125 return types.FchmodatArgs{}, err 9126 } 9127 9128 switch currArg { 9129 case 0: 9130 err = decoder.DecodeInt32(&result.Dirfd) 9131 if err != nil { 9132 return types.FchmodatArgs{}, err 9133 } 9134 case 1: 9135 result.Pathname, err = decoder.ReadStringFromBuff() 9136 if err != nil { 9137 return types.FchmodatArgs{}, err 9138 } 9139 case 2: 9140 err = decoder.DecodeUint32(&result.Mode) 9141 if err != nil { 9142 return types.FchmodatArgs{}, err 9143 } 9144 case 3: 9145 err = decoder.DecodeInt32(&result.Flags) 9146 if err != nil { 9147 return types.FchmodatArgs{}, err 9148 } 9149 } 9150 } 9151 return result, nil 9152 } 9153 9154 func ParseFaccessatArgs(decoder *Decoder) (types.FaccessatArgs, error) { 9155 var result types.FaccessatArgs 9156 var err error 9157 9158 var numArgs uint8 9159 err = decoder.DecodeUint8(&numArgs) 9160 if err != nil { 9161 return types.FaccessatArgs{}, err 9162 } 9163 9164 for arg := 0; arg < int(numArgs); arg++ { 9165 var currArg uint8 9166 err = decoder.DecodeUint8(&currArg) 9167 if err != nil { 9168 return types.FaccessatArgs{}, err 9169 } 9170 9171 switch currArg { 9172 case 0: 9173 err = decoder.DecodeInt32(&result.Dirfd) 9174 if err != nil { 9175 return types.FaccessatArgs{}, err 9176 } 9177 case 1: 9178 result.Pathname, err = decoder.ReadStringFromBuff() 9179 if err != nil { 9180 return types.FaccessatArgs{}, err 9181 } 9182 case 2: 9183 err = decoder.DecodeInt32(&result.Mode) 9184 if err != nil { 9185 return types.FaccessatArgs{}, err 9186 } 9187 case 3: 9188 err = decoder.DecodeInt32(&result.Flags) 9189 if err != nil { 9190 return types.FaccessatArgs{}, err 9191 } 9192 } 9193 } 9194 return result, nil 9195 } 9196 9197 func ParsePselect6Args(decoder *Decoder) (types.Pselect6Args, error) { 9198 var result types.Pselect6Args 9199 var err error 9200 9201 var numArgs uint8 9202 err = decoder.DecodeUint8(&numArgs) 9203 if err != nil { 9204 return types.Pselect6Args{}, err 9205 } 9206 9207 for arg := 0; arg < int(numArgs); arg++ { 9208 var currArg uint8 9209 err = decoder.DecodeUint8(&currArg) 9210 if err != nil { 9211 return types.Pselect6Args{}, err 9212 } 9213 9214 switch currArg { 9215 case 0: 9216 err = decoder.DecodeInt32(&result.Nfds) 9217 if err != nil { 9218 return types.Pselect6Args{}, err 9219 } 9220 case 1: 9221 var dataReadfds uint64 9222 err = decoder.DecodeUint64(&dataReadfds) 9223 if err != nil { 9224 return types.Pselect6Args{}, err 9225 } 9226 result.Readfds = uintptr(dataReadfds) 9227 case 2: 9228 var dataWritefds uint64 9229 err = decoder.DecodeUint64(&dataWritefds) 9230 if err != nil { 9231 return types.Pselect6Args{}, err 9232 } 9233 result.Writefds = uintptr(dataWritefds) 9234 case 3: 9235 var dataExceptfds uint64 9236 err = decoder.DecodeUint64(&dataExceptfds) 9237 if err != nil { 9238 return types.Pselect6Args{}, err 9239 } 9240 result.Exceptfds = uintptr(dataExceptfds) 9241 case 4: 9242 result.Timeout, err = decoder.ReadTimespec() 9243 if err != nil { 9244 return types.Pselect6Args{}, err 9245 } 9246 case 5: 9247 var dataSigmask uint64 9248 err = decoder.DecodeUint64(&dataSigmask) 9249 if err != nil { 9250 return types.Pselect6Args{}, err 9251 } 9252 result.Sigmask = uintptr(dataSigmask) 9253 } 9254 } 9255 return result, nil 9256 } 9257 9258 func ParsePpollArgs(decoder *Decoder) (types.PpollArgs, error) { 9259 var result types.PpollArgs 9260 var err error 9261 9262 var numArgs uint8 9263 err = decoder.DecodeUint8(&numArgs) 9264 if err != nil { 9265 return types.PpollArgs{}, err 9266 } 9267 9268 for arg := 0; arg < int(numArgs); arg++ { 9269 var currArg uint8 9270 err = decoder.DecodeUint8(&currArg) 9271 if err != nil { 9272 return types.PpollArgs{}, err 9273 } 9274 9275 switch currArg { 9276 case 0: 9277 var dataFds uint64 9278 err = decoder.DecodeUint64(&dataFds) 9279 if err != nil { 9280 return types.PpollArgs{}, err 9281 } 9282 result.Fds = uintptr(dataFds) 9283 case 1: 9284 err = decoder.DecodeUint32(&result.Nfds) 9285 if err != nil { 9286 return types.PpollArgs{}, err 9287 } 9288 case 2: 9289 result.TmoP, err = decoder.ReadTimespec() 9290 if err != nil { 9291 return types.PpollArgs{}, err 9292 } 9293 case 3: 9294 var dataSigmask uint64 9295 err = decoder.DecodeUint64(&dataSigmask) 9296 if err != nil { 9297 return types.PpollArgs{}, err 9298 } 9299 result.Sigmask = uintptr(dataSigmask) 9300 case 4: 9301 err = decoder.DecodeUint64(&result.Sigsetsize) 9302 if err != nil { 9303 return types.PpollArgs{}, err 9304 } 9305 } 9306 } 9307 return result, nil 9308 } 9309 9310 func ParseUnshareArgs(decoder *Decoder) (types.UnshareArgs, error) { 9311 var result types.UnshareArgs 9312 var err error 9313 9314 var numArgs uint8 9315 err = decoder.DecodeUint8(&numArgs) 9316 if err != nil { 9317 return types.UnshareArgs{}, err 9318 } 9319 9320 for arg := 0; arg < int(numArgs); arg++ { 9321 var currArg uint8 9322 err = decoder.DecodeUint8(&currArg) 9323 if err != nil { 9324 return types.UnshareArgs{}, err 9325 } 9326 9327 switch currArg { 9328 case 0: 9329 err = decoder.DecodeInt32(&result.Flags) 9330 if err != nil { 9331 return types.UnshareArgs{}, err 9332 } 9333 } 9334 } 9335 return result, nil 9336 } 9337 9338 func ParseSetRobustListArgs(decoder *Decoder) (types.SetRobustListArgs, error) { 9339 var result types.SetRobustListArgs 9340 var err error 9341 9342 var numArgs uint8 9343 err = decoder.DecodeUint8(&numArgs) 9344 if err != nil { 9345 return types.SetRobustListArgs{}, err 9346 } 9347 9348 for arg := 0; arg < int(numArgs); arg++ { 9349 var currArg uint8 9350 err = decoder.DecodeUint8(&currArg) 9351 if err != nil { 9352 return types.SetRobustListArgs{}, err 9353 } 9354 9355 switch currArg { 9356 case 0: 9357 var dataHead uint64 9358 err = decoder.DecodeUint64(&dataHead) 9359 if err != nil { 9360 return types.SetRobustListArgs{}, err 9361 } 9362 result.Head = uintptr(dataHead) 9363 case 1: 9364 err = decoder.DecodeUint64(&result.Len) 9365 if err != nil { 9366 return types.SetRobustListArgs{}, err 9367 } 9368 } 9369 } 9370 return result, nil 9371 } 9372 9373 func ParseGetRobustListArgs(decoder *Decoder) (types.GetRobustListArgs, error) { 9374 var result types.GetRobustListArgs 9375 var err error 9376 9377 var numArgs uint8 9378 err = decoder.DecodeUint8(&numArgs) 9379 if err != nil { 9380 return types.GetRobustListArgs{}, err 9381 } 9382 9383 for arg := 0; arg < int(numArgs); arg++ { 9384 var currArg uint8 9385 err = decoder.DecodeUint8(&currArg) 9386 if err != nil { 9387 return types.GetRobustListArgs{}, err 9388 } 9389 9390 switch currArg { 9391 case 0: 9392 err = decoder.DecodeInt32(&result.Pid) 9393 if err != nil { 9394 return types.GetRobustListArgs{}, err 9395 } 9396 case 1: 9397 var dataHeadPtr uint64 9398 err = decoder.DecodeUint64(&dataHeadPtr) 9399 if err != nil { 9400 return types.GetRobustListArgs{}, err 9401 } 9402 result.HeadPtr = uintptr(dataHeadPtr) 9403 case 2: 9404 var dataLenPtr uint64 9405 err = decoder.DecodeUint64(&dataLenPtr) 9406 if err != nil { 9407 return types.GetRobustListArgs{}, err 9408 } 9409 result.LenPtr = uintptr(dataLenPtr) 9410 } 9411 } 9412 return result, nil 9413 } 9414 9415 func ParseSpliceArgs(decoder *Decoder) (types.SpliceArgs, error) { 9416 var result types.SpliceArgs 9417 var err error 9418 9419 var numArgs uint8 9420 err = decoder.DecodeUint8(&numArgs) 9421 if err != nil { 9422 return types.SpliceArgs{}, err 9423 } 9424 9425 for arg := 0; arg < int(numArgs); arg++ { 9426 var currArg uint8 9427 err = decoder.DecodeUint8(&currArg) 9428 if err != nil { 9429 return types.SpliceArgs{}, err 9430 } 9431 9432 switch currArg { 9433 case 0: 9434 err = decoder.DecodeInt32(&result.FdIn) 9435 if err != nil { 9436 return types.SpliceArgs{}, err 9437 } 9438 case 1: 9439 var dataOffIn uint64 9440 err = decoder.DecodeUint64(&dataOffIn) 9441 if err != nil { 9442 return types.SpliceArgs{}, err 9443 } 9444 result.OffIn = uintptr(dataOffIn) 9445 case 2: 9446 err = decoder.DecodeInt32(&result.FdOut) 9447 if err != nil { 9448 return types.SpliceArgs{}, err 9449 } 9450 case 3: 9451 var dataOffOut uint64 9452 err = decoder.DecodeUint64(&dataOffOut) 9453 if err != nil { 9454 return types.SpliceArgs{}, err 9455 } 9456 result.OffOut = uintptr(dataOffOut) 9457 case 4: 9458 err = decoder.DecodeUint64(&result.Len) 9459 if err != nil { 9460 return types.SpliceArgs{}, err 9461 } 9462 case 5: 9463 err = decoder.DecodeUint32(&result.Flags) 9464 if err != nil { 9465 return types.SpliceArgs{}, err 9466 } 9467 } 9468 } 9469 return result, nil 9470 } 9471 9472 func ParseTeeArgs(decoder *Decoder) (types.TeeArgs, error) { 9473 var result types.TeeArgs 9474 var err error 9475 9476 var numArgs uint8 9477 err = decoder.DecodeUint8(&numArgs) 9478 if err != nil { 9479 return types.TeeArgs{}, err 9480 } 9481 9482 for arg := 0; arg < int(numArgs); arg++ { 9483 var currArg uint8 9484 err = decoder.DecodeUint8(&currArg) 9485 if err != nil { 9486 return types.TeeArgs{}, err 9487 } 9488 9489 switch currArg { 9490 case 0: 9491 err = decoder.DecodeInt32(&result.FdIn) 9492 if err != nil { 9493 return types.TeeArgs{}, err 9494 } 9495 case 1: 9496 err = decoder.DecodeInt32(&result.FdOut) 9497 if err != nil { 9498 return types.TeeArgs{}, err 9499 } 9500 case 2: 9501 err = decoder.DecodeUint64(&result.Len) 9502 if err != nil { 9503 return types.TeeArgs{}, err 9504 } 9505 case 3: 9506 err = decoder.DecodeUint32(&result.Flags) 9507 if err != nil { 9508 return types.TeeArgs{}, err 9509 } 9510 } 9511 } 9512 return result, nil 9513 } 9514 9515 func ParseSyncFileRangeArgs(decoder *Decoder) (types.SyncFileRangeArgs, error) { 9516 var result types.SyncFileRangeArgs 9517 var err error 9518 9519 var numArgs uint8 9520 err = decoder.DecodeUint8(&numArgs) 9521 if err != nil { 9522 return types.SyncFileRangeArgs{}, err 9523 } 9524 9525 for arg := 0; arg < int(numArgs); arg++ { 9526 var currArg uint8 9527 err = decoder.DecodeUint8(&currArg) 9528 if err != nil { 9529 return types.SyncFileRangeArgs{}, err 9530 } 9531 9532 switch currArg { 9533 case 0: 9534 err = decoder.DecodeInt32(&result.Fd) 9535 if err != nil { 9536 return types.SyncFileRangeArgs{}, err 9537 } 9538 case 1: 9539 err = decoder.DecodeUint64(&result.Offset) 9540 if err != nil { 9541 return types.SyncFileRangeArgs{}, err 9542 } 9543 case 2: 9544 err = decoder.DecodeUint64(&result.Nbytes) 9545 if err != nil { 9546 return types.SyncFileRangeArgs{}, err 9547 } 9548 case 3: 9549 err = decoder.DecodeUint32(&result.Flags) 9550 if err != nil { 9551 return types.SyncFileRangeArgs{}, err 9552 } 9553 } 9554 } 9555 return result, nil 9556 } 9557 9558 func ParseVmspliceArgs(decoder *Decoder) (types.VmspliceArgs, error) { 9559 var result types.VmspliceArgs 9560 var err error 9561 9562 var numArgs uint8 9563 err = decoder.DecodeUint8(&numArgs) 9564 if err != nil { 9565 return types.VmspliceArgs{}, err 9566 } 9567 9568 for arg := 0; arg < int(numArgs); arg++ { 9569 var currArg uint8 9570 err = decoder.DecodeUint8(&currArg) 9571 if err != nil { 9572 return types.VmspliceArgs{}, err 9573 } 9574 9575 switch currArg { 9576 case 0: 9577 err = decoder.DecodeInt32(&result.Fd) 9578 if err != nil { 9579 return types.VmspliceArgs{}, err 9580 } 9581 case 1: 9582 var dataIov uint64 9583 err = decoder.DecodeUint64(&dataIov) 9584 if err != nil { 9585 return types.VmspliceArgs{}, err 9586 } 9587 result.Iov = uintptr(dataIov) 9588 case 2: 9589 err = decoder.DecodeUint64(&result.NrSegs) 9590 if err != nil { 9591 return types.VmspliceArgs{}, err 9592 } 9593 case 3: 9594 err = decoder.DecodeUint32(&result.Flags) 9595 if err != nil { 9596 return types.VmspliceArgs{}, err 9597 } 9598 } 9599 } 9600 return result, nil 9601 } 9602 9603 func ParseMovePagesArgs(decoder *Decoder) (types.MovePagesArgs, error) { 9604 var result types.MovePagesArgs 9605 var err error 9606 9607 var numArgs uint8 9608 err = decoder.DecodeUint8(&numArgs) 9609 if err != nil { 9610 return types.MovePagesArgs{}, err 9611 } 9612 9613 for arg := 0; arg < int(numArgs); arg++ { 9614 var currArg uint8 9615 err = decoder.DecodeUint8(&currArg) 9616 if err != nil { 9617 return types.MovePagesArgs{}, err 9618 } 9619 9620 switch currArg { 9621 case 0: 9622 err = decoder.DecodeInt32(&result.Pid) 9623 if err != nil { 9624 return types.MovePagesArgs{}, err 9625 } 9626 case 1: 9627 err = decoder.DecodeUint64(&result.Count) 9628 if err != nil { 9629 return types.MovePagesArgs{}, err 9630 } 9631 case 2: 9632 var dataPages uint64 9633 err = decoder.DecodeUint64(&dataPages) 9634 if err != nil { 9635 return types.MovePagesArgs{}, err 9636 } 9637 result.Pages = uintptr(dataPages) 9638 case 3: 9639 var dataNodes uint64 9640 err = decoder.DecodeUint64(&dataNodes) 9641 if err != nil { 9642 return types.MovePagesArgs{}, err 9643 } 9644 result.Nodes = uintptr(dataNodes) 9645 case 4: 9646 var dataStatus uint64 9647 err = decoder.DecodeUint64(&dataStatus) 9648 if err != nil { 9649 return types.MovePagesArgs{}, err 9650 } 9651 result.Status = uintptr(dataStatus) 9652 case 5: 9653 err = decoder.DecodeInt32(&result.Flags) 9654 if err != nil { 9655 return types.MovePagesArgs{}, err 9656 } 9657 } 9658 } 9659 return result, nil 9660 } 9661 9662 func ParseUtimensatArgs(decoder *Decoder) (types.UtimensatArgs, error) { 9663 var result types.UtimensatArgs 9664 var err error 9665 9666 var numArgs uint8 9667 err = decoder.DecodeUint8(&numArgs) 9668 if err != nil { 9669 return types.UtimensatArgs{}, err 9670 } 9671 9672 for arg := 0; arg < int(numArgs); arg++ { 9673 var currArg uint8 9674 err = decoder.DecodeUint8(&currArg) 9675 if err != nil { 9676 return types.UtimensatArgs{}, err 9677 } 9678 9679 switch currArg { 9680 case 0: 9681 err = decoder.DecodeInt32(&result.Dirfd) 9682 if err != nil { 9683 return types.UtimensatArgs{}, err 9684 } 9685 case 1: 9686 result.Pathname, err = decoder.ReadStringFromBuff() 9687 if err != nil { 9688 return types.UtimensatArgs{}, err 9689 } 9690 case 2: 9691 result.Times, err = decoder.ReadTimespec() 9692 if err != nil { 9693 return types.UtimensatArgs{}, err 9694 } 9695 case 3: 9696 err = decoder.DecodeInt32(&result.Flags) 9697 if err != nil { 9698 return types.UtimensatArgs{}, err 9699 } 9700 } 9701 } 9702 return result, nil 9703 } 9704 9705 func ParseEpollPwaitArgs(decoder *Decoder) (types.EpollPwaitArgs, error) { 9706 var result types.EpollPwaitArgs 9707 var err error 9708 9709 var numArgs uint8 9710 err = decoder.DecodeUint8(&numArgs) 9711 if err != nil { 9712 return types.EpollPwaitArgs{}, err 9713 } 9714 9715 for arg := 0; arg < int(numArgs); arg++ { 9716 var currArg uint8 9717 err = decoder.DecodeUint8(&currArg) 9718 if err != nil { 9719 return types.EpollPwaitArgs{}, err 9720 } 9721 9722 switch currArg { 9723 case 0: 9724 err = decoder.DecodeInt32(&result.Epfd) 9725 if err != nil { 9726 return types.EpollPwaitArgs{}, err 9727 } 9728 case 1: 9729 var dataEvents uint64 9730 err = decoder.DecodeUint64(&dataEvents) 9731 if err != nil { 9732 return types.EpollPwaitArgs{}, err 9733 } 9734 result.Events = uintptr(dataEvents) 9735 case 2: 9736 err = decoder.DecodeInt32(&result.Maxevents) 9737 if err != nil { 9738 return types.EpollPwaitArgs{}, err 9739 } 9740 case 3: 9741 err = decoder.DecodeInt32(&result.Timeout) 9742 if err != nil { 9743 return types.EpollPwaitArgs{}, err 9744 } 9745 case 4: 9746 var dataSigmask uint64 9747 err = decoder.DecodeUint64(&dataSigmask) 9748 if err != nil { 9749 return types.EpollPwaitArgs{}, err 9750 } 9751 result.Sigmask = uintptr(dataSigmask) 9752 case 5: 9753 err = decoder.DecodeUint64(&result.Sigsetsize) 9754 if err != nil { 9755 return types.EpollPwaitArgs{}, err 9756 } 9757 } 9758 } 9759 return result, nil 9760 } 9761 9762 func ParseSignalfdArgs(decoder *Decoder) (types.SignalfdArgs, error) { 9763 var result types.SignalfdArgs 9764 var err error 9765 9766 var numArgs uint8 9767 err = decoder.DecodeUint8(&numArgs) 9768 if err != nil { 9769 return types.SignalfdArgs{}, err 9770 } 9771 9772 for arg := 0; arg < int(numArgs); arg++ { 9773 var currArg uint8 9774 err = decoder.DecodeUint8(&currArg) 9775 if err != nil { 9776 return types.SignalfdArgs{}, err 9777 } 9778 9779 switch currArg { 9780 case 0: 9781 err = decoder.DecodeInt32(&result.Fd) 9782 if err != nil { 9783 return types.SignalfdArgs{}, err 9784 } 9785 case 1: 9786 var dataMask uint64 9787 err = decoder.DecodeUint64(&dataMask) 9788 if err != nil { 9789 return types.SignalfdArgs{}, err 9790 } 9791 result.Mask = uintptr(dataMask) 9792 case 2: 9793 err = decoder.DecodeInt32(&result.Flags) 9794 if err != nil { 9795 return types.SignalfdArgs{}, err 9796 } 9797 } 9798 } 9799 return result, nil 9800 } 9801 9802 func ParseTimerfdCreateArgs(decoder *Decoder) (types.TimerfdCreateArgs, error) { 9803 var result types.TimerfdCreateArgs 9804 var err error 9805 9806 var numArgs uint8 9807 err = decoder.DecodeUint8(&numArgs) 9808 if err != nil { 9809 return types.TimerfdCreateArgs{}, err 9810 } 9811 9812 for arg := 0; arg < int(numArgs); arg++ { 9813 var currArg uint8 9814 err = decoder.DecodeUint8(&currArg) 9815 if err != nil { 9816 return types.TimerfdCreateArgs{}, err 9817 } 9818 9819 switch currArg { 9820 case 0: 9821 err = decoder.DecodeInt32(&result.Clockid) 9822 if err != nil { 9823 return types.TimerfdCreateArgs{}, err 9824 } 9825 case 1: 9826 err = decoder.DecodeInt32(&result.Flags) 9827 if err != nil { 9828 return types.TimerfdCreateArgs{}, err 9829 } 9830 } 9831 } 9832 return result, nil 9833 } 9834 9835 func ParseEventfdArgs(decoder *Decoder) (types.EventfdArgs, error) { 9836 var result types.EventfdArgs 9837 var err error 9838 9839 var numArgs uint8 9840 err = decoder.DecodeUint8(&numArgs) 9841 if err != nil { 9842 return types.EventfdArgs{}, err 9843 } 9844 9845 for arg := 0; arg < int(numArgs); arg++ { 9846 var currArg uint8 9847 err = decoder.DecodeUint8(&currArg) 9848 if err != nil { 9849 return types.EventfdArgs{}, err 9850 } 9851 9852 switch currArg { 9853 case 0: 9854 err = decoder.DecodeUint32(&result.Initval) 9855 if err != nil { 9856 return types.EventfdArgs{}, err 9857 } 9858 case 1: 9859 err = decoder.DecodeInt32(&result.Flags) 9860 if err != nil { 9861 return types.EventfdArgs{}, err 9862 } 9863 } 9864 } 9865 return result, nil 9866 } 9867 9868 func ParseFallocateArgs(decoder *Decoder) (types.FallocateArgs, error) { 9869 var result types.FallocateArgs 9870 var err error 9871 9872 var numArgs uint8 9873 err = decoder.DecodeUint8(&numArgs) 9874 if err != nil { 9875 return types.FallocateArgs{}, err 9876 } 9877 9878 for arg := 0; arg < int(numArgs); arg++ { 9879 var currArg uint8 9880 err = decoder.DecodeUint8(&currArg) 9881 if err != nil { 9882 return types.FallocateArgs{}, err 9883 } 9884 9885 switch currArg { 9886 case 0: 9887 err = decoder.DecodeInt32(&result.Fd) 9888 if err != nil { 9889 return types.FallocateArgs{}, err 9890 } 9891 case 1: 9892 err = decoder.DecodeInt32(&result.Mode) 9893 if err != nil { 9894 return types.FallocateArgs{}, err 9895 } 9896 case 2: 9897 err = decoder.DecodeUint64(&result.Offset) 9898 if err != nil { 9899 return types.FallocateArgs{}, err 9900 } 9901 case 3: 9902 err = decoder.DecodeUint64(&result.Len) 9903 if err != nil { 9904 return types.FallocateArgs{}, err 9905 } 9906 } 9907 } 9908 return result, nil 9909 } 9910 9911 func ParseTimerfdSettimeArgs(decoder *Decoder) (types.TimerfdSettimeArgs, error) { 9912 var result types.TimerfdSettimeArgs 9913 var err error 9914 9915 var numArgs uint8 9916 err = decoder.DecodeUint8(&numArgs) 9917 if err != nil { 9918 return types.TimerfdSettimeArgs{}, err 9919 } 9920 9921 for arg := 0; arg < int(numArgs); arg++ { 9922 var currArg uint8 9923 err = decoder.DecodeUint8(&currArg) 9924 if err != nil { 9925 return types.TimerfdSettimeArgs{}, err 9926 } 9927 9928 switch currArg { 9929 case 0: 9930 err = decoder.DecodeInt32(&result.Fd) 9931 if err != nil { 9932 return types.TimerfdSettimeArgs{}, err 9933 } 9934 case 1: 9935 err = decoder.DecodeInt32(&result.Flags) 9936 if err != nil { 9937 return types.TimerfdSettimeArgs{}, err 9938 } 9939 case 2: 9940 var dataNewValue uint64 9941 err = decoder.DecodeUint64(&dataNewValue) 9942 if err != nil { 9943 return types.TimerfdSettimeArgs{}, err 9944 } 9945 result.NewValue = uintptr(dataNewValue) 9946 case 3: 9947 var dataOldValue uint64 9948 err = decoder.DecodeUint64(&dataOldValue) 9949 if err != nil { 9950 return types.TimerfdSettimeArgs{}, err 9951 } 9952 result.OldValue = uintptr(dataOldValue) 9953 } 9954 } 9955 return result, nil 9956 } 9957 9958 func ParseTimerfdGettimeArgs(decoder *Decoder) (types.TimerfdGettimeArgs, error) { 9959 var result types.TimerfdGettimeArgs 9960 var err error 9961 9962 var numArgs uint8 9963 err = decoder.DecodeUint8(&numArgs) 9964 if err != nil { 9965 return types.TimerfdGettimeArgs{}, err 9966 } 9967 9968 for arg := 0; arg < int(numArgs); arg++ { 9969 var currArg uint8 9970 err = decoder.DecodeUint8(&currArg) 9971 if err != nil { 9972 return types.TimerfdGettimeArgs{}, err 9973 } 9974 9975 switch currArg { 9976 case 0: 9977 err = decoder.DecodeInt32(&result.Fd) 9978 if err != nil { 9979 return types.TimerfdGettimeArgs{}, err 9980 } 9981 case 1: 9982 var dataCurrValue uint64 9983 err = decoder.DecodeUint64(&dataCurrValue) 9984 if err != nil { 9985 return types.TimerfdGettimeArgs{}, err 9986 } 9987 result.CurrValue = uintptr(dataCurrValue) 9988 } 9989 } 9990 return result, nil 9991 } 9992 9993 func ParseAccept4Args(decoder *Decoder) (types.Accept4Args, error) { 9994 var result types.Accept4Args 9995 var err error 9996 9997 var numArgs uint8 9998 err = decoder.DecodeUint8(&numArgs) 9999 if err != nil { 10000 return types.Accept4Args{}, err 10001 } 10002 10003 for arg := 0; arg < int(numArgs); arg++ { 10004 var currArg uint8 10005 err = decoder.DecodeUint8(&currArg) 10006 if err != nil { 10007 return types.Accept4Args{}, err 10008 } 10009 10010 switch currArg { 10011 case 0: 10012 err = decoder.DecodeInt32(&result.Sockfd) 10013 if err != nil { 10014 return types.Accept4Args{}, err 10015 } 10016 case 1: 10017 result.Addr, err = decoder.ReadSockaddrFromBuff() 10018 if err != nil { 10019 return types.Accept4Args{}, err 10020 } 10021 case 2: 10022 var dataAddrlen uint64 10023 err = decoder.DecodeUint64(&dataAddrlen) 10024 if err != nil { 10025 return types.Accept4Args{}, err 10026 } 10027 result.Addrlen = uintptr(dataAddrlen) 10028 case 3: 10029 err = decoder.DecodeInt32(&result.Flags) 10030 if err != nil { 10031 return types.Accept4Args{}, err 10032 } 10033 } 10034 } 10035 return result, nil 10036 } 10037 10038 func ParseSignalfd4Args(decoder *Decoder) (types.Signalfd4Args, error) { 10039 var result types.Signalfd4Args 10040 var err error 10041 10042 var numArgs uint8 10043 err = decoder.DecodeUint8(&numArgs) 10044 if err != nil { 10045 return types.Signalfd4Args{}, err 10046 } 10047 10048 for arg := 0; arg < int(numArgs); arg++ { 10049 var currArg uint8 10050 err = decoder.DecodeUint8(&currArg) 10051 if err != nil { 10052 return types.Signalfd4Args{}, err 10053 } 10054 10055 switch currArg { 10056 case 0: 10057 err = decoder.DecodeInt32(&result.Fd) 10058 if err != nil { 10059 return types.Signalfd4Args{}, err 10060 } 10061 case 1: 10062 var dataMask uint64 10063 err = decoder.DecodeUint64(&dataMask) 10064 if err != nil { 10065 return types.Signalfd4Args{}, err 10066 } 10067 result.Mask = uintptr(dataMask) 10068 case 2: 10069 err = decoder.DecodeUint64(&result.Sizemask) 10070 if err != nil { 10071 return types.Signalfd4Args{}, err 10072 } 10073 case 3: 10074 err = decoder.DecodeInt32(&result.Flags) 10075 if err != nil { 10076 return types.Signalfd4Args{}, err 10077 } 10078 } 10079 } 10080 return result, nil 10081 } 10082 10083 func ParseEventfd2Args(decoder *Decoder) (types.Eventfd2Args, error) { 10084 var result types.Eventfd2Args 10085 var err error 10086 10087 var numArgs uint8 10088 err = decoder.DecodeUint8(&numArgs) 10089 if err != nil { 10090 return types.Eventfd2Args{}, err 10091 } 10092 10093 for arg := 0; arg < int(numArgs); arg++ { 10094 var currArg uint8 10095 err = decoder.DecodeUint8(&currArg) 10096 if err != nil { 10097 return types.Eventfd2Args{}, err 10098 } 10099 10100 switch currArg { 10101 case 0: 10102 err = decoder.DecodeUint32(&result.Initval) 10103 if err != nil { 10104 return types.Eventfd2Args{}, err 10105 } 10106 case 1: 10107 err = decoder.DecodeInt32(&result.Flags) 10108 if err != nil { 10109 return types.Eventfd2Args{}, err 10110 } 10111 } 10112 } 10113 return result, nil 10114 } 10115 10116 func ParseEpollCreate1Args(decoder *Decoder) (types.EpollCreate1Args, error) { 10117 var result types.EpollCreate1Args 10118 var err error 10119 10120 var numArgs uint8 10121 err = decoder.DecodeUint8(&numArgs) 10122 if err != nil { 10123 return types.EpollCreate1Args{}, err 10124 } 10125 10126 for arg := 0; arg < int(numArgs); arg++ { 10127 var currArg uint8 10128 err = decoder.DecodeUint8(&currArg) 10129 if err != nil { 10130 return types.EpollCreate1Args{}, err 10131 } 10132 10133 switch currArg { 10134 case 0: 10135 err = decoder.DecodeInt32(&result.Flags) 10136 if err != nil { 10137 return types.EpollCreate1Args{}, err 10138 } 10139 } 10140 } 10141 return result, nil 10142 } 10143 10144 func ParseDup3Args(decoder *Decoder) (types.Dup3Args, error) { 10145 var result types.Dup3Args 10146 var err error 10147 10148 var numArgs uint8 10149 err = decoder.DecodeUint8(&numArgs) 10150 if err != nil { 10151 return types.Dup3Args{}, err 10152 } 10153 10154 for arg := 0; arg < int(numArgs); arg++ { 10155 var currArg uint8 10156 err = decoder.DecodeUint8(&currArg) 10157 if err != nil { 10158 return types.Dup3Args{}, err 10159 } 10160 10161 switch currArg { 10162 case 0: 10163 err = decoder.DecodeInt32(&result.Oldfd) 10164 if err != nil { 10165 return types.Dup3Args{}, err 10166 } 10167 case 1: 10168 err = decoder.DecodeInt32(&result.Newfd) 10169 if err != nil { 10170 return types.Dup3Args{}, err 10171 } 10172 case 2: 10173 err = decoder.DecodeInt32(&result.Flags) 10174 if err != nil { 10175 return types.Dup3Args{}, err 10176 } 10177 } 10178 } 10179 return result, nil 10180 } 10181 10182 func ParsePipe2Args(decoder *Decoder) (types.Pipe2Args, error) { 10183 var result types.Pipe2Args 10184 var err error 10185 10186 var numArgs uint8 10187 err = decoder.DecodeUint8(&numArgs) 10188 if err != nil { 10189 return types.Pipe2Args{}, err 10190 } 10191 10192 for arg := 0; arg < int(numArgs); arg++ { 10193 var currArg uint8 10194 err = decoder.DecodeUint8(&currArg) 10195 if err != nil { 10196 return types.Pipe2Args{}, err 10197 } 10198 10199 switch currArg { 10200 case 0: 10201 err = decoder.DecodeIntArray(result.Pipefd[:], 2) 10202 if err != nil { 10203 return types.Pipe2Args{}, err 10204 } 10205 case 1: 10206 err = decoder.DecodeInt32(&result.Flags) 10207 if err != nil { 10208 return types.Pipe2Args{}, err 10209 } 10210 } 10211 } 10212 return result, nil 10213 } 10214 10215 func ParseInotifyInit1Args(decoder *Decoder) (types.InotifyInit1Args, error) { 10216 var result types.InotifyInit1Args 10217 var err error 10218 10219 var numArgs uint8 10220 err = decoder.DecodeUint8(&numArgs) 10221 if err != nil { 10222 return types.InotifyInit1Args{}, err 10223 } 10224 10225 for arg := 0; arg < int(numArgs); arg++ { 10226 var currArg uint8 10227 err = decoder.DecodeUint8(&currArg) 10228 if err != nil { 10229 return types.InotifyInit1Args{}, err 10230 } 10231 10232 switch currArg { 10233 case 0: 10234 err = decoder.DecodeInt32(&result.Flags) 10235 if err != nil { 10236 return types.InotifyInit1Args{}, err 10237 } 10238 } 10239 } 10240 return result, nil 10241 } 10242 10243 func ParsePreadvArgs(decoder *Decoder) (types.PreadvArgs, error) { 10244 var result types.PreadvArgs 10245 var err error 10246 10247 var numArgs uint8 10248 err = decoder.DecodeUint8(&numArgs) 10249 if err != nil { 10250 return types.PreadvArgs{}, err 10251 } 10252 10253 for arg := 0; arg < int(numArgs); arg++ { 10254 var currArg uint8 10255 err = decoder.DecodeUint8(&currArg) 10256 if err != nil { 10257 return types.PreadvArgs{}, err 10258 } 10259 10260 switch currArg { 10261 case 0: 10262 err = decoder.DecodeInt32(&result.Fd) 10263 if err != nil { 10264 return types.PreadvArgs{}, err 10265 } 10266 case 1: 10267 var dataIov uint64 10268 err = decoder.DecodeUint64(&dataIov) 10269 if err != nil { 10270 return types.PreadvArgs{}, err 10271 } 10272 result.Iov = uintptr(dataIov) 10273 case 2: 10274 err = decoder.DecodeUint64(&result.Iovcnt) 10275 if err != nil { 10276 return types.PreadvArgs{}, err 10277 } 10278 case 3: 10279 err = decoder.DecodeUint64(&result.PosL) 10280 if err != nil { 10281 return types.PreadvArgs{}, err 10282 } 10283 case 4: 10284 err = decoder.DecodeUint64(&result.PosH) 10285 if err != nil { 10286 return types.PreadvArgs{}, err 10287 } 10288 } 10289 } 10290 return result, nil 10291 } 10292 10293 func ParsePwritevArgs(decoder *Decoder) (types.PwritevArgs, error) { 10294 var result types.PwritevArgs 10295 var err error 10296 10297 var numArgs uint8 10298 err = decoder.DecodeUint8(&numArgs) 10299 if err != nil { 10300 return types.PwritevArgs{}, err 10301 } 10302 10303 for arg := 0; arg < int(numArgs); arg++ { 10304 var currArg uint8 10305 err = decoder.DecodeUint8(&currArg) 10306 if err != nil { 10307 return types.PwritevArgs{}, err 10308 } 10309 10310 switch currArg { 10311 case 0: 10312 err = decoder.DecodeInt32(&result.Fd) 10313 if err != nil { 10314 return types.PwritevArgs{}, err 10315 } 10316 case 1: 10317 var dataIov uint64 10318 err = decoder.DecodeUint64(&dataIov) 10319 if err != nil { 10320 return types.PwritevArgs{}, err 10321 } 10322 result.Iov = uintptr(dataIov) 10323 case 2: 10324 err = decoder.DecodeUint64(&result.Iovcnt) 10325 if err != nil { 10326 return types.PwritevArgs{}, err 10327 } 10328 case 3: 10329 err = decoder.DecodeUint64(&result.PosL) 10330 if err != nil { 10331 return types.PwritevArgs{}, err 10332 } 10333 case 4: 10334 err = decoder.DecodeUint64(&result.PosH) 10335 if err != nil { 10336 return types.PwritevArgs{}, err 10337 } 10338 } 10339 } 10340 return result, nil 10341 } 10342 10343 func ParseRtTgsigqueueinfoArgs(decoder *Decoder) (types.RtTgsigqueueinfoArgs, error) { 10344 var result types.RtTgsigqueueinfoArgs 10345 var err error 10346 10347 var numArgs uint8 10348 err = decoder.DecodeUint8(&numArgs) 10349 if err != nil { 10350 return types.RtTgsigqueueinfoArgs{}, err 10351 } 10352 10353 for arg := 0; arg < int(numArgs); arg++ { 10354 var currArg uint8 10355 err = decoder.DecodeUint8(&currArg) 10356 if err != nil { 10357 return types.RtTgsigqueueinfoArgs{}, err 10358 } 10359 10360 switch currArg { 10361 case 0: 10362 err = decoder.DecodeInt32(&result.Tgid) 10363 if err != nil { 10364 return types.RtTgsigqueueinfoArgs{}, err 10365 } 10366 case 1: 10367 err = decoder.DecodeInt32(&result.Tid) 10368 if err != nil { 10369 return types.RtTgsigqueueinfoArgs{}, err 10370 } 10371 case 2: 10372 err = decoder.DecodeInt32(&result.Sig) 10373 if err != nil { 10374 return types.RtTgsigqueueinfoArgs{}, err 10375 } 10376 case 3: 10377 var dataInfo uint64 10378 err = decoder.DecodeUint64(&dataInfo) 10379 if err != nil { 10380 return types.RtTgsigqueueinfoArgs{}, err 10381 } 10382 result.Info = uintptr(dataInfo) 10383 } 10384 } 10385 return result, nil 10386 } 10387 10388 func ParsePerfEventOpenArgs(decoder *Decoder) (types.PerfEventOpenArgs, error) { 10389 var result types.PerfEventOpenArgs 10390 var err error 10391 10392 var numArgs uint8 10393 err = decoder.DecodeUint8(&numArgs) 10394 if err != nil { 10395 return types.PerfEventOpenArgs{}, err 10396 } 10397 10398 for arg := 0; arg < int(numArgs); arg++ { 10399 var currArg uint8 10400 err = decoder.DecodeUint8(&currArg) 10401 if err != nil { 10402 return types.PerfEventOpenArgs{}, err 10403 } 10404 10405 switch currArg { 10406 case 0: 10407 var dataAttr uint64 10408 err = decoder.DecodeUint64(&dataAttr) 10409 if err != nil { 10410 return types.PerfEventOpenArgs{}, err 10411 } 10412 result.Attr = uintptr(dataAttr) 10413 case 1: 10414 err = decoder.DecodeInt32(&result.Pid) 10415 if err != nil { 10416 return types.PerfEventOpenArgs{}, err 10417 } 10418 case 2: 10419 err = decoder.DecodeInt32(&result.Cpu) 10420 if err != nil { 10421 return types.PerfEventOpenArgs{}, err 10422 } 10423 case 3: 10424 err = decoder.DecodeInt32(&result.GroupFd) 10425 if err != nil { 10426 return types.PerfEventOpenArgs{}, err 10427 } 10428 case 4: 10429 err = decoder.DecodeUint64(&result.Flags) 10430 if err != nil { 10431 return types.PerfEventOpenArgs{}, err 10432 } 10433 } 10434 } 10435 return result, nil 10436 } 10437 10438 func ParseRecvmmsgArgs(decoder *Decoder) (types.RecvmmsgArgs, error) { 10439 var result types.RecvmmsgArgs 10440 var err error 10441 10442 var numArgs uint8 10443 err = decoder.DecodeUint8(&numArgs) 10444 if err != nil { 10445 return types.RecvmmsgArgs{}, err 10446 } 10447 10448 for arg := 0; arg < int(numArgs); arg++ { 10449 var currArg uint8 10450 err = decoder.DecodeUint8(&currArg) 10451 if err != nil { 10452 return types.RecvmmsgArgs{}, err 10453 } 10454 10455 switch currArg { 10456 case 0: 10457 err = decoder.DecodeInt32(&result.Sockfd) 10458 if err != nil { 10459 return types.RecvmmsgArgs{}, err 10460 } 10461 case 1: 10462 var dataMsgvec uint64 10463 err = decoder.DecodeUint64(&dataMsgvec) 10464 if err != nil { 10465 return types.RecvmmsgArgs{}, err 10466 } 10467 result.Msgvec = uintptr(dataMsgvec) 10468 case 2: 10469 err = decoder.DecodeUint32(&result.Vlen) 10470 if err != nil { 10471 return types.RecvmmsgArgs{}, err 10472 } 10473 case 3: 10474 err = decoder.DecodeInt32(&result.Flags) 10475 if err != nil { 10476 return types.RecvmmsgArgs{}, err 10477 } 10478 case 4: 10479 result.Timeout, err = decoder.ReadTimespec() 10480 if err != nil { 10481 return types.RecvmmsgArgs{}, err 10482 } 10483 } 10484 } 10485 return result, nil 10486 } 10487 10488 func ParseFanotifyInitArgs(decoder *Decoder) (types.FanotifyInitArgs, error) { 10489 var result types.FanotifyInitArgs 10490 var err error 10491 10492 var numArgs uint8 10493 err = decoder.DecodeUint8(&numArgs) 10494 if err != nil { 10495 return types.FanotifyInitArgs{}, err 10496 } 10497 10498 for arg := 0; arg < int(numArgs); arg++ { 10499 var currArg uint8 10500 err = decoder.DecodeUint8(&currArg) 10501 if err != nil { 10502 return types.FanotifyInitArgs{}, err 10503 } 10504 10505 switch currArg { 10506 case 0: 10507 err = decoder.DecodeUint32(&result.Flags) 10508 if err != nil { 10509 return types.FanotifyInitArgs{}, err 10510 } 10511 case 1: 10512 err = decoder.DecodeUint32(&result.EventFFlags) 10513 if err != nil { 10514 return types.FanotifyInitArgs{}, err 10515 } 10516 } 10517 } 10518 return result, nil 10519 } 10520 10521 func ParseFanotifyMarkArgs(decoder *Decoder) (types.FanotifyMarkArgs, error) { 10522 var result types.FanotifyMarkArgs 10523 var err error 10524 10525 var numArgs uint8 10526 err = decoder.DecodeUint8(&numArgs) 10527 if err != nil { 10528 return types.FanotifyMarkArgs{}, err 10529 } 10530 10531 for arg := 0; arg < int(numArgs); arg++ { 10532 var currArg uint8 10533 err = decoder.DecodeUint8(&currArg) 10534 if err != nil { 10535 return types.FanotifyMarkArgs{}, err 10536 } 10537 10538 switch currArg { 10539 case 0: 10540 err = decoder.DecodeInt32(&result.FanotifyFd) 10541 if err != nil { 10542 return types.FanotifyMarkArgs{}, err 10543 } 10544 case 1: 10545 err = decoder.DecodeUint32(&result.Flags) 10546 if err != nil { 10547 return types.FanotifyMarkArgs{}, err 10548 } 10549 case 2: 10550 err = decoder.DecodeUint64(&result.Mask) 10551 if err != nil { 10552 return types.FanotifyMarkArgs{}, err 10553 } 10554 case 3: 10555 err = decoder.DecodeInt32(&result.Dirfd) 10556 if err != nil { 10557 return types.FanotifyMarkArgs{}, err 10558 } 10559 case 4: 10560 result.Pathname, err = decoder.ReadStringFromBuff() 10561 if err != nil { 10562 return types.FanotifyMarkArgs{}, err 10563 } 10564 } 10565 } 10566 return result, nil 10567 } 10568 10569 func ParsePrlimit64Args(decoder *Decoder) (types.Prlimit64Args, error) { 10570 var result types.Prlimit64Args 10571 var err error 10572 10573 var numArgs uint8 10574 err = decoder.DecodeUint8(&numArgs) 10575 if err != nil { 10576 return types.Prlimit64Args{}, err 10577 } 10578 10579 for arg := 0; arg < int(numArgs); arg++ { 10580 var currArg uint8 10581 err = decoder.DecodeUint8(&currArg) 10582 if err != nil { 10583 return types.Prlimit64Args{}, err 10584 } 10585 10586 switch currArg { 10587 case 0: 10588 err = decoder.DecodeInt32(&result.Pid) 10589 if err != nil { 10590 return types.Prlimit64Args{}, err 10591 } 10592 case 1: 10593 err = decoder.DecodeInt32(&result.Resource) 10594 if err != nil { 10595 return types.Prlimit64Args{}, err 10596 } 10597 case 2: 10598 var dataNewLimit uint64 10599 err = decoder.DecodeUint64(&dataNewLimit) 10600 if err != nil { 10601 return types.Prlimit64Args{}, err 10602 } 10603 result.NewLimit = uintptr(dataNewLimit) 10604 case 3: 10605 var dataOldLimit uint64 10606 err = decoder.DecodeUint64(&dataOldLimit) 10607 if err != nil { 10608 return types.Prlimit64Args{}, err 10609 } 10610 result.OldLimit = uintptr(dataOldLimit) 10611 } 10612 } 10613 return result, nil 10614 } 10615 10616 func ParseNameToHandleAtArgs(decoder *Decoder) (types.NameToHandleAtArgs, error) { 10617 var result types.NameToHandleAtArgs 10618 var err error 10619 10620 var numArgs uint8 10621 err = decoder.DecodeUint8(&numArgs) 10622 if err != nil { 10623 return types.NameToHandleAtArgs{}, err 10624 } 10625 10626 for arg := 0; arg < int(numArgs); arg++ { 10627 var currArg uint8 10628 err = decoder.DecodeUint8(&currArg) 10629 if err != nil { 10630 return types.NameToHandleAtArgs{}, err 10631 } 10632 10633 switch currArg { 10634 case 0: 10635 err = decoder.DecodeInt32(&result.Dirfd) 10636 if err != nil { 10637 return types.NameToHandleAtArgs{}, err 10638 } 10639 case 1: 10640 result.Pathname, err = decoder.ReadStringFromBuff() 10641 if err != nil { 10642 return types.NameToHandleAtArgs{}, err 10643 } 10644 case 2: 10645 var dataHandle uint64 10646 err = decoder.DecodeUint64(&dataHandle) 10647 if err != nil { 10648 return types.NameToHandleAtArgs{}, err 10649 } 10650 result.Handle = uintptr(dataHandle) 10651 case 3: 10652 var dataMountId uint64 10653 err = decoder.DecodeUint64(&dataMountId) 10654 if err != nil { 10655 return types.NameToHandleAtArgs{}, err 10656 } 10657 result.MountId = uintptr(dataMountId) 10658 case 4: 10659 err = decoder.DecodeInt32(&result.Flags) 10660 if err != nil { 10661 return types.NameToHandleAtArgs{}, err 10662 } 10663 } 10664 } 10665 return result, nil 10666 } 10667 10668 func ParseOpenByHandleAtArgs(decoder *Decoder) (types.OpenByHandleAtArgs, error) { 10669 var result types.OpenByHandleAtArgs 10670 var err error 10671 10672 var numArgs uint8 10673 err = decoder.DecodeUint8(&numArgs) 10674 if err != nil { 10675 return types.OpenByHandleAtArgs{}, err 10676 } 10677 10678 for arg := 0; arg < int(numArgs); arg++ { 10679 var currArg uint8 10680 err = decoder.DecodeUint8(&currArg) 10681 if err != nil { 10682 return types.OpenByHandleAtArgs{}, err 10683 } 10684 10685 switch currArg { 10686 case 0: 10687 err = decoder.DecodeInt32(&result.MountFd) 10688 if err != nil { 10689 return types.OpenByHandleAtArgs{}, err 10690 } 10691 case 1: 10692 var dataHandle uint64 10693 err = decoder.DecodeUint64(&dataHandle) 10694 if err != nil { 10695 return types.OpenByHandleAtArgs{}, err 10696 } 10697 result.Handle = uintptr(dataHandle) 10698 case 2: 10699 err = decoder.DecodeInt32(&result.Flags) 10700 if err != nil { 10701 return types.OpenByHandleAtArgs{}, err 10702 } 10703 } 10704 } 10705 return result, nil 10706 } 10707 10708 func ParseClockAdjtimeArgs(decoder *Decoder) (types.ClockAdjtimeArgs, error) { 10709 var result types.ClockAdjtimeArgs 10710 var err error 10711 10712 var numArgs uint8 10713 err = decoder.DecodeUint8(&numArgs) 10714 if err != nil { 10715 return types.ClockAdjtimeArgs{}, err 10716 } 10717 10718 for arg := 0; arg < int(numArgs); arg++ { 10719 var currArg uint8 10720 err = decoder.DecodeUint8(&currArg) 10721 if err != nil { 10722 return types.ClockAdjtimeArgs{}, err 10723 } 10724 10725 switch currArg { 10726 case 0: 10727 err = decoder.DecodeInt32(&result.ClkId) 10728 if err != nil { 10729 return types.ClockAdjtimeArgs{}, err 10730 } 10731 case 1: 10732 var dataBuf uint64 10733 err = decoder.DecodeUint64(&dataBuf) 10734 if err != nil { 10735 return types.ClockAdjtimeArgs{}, err 10736 } 10737 result.Buf = uintptr(dataBuf) 10738 } 10739 } 10740 return result, nil 10741 } 10742 10743 func ParseSyncfsArgs(decoder *Decoder) (types.SyncfsArgs, error) { 10744 var result types.SyncfsArgs 10745 var err error 10746 10747 var numArgs uint8 10748 err = decoder.DecodeUint8(&numArgs) 10749 if err != nil { 10750 return types.SyncfsArgs{}, err 10751 } 10752 10753 for arg := 0; arg < int(numArgs); arg++ { 10754 var currArg uint8 10755 err = decoder.DecodeUint8(&currArg) 10756 if err != nil { 10757 return types.SyncfsArgs{}, err 10758 } 10759 10760 switch currArg { 10761 case 0: 10762 err = decoder.DecodeInt32(&result.Fd) 10763 if err != nil { 10764 return types.SyncfsArgs{}, err 10765 } 10766 } 10767 } 10768 return result, nil 10769 } 10770 10771 func ParseSendmmsgArgs(decoder *Decoder) (types.SendmmsgArgs, error) { 10772 var result types.SendmmsgArgs 10773 var err error 10774 10775 var numArgs uint8 10776 err = decoder.DecodeUint8(&numArgs) 10777 if err != nil { 10778 return types.SendmmsgArgs{}, err 10779 } 10780 10781 for arg := 0; arg < int(numArgs); arg++ { 10782 var currArg uint8 10783 err = decoder.DecodeUint8(&currArg) 10784 if err != nil { 10785 return types.SendmmsgArgs{}, err 10786 } 10787 10788 switch currArg { 10789 case 0: 10790 err = decoder.DecodeInt32(&result.Sockfd) 10791 if err != nil { 10792 return types.SendmmsgArgs{}, err 10793 } 10794 case 1: 10795 var dataMsgvec uint64 10796 err = decoder.DecodeUint64(&dataMsgvec) 10797 if err != nil { 10798 return types.SendmmsgArgs{}, err 10799 } 10800 result.Msgvec = uintptr(dataMsgvec) 10801 case 2: 10802 err = decoder.DecodeUint32(&result.Vlen) 10803 if err != nil { 10804 return types.SendmmsgArgs{}, err 10805 } 10806 case 3: 10807 err = decoder.DecodeInt32(&result.Flags) 10808 if err != nil { 10809 return types.SendmmsgArgs{}, err 10810 } 10811 } 10812 } 10813 return result, nil 10814 } 10815 10816 func ParseSetnsArgs(decoder *Decoder) (types.SetnsArgs, error) { 10817 var result types.SetnsArgs 10818 var err error 10819 10820 var numArgs uint8 10821 err = decoder.DecodeUint8(&numArgs) 10822 if err != nil { 10823 return types.SetnsArgs{}, err 10824 } 10825 10826 for arg := 0; arg < int(numArgs); arg++ { 10827 var currArg uint8 10828 err = decoder.DecodeUint8(&currArg) 10829 if err != nil { 10830 return types.SetnsArgs{}, err 10831 } 10832 10833 switch currArg { 10834 case 0: 10835 err = decoder.DecodeInt32(&result.Fd) 10836 if err != nil { 10837 return types.SetnsArgs{}, err 10838 } 10839 case 1: 10840 err = decoder.DecodeInt32(&result.Nstype) 10841 if err != nil { 10842 return types.SetnsArgs{}, err 10843 } 10844 } 10845 } 10846 return result, nil 10847 } 10848 10849 func ParseGetcpuArgs(decoder *Decoder) (types.GetcpuArgs, error) { 10850 var result types.GetcpuArgs 10851 var err error 10852 10853 var numArgs uint8 10854 err = decoder.DecodeUint8(&numArgs) 10855 if err != nil { 10856 return types.GetcpuArgs{}, err 10857 } 10858 10859 for arg := 0; arg < int(numArgs); arg++ { 10860 var currArg uint8 10861 err = decoder.DecodeUint8(&currArg) 10862 if err != nil { 10863 return types.GetcpuArgs{}, err 10864 } 10865 10866 switch currArg { 10867 case 0: 10868 var dataCpu uint64 10869 err = decoder.DecodeUint64(&dataCpu) 10870 if err != nil { 10871 return types.GetcpuArgs{}, err 10872 } 10873 result.Cpu = uintptr(dataCpu) 10874 case 1: 10875 var dataNode uint64 10876 err = decoder.DecodeUint64(&dataNode) 10877 if err != nil { 10878 return types.GetcpuArgs{}, err 10879 } 10880 result.Node = uintptr(dataNode) 10881 case 2: 10882 var dataTcache uint64 10883 err = decoder.DecodeUint64(&dataTcache) 10884 if err != nil { 10885 return types.GetcpuArgs{}, err 10886 } 10887 result.Tcache = uintptr(dataTcache) 10888 } 10889 } 10890 return result, nil 10891 } 10892 10893 func ParseProcessVmReadvArgs(decoder *Decoder) (types.ProcessVmReadvArgs, error) { 10894 var result types.ProcessVmReadvArgs 10895 var err error 10896 10897 var numArgs uint8 10898 err = decoder.DecodeUint8(&numArgs) 10899 if err != nil { 10900 return types.ProcessVmReadvArgs{}, err 10901 } 10902 10903 for arg := 0; arg < int(numArgs); arg++ { 10904 var currArg uint8 10905 err = decoder.DecodeUint8(&currArg) 10906 if err != nil { 10907 return types.ProcessVmReadvArgs{}, err 10908 } 10909 10910 switch currArg { 10911 case 0: 10912 err = decoder.DecodeInt32(&result.Pid) 10913 if err != nil { 10914 return types.ProcessVmReadvArgs{}, err 10915 } 10916 case 1: 10917 var dataLocalIov uint64 10918 err = decoder.DecodeUint64(&dataLocalIov) 10919 if err != nil { 10920 return types.ProcessVmReadvArgs{}, err 10921 } 10922 result.LocalIov = uintptr(dataLocalIov) 10923 case 2: 10924 err = decoder.DecodeUint64(&result.Liovcnt) 10925 if err != nil { 10926 return types.ProcessVmReadvArgs{}, err 10927 } 10928 case 3: 10929 var dataRemoteIov uint64 10930 err = decoder.DecodeUint64(&dataRemoteIov) 10931 if err != nil { 10932 return types.ProcessVmReadvArgs{}, err 10933 } 10934 result.RemoteIov = uintptr(dataRemoteIov) 10935 case 4: 10936 err = decoder.DecodeUint64(&result.Riovcnt) 10937 if err != nil { 10938 return types.ProcessVmReadvArgs{}, err 10939 } 10940 case 5: 10941 err = decoder.DecodeUint64(&result.Flags) 10942 if err != nil { 10943 return types.ProcessVmReadvArgs{}, err 10944 } 10945 } 10946 } 10947 return result, nil 10948 } 10949 10950 func ParseProcessVmWritevArgs(decoder *Decoder) (types.ProcessVmWritevArgs, error) { 10951 var result types.ProcessVmWritevArgs 10952 var err error 10953 10954 var numArgs uint8 10955 err = decoder.DecodeUint8(&numArgs) 10956 if err != nil { 10957 return types.ProcessVmWritevArgs{}, err 10958 } 10959 10960 for arg := 0; arg < int(numArgs); arg++ { 10961 var currArg uint8 10962 err = decoder.DecodeUint8(&currArg) 10963 if err != nil { 10964 return types.ProcessVmWritevArgs{}, err 10965 } 10966 10967 switch currArg { 10968 case 0: 10969 err = decoder.DecodeInt32(&result.Pid) 10970 if err != nil { 10971 return types.ProcessVmWritevArgs{}, err 10972 } 10973 case 1: 10974 var dataLocalIov uint64 10975 err = decoder.DecodeUint64(&dataLocalIov) 10976 if err != nil { 10977 return types.ProcessVmWritevArgs{}, err 10978 } 10979 result.LocalIov = uintptr(dataLocalIov) 10980 case 2: 10981 err = decoder.DecodeUint64(&result.Liovcnt) 10982 if err != nil { 10983 return types.ProcessVmWritevArgs{}, err 10984 } 10985 case 3: 10986 var dataRemoteIov uint64 10987 err = decoder.DecodeUint64(&dataRemoteIov) 10988 if err != nil { 10989 return types.ProcessVmWritevArgs{}, err 10990 } 10991 result.RemoteIov = uintptr(dataRemoteIov) 10992 case 4: 10993 err = decoder.DecodeUint64(&result.Riovcnt) 10994 if err != nil { 10995 return types.ProcessVmWritevArgs{}, err 10996 } 10997 case 5: 10998 err = decoder.DecodeUint64(&result.Flags) 10999 if err != nil { 11000 return types.ProcessVmWritevArgs{}, err 11001 } 11002 } 11003 } 11004 return result, nil 11005 } 11006 11007 func ParseKcmpArgs(decoder *Decoder) (types.KcmpArgs, error) { 11008 var result types.KcmpArgs 11009 var err error 11010 11011 var numArgs uint8 11012 err = decoder.DecodeUint8(&numArgs) 11013 if err != nil { 11014 return types.KcmpArgs{}, err 11015 } 11016 11017 for arg := 0; arg < int(numArgs); arg++ { 11018 var currArg uint8 11019 err = decoder.DecodeUint8(&currArg) 11020 if err != nil { 11021 return types.KcmpArgs{}, err 11022 } 11023 11024 switch currArg { 11025 case 0: 11026 err = decoder.DecodeInt32(&result.Pid1) 11027 if err != nil { 11028 return types.KcmpArgs{}, err 11029 } 11030 case 1: 11031 err = decoder.DecodeInt32(&result.Pid2) 11032 if err != nil { 11033 return types.KcmpArgs{}, err 11034 } 11035 case 2: 11036 err = decoder.DecodeInt32(&result.Type) 11037 if err != nil { 11038 return types.KcmpArgs{}, err 11039 } 11040 case 3: 11041 err = decoder.DecodeUint64(&result.Idx1) 11042 if err != nil { 11043 return types.KcmpArgs{}, err 11044 } 11045 case 4: 11046 err = decoder.DecodeUint64(&result.Idx2) 11047 if err != nil { 11048 return types.KcmpArgs{}, err 11049 } 11050 } 11051 } 11052 return result, nil 11053 } 11054 11055 func ParseFinitModuleArgs(decoder *Decoder) (types.FinitModuleArgs, error) { 11056 var result types.FinitModuleArgs 11057 var err error 11058 11059 var numArgs uint8 11060 err = decoder.DecodeUint8(&numArgs) 11061 if err != nil { 11062 return types.FinitModuleArgs{}, err 11063 } 11064 11065 for arg := 0; arg < int(numArgs); arg++ { 11066 var currArg uint8 11067 err = decoder.DecodeUint8(&currArg) 11068 if err != nil { 11069 return types.FinitModuleArgs{}, err 11070 } 11071 11072 switch currArg { 11073 case 0: 11074 err = decoder.DecodeInt32(&result.Fd) 11075 if err != nil { 11076 return types.FinitModuleArgs{}, err 11077 } 11078 case 1: 11079 result.ParamValues, err = decoder.ReadStringFromBuff() 11080 if err != nil { 11081 return types.FinitModuleArgs{}, err 11082 } 11083 case 2: 11084 err = decoder.DecodeInt32(&result.Flags) 11085 if err != nil { 11086 return types.FinitModuleArgs{}, err 11087 } 11088 } 11089 } 11090 return result, nil 11091 } 11092 11093 func ParseSchedSetattrArgs(decoder *Decoder) (types.SchedSetattrArgs, error) { 11094 var result types.SchedSetattrArgs 11095 var err error 11096 11097 var numArgs uint8 11098 err = decoder.DecodeUint8(&numArgs) 11099 if err != nil { 11100 return types.SchedSetattrArgs{}, err 11101 } 11102 11103 for arg := 0; arg < int(numArgs); arg++ { 11104 var currArg uint8 11105 err = decoder.DecodeUint8(&currArg) 11106 if err != nil { 11107 return types.SchedSetattrArgs{}, err 11108 } 11109 11110 switch currArg { 11111 case 0: 11112 err = decoder.DecodeInt32(&result.Pid) 11113 if err != nil { 11114 return types.SchedSetattrArgs{}, err 11115 } 11116 case 1: 11117 var dataAttr uint64 11118 err = decoder.DecodeUint64(&dataAttr) 11119 if err != nil { 11120 return types.SchedSetattrArgs{}, err 11121 } 11122 result.Attr = uintptr(dataAttr) 11123 case 2: 11124 err = decoder.DecodeUint32(&result.Flags) 11125 if err != nil { 11126 return types.SchedSetattrArgs{}, err 11127 } 11128 } 11129 } 11130 return result, nil 11131 } 11132 11133 func ParseSchedGetattrArgs(decoder *Decoder) (types.SchedGetattrArgs, error) { 11134 var result types.SchedGetattrArgs 11135 var err error 11136 11137 var numArgs uint8 11138 err = decoder.DecodeUint8(&numArgs) 11139 if err != nil { 11140 return types.SchedGetattrArgs{}, err 11141 } 11142 11143 for arg := 0; arg < int(numArgs); arg++ { 11144 var currArg uint8 11145 err = decoder.DecodeUint8(&currArg) 11146 if err != nil { 11147 return types.SchedGetattrArgs{}, err 11148 } 11149 11150 switch currArg { 11151 case 0: 11152 err = decoder.DecodeInt32(&result.Pid) 11153 if err != nil { 11154 return types.SchedGetattrArgs{}, err 11155 } 11156 case 1: 11157 var dataAttr uint64 11158 err = decoder.DecodeUint64(&dataAttr) 11159 if err != nil { 11160 return types.SchedGetattrArgs{}, err 11161 } 11162 result.Attr = uintptr(dataAttr) 11163 case 2: 11164 err = decoder.DecodeUint32(&result.Size) 11165 if err != nil { 11166 return types.SchedGetattrArgs{}, err 11167 } 11168 case 3: 11169 err = decoder.DecodeUint32(&result.Flags) 11170 if err != nil { 11171 return types.SchedGetattrArgs{}, err 11172 } 11173 } 11174 } 11175 return result, nil 11176 } 11177 11178 func ParseRenameat2Args(decoder *Decoder) (types.Renameat2Args, error) { 11179 var result types.Renameat2Args 11180 var err error 11181 11182 var numArgs uint8 11183 err = decoder.DecodeUint8(&numArgs) 11184 if err != nil { 11185 return types.Renameat2Args{}, err 11186 } 11187 11188 for arg := 0; arg < int(numArgs); arg++ { 11189 var currArg uint8 11190 err = decoder.DecodeUint8(&currArg) 11191 if err != nil { 11192 return types.Renameat2Args{}, err 11193 } 11194 11195 switch currArg { 11196 case 0: 11197 err = decoder.DecodeInt32(&result.Olddirfd) 11198 if err != nil { 11199 return types.Renameat2Args{}, err 11200 } 11201 case 1: 11202 result.Oldpath, err = decoder.ReadStringFromBuff() 11203 if err != nil { 11204 return types.Renameat2Args{}, err 11205 } 11206 case 2: 11207 err = decoder.DecodeInt32(&result.Newdirfd) 11208 if err != nil { 11209 return types.Renameat2Args{}, err 11210 } 11211 case 3: 11212 result.Newpath, err = decoder.ReadStringFromBuff() 11213 if err != nil { 11214 return types.Renameat2Args{}, err 11215 } 11216 case 4: 11217 err = decoder.DecodeUint32(&result.Flags) 11218 if err != nil { 11219 return types.Renameat2Args{}, err 11220 } 11221 } 11222 } 11223 return result, nil 11224 } 11225 11226 func ParseSeccompArgs(decoder *Decoder) (types.SeccompArgs, error) { 11227 var result types.SeccompArgs 11228 var err error 11229 11230 var numArgs uint8 11231 err = decoder.DecodeUint8(&numArgs) 11232 if err != nil { 11233 return types.SeccompArgs{}, err 11234 } 11235 11236 for arg := 0; arg < int(numArgs); arg++ { 11237 var currArg uint8 11238 err = decoder.DecodeUint8(&currArg) 11239 if err != nil { 11240 return types.SeccompArgs{}, err 11241 } 11242 11243 switch currArg { 11244 case 0: 11245 err = decoder.DecodeUint32(&result.Operation) 11246 if err != nil { 11247 return types.SeccompArgs{}, err 11248 } 11249 case 1: 11250 err = decoder.DecodeUint32(&result.Flags) 11251 if err != nil { 11252 return types.SeccompArgs{}, err 11253 } 11254 case 2: 11255 var dataArgs uint64 11256 err = decoder.DecodeUint64(&dataArgs) 11257 if err != nil { 11258 return types.SeccompArgs{}, err 11259 } 11260 result.Args = uintptr(dataArgs) 11261 } 11262 } 11263 return result, nil 11264 } 11265 11266 func ParseGetrandomArgs(decoder *Decoder) (types.GetrandomArgs, error) { 11267 var result types.GetrandomArgs 11268 var err error 11269 11270 var numArgs uint8 11271 err = decoder.DecodeUint8(&numArgs) 11272 if err != nil { 11273 return types.GetrandomArgs{}, err 11274 } 11275 11276 for arg := 0; arg < int(numArgs); arg++ { 11277 var currArg uint8 11278 err = decoder.DecodeUint8(&currArg) 11279 if err != nil { 11280 return types.GetrandomArgs{}, err 11281 } 11282 11283 switch currArg { 11284 case 0: 11285 var dataBuf uint64 11286 err = decoder.DecodeUint64(&dataBuf) 11287 if err != nil { 11288 return types.GetrandomArgs{}, err 11289 } 11290 result.Buf = uintptr(dataBuf) 11291 case 1: 11292 err = decoder.DecodeUint64(&result.Buflen) 11293 if err != nil { 11294 return types.GetrandomArgs{}, err 11295 } 11296 case 2: 11297 err = decoder.DecodeUint32(&result.Flags) 11298 if err != nil { 11299 return types.GetrandomArgs{}, err 11300 } 11301 } 11302 } 11303 return result, nil 11304 } 11305 11306 func ParseMemfdCreateArgs(decoder *Decoder) (types.MemfdCreateArgs, error) { 11307 var result types.MemfdCreateArgs 11308 var err error 11309 11310 var numArgs uint8 11311 err = decoder.DecodeUint8(&numArgs) 11312 if err != nil { 11313 return types.MemfdCreateArgs{}, err 11314 } 11315 11316 for arg := 0; arg < int(numArgs); arg++ { 11317 var currArg uint8 11318 err = decoder.DecodeUint8(&currArg) 11319 if err != nil { 11320 return types.MemfdCreateArgs{}, err 11321 } 11322 11323 switch currArg { 11324 case 0: 11325 result.Name, err = decoder.ReadStringFromBuff() 11326 if err != nil { 11327 return types.MemfdCreateArgs{}, err 11328 } 11329 case 1: 11330 err = decoder.DecodeUint32(&result.Flags) 11331 if err != nil { 11332 return types.MemfdCreateArgs{}, err 11333 } 11334 } 11335 } 11336 return result, nil 11337 } 11338 11339 func ParseKexecFileLoadArgs(decoder *Decoder) (types.KexecFileLoadArgs, error) { 11340 var result types.KexecFileLoadArgs 11341 var err error 11342 11343 var numArgs uint8 11344 err = decoder.DecodeUint8(&numArgs) 11345 if err != nil { 11346 return types.KexecFileLoadArgs{}, err 11347 } 11348 11349 for arg := 0; arg < int(numArgs); arg++ { 11350 var currArg uint8 11351 err = decoder.DecodeUint8(&currArg) 11352 if err != nil { 11353 return types.KexecFileLoadArgs{}, err 11354 } 11355 11356 switch currArg { 11357 case 0: 11358 err = decoder.DecodeInt32(&result.KernelFd) 11359 if err != nil { 11360 return types.KexecFileLoadArgs{}, err 11361 } 11362 case 1: 11363 err = decoder.DecodeInt32(&result.InitrdFd) 11364 if err != nil { 11365 return types.KexecFileLoadArgs{}, err 11366 } 11367 case 2: 11368 err = decoder.DecodeUint64(&result.CmdlineLen) 11369 if err != nil { 11370 return types.KexecFileLoadArgs{}, err 11371 } 11372 case 3: 11373 result.Cmdline, err = decoder.ReadStringFromBuff() 11374 if err != nil { 11375 return types.KexecFileLoadArgs{}, err 11376 } 11377 case 4: 11378 err = decoder.DecodeUint64(&result.Flags) 11379 if err != nil { 11380 return types.KexecFileLoadArgs{}, err 11381 } 11382 } 11383 } 11384 return result, nil 11385 } 11386 11387 func ParseBpfArgs(decoder *Decoder) (types.BpfArgs, error) { 11388 var result types.BpfArgs 11389 var err error 11390 11391 var numArgs uint8 11392 err = decoder.DecodeUint8(&numArgs) 11393 if err != nil { 11394 return types.BpfArgs{}, err 11395 } 11396 11397 for arg := 0; arg < int(numArgs); arg++ { 11398 var currArg uint8 11399 err = decoder.DecodeUint8(&currArg) 11400 if err != nil { 11401 return types.BpfArgs{}, err 11402 } 11403 11404 switch currArg { 11405 case 0: 11406 err = decoder.DecodeInt32(&result.Cmd) 11407 if err != nil { 11408 return types.BpfArgs{}, err 11409 } 11410 case 1: 11411 var dataAttr uint64 11412 err = decoder.DecodeUint64(&dataAttr) 11413 if err != nil { 11414 return types.BpfArgs{}, err 11415 } 11416 result.Attr = uintptr(dataAttr) 11417 case 2: 11418 err = decoder.DecodeUint32(&result.Size) 11419 if err != nil { 11420 return types.BpfArgs{}, err 11421 } 11422 } 11423 } 11424 return result, nil 11425 } 11426 11427 func ParseExecveatArgs(decoder *Decoder) (types.ExecveatArgs, error) { 11428 var result types.ExecveatArgs 11429 var err error 11430 11431 var numArgs uint8 11432 err = decoder.DecodeUint8(&numArgs) 11433 if err != nil { 11434 return types.ExecveatArgs{}, err 11435 } 11436 11437 for arg := 0; arg < int(numArgs); arg++ { 11438 var currArg uint8 11439 err = decoder.DecodeUint8(&currArg) 11440 if err != nil { 11441 return types.ExecveatArgs{}, err 11442 } 11443 11444 switch currArg { 11445 case 0: 11446 err = decoder.DecodeInt32(&result.Dirfd) 11447 if err != nil { 11448 return types.ExecveatArgs{}, err 11449 } 11450 case 1: 11451 result.Pathname, err = decoder.ReadStringFromBuff() 11452 if err != nil { 11453 return types.ExecveatArgs{}, err 11454 } 11455 case 2: 11456 result.Argv, err = decoder.ReadStringArrayFromBuff() 11457 if err != nil { 11458 return types.ExecveatArgs{}, err 11459 } 11460 case 3: 11461 result.Envp, err = decoder.ReadStringArrayFromBuff() 11462 if err != nil { 11463 return types.ExecveatArgs{}, err 11464 } 11465 case 4: 11466 err = decoder.DecodeInt32(&result.Flags) 11467 if err != nil { 11468 return types.ExecveatArgs{}, err 11469 } 11470 } 11471 } 11472 return result, nil 11473 } 11474 11475 func ParseUserfaultfdArgs(decoder *Decoder) (types.UserfaultfdArgs, error) { 11476 var result types.UserfaultfdArgs 11477 var err error 11478 11479 var numArgs uint8 11480 err = decoder.DecodeUint8(&numArgs) 11481 if err != nil { 11482 return types.UserfaultfdArgs{}, err 11483 } 11484 11485 for arg := 0; arg < int(numArgs); arg++ { 11486 var currArg uint8 11487 err = decoder.DecodeUint8(&currArg) 11488 if err != nil { 11489 return types.UserfaultfdArgs{}, err 11490 } 11491 11492 switch currArg { 11493 case 0: 11494 err = decoder.DecodeInt32(&result.Flags) 11495 if err != nil { 11496 return types.UserfaultfdArgs{}, err 11497 } 11498 } 11499 } 11500 return result, nil 11501 } 11502 11503 func ParseMembarrierArgs(decoder *Decoder) (types.MembarrierArgs, error) { 11504 var result types.MembarrierArgs 11505 var err error 11506 11507 var numArgs uint8 11508 err = decoder.DecodeUint8(&numArgs) 11509 if err != nil { 11510 return types.MembarrierArgs{}, err 11511 } 11512 11513 for arg := 0; arg < int(numArgs); arg++ { 11514 var currArg uint8 11515 err = decoder.DecodeUint8(&currArg) 11516 if err != nil { 11517 return types.MembarrierArgs{}, err 11518 } 11519 11520 switch currArg { 11521 case 0: 11522 err = decoder.DecodeInt32(&result.Cmd) 11523 if err != nil { 11524 return types.MembarrierArgs{}, err 11525 } 11526 case 1: 11527 err = decoder.DecodeInt32(&result.Flags) 11528 if err != nil { 11529 return types.MembarrierArgs{}, err 11530 } 11531 } 11532 } 11533 return result, nil 11534 } 11535 11536 func ParseMlock2Args(decoder *Decoder) (types.Mlock2Args, error) { 11537 var result types.Mlock2Args 11538 var err error 11539 11540 var numArgs uint8 11541 err = decoder.DecodeUint8(&numArgs) 11542 if err != nil { 11543 return types.Mlock2Args{}, err 11544 } 11545 11546 for arg := 0; arg < int(numArgs); arg++ { 11547 var currArg uint8 11548 err = decoder.DecodeUint8(&currArg) 11549 if err != nil { 11550 return types.Mlock2Args{}, err 11551 } 11552 11553 switch currArg { 11554 case 0: 11555 var dataAddr uint64 11556 err = decoder.DecodeUint64(&dataAddr) 11557 if err != nil { 11558 return types.Mlock2Args{}, err 11559 } 11560 result.Addr = uintptr(dataAddr) 11561 case 1: 11562 err = decoder.DecodeUint64(&result.Len) 11563 if err != nil { 11564 return types.Mlock2Args{}, err 11565 } 11566 case 2: 11567 err = decoder.DecodeInt32(&result.Flags) 11568 if err != nil { 11569 return types.Mlock2Args{}, err 11570 } 11571 } 11572 } 11573 return result, nil 11574 } 11575 11576 func ParseCopyFileRangeArgs(decoder *Decoder) (types.CopyFileRangeArgs, error) { 11577 var result types.CopyFileRangeArgs 11578 var err error 11579 11580 var numArgs uint8 11581 err = decoder.DecodeUint8(&numArgs) 11582 if err != nil { 11583 return types.CopyFileRangeArgs{}, err 11584 } 11585 11586 for arg := 0; arg < int(numArgs); arg++ { 11587 var currArg uint8 11588 err = decoder.DecodeUint8(&currArg) 11589 if err != nil { 11590 return types.CopyFileRangeArgs{}, err 11591 } 11592 11593 switch currArg { 11594 case 0: 11595 err = decoder.DecodeInt32(&result.FdIn) 11596 if err != nil { 11597 return types.CopyFileRangeArgs{}, err 11598 } 11599 case 1: 11600 var dataOffIn uint64 11601 err = decoder.DecodeUint64(&dataOffIn) 11602 if err != nil { 11603 return types.CopyFileRangeArgs{}, err 11604 } 11605 result.OffIn = uintptr(dataOffIn) 11606 case 2: 11607 err = decoder.DecodeInt32(&result.FdOut) 11608 if err != nil { 11609 return types.CopyFileRangeArgs{}, err 11610 } 11611 case 3: 11612 var dataOffOut uint64 11613 err = decoder.DecodeUint64(&dataOffOut) 11614 if err != nil { 11615 return types.CopyFileRangeArgs{}, err 11616 } 11617 result.OffOut = uintptr(dataOffOut) 11618 case 4: 11619 err = decoder.DecodeUint64(&result.Len) 11620 if err != nil { 11621 return types.CopyFileRangeArgs{}, err 11622 } 11623 case 5: 11624 err = decoder.DecodeUint32(&result.Flags) 11625 if err != nil { 11626 return types.CopyFileRangeArgs{}, err 11627 } 11628 } 11629 } 11630 return result, nil 11631 } 11632 11633 func ParsePreadv2Args(decoder *Decoder) (types.Preadv2Args, error) { 11634 var result types.Preadv2Args 11635 var err error 11636 11637 var numArgs uint8 11638 err = decoder.DecodeUint8(&numArgs) 11639 if err != nil { 11640 return types.Preadv2Args{}, err 11641 } 11642 11643 for arg := 0; arg < int(numArgs); arg++ { 11644 var currArg uint8 11645 err = decoder.DecodeUint8(&currArg) 11646 if err != nil { 11647 return types.Preadv2Args{}, err 11648 } 11649 11650 switch currArg { 11651 case 0: 11652 err = decoder.DecodeInt32(&result.Fd) 11653 if err != nil { 11654 return types.Preadv2Args{}, err 11655 } 11656 case 1: 11657 var dataIov uint64 11658 err = decoder.DecodeUint64(&dataIov) 11659 if err != nil { 11660 return types.Preadv2Args{}, err 11661 } 11662 result.Iov = uintptr(dataIov) 11663 case 2: 11664 err = decoder.DecodeUint64(&result.Iovcnt) 11665 if err != nil { 11666 return types.Preadv2Args{}, err 11667 } 11668 case 3: 11669 err = decoder.DecodeUint64(&result.PosL) 11670 if err != nil { 11671 return types.Preadv2Args{}, err 11672 } 11673 case 4: 11674 err = decoder.DecodeUint64(&result.PosH) 11675 if err != nil { 11676 return types.Preadv2Args{}, err 11677 } 11678 case 5: 11679 err = decoder.DecodeInt32(&result.Flags) 11680 if err != nil { 11681 return types.Preadv2Args{}, err 11682 } 11683 } 11684 } 11685 return result, nil 11686 } 11687 11688 func ParsePwritev2Args(decoder *Decoder) (types.Pwritev2Args, error) { 11689 var result types.Pwritev2Args 11690 var err error 11691 11692 var numArgs uint8 11693 err = decoder.DecodeUint8(&numArgs) 11694 if err != nil { 11695 return types.Pwritev2Args{}, err 11696 } 11697 11698 for arg := 0; arg < int(numArgs); arg++ { 11699 var currArg uint8 11700 err = decoder.DecodeUint8(&currArg) 11701 if err != nil { 11702 return types.Pwritev2Args{}, err 11703 } 11704 11705 switch currArg { 11706 case 0: 11707 err = decoder.DecodeInt32(&result.Fd) 11708 if err != nil { 11709 return types.Pwritev2Args{}, err 11710 } 11711 case 1: 11712 var dataIov uint64 11713 err = decoder.DecodeUint64(&dataIov) 11714 if err != nil { 11715 return types.Pwritev2Args{}, err 11716 } 11717 result.Iov = uintptr(dataIov) 11718 case 2: 11719 err = decoder.DecodeUint64(&result.Iovcnt) 11720 if err != nil { 11721 return types.Pwritev2Args{}, err 11722 } 11723 case 3: 11724 err = decoder.DecodeUint64(&result.PosL) 11725 if err != nil { 11726 return types.Pwritev2Args{}, err 11727 } 11728 case 4: 11729 err = decoder.DecodeUint64(&result.PosH) 11730 if err != nil { 11731 return types.Pwritev2Args{}, err 11732 } 11733 case 5: 11734 err = decoder.DecodeInt32(&result.Flags) 11735 if err != nil { 11736 return types.Pwritev2Args{}, err 11737 } 11738 } 11739 } 11740 return result, nil 11741 } 11742 11743 func ParsePkeyMprotectArgs(decoder *Decoder) (types.PkeyMprotectArgs, error) { 11744 var result types.PkeyMprotectArgs 11745 var err error 11746 11747 var numArgs uint8 11748 err = decoder.DecodeUint8(&numArgs) 11749 if err != nil { 11750 return types.PkeyMprotectArgs{}, err 11751 } 11752 11753 for arg := 0; arg < int(numArgs); arg++ { 11754 var currArg uint8 11755 err = decoder.DecodeUint8(&currArg) 11756 if err != nil { 11757 return types.PkeyMprotectArgs{}, err 11758 } 11759 11760 switch currArg { 11761 case 0: 11762 var dataAddr uint64 11763 err = decoder.DecodeUint64(&dataAddr) 11764 if err != nil { 11765 return types.PkeyMprotectArgs{}, err 11766 } 11767 result.Addr = uintptr(dataAddr) 11768 case 1: 11769 err = decoder.DecodeUint64(&result.Len) 11770 if err != nil { 11771 return types.PkeyMprotectArgs{}, err 11772 } 11773 case 2: 11774 err = decoder.DecodeInt32(&result.Prot) 11775 if err != nil { 11776 return types.PkeyMprotectArgs{}, err 11777 } 11778 case 3: 11779 err = decoder.DecodeInt32(&result.Pkey) 11780 if err != nil { 11781 return types.PkeyMprotectArgs{}, err 11782 } 11783 } 11784 } 11785 return result, nil 11786 } 11787 11788 func ParsePkeyAllocArgs(decoder *Decoder) (types.PkeyAllocArgs, error) { 11789 var result types.PkeyAllocArgs 11790 var err error 11791 11792 var numArgs uint8 11793 err = decoder.DecodeUint8(&numArgs) 11794 if err != nil { 11795 return types.PkeyAllocArgs{}, err 11796 } 11797 11798 for arg := 0; arg < int(numArgs); arg++ { 11799 var currArg uint8 11800 err = decoder.DecodeUint8(&currArg) 11801 if err != nil { 11802 return types.PkeyAllocArgs{}, err 11803 } 11804 11805 switch currArg { 11806 case 0: 11807 err = decoder.DecodeUint32(&result.Flags) 11808 if err != nil { 11809 return types.PkeyAllocArgs{}, err 11810 } 11811 case 1: 11812 err = decoder.DecodeUint64(&result.AccessRights) 11813 if err != nil { 11814 return types.PkeyAllocArgs{}, err 11815 } 11816 } 11817 } 11818 return result, nil 11819 } 11820 11821 func ParsePkeyFreeArgs(decoder *Decoder) (types.PkeyFreeArgs, error) { 11822 var result types.PkeyFreeArgs 11823 var err error 11824 11825 var numArgs uint8 11826 err = decoder.DecodeUint8(&numArgs) 11827 if err != nil { 11828 return types.PkeyFreeArgs{}, err 11829 } 11830 11831 for arg := 0; arg < int(numArgs); arg++ { 11832 var currArg uint8 11833 err = decoder.DecodeUint8(&currArg) 11834 if err != nil { 11835 return types.PkeyFreeArgs{}, err 11836 } 11837 11838 switch currArg { 11839 case 0: 11840 err = decoder.DecodeInt32(&result.Pkey) 11841 if err != nil { 11842 return types.PkeyFreeArgs{}, err 11843 } 11844 } 11845 } 11846 return result, nil 11847 } 11848 11849 func ParseStatxArgs(decoder *Decoder) (types.StatxArgs, error) { 11850 var result types.StatxArgs 11851 var err error 11852 11853 var numArgs uint8 11854 err = decoder.DecodeUint8(&numArgs) 11855 if err != nil { 11856 return types.StatxArgs{}, err 11857 } 11858 11859 for arg := 0; arg < int(numArgs); arg++ { 11860 var currArg uint8 11861 err = decoder.DecodeUint8(&currArg) 11862 if err != nil { 11863 return types.StatxArgs{}, err 11864 } 11865 11866 switch currArg { 11867 case 0: 11868 err = decoder.DecodeInt32(&result.Dirfd) 11869 if err != nil { 11870 return types.StatxArgs{}, err 11871 } 11872 case 1: 11873 result.Pathname, err = decoder.ReadStringFromBuff() 11874 if err != nil { 11875 return types.StatxArgs{}, err 11876 } 11877 case 2: 11878 err = decoder.DecodeInt32(&result.Flags) 11879 if err != nil { 11880 return types.StatxArgs{}, err 11881 } 11882 case 3: 11883 err = decoder.DecodeUint32(&result.Mask) 11884 if err != nil { 11885 return types.StatxArgs{}, err 11886 } 11887 case 4: 11888 var dataStatxbuf uint64 11889 err = decoder.DecodeUint64(&dataStatxbuf) 11890 if err != nil { 11891 return types.StatxArgs{}, err 11892 } 11893 result.Statxbuf = uintptr(dataStatxbuf) 11894 } 11895 } 11896 return result, nil 11897 } 11898 11899 func ParseIoPgeteventsArgs(decoder *Decoder) (types.IoPgeteventsArgs, error) { 11900 var result types.IoPgeteventsArgs 11901 var err error 11902 11903 var numArgs uint8 11904 err = decoder.DecodeUint8(&numArgs) 11905 if err != nil { 11906 return types.IoPgeteventsArgs{}, err 11907 } 11908 11909 for arg := 0; arg < int(numArgs); arg++ { 11910 var currArg uint8 11911 err = decoder.DecodeUint8(&currArg) 11912 if err != nil { 11913 return types.IoPgeteventsArgs{}, err 11914 } 11915 11916 switch currArg { 11917 case 0: 11918 var dataCtxId uint64 11919 err = decoder.DecodeUint64(&dataCtxId) 11920 if err != nil { 11921 return types.IoPgeteventsArgs{}, err 11922 } 11923 result.CtxId = uintptr(dataCtxId) 11924 case 1: 11925 err = decoder.DecodeInt64(&result.MinNr) 11926 if err != nil { 11927 return types.IoPgeteventsArgs{}, err 11928 } 11929 case 2: 11930 err = decoder.DecodeInt64(&result.Nr) 11931 if err != nil { 11932 return types.IoPgeteventsArgs{}, err 11933 } 11934 case 3: 11935 var dataEvents uint64 11936 err = decoder.DecodeUint64(&dataEvents) 11937 if err != nil { 11938 return types.IoPgeteventsArgs{}, err 11939 } 11940 result.Events = uintptr(dataEvents) 11941 case 4: 11942 result.Timeout, err = decoder.ReadTimespec() 11943 if err != nil { 11944 return types.IoPgeteventsArgs{}, err 11945 } 11946 case 5: 11947 var dataUsig uint64 11948 err = decoder.DecodeUint64(&dataUsig) 11949 if err != nil { 11950 return types.IoPgeteventsArgs{}, err 11951 } 11952 result.Usig = uintptr(dataUsig) 11953 } 11954 } 11955 return result, nil 11956 } 11957 11958 func ParseRseqArgs(decoder *Decoder) (types.RseqArgs, error) { 11959 var result types.RseqArgs 11960 var err error 11961 11962 var numArgs uint8 11963 err = decoder.DecodeUint8(&numArgs) 11964 if err != nil { 11965 return types.RseqArgs{}, err 11966 } 11967 11968 for arg := 0; arg < int(numArgs); arg++ { 11969 var currArg uint8 11970 err = decoder.DecodeUint8(&currArg) 11971 if err != nil { 11972 return types.RseqArgs{}, err 11973 } 11974 11975 switch currArg { 11976 case 0: 11977 var dataRseq uint64 11978 err = decoder.DecodeUint64(&dataRseq) 11979 if err != nil { 11980 return types.RseqArgs{}, err 11981 } 11982 result.Rseq = uintptr(dataRseq) 11983 case 1: 11984 err = decoder.DecodeUint32(&result.RseqLen) 11985 if err != nil { 11986 return types.RseqArgs{}, err 11987 } 11988 case 2: 11989 err = decoder.DecodeInt32(&result.Flags) 11990 if err != nil { 11991 return types.RseqArgs{}, err 11992 } 11993 case 3: 11994 err = decoder.DecodeUint32(&result.Sig) 11995 if err != nil { 11996 return types.RseqArgs{}, err 11997 } 11998 } 11999 } 12000 return result, nil 12001 } 12002 12003 func ParsePidfdSendSignalArgs(decoder *Decoder) (types.PidfdSendSignalArgs, error) { 12004 var result types.PidfdSendSignalArgs 12005 var err error 12006 12007 var numArgs uint8 12008 err = decoder.DecodeUint8(&numArgs) 12009 if err != nil { 12010 return types.PidfdSendSignalArgs{}, err 12011 } 12012 12013 for arg := 0; arg < int(numArgs); arg++ { 12014 var currArg uint8 12015 err = decoder.DecodeUint8(&currArg) 12016 if err != nil { 12017 return types.PidfdSendSignalArgs{}, err 12018 } 12019 12020 switch currArg { 12021 case 0: 12022 err = decoder.DecodeInt32(&result.Pidfd) 12023 if err != nil { 12024 return types.PidfdSendSignalArgs{}, err 12025 } 12026 case 1: 12027 err = decoder.DecodeInt32(&result.Sig) 12028 if err != nil { 12029 return types.PidfdSendSignalArgs{}, err 12030 } 12031 case 2: 12032 var dataInfo uint64 12033 err = decoder.DecodeUint64(&dataInfo) 12034 if err != nil { 12035 return types.PidfdSendSignalArgs{}, err 12036 } 12037 result.Info = uintptr(dataInfo) 12038 case 3: 12039 err = decoder.DecodeUint32(&result.Flags) 12040 if err != nil { 12041 return types.PidfdSendSignalArgs{}, err 12042 } 12043 } 12044 } 12045 return result, nil 12046 } 12047 12048 func ParseIoUringSetupArgs(decoder *Decoder) (types.IoUringSetupArgs, error) { 12049 var result types.IoUringSetupArgs 12050 var err error 12051 12052 var numArgs uint8 12053 err = decoder.DecodeUint8(&numArgs) 12054 if err != nil { 12055 return types.IoUringSetupArgs{}, err 12056 } 12057 12058 for arg := 0; arg < int(numArgs); arg++ { 12059 var currArg uint8 12060 err = decoder.DecodeUint8(&currArg) 12061 if err != nil { 12062 return types.IoUringSetupArgs{}, err 12063 } 12064 12065 switch currArg { 12066 case 0: 12067 err = decoder.DecodeUint32(&result.Entries) 12068 if err != nil { 12069 return types.IoUringSetupArgs{}, err 12070 } 12071 case 1: 12072 var dataP uint64 12073 err = decoder.DecodeUint64(&dataP) 12074 if err != nil { 12075 return types.IoUringSetupArgs{}, err 12076 } 12077 result.P = uintptr(dataP) 12078 } 12079 } 12080 return result, nil 12081 } 12082 12083 func ParseIoUringEnterArgs(decoder *Decoder) (types.IoUringEnterArgs, error) { 12084 var result types.IoUringEnterArgs 12085 var err error 12086 12087 var numArgs uint8 12088 err = decoder.DecodeUint8(&numArgs) 12089 if err != nil { 12090 return types.IoUringEnterArgs{}, err 12091 } 12092 12093 for arg := 0; arg < int(numArgs); arg++ { 12094 var currArg uint8 12095 err = decoder.DecodeUint8(&currArg) 12096 if err != nil { 12097 return types.IoUringEnterArgs{}, err 12098 } 12099 12100 switch currArg { 12101 case 0: 12102 err = decoder.DecodeUint32(&result.Fd) 12103 if err != nil { 12104 return types.IoUringEnterArgs{}, err 12105 } 12106 case 1: 12107 err = decoder.DecodeUint32(&result.ToSubmit) 12108 if err != nil { 12109 return types.IoUringEnterArgs{}, err 12110 } 12111 case 2: 12112 err = decoder.DecodeUint32(&result.MinComplete) 12113 if err != nil { 12114 return types.IoUringEnterArgs{}, err 12115 } 12116 case 3: 12117 err = decoder.DecodeUint32(&result.Flags) 12118 if err != nil { 12119 return types.IoUringEnterArgs{}, err 12120 } 12121 case 4: 12122 var dataSig uint64 12123 err = decoder.DecodeUint64(&dataSig) 12124 if err != nil { 12125 return types.IoUringEnterArgs{}, err 12126 } 12127 result.Sig = uintptr(dataSig) 12128 } 12129 } 12130 return result, nil 12131 } 12132 12133 func ParseIoUringRegisterArgs(decoder *Decoder) (types.IoUringRegisterArgs, error) { 12134 var result types.IoUringRegisterArgs 12135 var err error 12136 12137 var numArgs uint8 12138 err = decoder.DecodeUint8(&numArgs) 12139 if err != nil { 12140 return types.IoUringRegisterArgs{}, err 12141 } 12142 12143 for arg := 0; arg < int(numArgs); arg++ { 12144 var currArg uint8 12145 err = decoder.DecodeUint8(&currArg) 12146 if err != nil { 12147 return types.IoUringRegisterArgs{}, err 12148 } 12149 12150 switch currArg { 12151 case 0: 12152 err = decoder.DecodeUint32(&result.Fd) 12153 if err != nil { 12154 return types.IoUringRegisterArgs{}, err 12155 } 12156 case 1: 12157 err = decoder.DecodeUint32(&result.Opcode) 12158 if err != nil { 12159 return types.IoUringRegisterArgs{}, err 12160 } 12161 case 2: 12162 var dataArg uint64 12163 err = decoder.DecodeUint64(&dataArg) 12164 if err != nil { 12165 return types.IoUringRegisterArgs{}, err 12166 } 12167 result.Arg = uintptr(dataArg) 12168 case 3: 12169 err = decoder.DecodeUint32(&result.NrArgs) 12170 if err != nil { 12171 return types.IoUringRegisterArgs{}, err 12172 } 12173 } 12174 } 12175 return result, nil 12176 } 12177 12178 func ParseOpenTreeArgs(decoder *Decoder) (types.OpenTreeArgs, error) { 12179 var result types.OpenTreeArgs 12180 var err error 12181 12182 var numArgs uint8 12183 err = decoder.DecodeUint8(&numArgs) 12184 if err != nil { 12185 return types.OpenTreeArgs{}, err 12186 } 12187 12188 for arg := 0; arg < int(numArgs); arg++ { 12189 var currArg uint8 12190 err = decoder.DecodeUint8(&currArg) 12191 if err != nil { 12192 return types.OpenTreeArgs{}, err 12193 } 12194 12195 switch currArg { 12196 case 0: 12197 err = decoder.DecodeInt32(&result.Dfd) 12198 if err != nil { 12199 return types.OpenTreeArgs{}, err 12200 } 12201 case 1: 12202 result.Filename, err = decoder.ReadStringFromBuff() 12203 if err != nil { 12204 return types.OpenTreeArgs{}, err 12205 } 12206 case 2: 12207 err = decoder.DecodeUint32(&result.Flags) 12208 if err != nil { 12209 return types.OpenTreeArgs{}, err 12210 } 12211 } 12212 } 12213 return result, nil 12214 } 12215 12216 func ParseMoveMountArgs(decoder *Decoder) (types.MoveMountArgs, error) { 12217 var result types.MoveMountArgs 12218 var err error 12219 12220 var numArgs uint8 12221 err = decoder.DecodeUint8(&numArgs) 12222 if err != nil { 12223 return types.MoveMountArgs{}, err 12224 } 12225 12226 for arg := 0; arg < int(numArgs); arg++ { 12227 var currArg uint8 12228 err = decoder.DecodeUint8(&currArg) 12229 if err != nil { 12230 return types.MoveMountArgs{}, err 12231 } 12232 12233 switch currArg { 12234 case 0: 12235 err = decoder.DecodeInt32(&result.FromDfd) 12236 if err != nil { 12237 return types.MoveMountArgs{}, err 12238 } 12239 case 1: 12240 result.FromPath, err = decoder.ReadStringFromBuff() 12241 if err != nil { 12242 return types.MoveMountArgs{}, err 12243 } 12244 case 2: 12245 err = decoder.DecodeInt32(&result.ToDfd) 12246 if err != nil { 12247 return types.MoveMountArgs{}, err 12248 } 12249 case 3: 12250 result.ToPath, err = decoder.ReadStringFromBuff() 12251 if err != nil { 12252 return types.MoveMountArgs{}, err 12253 } 12254 case 4: 12255 err = decoder.DecodeUint32(&result.Flags) 12256 if err != nil { 12257 return types.MoveMountArgs{}, err 12258 } 12259 } 12260 } 12261 return result, nil 12262 } 12263 12264 func ParseFsopenArgs(decoder *Decoder) (types.FsopenArgs, error) { 12265 var result types.FsopenArgs 12266 var err error 12267 12268 var numArgs uint8 12269 err = decoder.DecodeUint8(&numArgs) 12270 if err != nil { 12271 return types.FsopenArgs{}, err 12272 } 12273 12274 for arg := 0; arg < int(numArgs); arg++ { 12275 var currArg uint8 12276 err = decoder.DecodeUint8(&currArg) 12277 if err != nil { 12278 return types.FsopenArgs{}, err 12279 } 12280 12281 switch currArg { 12282 case 0: 12283 result.Fsname, err = decoder.ReadStringFromBuff() 12284 if err != nil { 12285 return types.FsopenArgs{}, err 12286 } 12287 case 1: 12288 err = decoder.DecodeUint32(&result.Flags) 12289 if err != nil { 12290 return types.FsopenArgs{}, err 12291 } 12292 } 12293 } 12294 return result, nil 12295 } 12296 12297 func ParseFsconfigArgs(decoder *Decoder) (types.FsconfigArgs, error) { 12298 var result types.FsconfigArgs 12299 var err error 12300 12301 var numArgs uint8 12302 err = decoder.DecodeUint8(&numArgs) 12303 if err != nil { 12304 return types.FsconfigArgs{}, err 12305 } 12306 12307 for arg := 0; arg < int(numArgs); arg++ { 12308 var currArg uint8 12309 err = decoder.DecodeUint8(&currArg) 12310 if err != nil { 12311 return types.FsconfigArgs{}, err 12312 } 12313 12314 switch currArg { 12315 case 0: 12316 var dataFsFd uint64 12317 err = decoder.DecodeUint64(&dataFsFd) 12318 if err != nil { 12319 return types.FsconfigArgs{}, err 12320 } 12321 result.FsFd = uintptr(dataFsFd) 12322 case 1: 12323 err = decoder.DecodeUint32(&result.Cmd) 12324 if err != nil { 12325 return types.FsconfigArgs{}, err 12326 } 12327 case 2: 12328 result.Key, err = decoder.ReadStringFromBuff() 12329 if err != nil { 12330 return types.FsconfigArgs{}, err 12331 } 12332 case 3: 12333 var dataValue uint64 12334 err = decoder.DecodeUint64(&dataValue) 12335 if err != nil { 12336 return types.FsconfigArgs{}, err 12337 } 12338 result.Value = uintptr(dataValue) 12339 case 4: 12340 err = decoder.DecodeInt32(&result.Aux) 12341 if err != nil { 12342 return types.FsconfigArgs{}, err 12343 } 12344 } 12345 } 12346 return result, nil 12347 } 12348 12349 func ParseFsmountArgs(decoder *Decoder) (types.FsmountArgs, error) { 12350 var result types.FsmountArgs 12351 var err error 12352 12353 var numArgs uint8 12354 err = decoder.DecodeUint8(&numArgs) 12355 if err != nil { 12356 return types.FsmountArgs{}, err 12357 } 12358 12359 for arg := 0; arg < int(numArgs); arg++ { 12360 var currArg uint8 12361 err = decoder.DecodeUint8(&currArg) 12362 if err != nil { 12363 return types.FsmountArgs{}, err 12364 } 12365 12366 switch currArg { 12367 case 0: 12368 err = decoder.DecodeInt32(&result.Fsfd) 12369 if err != nil { 12370 return types.FsmountArgs{}, err 12371 } 12372 case 1: 12373 err = decoder.DecodeUint32(&result.Flags) 12374 if err != nil { 12375 return types.FsmountArgs{}, err 12376 } 12377 case 2: 12378 err = decoder.DecodeUint32(&result.MsFlags) 12379 if err != nil { 12380 return types.FsmountArgs{}, err 12381 } 12382 } 12383 } 12384 return result, nil 12385 } 12386 12387 func ParseFspickArgs(decoder *Decoder) (types.FspickArgs, error) { 12388 var result types.FspickArgs 12389 var err error 12390 12391 var numArgs uint8 12392 err = decoder.DecodeUint8(&numArgs) 12393 if err != nil { 12394 return types.FspickArgs{}, err 12395 } 12396 12397 for arg := 0; arg < int(numArgs); arg++ { 12398 var currArg uint8 12399 err = decoder.DecodeUint8(&currArg) 12400 if err != nil { 12401 return types.FspickArgs{}, err 12402 } 12403 12404 switch currArg { 12405 case 0: 12406 err = decoder.DecodeInt32(&result.Dirfd) 12407 if err != nil { 12408 return types.FspickArgs{}, err 12409 } 12410 case 1: 12411 result.Pathname, err = decoder.ReadStringFromBuff() 12412 if err != nil { 12413 return types.FspickArgs{}, err 12414 } 12415 case 2: 12416 err = decoder.DecodeUint32(&result.Flags) 12417 if err != nil { 12418 return types.FspickArgs{}, err 12419 } 12420 } 12421 } 12422 return result, nil 12423 } 12424 12425 func ParsePidfdOpenArgs(decoder *Decoder) (types.PidfdOpenArgs, error) { 12426 var result types.PidfdOpenArgs 12427 var err error 12428 12429 var numArgs uint8 12430 err = decoder.DecodeUint8(&numArgs) 12431 if err != nil { 12432 return types.PidfdOpenArgs{}, err 12433 } 12434 12435 for arg := 0; arg < int(numArgs); arg++ { 12436 var currArg uint8 12437 err = decoder.DecodeUint8(&currArg) 12438 if err != nil { 12439 return types.PidfdOpenArgs{}, err 12440 } 12441 12442 switch currArg { 12443 case 0: 12444 err = decoder.DecodeInt32(&result.Pid) 12445 if err != nil { 12446 return types.PidfdOpenArgs{}, err 12447 } 12448 case 1: 12449 err = decoder.DecodeUint32(&result.Flags) 12450 if err != nil { 12451 return types.PidfdOpenArgs{}, err 12452 } 12453 } 12454 } 12455 return result, nil 12456 } 12457 12458 func ParseClone3Args(decoder *Decoder) (types.Clone3Args, error) { 12459 var result types.Clone3Args 12460 var err error 12461 12462 var numArgs uint8 12463 err = decoder.DecodeUint8(&numArgs) 12464 if err != nil { 12465 return types.Clone3Args{}, err 12466 } 12467 12468 for arg := 0; arg < int(numArgs); arg++ { 12469 var currArg uint8 12470 err = decoder.DecodeUint8(&currArg) 12471 if err != nil { 12472 return types.Clone3Args{}, err 12473 } 12474 12475 switch currArg { 12476 case 0: 12477 var dataClArgs uint64 12478 err = decoder.DecodeUint64(&dataClArgs) 12479 if err != nil { 12480 return types.Clone3Args{}, err 12481 } 12482 result.ClArgs = uintptr(dataClArgs) 12483 case 1: 12484 err = decoder.DecodeUint64(&result.Size) 12485 if err != nil { 12486 return types.Clone3Args{}, err 12487 } 12488 } 12489 } 12490 return result, nil 12491 } 12492 12493 func ParseCloseRangeArgs(decoder *Decoder) (types.CloseRangeArgs, error) { 12494 var result types.CloseRangeArgs 12495 var err error 12496 12497 var numArgs uint8 12498 err = decoder.DecodeUint8(&numArgs) 12499 if err != nil { 12500 return types.CloseRangeArgs{}, err 12501 } 12502 12503 for arg := 0; arg < int(numArgs); arg++ { 12504 var currArg uint8 12505 err = decoder.DecodeUint8(&currArg) 12506 if err != nil { 12507 return types.CloseRangeArgs{}, err 12508 } 12509 12510 switch currArg { 12511 case 0: 12512 err = decoder.DecodeUint32(&result.First) 12513 if err != nil { 12514 return types.CloseRangeArgs{}, err 12515 } 12516 case 1: 12517 err = decoder.DecodeUint32(&result.Last) 12518 if err != nil { 12519 return types.CloseRangeArgs{}, err 12520 } 12521 } 12522 } 12523 return result, nil 12524 } 12525 12526 func ParseOpenat2Args(decoder *Decoder) (types.Openat2Args, error) { 12527 var result types.Openat2Args 12528 var err error 12529 12530 var numArgs uint8 12531 err = decoder.DecodeUint8(&numArgs) 12532 if err != nil { 12533 return types.Openat2Args{}, err 12534 } 12535 12536 for arg := 0; arg < int(numArgs); arg++ { 12537 var currArg uint8 12538 err = decoder.DecodeUint8(&currArg) 12539 if err != nil { 12540 return types.Openat2Args{}, err 12541 } 12542 12543 switch currArg { 12544 case 0: 12545 err = decoder.DecodeInt32(&result.Dirfd) 12546 if err != nil { 12547 return types.Openat2Args{}, err 12548 } 12549 case 1: 12550 result.Pathname, err = decoder.ReadStringFromBuff() 12551 if err != nil { 12552 return types.Openat2Args{}, err 12553 } 12554 case 2: 12555 var dataHow uint64 12556 err = decoder.DecodeUint64(&dataHow) 12557 if err != nil { 12558 return types.Openat2Args{}, err 12559 } 12560 result.How = uintptr(dataHow) 12561 case 3: 12562 err = decoder.DecodeUint64(&result.Size) 12563 if err != nil { 12564 return types.Openat2Args{}, err 12565 } 12566 } 12567 } 12568 return result, nil 12569 } 12570 12571 func ParsePidfdGetfdArgs(decoder *Decoder) (types.PidfdGetfdArgs, error) { 12572 var result types.PidfdGetfdArgs 12573 var err error 12574 12575 var numArgs uint8 12576 err = decoder.DecodeUint8(&numArgs) 12577 if err != nil { 12578 return types.PidfdGetfdArgs{}, err 12579 } 12580 12581 for arg := 0; arg < int(numArgs); arg++ { 12582 var currArg uint8 12583 err = decoder.DecodeUint8(&currArg) 12584 if err != nil { 12585 return types.PidfdGetfdArgs{}, err 12586 } 12587 12588 switch currArg { 12589 case 0: 12590 err = decoder.DecodeInt32(&result.Pidfd) 12591 if err != nil { 12592 return types.PidfdGetfdArgs{}, err 12593 } 12594 case 1: 12595 err = decoder.DecodeInt32(&result.Targetfd) 12596 if err != nil { 12597 return types.PidfdGetfdArgs{}, err 12598 } 12599 case 2: 12600 err = decoder.DecodeUint32(&result.Flags) 12601 if err != nil { 12602 return types.PidfdGetfdArgs{}, err 12603 } 12604 } 12605 } 12606 return result, nil 12607 } 12608 12609 func ParseFaccessat2Args(decoder *Decoder) (types.Faccessat2Args, error) { 12610 var result types.Faccessat2Args 12611 var err error 12612 12613 var numArgs uint8 12614 err = decoder.DecodeUint8(&numArgs) 12615 if err != nil { 12616 return types.Faccessat2Args{}, err 12617 } 12618 12619 for arg := 0; arg < int(numArgs); arg++ { 12620 var currArg uint8 12621 err = decoder.DecodeUint8(&currArg) 12622 if err != nil { 12623 return types.Faccessat2Args{}, err 12624 } 12625 12626 switch currArg { 12627 case 0: 12628 err = decoder.DecodeInt32(&result.Fd) 12629 if err != nil { 12630 return types.Faccessat2Args{}, err 12631 } 12632 case 1: 12633 result.Path, err = decoder.ReadStringFromBuff() 12634 if err != nil { 12635 return types.Faccessat2Args{}, err 12636 } 12637 case 2: 12638 err = decoder.DecodeInt32(&result.Mode) 12639 if err != nil { 12640 return types.Faccessat2Args{}, err 12641 } 12642 case 3: 12643 err = decoder.DecodeInt32(&result.Flag) 12644 if err != nil { 12645 return types.Faccessat2Args{}, err 12646 } 12647 } 12648 } 12649 return result, nil 12650 } 12651 12652 func ParseProcessMadviseArgs(decoder *Decoder) (types.ProcessMadviseArgs, error) { 12653 var result types.ProcessMadviseArgs 12654 var err error 12655 12656 var numArgs uint8 12657 err = decoder.DecodeUint8(&numArgs) 12658 if err != nil { 12659 return types.ProcessMadviseArgs{}, err 12660 } 12661 12662 for arg := 0; arg < int(numArgs); arg++ { 12663 var currArg uint8 12664 err = decoder.DecodeUint8(&currArg) 12665 if err != nil { 12666 return types.ProcessMadviseArgs{}, err 12667 } 12668 12669 switch currArg { 12670 case 0: 12671 err = decoder.DecodeInt32(&result.Pidfd) 12672 if err != nil { 12673 return types.ProcessMadviseArgs{}, err 12674 } 12675 case 1: 12676 var dataAddr uint64 12677 err = decoder.DecodeUint64(&dataAddr) 12678 if err != nil { 12679 return types.ProcessMadviseArgs{}, err 12680 } 12681 result.Addr = uintptr(dataAddr) 12682 case 2: 12683 err = decoder.DecodeUint64(&result.Length) 12684 if err != nil { 12685 return types.ProcessMadviseArgs{}, err 12686 } 12687 case 3: 12688 err = decoder.DecodeInt32(&result.Advice) 12689 if err != nil { 12690 return types.ProcessMadviseArgs{}, err 12691 } 12692 case 4: 12693 err = decoder.DecodeUint64(&result.Flags) 12694 if err != nil { 12695 return types.ProcessMadviseArgs{}, err 12696 } 12697 } 12698 } 12699 return result, nil 12700 } 12701 12702 func ParseEpollPwait2Args(decoder *Decoder) (types.EpollPwait2Args, error) { 12703 var result types.EpollPwait2Args 12704 var err error 12705 12706 var numArgs uint8 12707 err = decoder.DecodeUint8(&numArgs) 12708 if err != nil { 12709 return types.EpollPwait2Args{}, err 12710 } 12711 12712 for arg := 0; arg < int(numArgs); arg++ { 12713 var currArg uint8 12714 err = decoder.DecodeUint8(&currArg) 12715 if err != nil { 12716 return types.EpollPwait2Args{}, err 12717 } 12718 12719 switch currArg { 12720 case 0: 12721 err = decoder.DecodeInt32(&result.Fd) 12722 if err != nil { 12723 return types.EpollPwait2Args{}, err 12724 } 12725 case 1: 12726 var dataEvents uint64 12727 err = decoder.DecodeUint64(&dataEvents) 12728 if err != nil { 12729 return types.EpollPwait2Args{}, err 12730 } 12731 result.Events = uintptr(dataEvents) 12732 case 2: 12733 err = decoder.DecodeInt32(&result.Maxevents) 12734 if err != nil { 12735 return types.EpollPwait2Args{}, err 12736 } 12737 case 3: 12738 result.Timeout, err = decoder.ReadTimespec() 12739 if err != nil { 12740 return types.EpollPwait2Args{}, err 12741 } 12742 case 4: 12743 var dataSigset uint64 12744 err = decoder.DecodeUint64(&dataSigset) 12745 if err != nil { 12746 return types.EpollPwait2Args{}, err 12747 } 12748 result.Sigset = uintptr(dataSigset) 12749 } 12750 } 12751 return result, nil 12752 } 12753 12754 func ParseMountSetattArgs(decoder *Decoder) (types.MountSetattArgs, error) { 12755 var result types.MountSetattArgs 12756 var err error 12757 12758 var numArgs uint8 12759 err = decoder.DecodeUint8(&numArgs) 12760 if err != nil { 12761 return types.MountSetattArgs{}, err 12762 } 12763 12764 for arg := 0; arg < int(numArgs); arg++ { 12765 var currArg uint8 12766 err = decoder.DecodeUint8(&currArg) 12767 if err != nil { 12768 return types.MountSetattArgs{}, err 12769 } 12770 12771 switch currArg { 12772 case 0: 12773 err = decoder.DecodeInt32(&result.Dfd) 12774 if err != nil { 12775 return types.MountSetattArgs{}, err 12776 } 12777 case 1: 12778 result.Path, err = decoder.ReadStringFromBuff() 12779 if err != nil { 12780 return types.MountSetattArgs{}, err 12781 } 12782 case 2: 12783 err = decoder.DecodeUint32(&result.Flags) 12784 if err != nil { 12785 return types.MountSetattArgs{}, err 12786 } 12787 case 3: 12788 var dataUattr uint64 12789 err = decoder.DecodeUint64(&dataUattr) 12790 if err != nil { 12791 return types.MountSetattArgs{}, err 12792 } 12793 result.Uattr = uintptr(dataUattr) 12794 case 4: 12795 err = decoder.DecodeUint64(&result.Usize) 12796 if err != nil { 12797 return types.MountSetattArgs{}, err 12798 } 12799 } 12800 } 12801 return result, nil 12802 } 12803 12804 func ParseQuotactlFdArgs(decoder *Decoder) (types.QuotactlFdArgs, error) { 12805 var result types.QuotactlFdArgs 12806 var err error 12807 12808 var numArgs uint8 12809 err = decoder.DecodeUint8(&numArgs) 12810 if err != nil { 12811 return types.QuotactlFdArgs{}, err 12812 } 12813 12814 for arg := 0; arg < int(numArgs); arg++ { 12815 var currArg uint8 12816 err = decoder.DecodeUint8(&currArg) 12817 if err != nil { 12818 return types.QuotactlFdArgs{}, err 12819 } 12820 12821 switch currArg { 12822 case 0: 12823 err = decoder.DecodeUint32(&result.Fd) 12824 if err != nil { 12825 return types.QuotactlFdArgs{}, err 12826 } 12827 case 1: 12828 err = decoder.DecodeUint32(&result.Cmd) 12829 if err != nil { 12830 return types.QuotactlFdArgs{}, err 12831 } 12832 case 2: 12833 var dataId uint64 12834 err = decoder.DecodeUint64(&dataId) 12835 if err != nil { 12836 return types.QuotactlFdArgs{}, err 12837 } 12838 result.Id = uintptr(dataId) 12839 case 3: 12840 var dataAddr uint64 12841 err = decoder.DecodeUint64(&dataAddr) 12842 if err != nil { 12843 return types.QuotactlFdArgs{}, err 12844 } 12845 result.Addr = uintptr(dataAddr) 12846 } 12847 } 12848 return result, nil 12849 } 12850 12851 func ParseLandlockCreateRulesetArgs(decoder *Decoder) (types.LandlockCreateRulesetArgs, error) { 12852 var result types.LandlockCreateRulesetArgs 12853 var err error 12854 12855 var numArgs uint8 12856 err = decoder.DecodeUint8(&numArgs) 12857 if err != nil { 12858 return types.LandlockCreateRulesetArgs{}, err 12859 } 12860 12861 for arg := 0; arg < int(numArgs); arg++ { 12862 var currArg uint8 12863 err = decoder.DecodeUint8(&currArg) 12864 if err != nil { 12865 return types.LandlockCreateRulesetArgs{}, err 12866 } 12867 12868 switch currArg { 12869 case 0: 12870 var dataAttr uint64 12871 err = decoder.DecodeUint64(&dataAttr) 12872 if err != nil { 12873 return types.LandlockCreateRulesetArgs{}, err 12874 } 12875 result.Attr = uintptr(dataAttr) 12876 case 1: 12877 err = decoder.DecodeUint64(&result.Size) 12878 if err != nil { 12879 return types.LandlockCreateRulesetArgs{}, err 12880 } 12881 case 2: 12882 err = decoder.DecodeUint32(&result.Flags) 12883 if err != nil { 12884 return types.LandlockCreateRulesetArgs{}, err 12885 } 12886 } 12887 } 12888 return result, nil 12889 } 12890 12891 func ParseLandlockAddRuleArgs(decoder *Decoder) (types.LandlockAddRuleArgs, error) { 12892 var result types.LandlockAddRuleArgs 12893 var err error 12894 12895 var numArgs uint8 12896 err = decoder.DecodeUint8(&numArgs) 12897 if err != nil { 12898 return types.LandlockAddRuleArgs{}, err 12899 } 12900 12901 for arg := 0; arg < int(numArgs); arg++ { 12902 var currArg uint8 12903 err = decoder.DecodeUint8(&currArg) 12904 if err != nil { 12905 return types.LandlockAddRuleArgs{}, err 12906 } 12907 12908 switch currArg { 12909 case 0: 12910 err = decoder.DecodeInt32(&result.RulesetFd) 12911 if err != nil { 12912 return types.LandlockAddRuleArgs{}, err 12913 } 12914 case 1: 12915 var dataRuleType uint64 12916 err = decoder.DecodeUint64(&dataRuleType) 12917 if err != nil { 12918 return types.LandlockAddRuleArgs{}, err 12919 } 12920 result.RuleType = uintptr(dataRuleType) 12921 case 2: 12922 var dataRuleAttr uint64 12923 err = decoder.DecodeUint64(&dataRuleAttr) 12924 if err != nil { 12925 return types.LandlockAddRuleArgs{}, err 12926 } 12927 result.RuleAttr = uintptr(dataRuleAttr) 12928 case 3: 12929 err = decoder.DecodeUint32(&result.Flags) 12930 if err != nil { 12931 return types.LandlockAddRuleArgs{}, err 12932 } 12933 } 12934 } 12935 return result, nil 12936 } 12937 12938 func ParseLandloclRestrictSetArgs(decoder *Decoder) (types.LandloclRestrictSetArgs, error) { 12939 var result types.LandloclRestrictSetArgs 12940 var err error 12941 12942 var numArgs uint8 12943 err = decoder.DecodeUint8(&numArgs) 12944 if err != nil { 12945 return types.LandloclRestrictSetArgs{}, err 12946 } 12947 12948 for arg := 0; arg < int(numArgs); arg++ { 12949 var currArg uint8 12950 err = decoder.DecodeUint8(&currArg) 12951 if err != nil { 12952 return types.LandloclRestrictSetArgs{}, err 12953 } 12954 12955 switch currArg { 12956 case 0: 12957 err = decoder.DecodeInt32(&result.RulesetFd) 12958 if err != nil { 12959 return types.LandloclRestrictSetArgs{}, err 12960 } 12961 case 1: 12962 err = decoder.DecodeUint32(&result.Flags) 12963 if err != nil { 12964 return types.LandloclRestrictSetArgs{}, err 12965 } 12966 } 12967 } 12968 return result, nil 12969 } 12970 12971 func ParseMemfdSecretArgs(decoder *Decoder) (types.MemfdSecretArgs, error) { 12972 var result types.MemfdSecretArgs 12973 var err error 12974 12975 var numArgs uint8 12976 err = decoder.DecodeUint8(&numArgs) 12977 if err != nil { 12978 return types.MemfdSecretArgs{}, err 12979 } 12980 12981 for arg := 0; arg < int(numArgs); arg++ { 12982 var currArg uint8 12983 err = decoder.DecodeUint8(&currArg) 12984 if err != nil { 12985 return types.MemfdSecretArgs{}, err 12986 } 12987 12988 switch currArg { 12989 case 0: 12990 err = decoder.DecodeUint32(&result.Flags) 12991 if err != nil { 12992 return types.MemfdSecretArgs{}, err 12993 } 12994 } 12995 } 12996 return result, nil 12997 } 12998 12999 func ParseProcessMreleaseArgs(decoder *Decoder) (types.ProcessMreleaseArgs, error) { 13000 var result types.ProcessMreleaseArgs 13001 var err error 13002 13003 var numArgs uint8 13004 err = decoder.DecodeUint8(&numArgs) 13005 if err != nil { 13006 return types.ProcessMreleaseArgs{}, err 13007 } 13008 13009 for arg := 0; arg < int(numArgs); arg++ { 13010 var currArg uint8 13011 err = decoder.DecodeUint8(&currArg) 13012 if err != nil { 13013 return types.ProcessMreleaseArgs{}, err 13014 } 13015 13016 switch currArg { 13017 case 0: 13018 err = decoder.DecodeInt32(&result.Pidfd) 13019 if err != nil { 13020 return types.ProcessMreleaseArgs{}, err 13021 } 13022 case 1: 13023 err = decoder.DecodeUint32(&result.Flags) 13024 if err != nil { 13025 return types.ProcessMreleaseArgs{}, err 13026 } 13027 } 13028 } 13029 return result, nil 13030 } 13031 13032 func ParseWaitpidArgs(decoder *Decoder) (types.WaitpidArgs, error) { 13033 var result types.WaitpidArgs 13034 var err error 13035 13036 var numArgs uint8 13037 err = decoder.DecodeUint8(&numArgs) 13038 if err != nil { 13039 return types.WaitpidArgs{}, err 13040 } 13041 13042 for arg := 0; arg < int(numArgs); arg++ { 13043 var currArg uint8 13044 err = decoder.DecodeUint8(&currArg) 13045 if err != nil { 13046 return types.WaitpidArgs{}, err 13047 } 13048 13049 switch currArg { 13050 case 0: 13051 err = decoder.DecodeInt32(&result.Pid) 13052 if err != nil { 13053 return types.WaitpidArgs{}, err 13054 } 13055 case 1: 13056 var dataStatus uint64 13057 err = decoder.DecodeUint64(&dataStatus) 13058 if err != nil { 13059 return types.WaitpidArgs{}, err 13060 } 13061 result.Status = uintptr(dataStatus) 13062 case 2: 13063 err = decoder.DecodeInt32(&result.Options) 13064 if err != nil { 13065 return types.WaitpidArgs{}, err 13066 } 13067 } 13068 } 13069 return result, nil 13070 } 13071 13072 func ParseOldfstatArgs(decoder *Decoder) (types.OldfstatArgs, error) { 13073 return types.OldfstatArgs{}, nil 13074 } 13075 13076 func ParseBreakArgs(decoder *Decoder) (types.BreakArgs, error) { 13077 return types.BreakArgs{}, nil 13078 } 13079 13080 func ParseOldstatArgs(decoder *Decoder) (types.OldstatArgs, error) { 13081 var result types.OldstatArgs 13082 var err error 13083 13084 var numArgs uint8 13085 err = decoder.DecodeUint8(&numArgs) 13086 if err != nil { 13087 return types.OldstatArgs{}, err 13088 } 13089 13090 for arg := 0; arg < int(numArgs); arg++ { 13091 var currArg uint8 13092 err = decoder.DecodeUint8(&currArg) 13093 if err != nil { 13094 return types.OldstatArgs{}, err 13095 } 13096 13097 switch currArg { 13098 case 0: 13099 result.Filename, err = decoder.ReadStringFromBuff() 13100 if err != nil { 13101 return types.OldstatArgs{}, err 13102 } 13103 case 1: 13104 var dataStatbuf uint64 13105 err = decoder.DecodeUint64(&dataStatbuf) 13106 if err != nil { 13107 return types.OldstatArgs{}, err 13108 } 13109 result.Statbuf = uintptr(dataStatbuf) 13110 } 13111 } 13112 return result, nil 13113 } 13114 13115 func ParseUmountArgs(decoder *Decoder) (types.UmountArgs, error) { 13116 var result types.UmountArgs 13117 var err error 13118 13119 var numArgs uint8 13120 err = decoder.DecodeUint8(&numArgs) 13121 if err != nil { 13122 return types.UmountArgs{}, err 13123 } 13124 13125 for arg := 0; arg < int(numArgs); arg++ { 13126 var currArg uint8 13127 err = decoder.DecodeUint8(&currArg) 13128 if err != nil { 13129 return types.UmountArgs{}, err 13130 } 13131 13132 switch currArg { 13133 case 0: 13134 result.Target, err = decoder.ReadStringFromBuff() 13135 if err != nil { 13136 return types.UmountArgs{}, err 13137 } 13138 } 13139 } 13140 return result, nil 13141 } 13142 13143 func ParseStimeArgs(decoder *Decoder) (types.StimeArgs, error) { 13144 var result types.StimeArgs 13145 var err error 13146 13147 var numArgs uint8 13148 err = decoder.DecodeUint8(&numArgs) 13149 if err != nil { 13150 return types.StimeArgs{}, err 13151 } 13152 13153 for arg := 0; arg < int(numArgs); arg++ { 13154 var currArg uint8 13155 err = decoder.DecodeUint8(&currArg) 13156 if err != nil { 13157 return types.StimeArgs{}, err 13158 } 13159 13160 switch currArg { 13161 case 0: 13162 var dataT uint64 13163 err = decoder.DecodeUint64(&dataT) 13164 if err != nil { 13165 return types.StimeArgs{}, err 13166 } 13167 result.T = uintptr(dataT) 13168 } 13169 } 13170 return result, nil 13171 } 13172 13173 func ParseSttyArgs(decoder *Decoder) (types.SttyArgs, error) { 13174 return types.SttyArgs{}, nil 13175 } 13176 13177 func ParseGttyArgs(decoder *Decoder) (types.GttyArgs, error) { 13178 return types.GttyArgs{}, nil 13179 } 13180 13181 func ParseNiceArgs(decoder *Decoder) (types.NiceArgs, error) { 13182 var result types.NiceArgs 13183 var err error 13184 13185 var numArgs uint8 13186 err = decoder.DecodeUint8(&numArgs) 13187 if err != nil { 13188 return types.NiceArgs{}, err 13189 } 13190 13191 for arg := 0; arg < int(numArgs); arg++ { 13192 var currArg uint8 13193 err = decoder.DecodeUint8(&currArg) 13194 if err != nil { 13195 return types.NiceArgs{}, err 13196 } 13197 13198 switch currArg { 13199 case 0: 13200 err = decoder.DecodeInt32(&result.Inc) 13201 if err != nil { 13202 return types.NiceArgs{}, err 13203 } 13204 } 13205 } 13206 return result, nil 13207 } 13208 13209 func ParseFtimeArgs(decoder *Decoder) (types.FtimeArgs, error) { 13210 return types.FtimeArgs{}, nil 13211 } 13212 13213 func ParseProfArgs(decoder *Decoder) (types.ProfArgs, error) { 13214 return types.ProfArgs{}, nil 13215 } 13216 13217 func ParseSignalArgs(decoder *Decoder) (types.SignalArgs, error) { 13218 var result types.SignalArgs 13219 var err error 13220 13221 var numArgs uint8 13222 err = decoder.DecodeUint8(&numArgs) 13223 if err != nil { 13224 return types.SignalArgs{}, err 13225 } 13226 13227 for arg := 0; arg < int(numArgs); arg++ { 13228 var currArg uint8 13229 err = decoder.DecodeUint8(&currArg) 13230 if err != nil { 13231 return types.SignalArgs{}, err 13232 } 13233 13234 switch currArg { 13235 case 0: 13236 err = decoder.DecodeInt32(&result.Signum) 13237 if err != nil { 13238 return types.SignalArgs{}, err 13239 } 13240 case 1: 13241 var dataHandler uint64 13242 err = decoder.DecodeUint64(&dataHandler) 13243 if err != nil { 13244 return types.SignalArgs{}, err 13245 } 13246 result.Handler = uintptr(dataHandler) 13247 } 13248 } 13249 return result, nil 13250 } 13251 13252 func ParseLockArgs(decoder *Decoder) (types.LockArgs, error) { 13253 return types.LockArgs{}, nil 13254 } 13255 13256 func ParseMpxArgs(decoder *Decoder) (types.MpxArgs, error) { 13257 return types.MpxArgs{}, nil 13258 } 13259 13260 func ParseUlimitArgs(decoder *Decoder) (types.UlimitArgs, error) { 13261 return types.UlimitArgs{}, nil 13262 } 13263 13264 func ParseOldoldunameArgs(decoder *Decoder) (types.OldoldunameArgs, error) { 13265 var result types.OldoldunameArgs 13266 var err error 13267 13268 var numArgs uint8 13269 err = decoder.DecodeUint8(&numArgs) 13270 if err != nil { 13271 return types.OldoldunameArgs{}, err 13272 } 13273 13274 for arg := 0; arg < int(numArgs); arg++ { 13275 var currArg uint8 13276 err = decoder.DecodeUint8(&currArg) 13277 if err != nil { 13278 return types.OldoldunameArgs{}, err 13279 } 13280 13281 switch currArg { 13282 case 0: 13283 var dataName uint64 13284 err = decoder.DecodeUint64(&dataName) 13285 if err != nil { 13286 return types.OldoldunameArgs{}, err 13287 } 13288 result.Name = uintptr(dataName) 13289 } 13290 } 13291 return result, nil 13292 } 13293 13294 func ParseSigactionArgs(decoder *Decoder) (types.SigactionArgs, error) { 13295 var result types.SigactionArgs 13296 var err error 13297 13298 var numArgs uint8 13299 err = decoder.DecodeUint8(&numArgs) 13300 if err != nil { 13301 return types.SigactionArgs{}, err 13302 } 13303 13304 for arg := 0; arg < int(numArgs); arg++ { 13305 var currArg uint8 13306 err = decoder.DecodeUint8(&currArg) 13307 if err != nil { 13308 return types.SigactionArgs{}, err 13309 } 13310 13311 switch currArg { 13312 case 0: 13313 err = decoder.DecodeInt32(&result.Sig) 13314 if err != nil { 13315 return types.SigactionArgs{}, err 13316 } 13317 case 1: 13318 var dataAct uint64 13319 err = decoder.DecodeUint64(&dataAct) 13320 if err != nil { 13321 return types.SigactionArgs{}, err 13322 } 13323 result.Act = uintptr(dataAct) 13324 case 2: 13325 var dataOact uint64 13326 err = decoder.DecodeUint64(&dataOact) 13327 if err != nil { 13328 return types.SigactionArgs{}, err 13329 } 13330 result.Oact = uintptr(dataOact) 13331 } 13332 } 13333 return result, nil 13334 } 13335 13336 func ParseSgetmaskArgs(decoder *Decoder) (types.SgetmaskArgs, error) { 13337 return types.SgetmaskArgs{}, nil 13338 } 13339 13340 func ParseSsetmaskArgs(decoder *Decoder) (types.SsetmaskArgs, error) { 13341 var result types.SsetmaskArgs 13342 var err error 13343 13344 var numArgs uint8 13345 err = decoder.DecodeUint8(&numArgs) 13346 if err != nil { 13347 return types.SsetmaskArgs{}, err 13348 } 13349 13350 for arg := 0; arg < int(numArgs); arg++ { 13351 var currArg uint8 13352 err = decoder.DecodeUint8(&currArg) 13353 if err != nil { 13354 return types.SsetmaskArgs{}, err 13355 } 13356 13357 switch currArg { 13358 case 0: 13359 err = decoder.DecodeInt64(&result.Newmask) 13360 if err != nil { 13361 return types.SsetmaskArgs{}, err 13362 } 13363 } 13364 } 13365 return result, nil 13366 } 13367 13368 func ParseSigsuspendArgs(decoder *Decoder) (types.SigsuspendArgs, error) { 13369 var result types.SigsuspendArgs 13370 var err error 13371 13372 var numArgs uint8 13373 err = decoder.DecodeUint8(&numArgs) 13374 if err != nil { 13375 return types.SigsuspendArgs{}, err 13376 } 13377 13378 for arg := 0; arg < int(numArgs); arg++ { 13379 var currArg uint8 13380 err = decoder.DecodeUint8(&currArg) 13381 if err != nil { 13382 return types.SigsuspendArgs{}, err 13383 } 13384 13385 switch currArg { 13386 case 0: 13387 var dataMask uint64 13388 err = decoder.DecodeUint64(&dataMask) 13389 if err != nil { 13390 return types.SigsuspendArgs{}, err 13391 } 13392 result.Mask = uintptr(dataMask) 13393 } 13394 } 13395 return result, nil 13396 } 13397 13398 func ParseSigpendingArgs(decoder *Decoder) (types.SigpendingArgs, error) { 13399 var result types.SigpendingArgs 13400 var err error 13401 13402 var numArgs uint8 13403 err = decoder.DecodeUint8(&numArgs) 13404 if err != nil { 13405 return types.SigpendingArgs{}, err 13406 } 13407 13408 for arg := 0; arg < int(numArgs); arg++ { 13409 var currArg uint8 13410 err = decoder.DecodeUint8(&currArg) 13411 if err != nil { 13412 return types.SigpendingArgs{}, err 13413 } 13414 13415 switch currArg { 13416 case 0: 13417 var dataSet uint64 13418 err = decoder.DecodeUint64(&dataSet) 13419 if err != nil { 13420 return types.SigpendingArgs{}, err 13421 } 13422 result.Set = uintptr(dataSet) 13423 } 13424 } 13425 return result, nil 13426 } 13427 13428 func ParseOldlstatArgs(decoder *Decoder) (types.OldlstatArgs, error) { 13429 var result types.OldlstatArgs 13430 var err error 13431 13432 var numArgs uint8 13433 err = decoder.DecodeUint8(&numArgs) 13434 if err != nil { 13435 return types.OldlstatArgs{}, err 13436 } 13437 13438 for arg := 0; arg < int(numArgs); arg++ { 13439 var currArg uint8 13440 err = decoder.DecodeUint8(&currArg) 13441 if err != nil { 13442 return types.OldlstatArgs{}, err 13443 } 13444 13445 switch currArg { 13446 case 0: 13447 result.Pathname, err = decoder.ReadStringFromBuff() 13448 if err != nil { 13449 return types.OldlstatArgs{}, err 13450 } 13451 case 1: 13452 var dataStatbuf uint64 13453 err = decoder.DecodeUint64(&dataStatbuf) 13454 if err != nil { 13455 return types.OldlstatArgs{}, err 13456 } 13457 result.Statbuf = uintptr(dataStatbuf) 13458 } 13459 } 13460 return result, nil 13461 } 13462 13463 func ParseReaddirArgs(decoder *Decoder) (types.ReaddirArgs, error) { 13464 var result types.ReaddirArgs 13465 var err error 13466 13467 var numArgs uint8 13468 err = decoder.DecodeUint8(&numArgs) 13469 if err != nil { 13470 return types.ReaddirArgs{}, err 13471 } 13472 13473 for arg := 0; arg < int(numArgs); arg++ { 13474 var currArg uint8 13475 err = decoder.DecodeUint8(&currArg) 13476 if err != nil { 13477 return types.ReaddirArgs{}, err 13478 } 13479 13480 switch currArg { 13481 case 0: 13482 err = decoder.DecodeUint32(&result.Fd) 13483 if err != nil { 13484 return types.ReaddirArgs{}, err 13485 } 13486 case 1: 13487 var dataDirp uint64 13488 err = decoder.DecodeUint64(&dataDirp) 13489 if err != nil { 13490 return types.ReaddirArgs{}, err 13491 } 13492 result.Dirp = uintptr(dataDirp) 13493 case 2: 13494 err = decoder.DecodeUint32(&result.Count) 13495 if err != nil { 13496 return types.ReaddirArgs{}, err 13497 } 13498 } 13499 } 13500 return result, nil 13501 } 13502 13503 func ParseProfilArgs(decoder *Decoder) (types.ProfilArgs, error) { 13504 return types.ProfilArgs{}, nil 13505 } 13506 13507 func ParseSocketcallArgs(decoder *Decoder) (types.SocketcallArgs, error) { 13508 var result types.SocketcallArgs 13509 var err error 13510 13511 var numArgs uint8 13512 err = decoder.DecodeUint8(&numArgs) 13513 if err != nil { 13514 return types.SocketcallArgs{}, err 13515 } 13516 13517 for arg := 0; arg < int(numArgs); arg++ { 13518 var currArg uint8 13519 err = decoder.DecodeUint8(&currArg) 13520 if err != nil { 13521 return types.SocketcallArgs{}, err 13522 } 13523 13524 switch currArg { 13525 case 0: 13526 err = decoder.DecodeInt32(&result.Call) 13527 if err != nil { 13528 return types.SocketcallArgs{}, err 13529 } 13530 case 1: 13531 var dataArgs uint64 13532 err = decoder.DecodeUint64(&dataArgs) 13533 if err != nil { 13534 return types.SocketcallArgs{}, err 13535 } 13536 result.Args = uintptr(dataArgs) 13537 } 13538 } 13539 return result, nil 13540 } 13541 13542 func ParseOldunameArgs(decoder *Decoder) (types.OldunameArgs, error) { 13543 var result types.OldunameArgs 13544 var err error 13545 13546 var numArgs uint8 13547 err = decoder.DecodeUint8(&numArgs) 13548 if err != nil { 13549 return types.OldunameArgs{}, err 13550 } 13551 13552 for arg := 0; arg < int(numArgs); arg++ { 13553 var currArg uint8 13554 err = decoder.DecodeUint8(&currArg) 13555 if err != nil { 13556 return types.OldunameArgs{}, err 13557 } 13558 13559 switch currArg { 13560 case 0: 13561 var dataBuf uint64 13562 err = decoder.DecodeUint64(&dataBuf) 13563 if err != nil { 13564 return types.OldunameArgs{}, err 13565 } 13566 result.Buf = uintptr(dataBuf) 13567 } 13568 } 13569 return result, nil 13570 } 13571 13572 func ParseIdleArgs(decoder *Decoder) (types.IdleArgs, error) { 13573 return types.IdleArgs{}, nil 13574 } 13575 13576 func ParseVm86oldArgs(decoder *Decoder) (types.Vm86oldArgs, error) { 13577 var result types.Vm86oldArgs 13578 var err error 13579 13580 var numArgs uint8 13581 err = decoder.DecodeUint8(&numArgs) 13582 if err != nil { 13583 return types.Vm86oldArgs{}, err 13584 } 13585 13586 for arg := 0; arg < int(numArgs); arg++ { 13587 var currArg uint8 13588 err = decoder.DecodeUint8(&currArg) 13589 if err != nil { 13590 return types.Vm86oldArgs{}, err 13591 } 13592 13593 switch currArg { 13594 case 0: 13595 var dataInfo uint64 13596 err = decoder.DecodeUint64(&dataInfo) 13597 if err != nil { 13598 return types.Vm86oldArgs{}, err 13599 } 13600 result.Info = uintptr(dataInfo) 13601 } 13602 } 13603 return result, nil 13604 } 13605 13606 func ParseIpcArgs(decoder *Decoder) (types.IpcArgs, error) { 13607 var result types.IpcArgs 13608 var err error 13609 13610 var numArgs uint8 13611 err = decoder.DecodeUint8(&numArgs) 13612 if err != nil { 13613 return types.IpcArgs{}, err 13614 } 13615 13616 for arg := 0; arg < int(numArgs); arg++ { 13617 var currArg uint8 13618 err = decoder.DecodeUint8(&currArg) 13619 if err != nil { 13620 return types.IpcArgs{}, err 13621 } 13622 13623 switch currArg { 13624 case 0: 13625 err = decoder.DecodeUint32(&result.Call) 13626 if err != nil { 13627 return types.IpcArgs{}, err 13628 } 13629 case 1: 13630 err = decoder.DecodeInt32(&result.First) 13631 if err != nil { 13632 return types.IpcArgs{}, err 13633 } 13634 case 2: 13635 err = decoder.DecodeUint64(&result.Second) 13636 if err != nil { 13637 return types.IpcArgs{}, err 13638 } 13639 case 3: 13640 err = decoder.DecodeUint64(&result.Third) 13641 if err != nil { 13642 return types.IpcArgs{}, err 13643 } 13644 case 4: 13645 var dataPtr uint64 13646 err = decoder.DecodeUint64(&dataPtr) 13647 if err != nil { 13648 return types.IpcArgs{}, err 13649 } 13650 result.Ptr = uintptr(dataPtr) 13651 case 5: 13652 err = decoder.DecodeInt64(&result.Fifth) 13653 if err != nil { 13654 return types.IpcArgs{}, err 13655 } 13656 } 13657 } 13658 return result, nil 13659 } 13660 13661 func ParseSigreturnArgs(decoder *Decoder) (types.SigreturnArgs, error) { 13662 return types.SigreturnArgs{}, nil 13663 } 13664 13665 func ParseSigprocmaskArgs(decoder *Decoder) (types.SigprocmaskArgs, error) { 13666 var result types.SigprocmaskArgs 13667 var err error 13668 13669 var numArgs uint8 13670 err = decoder.DecodeUint8(&numArgs) 13671 if err != nil { 13672 return types.SigprocmaskArgs{}, err 13673 } 13674 13675 for arg := 0; arg < int(numArgs); arg++ { 13676 var currArg uint8 13677 err = decoder.DecodeUint8(&currArg) 13678 if err != nil { 13679 return types.SigprocmaskArgs{}, err 13680 } 13681 13682 switch currArg { 13683 case 0: 13684 err = decoder.DecodeInt32(&result.How) 13685 if err != nil { 13686 return types.SigprocmaskArgs{}, err 13687 } 13688 case 1: 13689 var dataSet uint64 13690 err = decoder.DecodeUint64(&dataSet) 13691 if err != nil { 13692 return types.SigprocmaskArgs{}, err 13693 } 13694 result.Set = uintptr(dataSet) 13695 case 2: 13696 var dataOldset uint64 13697 err = decoder.DecodeUint64(&dataOldset) 13698 if err != nil { 13699 return types.SigprocmaskArgs{}, err 13700 } 13701 result.Oldset = uintptr(dataOldset) 13702 } 13703 } 13704 return result, nil 13705 } 13706 13707 func ParseBdflushArgs(decoder *Decoder) (types.BdflushArgs, error) { 13708 return types.BdflushArgs{}, nil 13709 } 13710 13711 func ParseAfs_syscallArgs(decoder *Decoder) (types.Afs_syscallArgs, error) { 13712 return types.Afs_syscallArgs{}, nil 13713 } 13714 13715 func ParseLlseekArgs(decoder *Decoder) (types.LlseekArgs, error) { 13716 var result types.LlseekArgs 13717 var err error 13718 13719 var numArgs uint8 13720 err = decoder.DecodeUint8(&numArgs) 13721 if err != nil { 13722 return types.LlseekArgs{}, err 13723 } 13724 13725 for arg := 0; arg < int(numArgs); arg++ { 13726 var currArg uint8 13727 err = decoder.DecodeUint8(&currArg) 13728 if err != nil { 13729 return types.LlseekArgs{}, err 13730 } 13731 13732 switch currArg { 13733 case 0: 13734 err = decoder.DecodeUint32(&result.Fd) 13735 if err != nil { 13736 return types.LlseekArgs{}, err 13737 } 13738 case 1: 13739 err = decoder.DecodeUint64(&result.OffsetHigh) 13740 if err != nil { 13741 return types.LlseekArgs{}, err 13742 } 13743 case 2: 13744 err = decoder.DecodeUint64(&result.OffsetLow) 13745 if err != nil { 13746 return types.LlseekArgs{}, err 13747 } 13748 case 3: 13749 var dataResult uint64 13750 err = decoder.DecodeUint64(&dataResult) 13751 if err != nil { 13752 return types.LlseekArgs{}, err 13753 } 13754 result.Result = uintptr(dataResult) 13755 case 4: 13756 err = decoder.DecodeUint32(&result.Whence) 13757 if err != nil { 13758 return types.LlseekArgs{}, err 13759 } 13760 } 13761 } 13762 return result, nil 13763 } 13764 13765 func ParseOldSelectArgs(decoder *Decoder) (types.OldSelectArgs, error) { 13766 var result types.OldSelectArgs 13767 var err error 13768 13769 var numArgs uint8 13770 err = decoder.DecodeUint8(&numArgs) 13771 if err != nil { 13772 return types.OldSelectArgs{}, err 13773 } 13774 13775 for arg := 0; arg < int(numArgs); arg++ { 13776 var currArg uint8 13777 err = decoder.DecodeUint8(&currArg) 13778 if err != nil { 13779 return types.OldSelectArgs{}, err 13780 } 13781 13782 switch currArg { 13783 case 0: 13784 err = decoder.DecodeInt32(&result.Nfds) 13785 if err != nil { 13786 return types.OldSelectArgs{}, err 13787 } 13788 case 1: 13789 var dataReadfds uint64 13790 err = decoder.DecodeUint64(&dataReadfds) 13791 if err != nil { 13792 return types.OldSelectArgs{}, err 13793 } 13794 result.Readfds = uintptr(dataReadfds) 13795 case 2: 13796 var dataWritefds uint64 13797 err = decoder.DecodeUint64(&dataWritefds) 13798 if err != nil { 13799 return types.OldSelectArgs{}, err 13800 } 13801 result.Writefds = uintptr(dataWritefds) 13802 case 3: 13803 var dataExceptfds uint64 13804 err = decoder.DecodeUint64(&dataExceptfds) 13805 if err != nil { 13806 return types.OldSelectArgs{}, err 13807 } 13808 result.Exceptfds = uintptr(dataExceptfds) 13809 case 4: 13810 var dataTimeout uint64 13811 err = decoder.DecodeUint64(&dataTimeout) 13812 if err != nil { 13813 return types.OldSelectArgs{}, err 13814 } 13815 result.Timeout = uintptr(dataTimeout) 13816 } 13817 } 13818 return result, nil 13819 } 13820 13821 func ParseVm86Args(decoder *Decoder) (types.Vm86Args, error) { 13822 var result types.Vm86Args 13823 var err error 13824 13825 var numArgs uint8 13826 err = decoder.DecodeUint8(&numArgs) 13827 if err != nil { 13828 return types.Vm86Args{}, err 13829 } 13830 13831 for arg := 0; arg < int(numArgs); arg++ { 13832 var currArg uint8 13833 err = decoder.DecodeUint8(&currArg) 13834 if err != nil { 13835 return types.Vm86Args{}, err 13836 } 13837 13838 switch currArg { 13839 case 0: 13840 err = decoder.DecodeUint64(&result.Fn) 13841 if err != nil { 13842 return types.Vm86Args{}, err 13843 } 13844 case 1: 13845 var dataV86 uint64 13846 err = decoder.DecodeUint64(&dataV86) 13847 if err != nil { 13848 return types.Vm86Args{}, err 13849 } 13850 result.V86 = uintptr(dataV86) 13851 } 13852 } 13853 return result, nil 13854 } 13855 13856 func ParseOldGetrlimitArgs(decoder *Decoder) (types.OldGetrlimitArgs, error) { 13857 var result types.OldGetrlimitArgs 13858 var err error 13859 13860 var numArgs uint8 13861 err = decoder.DecodeUint8(&numArgs) 13862 if err != nil { 13863 return types.OldGetrlimitArgs{}, err 13864 } 13865 13866 for arg := 0; arg < int(numArgs); arg++ { 13867 var currArg uint8 13868 err = decoder.DecodeUint8(&currArg) 13869 if err != nil { 13870 return types.OldGetrlimitArgs{}, err 13871 } 13872 13873 switch currArg { 13874 case 0: 13875 err = decoder.DecodeInt32(&result.Resource) 13876 if err != nil { 13877 return types.OldGetrlimitArgs{}, err 13878 } 13879 case 1: 13880 var dataRlim uint64 13881 err = decoder.DecodeUint64(&dataRlim) 13882 if err != nil { 13883 return types.OldGetrlimitArgs{}, err 13884 } 13885 result.Rlim = uintptr(dataRlim) 13886 } 13887 } 13888 return result, nil 13889 } 13890 13891 func ParseMmap2Args(decoder *Decoder) (types.Mmap2Args, error) { 13892 var result types.Mmap2Args 13893 var err error 13894 13895 var numArgs uint8 13896 err = decoder.DecodeUint8(&numArgs) 13897 if err != nil { 13898 return types.Mmap2Args{}, err 13899 } 13900 13901 for arg := 0; arg < int(numArgs); arg++ { 13902 var currArg uint8 13903 err = decoder.DecodeUint8(&currArg) 13904 if err != nil { 13905 return types.Mmap2Args{}, err 13906 } 13907 13908 switch currArg { 13909 case 0: 13910 err = decoder.DecodeUint64(&result.Addr) 13911 if err != nil { 13912 return types.Mmap2Args{}, err 13913 } 13914 case 1: 13915 err = decoder.DecodeUint64(&result.Length) 13916 if err != nil { 13917 return types.Mmap2Args{}, err 13918 } 13919 case 2: 13920 err = decoder.DecodeUint64(&result.Prot) 13921 if err != nil { 13922 return types.Mmap2Args{}, err 13923 } 13924 case 3: 13925 err = decoder.DecodeUint64(&result.Flags) 13926 if err != nil { 13927 return types.Mmap2Args{}, err 13928 } 13929 case 4: 13930 err = decoder.DecodeUint64(&result.Fd) 13931 if err != nil { 13932 return types.Mmap2Args{}, err 13933 } 13934 case 5: 13935 err = decoder.DecodeUint64(&result.Pgoffset) 13936 if err != nil { 13937 return types.Mmap2Args{}, err 13938 } 13939 } 13940 } 13941 return result, nil 13942 } 13943 13944 func ParseTruncate64Args(decoder *Decoder) (types.Truncate64Args, error) { 13945 var result types.Truncate64Args 13946 var err error 13947 13948 var numArgs uint8 13949 err = decoder.DecodeUint8(&numArgs) 13950 if err != nil { 13951 return types.Truncate64Args{}, err 13952 } 13953 13954 for arg := 0; arg < int(numArgs); arg++ { 13955 var currArg uint8 13956 err = decoder.DecodeUint8(&currArg) 13957 if err != nil { 13958 return types.Truncate64Args{}, err 13959 } 13960 13961 switch currArg { 13962 case 0: 13963 result.Path, err = decoder.ReadStringFromBuff() 13964 if err != nil { 13965 return types.Truncate64Args{}, err 13966 } 13967 case 1: 13968 err = decoder.DecodeUint64(&result.Length) 13969 if err != nil { 13970 return types.Truncate64Args{}, err 13971 } 13972 } 13973 } 13974 return result, nil 13975 } 13976 13977 func ParseFtruncate64Args(decoder *Decoder) (types.Ftruncate64Args, error) { 13978 var result types.Ftruncate64Args 13979 var err error 13980 13981 var numArgs uint8 13982 err = decoder.DecodeUint8(&numArgs) 13983 if err != nil { 13984 return types.Ftruncate64Args{}, err 13985 } 13986 13987 for arg := 0; arg < int(numArgs); arg++ { 13988 var currArg uint8 13989 err = decoder.DecodeUint8(&currArg) 13990 if err != nil { 13991 return types.Ftruncate64Args{}, err 13992 } 13993 13994 switch currArg { 13995 case 0: 13996 err = decoder.DecodeInt32(&result.Fd) 13997 if err != nil { 13998 return types.Ftruncate64Args{}, err 13999 } 14000 case 1: 14001 err = decoder.DecodeUint64(&result.Length) 14002 if err != nil { 14003 return types.Ftruncate64Args{}, err 14004 } 14005 } 14006 } 14007 return result, nil 14008 } 14009 14010 func ParseStat64Args(decoder *Decoder) (types.Stat64Args, error) { 14011 var result types.Stat64Args 14012 var err error 14013 14014 var numArgs uint8 14015 err = decoder.DecodeUint8(&numArgs) 14016 if err != nil { 14017 return types.Stat64Args{}, err 14018 } 14019 14020 for arg := 0; arg < int(numArgs); arg++ { 14021 var currArg uint8 14022 err = decoder.DecodeUint8(&currArg) 14023 if err != nil { 14024 return types.Stat64Args{}, err 14025 } 14026 14027 switch currArg { 14028 case 0: 14029 result.Pathname, err = decoder.ReadStringFromBuff() 14030 if err != nil { 14031 return types.Stat64Args{}, err 14032 } 14033 case 1: 14034 var dataStatbuf uint64 14035 err = decoder.DecodeUint64(&dataStatbuf) 14036 if err != nil { 14037 return types.Stat64Args{}, err 14038 } 14039 result.Statbuf = uintptr(dataStatbuf) 14040 } 14041 } 14042 return result, nil 14043 } 14044 14045 func ParseLstat64Args(decoder *Decoder) (types.Lstat64Args, error) { 14046 var result types.Lstat64Args 14047 var err error 14048 14049 var numArgs uint8 14050 err = decoder.DecodeUint8(&numArgs) 14051 if err != nil { 14052 return types.Lstat64Args{}, err 14053 } 14054 14055 for arg := 0; arg < int(numArgs); arg++ { 14056 var currArg uint8 14057 err = decoder.DecodeUint8(&currArg) 14058 if err != nil { 14059 return types.Lstat64Args{}, err 14060 } 14061 14062 switch currArg { 14063 case 0: 14064 result.Pathname, err = decoder.ReadStringFromBuff() 14065 if err != nil { 14066 return types.Lstat64Args{}, err 14067 } 14068 case 1: 14069 var dataStatbuf uint64 14070 err = decoder.DecodeUint64(&dataStatbuf) 14071 if err != nil { 14072 return types.Lstat64Args{}, err 14073 } 14074 result.Statbuf = uintptr(dataStatbuf) 14075 } 14076 } 14077 return result, nil 14078 } 14079 14080 func ParseFstat64Args(decoder *Decoder) (types.Fstat64Args, error) { 14081 var result types.Fstat64Args 14082 var err error 14083 14084 var numArgs uint8 14085 err = decoder.DecodeUint8(&numArgs) 14086 if err != nil { 14087 return types.Fstat64Args{}, err 14088 } 14089 14090 for arg := 0; arg < int(numArgs); arg++ { 14091 var currArg uint8 14092 err = decoder.DecodeUint8(&currArg) 14093 if err != nil { 14094 return types.Fstat64Args{}, err 14095 } 14096 14097 switch currArg { 14098 case 0: 14099 err = decoder.DecodeInt32(&result.Fd) 14100 if err != nil { 14101 return types.Fstat64Args{}, err 14102 } 14103 case 1: 14104 var dataStatbuf uint64 14105 err = decoder.DecodeUint64(&dataStatbuf) 14106 if err != nil { 14107 return types.Fstat64Args{}, err 14108 } 14109 result.Statbuf = uintptr(dataStatbuf) 14110 } 14111 } 14112 return result, nil 14113 } 14114 14115 func ParseLchown16Args(decoder *Decoder) (types.Lchown16Args, error) { 14116 var result types.Lchown16Args 14117 var err error 14118 14119 var numArgs uint8 14120 err = decoder.DecodeUint8(&numArgs) 14121 if err != nil { 14122 return types.Lchown16Args{}, err 14123 } 14124 14125 for arg := 0; arg < int(numArgs); arg++ { 14126 var currArg uint8 14127 err = decoder.DecodeUint8(&currArg) 14128 if err != nil { 14129 return types.Lchown16Args{}, err 14130 } 14131 14132 switch currArg { 14133 case 0: 14134 result.Pathname, err = decoder.ReadStringFromBuff() 14135 if err != nil { 14136 return types.Lchown16Args{}, err 14137 } 14138 case 1: 14139 var dataOwner uint64 14140 err = decoder.DecodeUint64(&dataOwner) 14141 if err != nil { 14142 return types.Lchown16Args{}, err 14143 } 14144 result.Owner = uintptr(dataOwner) 14145 case 2: 14146 var dataGroup uint64 14147 err = decoder.DecodeUint64(&dataGroup) 14148 if err != nil { 14149 return types.Lchown16Args{}, err 14150 } 14151 result.Group = uintptr(dataGroup) 14152 } 14153 } 14154 return result, nil 14155 } 14156 14157 func ParseGetuid16Args(decoder *Decoder) (types.Getuid16Args, error) { 14158 return types.Getuid16Args{}, nil 14159 } 14160 14161 func ParseGetgid16Args(decoder *Decoder) (types.Getgid16Args, error) { 14162 return types.Getgid16Args{}, nil 14163 } 14164 14165 func ParseGeteuid16Args(decoder *Decoder) (types.Geteuid16Args, error) { 14166 return types.Geteuid16Args{}, nil 14167 } 14168 14169 func ParseGetegid16Args(decoder *Decoder) (types.Getegid16Args, error) { 14170 return types.Getegid16Args{}, nil 14171 } 14172 14173 func ParseSetreuid16Args(decoder *Decoder) (types.Setreuid16Args, error) { 14174 var result types.Setreuid16Args 14175 var err error 14176 14177 var numArgs uint8 14178 err = decoder.DecodeUint8(&numArgs) 14179 if err != nil { 14180 return types.Setreuid16Args{}, err 14181 } 14182 14183 for arg := 0; arg < int(numArgs); arg++ { 14184 var currArg uint8 14185 err = decoder.DecodeUint8(&currArg) 14186 if err != nil { 14187 return types.Setreuid16Args{}, err 14188 } 14189 14190 switch currArg { 14191 case 0: 14192 var dataRuid uint64 14193 err = decoder.DecodeUint64(&dataRuid) 14194 if err != nil { 14195 return types.Setreuid16Args{}, err 14196 } 14197 result.Ruid = uintptr(dataRuid) 14198 case 1: 14199 var dataEuid uint64 14200 err = decoder.DecodeUint64(&dataEuid) 14201 if err != nil { 14202 return types.Setreuid16Args{}, err 14203 } 14204 result.Euid = uintptr(dataEuid) 14205 } 14206 } 14207 return result, nil 14208 } 14209 14210 func ParseSetregid16Args(decoder *Decoder) (types.Setregid16Args, error) { 14211 var result types.Setregid16Args 14212 var err error 14213 14214 var numArgs uint8 14215 err = decoder.DecodeUint8(&numArgs) 14216 if err != nil { 14217 return types.Setregid16Args{}, err 14218 } 14219 14220 for arg := 0; arg < int(numArgs); arg++ { 14221 var currArg uint8 14222 err = decoder.DecodeUint8(&currArg) 14223 if err != nil { 14224 return types.Setregid16Args{}, err 14225 } 14226 14227 switch currArg { 14228 case 0: 14229 var dataRgid uint64 14230 err = decoder.DecodeUint64(&dataRgid) 14231 if err != nil { 14232 return types.Setregid16Args{}, err 14233 } 14234 result.Rgid = uintptr(dataRgid) 14235 case 1: 14236 var dataEgid uint64 14237 err = decoder.DecodeUint64(&dataEgid) 14238 if err != nil { 14239 return types.Setregid16Args{}, err 14240 } 14241 result.Egid = uintptr(dataEgid) 14242 } 14243 } 14244 return result, nil 14245 } 14246 14247 func ParseGetgroups16Args(decoder *Decoder) (types.Getgroups16Args, error) { 14248 var result types.Getgroups16Args 14249 var err error 14250 14251 var numArgs uint8 14252 err = decoder.DecodeUint8(&numArgs) 14253 if err != nil { 14254 return types.Getgroups16Args{}, err 14255 } 14256 14257 for arg := 0; arg < int(numArgs); arg++ { 14258 var currArg uint8 14259 err = decoder.DecodeUint8(&currArg) 14260 if err != nil { 14261 return types.Getgroups16Args{}, err 14262 } 14263 14264 switch currArg { 14265 case 0: 14266 err = decoder.DecodeInt32(&result.Size) 14267 if err != nil { 14268 return types.Getgroups16Args{}, err 14269 } 14270 case 1: 14271 var dataList uint64 14272 err = decoder.DecodeUint64(&dataList) 14273 if err != nil { 14274 return types.Getgroups16Args{}, err 14275 } 14276 result.List = uintptr(dataList) 14277 } 14278 } 14279 return result, nil 14280 } 14281 14282 func ParseSetgroups16Args(decoder *Decoder) (types.Setgroups16Args, error) { 14283 var result types.Setgroups16Args 14284 var err error 14285 14286 var numArgs uint8 14287 err = decoder.DecodeUint8(&numArgs) 14288 if err != nil { 14289 return types.Setgroups16Args{}, err 14290 } 14291 14292 for arg := 0; arg < int(numArgs); arg++ { 14293 var currArg uint8 14294 err = decoder.DecodeUint8(&currArg) 14295 if err != nil { 14296 return types.Setgroups16Args{}, err 14297 } 14298 14299 switch currArg { 14300 case 0: 14301 err = decoder.DecodeUint64(&result.Size) 14302 if err != nil { 14303 return types.Setgroups16Args{}, err 14304 } 14305 case 1: 14306 var dataList uint64 14307 err = decoder.DecodeUint64(&dataList) 14308 if err != nil { 14309 return types.Setgroups16Args{}, err 14310 } 14311 result.List = uintptr(dataList) 14312 } 14313 } 14314 return result, nil 14315 } 14316 14317 func ParseFchown16Args(decoder *Decoder) (types.Fchown16Args, error) { 14318 var result types.Fchown16Args 14319 var err error 14320 14321 var numArgs uint8 14322 err = decoder.DecodeUint8(&numArgs) 14323 if err != nil { 14324 return types.Fchown16Args{}, err 14325 } 14326 14327 for arg := 0; arg < int(numArgs); arg++ { 14328 var currArg uint8 14329 err = decoder.DecodeUint8(&currArg) 14330 if err != nil { 14331 return types.Fchown16Args{}, err 14332 } 14333 14334 switch currArg { 14335 case 0: 14336 err = decoder.DecodeUint32(&result.Fd) 14337 if err != nil { 14338 return types.Fchown16Args{}, err 14339 } 14340 case 1: 14341 var dataUser uint64 14342 err = decoder.DecodeUint64(&dataUser) 14343 if err != nil { 14344 return types.Fchown16Args{}, err 14345 } 14346 result.User = uintptr(dataUser) 14347 case 2: 14348 var dataGroup uint64 14349 err = decoder.DecodeUint64(&dataGroup) 14350 if err != nil { 14351 return types.Fchown16Args{}, err 14352 } 14353 result.Group = uintptr(dataGroup) 14354 } 14355 } 14356 return result, nil 14357 } 14358 14359 func ParseSetresuid16Args(decoder *Decoder) (types.Setresuid16Args, error) { 14360 var result types.Setresuid16Args 14361 var err error 14362 14363 var numArgs uint8 14364 err = decoder.DecodeUint8(&numArgs) 14365 if err != nil { 14366 return types.Setresuid16Args{}, err 14367 } 14368 14369 for arg := 0; arg < int(numArgs); arg++ { 14370 var currArg uint8 14371 err = decoder.DecodeUint8(&currArg) 14372 if err != nil { 14373 return types.Setresuid16Args{}, err 14374 } 14375 14376 switch currArg { 14377 case 0: 14378 var dataRuid uint64 14379 err = decoder.DecodeUint64(&dataRuid) 14380 if err != nil { 14381 return types.Setresuid16Args{}, err 14382 } 14383 result.Ruid = uintptr(dataRuid) 14384 case 1: 14385 var dataEuid uint64 14386 err = decoder.DecodeUint64(&dataEuid) 14387 if err != nil { 14388 return types.Setresuid16Args{}, err 14389 } 14390 result.Euid = uintptr(dataEuid) 14391 case 2: 14392 var dataSuid uint64 14393 err = decoder.DecodeUint64(&dataSuid) 14394 if err != nil { 14395 return types.Setresuid16Args{}, err 14396 } 14397 result.Suid = uintptr(dataSuid) 14398 } 14399 } 14400 return result, nil 14401 } 14402 14403 func ParseGetresuid16Args(decoder *Decoder) (types.Getresuid16Args, error) { 14404 var result types.Getresuid16Args 14405 var err error 14406 14407 var numArgs uint8 14408 err = decoder.DecodeUint8(&numArgs) 14409 if err != nil { 14410 return types.Getresuid16Args{}, err 14411 } 14412 14413 for arg := 0; arg < int(numArgs); arg++ { 14414 var currArg uint8 14415 err = decoder.DecodeUint8(&currArg) 14416 if err != nil { 14417 return types.Getresuid16Args{}, err 14418 } 14419 14420 switch currArg { 14421 case 0: 14422 var dataRuid uint64 14423 err = decoder.DecodeUint64(&dataRuid) 14424 if err != nil { 14425 return types.Getresuid16Args{}, err 14426 } 14427 result.Ruid = uintptr(dataRuid) 14428 case 1: 14429 var dataEuid uint64 14430 err = decoder.DecodeUint64(&dataEuid) 14431 if err != nil { 14432 return types.Getresuid16Args{}, err 14433 } 14434 result.Euid = uintptr(dataEuid) 14435 case 2: 14436 var dataSuid uint64 14437 err = decoder.DecodeUint64(&dataSuid) 14438 if err != nil { 14439 return types.Getresuid16Args{}, err 14440 } 14441 result.Suid = uintptr(dataSuid) 14442 } 14443 } 14444 return result, nil 14445 } 14446 14447 func ParseSetresgid16Args(decoder *Decoder) (types.Setresgid16Args, error) { 14448 var result types.Setresgid16Args 14449 var err error 14450 14451 var numArgs uint8 14452 err = decoder.DecodeUint8(&numArgs) 14453 if err != nil { 14454 return types.Setresgid16Args{}, err 14455 } 14456 14457 for arg := 0; arg < int(numArgs); arg++ { 14458 var currArg uint8 14459 err = decoder.DecodeUint8(&currArg) 14460 if err != nil { 14461 return types.Setresgid16Args{}, err 14462 } 14463 14464 switch currArg { 14465 case 0: 14466 var dataRgid uint64 14467 err = decoder.DecodeUint64(&dataRgid) 14468 if err != nil { 14469 return types.Setresgid16Args{}, err 14470 } 14471 result.Rgid = uintptr(dataRgid) 14472 case 1: 14473 var dataEuid uint64 14474 err = decoder.DecodeUint64(&dataEuid) 14475 if err != nil { 14476 return types.Setresgid16Args{}, err 14477 } 14478 result.Euid = uintptr(dataEuid) 14479 case 2: 14480 var dataSuid uint64 14481 err = decoder.DecodeUint64(&dataSuid) 14482 if err != nil { 14483 return types.Setresgid16Args{}, err 14484 } 14485 result.Suid = uintptr(dataSuid) 14486 } 14487 } 14488 return result, nil 14489 } 14490 14491 func ParseGetresgid16Args(decoder *Decoder) (types.Getresgid16Args, error) { 14492 var result types.Getresgid16Args 14493 var err error 14494 14495 var numArgs uint8 14496 err = decoder.DecodeUint8(&numArgs) 14497 if err != nil { 14498 return types.Getresgid16Args{}, err 14499 } 14500 14501 for arg := 0; arg < int(numArgs); arg++ { 14502 var currArg uint8 14503 err = decoder.DecodeUint8(&currArg) 14504 if err != nil { 14505 return types.Getresgid16Args{}, err 14506 } 14507 14508 switch currArg { 14509 case 0: 14510 var dataRgid uint64 14511 err = decoder.DecodeUint64(&dataRgid) 14512 if err != nil { 14513 return types.Getresgid16Args{}, err 14514 } 14515 result.Rgid = uintptr(dataRgid) 14516 case 1: 14517 var dataEgid uint64 14518 err = decoder.DecodeUint64(&dataEgid) 14519 if err != nil { 14520 return types.Getresgid16Args{}, err 14521 } 14522 result.Egid = uintptr(dataEgid) 14523 case 2: 14524 var dataSgid uint64 14525 err = decoder.DecodeUint64(&dataSgid) 14526 if err != nil { 14527 return types.Getresgid16Args{}, err 14528 } 14529 result.Sgid = uintptr(dataSgid) 14530 } 14531 } 14532 return result, nil 14533 } 14534 14535 func ParseChown16Args(decoder *Decoder) (types.Chown16Args, error) { 14536 var result types.Chown16Args 14537 var err error 14538 14539 var numArgs uint8 14540 err = decoder.DecodeUint8(&numArgs) 14541 if err != nil { 14542 return types.Chown16Args{}, err 14543 } 14544 14545 for arg := 0; arg < int(numArgs); arg++ { 14546 var currArg uint8 14547 err = decoder.DecodeUint8(&currArg) 14548 if err != nil { 14549 return types.Chown16Args{}, err 14550 } 14551 14552 switch currArg { 14553 case 0: 14554 result.Pathname, err = decoder.ReadStringFromBuff() 14555 if err != nil { 14556 return types.Chown16Args{}, err 14557 } 14558 case 1: 14559 var dataOwner uint64 14560 err = decoder.DecodeUint64(&dataOwner) 14561 if err != nil { 14562 return types.Chown16Args{}, err 14563 } 14564 result.Owner = uintptr(dataOwner) 14565 case 2: 14566 var dataGroup uint64 14567 err = decoder.DecodeUint64(&dataGroup) 14568 if err != nil { 14569 return types.Chown16Args{}, err 14570 } 14571 result.Group = uintptr(dataGroup) 14572 } 14573 } 14574 return result, nil 14575 } 14576 14577 func ParseSetuid16Args(decoder *Decoder) (types.Setuid16Args, error) { 14578 var result types.Setuid16Args 14579 var err error 14580 14581 var numArgs uint8 14582 err = decoder.DecodeUint8(&numArgs) 14583 if err != nil { 14584 return types.Setuid16Args{}, err 14585 } 14586 14587 for arg := 0; arg < int(numArgs); arg++ { 14588 var currArg uint8 14589 err = decoder.DecodeUint8(&currArg) 14590 if err != nil { 14591 return types.Setuid16Args{}, err 14592 } 14593 14594 switch currArg { 14595 case 0: 14596 var dataUid uint64 14597 err = decoder.DecodeUint64(&dataUid) 14598 if err != nil { 14599 return types.Setuid16Args{}, err 14600 } 14601 result.Uid = uintptr(dataUid) 14602 } 14603 } 14604 return result, nil 14605 } 14606 14607 func ParseSetgid16Args(decoder *Decoder) (types.Setgid16Args, error) { 14608 var result types.Setgid16Args 14609 var err error 14610 14611 var numArgs uint8 14612 err = decoder.DecodeUint8(&numArgs) 14613 if err != nil { 14614 return types.Setgid16Args{}, err 14615 } 14616 14617 for arg := 0; arg < int(numArgs); arg++ { 14618 var currArg uint8 14619 err = decoder.DecodeUint8(&currArg) 14620 if err != nil { 14621 return types.Setgid16Args{}, err 14622 } 14623 14624 switch currArg { 14625 case 0: 14626 var dataGid uint64 14627 err = decoder.DecodeUint64(&dataGid) 14628 if err != nil { 14629 return types.Setgid16Args{}, err 14630 } 14631 result.Gid = uintptr(dataGid) 14632 } 14633 } 14634 return result, nil 14635 } 14636 14637 func ParseSetfsuid16Args(decoder *Decoder) (types.Setfsuid16Args, error) { 14638 var result types.Setfsuid16Args 14639 var err error 14640 14641 var numArgs uint8 14642 err = decoder.DecodeUint8(&numArgs) 14643 if err != nil { 14644 return types.Setfsuid16Args{}, err 14645 } 14646 14647 for arg := 0; arg < int(numArgs); arg++ { 14648 var currArg uint8 14649 err = decoder.DecodeUint8(&currArg) 14650 if err != nil { 14651 return types.Setfsuid16Args{}, err 14652 } 14653 14654 switch currArg { 14655 case 0: 14656 var dataFsuid uint64 14657 err = decoder.DecodeUint64(&dataFsuid) 14658 if err != nil { 14659 return types.Setfsuid16Args{}, err 14660 } 14661 result.Fsuid = uintptr(dataFsuid) 14662 } 14663 } 14664 return result, nil 14665 } 14666 14667 func ParseSetfsgid16Args(decoder *Decoder) (types.Setfsgid16Args, error) { 14668 var result types.Setfsgid16Args 14669 var err error 14670 14671 var numArgs uint8 14672 err = decoder.DecodeUint8(&numArgs) 14673 if err != nil { 14674 return types.Setfsgid16Args{}, err 14675 } 14676 14677 for arg := 0; arg < int(numArgs); arg++ { 14678 var currArg uint8 14679 err = decoder.DecodeUint8(&currArg) 14680 if err != nil { 14681 return types.Setfsgid16Args{}, err 14682 } 14683 14684 switch currArg { 14685 case 0: 14686 var dataFsgid uint64 14687 err = decoder.DecodeUint64(&dataFsgid) 14688 if err != nil { 14689 return types.Setfsgid16Args{}, err 14690 } 14691 result.Fsgid = uintptr(dataFsgid) 14692 } 14693 } 14694 return result, nil 14695 } 14696 14697 func ParseFcntl64Args(decoder *Decoder) (types.Fcntl64Args, error) { 14698 var result types.Fcntl64Args 14699 var err error 14700 14701 var numArgs uint8 14702 err = decoder.DecodeUint8(&numArgs) 14703 if err != nil { 14704 return types.Fcntl64Args{}, err 14705 } 14706 14707 for arg := 0; arg < int(numArgs); arg++ { 14708 var currArg uint8 14709 err = decoder.DecodeUint8(&currArg) 14710 if err != nil { 14711 return types.Fcntl64Args{}, err 14712 } 14713 14714 switch currArg { 14715 case 0: 14716 err = decoder.DecodeInt32(&result.Fd) 14717 if err != nil { 14718 return types.Fcntl64Args{}, err 14719 } 14720 case 1: 14721 err = decoder.DecodeInt32(&result.Cmd) 14722 if err != nil { 14723 return types.Fcntl64Args{}, err 14724 } 14725 case 2: 14726 err = decoder.DecodeUint64(&result.Arg) 14727 if err != nil { 14728 return types.Fcntl64Args{}, err 14729 } 14730 } 14731 } 14732 return result, nil 14733 } 14734 14735 func ParseSendfile32Args(decoder *Decoder) (types.Sendfile32Args, error) { 14736 var result types.Sendfile32Args 14737 var err error 14738 14739 var numArgs uint8 14740 err = decoder.DecodeUint8(&numArgs) 14741 if err != nil { 14742 return types.Sendfile32Args{}, err 14743 } 14744 14745 for arg := 0; arg < int(numArgs); arg++ { 14746 var currArg uint8 14747 err = decoder.DecodeUint8(&currArg) 14748 if err != nil { 14749 return types.Sendfile32Args{}, err 14750 } 14751 14752 switch currArg { 14753 case 0: 14754 err = decoder.DecodeInt32(&result.OutFd) 14755 if err != nil { 14756 return types.Sendfile32Args{}, err 14757 } 14758 case 1: 14759 err = decoder.DecodeInt32(&result.InFd) 14760 if err != nil { 14761 return types.Sendfile32Args{}, err 14762 } 14763 case 2: 14764 var dataOffset uint64 14765 err = decoder.DecodeUint64(&dataOffset) 14766 if err != nil { 14767 return types.Sendfile32Args{}, err 14768 } 14769 result.Offset = uintptr(dataOffset) 14770 case 3: 14771 err = decoder.DecodeUint64(&result.Count) 14772 if err != nil { 14773 return types.Sendfile32Args{}, err 14774 } 14775 } 14776 } 14777 return result, nil 14778 } 14779 14780 func ParseStatfs64Args(decoder *Decoder) (types.Statfs64Args, error) { 14781 var result types.Statfs64Args 14782 var err error 14783 14784 var numArgs uint8 14785 err = decoder.DecodeUint8(&numArgs) 14786 if err != nil { 14787 return types.Statfs64Args{}, err 14788 } 14789 14790 for arg := 0; arg < int(numArgs); arg++ { 14791 var currArg uint8 14792 err = decoder.DecodeUint8(&currArg) 14793 if err != nil { 14794 return types.Statfs64Args{}, err 14795 } 14796 14797 switch currArg { 14798 case 0: 14799 result.Path, err = decoder.ReadStringFromBuff() 14800 if err != nil { 14801 return types.Statfs64Args{}, err 14802 } 14803 case 1: 14804 err = decoder.DecodeUint64(&result.Sz) 14805 if err != nil { 14806 return types.Statfs64Args{}, err 14807 } 14808 case 2: 14809 var dataBuf uint64 14810 err = decoder.DecodeUint64(&dataBuf) 14811 if err != nil { 14812 return types.Statfs64Args{}, err 14813 } 14814 result.Buf = uintptr(dataBuf) 14815 } 14816 } 14817 return result, nil 14818 } 14819 14820 func ParseFstatfs64Args(decoder *Decoder) (types.Fstatfs64Args, error) { 14821 var result types.Fstatfs64Args 14822 var err error 14823 14824 var numArgs uint8 14825 err = decoder.DecodeUint8(&numArgs) 14826 if err != nil { 14827 return types.Fstatfs64Args{}, err 14828 } 14829 14830 for arg := 0; arg < int(numArgs); arg++ { 14831 var currArg uint8 14832 err = decoder.DecodeUint8(&currArg) 14833 if err != nil { 14834 return types.Fstatfs64Args{}, err 14835 } 14836 14837 switch currArg { 14838 case 0: 14839 err = decoder.DecodeInt32(&result.Fd) 14840 if err != nil { 14841 return types.Fstatfs64Args{}, err 14842 } 14843 case 1: 14844 err = decoder.DecodeUint64(&result.Sz) 14845 if err != nil { 14846 return types.Fstatfs64Args{}, err 14847 } 14848 case 2: 14849 var dataBuf uint64 14850 err = decoder.DecodeUint64(&dataBuf) 14851 if err != nil { 14852 return types.Fstatfs64Args{}, err 14853 } 14854 result.Buf = uintptr(dataBuf) 14855 } 14856 } 14857 return result, nil 14858 } 14859 14860 func ParseFadvise64_64Args(decoder *Decoder) (types.Fadvise64_64Args, error) { 14861 var result types.Fadvise64_64Args 14862 var err error 14863 14864 var numArgs uint8 14865 err = decoder.DecodeUint8(&numArgs) 14866 if err != nil { 14867 return types.Fadvise64_64Args{}, err 14868 } 14869 14870 for arg := 0; arg < int(numArgs); arg++ { 14871 var currArg uint8 14872 err = decoder.DecodeUint8(&currArg) 14873 if err != nil { 14874 return types.Fadvise64_64Args{}, err 14875 } 14876 14877 switch currArg { 14878 case 0: 14879 err = decoder.DecodeInt32(&result.Fd) 14880 if err != nil { 14881 return types.Fadvise64_64Args{}, err 14882 } 14883 case 1: 14884 err = decoder.DecodeUint64(&result.Offset) 14885 if err != nil { 14886 return types.Fadvise64_64Args{}, err 14887 } 14888 case 2: 14889 err = decoder.DecodeUint64(&result.Len) 14890 if err != nil { 14891 return types.Fadvise64_64Args{}, err 14892 } 14893 case 3: 14894 err = decoder.DecodeInt32(&result.Advice) 14895 if err != nil { 14896 return types.Fadvise64_64Args{}, err 14897 } 14898 } 14899 } 14900 return result, nil 14901 } 14902 14903 func ParseClockGettime32Args(decoder *Decoder) (types.ClockGettime32Args, error) { 14904 var result types.ClockGettime32Args 14905 var err error 14906 14907 var numArgs uint8 14908 err = decoder.DecodeUint8(&numArgs) 14909 if err != nil { 14910 return types.ClockGettime32Args{}, err 14911 } 14912 14913 for arg := 0; arg < int(numArgs); arg++ { 14914 var currArg uint8 14915 err = decoder.DecodeUint8(&currArg) 14916 if err != nil { 14917 return types.ClockGettime32Args{}, err 14918 } 14919 14920 switch currArg { 14921 case 0: 14922 err = decoder.DecodeInt32(&result.WhichClock) 14923 if err != nil { 14924 return types.ClockGettime32Args{}, err 14925 } 14926 case 1: 14927 var dataTp uint64 14928 err = decoder.DecodeUint64(&dataTp) 14929 if err != nil { 14930 return types.ClockGettime32Args{}, err 14931 } 14932 result.Tp = uintptr(dataTp) 14933 } 14934 } 14935 return result, nil 14936 } 14937 14938 func ParseClockSettime32Args(decoder *Decoder) (types.ClockSettime32Args, error) { 14939 var result types.ClockSettime32Args 14940 var err error 14941 14942 var numArgs uint8 14943 err = decoder.DecodeUint8(&numArgs) 14944 if err != nil { 14945 return types.ClockSettime32Args{}, err 14946 } 14947 14948 for arg := 0; arg < int(numArgs); arg++ { 14949 var currArg uint8 14950 err = decoder.DecodeUint8(&currArg) 14951 if err != nil { 14952 return types.ClockSettime32Args{}, err 14953 } 14954 14955 switch currArg { 14956 case 0: 14957 err = decoder.DecodeInt32(&result.WhichClock) 14958 if err != nil { 14959 return types.ClockSettime32Args{}, err 14960 } 14961 case 1: 14962 var dataTp uint64 14963 err = decoder.DecodeUint64(&dataTp) 14964 if err != nil { 14965 return types.ClockSettime32Args{}, err 14966 } 14967 result.Tp = uintptr(dataTp) 14968 } 14969 } 14970 return result, nil 14971 } 14972 14973 func ParseClockAdjtime64Args(decoder *Decoder) (types.ClockAdjtime64Args, error) { 14974 return types.ClockAdjtime64Args{}, nil 14975 } 14976 14977 func ParseClockGetresTime32Args(decoder *Decoder) (types.ClockGetresTime32Args, error) { 14978 var result types.ClockGetresTime32Args 14979 var err error 14980 14981 var numArgs uint8 14982 err = decoder.DecodeUint8(&numArgs) 14983 if err != nil { 14984 return types.ClockGetresTime32Args{}, err 14985 } 14986 14987 for arg := 0; arg < int(numArgs); arg++ { 14988 var currArg uint8 14989 err = decoder.DecodeUint8(&currArg) 14990 if err != nil { 14991 return types.ClockGetresTime32Args{}, err 14992 } 14993 14994 switch currArg { 14995 case 0: 14996 err = decoder.DecodeInt32(&result.WhichClock) 14997 if err != nil { 14998 return types.ClockGetresTime32Args{}, err 14999 } 15000 case 1: 15001 var dataTp uint64 15002 err = decoder.DecodeUint64(&dataTp) 15003 if err != nil { 15004 return types.ClockGetresTime32Args{}, err 15005 } 15006 result.Tp = uintptr(dataTp) 15007 } 15008 } 15009 return result, nil 15010 } 15011 15012 func ParseClockNanosleepTime32Args(decoder *Decoder) (types.ClockNanosleepTime32Args, error) { 15013 var result types.ClockNanosleepTime32Args 15014 var err error 15015 15016 var numArgs uint8 15017 err = decoder.DecodeUint8(&numArgs) 15018 if err != nil { 15019 return types.ClockNanosleepTime32Args{}, err 15020 } 15021 15022 for arg := 0; arg < int(numArgs); arg++ { 15023 var currArg uint8 15024 err = decoder.DecodeUint8(&currArg) 15025 if err != nil { 15026 return types.ClockNanosleepTime32Args{}, err 15027 } 15028 15029 switch currArg { 15030 case 0: 15031 err = decoder.DecodeInt32(&result.WhichClock) 15032 if err != nil { 15033 return types.ClockNanosleepTime32Args{}, err 15034 } 15035 case 1: 15036 err = decoder.DecodeInt32(&result.Flags) 15037 if err != nil { 15038 return types.ClockNanosleepTime32Args{}, err 15039 } 15040 case 2: 15041 var dataRqtp uint64 15042 err = decoder.DecodeUint64(&dataRqtp) 15043 if err != nil { 15044 return types.ClockNanosleepTime32Args{}, err 15045 } 15046 result.Rqtp = uintptr(dataRqtp) 15047 case 3: 15048 var dataRmtp uint64 15049 err = decoder.DecodeUint64(&dataRmtp) 15050 if err != nil { 15051 return types.ClockNanosleepTime32Args{}, err 15052 } 15053 result.Rmtp = uintptr(dataRmtp) 15054 } 15055 } 15056 return result, nil 15057 } 15058 15059 func ParseTimerGettime32Args(decoder *Decoder) (types.TimerGettime32Args, error) { 15060 var result types.TimerGettime32Args 15061 var err error 15062 15063 var numArgs uint8 15064 err = decoder.DecodeUint8(&numArgs) 15065 if err != nil { 15066 return types.TimerGettime32Args{}, err 15067 } 15068 15069 for arg := 0; arg < int(numArgs); arg++ { 15070 var currArg uint8 15071 err = decoder.DecodeUint8(&currArg) 15072 if err != nil { 15073 return types.TimerGettime32Args{}, err 15074 } 15075 15076 switch currArg { 15077 case 0: 15078 err = decoder.DecodeInt32(&result.TimerId) 15079 if err != nil { 15080 return types.TimerGettime32Args{}, err 15081 } 15082 case 1: 15083 var dataSetting uint64 15084 err = decoder.DecodeUint64(&dataSetting) 15085 if err != nil { 15086 return types.TimerGettime32Args{}, err 15087 } 15088 result.Setting = uintptr(dataSetting) 15089 } 15090 } 15091 return result, nil 15092 } 15093 15094 func ParseTimerSettime32Args(decoder *Decoder) (types.TimerSettime32Args, error) { 15095 var result types.TimerSettime32Args 15096 var err error 15097 15098 var numArgs uint8 15099 err = decoder.DecodeUint8(&numArgs) 15100 if err != nil { 15101 return types.TimerSettime32Args{}, err 15102 } 15103 15104 for arg := 0; arg < int(numArgs); arg++ { 15105 var currArg uint8 15106 err = decoder.DecodeUint8(&currArg) 15107 if err != nil { 15108 return types.TimerSettime32Args{}, err 15109 } 15110 15111 switch currArg { 15112 case 0: 15113 err = decoder.DecodeInt32(&result.TimerId) 15114 if err != nil { 15115 return types.TimerSettime32Args{}, err 15116 } 15117 case 1: 15118 err = decoder.DecodeInt32(&result.Flags) 15119 if err != nil { 15120 return types.TimerSettime32Args{}, err 15121 } 15122 case 2: 15123 var dataNew uint64 15124 err = decoder.DecodeUint64(&dataNew) 15125 if err != nil { 15126 return types.TimerSettime32Args{}, err 15127 } 15128 result.New = uintptr(dataNew) 15129 case 3: 15130 var dataOld uint64 15131 err = decoder.DecodeUint64(&dataOld) 15132 if err != nil { 15133 return types.TimerSettime32Args{}, err 15134 } 15135 result.Old = uintptr(dataOld) 15136 } 15137 } 15138 return result, nil 15139 } 15140 15141 func ParseTimerfdGettime32Args(decoder *Decoder) (types.TimerfdGettime32Args, error) { 15142 var result types.TimerfdGettime32Args 15143 var err error 15144 15145 var numArgs uint8 15146 err = decoder.DecodeUint8(&numArgs) 15147 if err != nil { 15148 return types.TimerfdGettime32Args{}, err 15149 } 15150 15151 for arg := 0; arg < int(numArgs); arg++ { 15152 var currArg uint8 15153 err = decoder.DecodeUint8(&currArg) 15154 if err != nil { 15155 return types.TimerfdGettime32Args{}, err 15156 } 15157 15158 switch currArg { 15159 case 0: 15160 err = decoder.DecodeInt32(&result.Ufd) 15161 if err != nil { 15162 return types.TimerfdGettime32Args{}, err 15163 } 15164 case 1: 15165 var dataOtmr uint64 15166 err = decoder.DecodeUint64(&dataOtmr) 15167 if err != nil { 15168 return types.TimerfdGettime32Args{}, err 15169 } 15170 result.Otmr = uintptr(dataOtmr) 15171 } 15172 } 15173 return result, nil 15174 } 15175 15176 func ParseTimerfdSettime32Args(decoder *Decoder) (types.TimerfdSettime32Args, error) { 15177 var result types.TimerfdSettime32Args 15178 var err error 15179 15180 var numArgs uint8 15181 err = decoder.DecodeUint8(&numArgs) 15182 if err != nil { 15183 return types.TimerfdSettime32Args{}, err 15184 } 15185 15186 for arg := 0; arg < int(numArgs); arg++ { 15187 var currArg uint8 15188 err = decoder.DecodeUint8(&currArg) 15189 if err != nil { 15190 return types.TimerfdSettime32Args{}, err 15191 } 15192 15193 switch currArg { 15194 case 0: 15195 err = decoder.DecodeInt32(&result.Ufd) 15196 if err != nil { 15197 return types.TimerfdSettime32Args{}, err 15198 } 15199 case 1: 15200 err = decoder.DecodeInt32(&result.Flags) 15201 if err != nil { 15202 return types.TimerfdSettime32Args{}, err 15203 } 15204 case 2: 15205 var dataUtmr uint64 15206 err = decoder.DecodeUint64(&dataUtmr) 15207 if err != nil { 15208 return types.TimerfdSettime32Args{}, err 15209 } 15210 result.Utmr = uintptr(dataUtmr) 15211 case 3: 15212 var dataOtmr uint64 15213 err = decoder.DecodeUint64(&dataOtmr) 15214 if err != nil { 15215 return types.TimerfdSettime32Args{}, err 15216 } 15217 result.Otmr = uintptr(dataOtmr) 15218 } 15219 } 15220 return result, nil 15221 } 15222 15223 func ParseUtimensatTime32Args(decoder *Decoder) (types.UtimensatTime32Args, error) { 15224 var result types.UtimensatTime32Args 15225 var err error 15226 15227 var numArgs uint8 15228 err = decoder.DecodeUint8(&numArgs) 15229 if err != nil { 15230 return types.UtimensatTime32Args{}, err 15231 } 15232 15233 for arg := 0; arg < int(numArgs); arg++ { 15234 var currArg uint8 15235 err = decoder.DecodeUint8(&currArg) 15236 if err != nil { 15237 return types.UtimensatTime32Args{}, err 15238 } 15239 15240 switch currArg { 15241 case 0: 15242 err = decoder.DecodeUint32(&result.Dfd) 15243 if err != nil { 15244 return types.UtimensatTime32Args{}, err 15245 } 15246 case 1: 15247 result.Filename, err = decoder.ReadStringFromBuff() 15248 if err != nil { 15249 return types.UtimensatTime32Args{}, err 15250 } 15251 case 2: 15252 var dataT uint64 15253 err = decoder.DecodeUint64(&dataT) 15254 if err != nil { 15255 return types.UtimensatTime32Args{}, err 15256 } 15257 result.T = uintptr(dataT) 15258 case 3: 15259 err = decoder.DecodeInt32(&result.Flags) 15260 if err != nil { 15261 return types.UtimensatTime32Args{}, err 15262 } 15263 } 15264 } 15265 return result, nil 15266 } 15267 15268 func ParsePselect6Time32Args(decoder *Decoder) (types.Pselect6Time32Args, error) { 15269 var result types.Pselect6Time32Args 15270 var err error 15271 15272 var numArgs uint8 15273 err = decoder.DecodeUint8(&numArgs) 15274 if err != nil { 15275 return types.Pselect6Time32Args{}, err 15276 } 15277 15278 for arg := 0; arg < int(numArgs); arg++ { 15279 var currArg uint8 15280 err = decoder.DecodeUint8(&currArg) 15281 if err != nil { 15282 return types.Pselect6Time32Args{}, err 15283 } 15284 15285 switch currArg { 15286 case 0: 15287 err = decoder.DecodeInt32(&result.N) 15288 if err != nil { 15289 return types.Pselect6Time32Args{}, err 15290 } 15291 case 1: 15292 var dataInp uint64 15293 err = decoder.DecodeUint64(&dataInp) 15294 if err != nil { 15295 return types.Pselect6Time32Args{}, err 15296 } 15297 result.Inp = uintptr(dataInp) 15298 case 2: 15299 var dataOutp uint64 15300 err = decoder.DecodeUint64(&dataOutp) 15301 if err != nil { 15302 return types.Pselect6Time32Args{}, err 15303 } 15304 result.Outp = uintptr(dataOutp) 15305 case 3: 15306 var dataExp uint64 15307 err = decoder.DecodeUint64(&dataExp) 15308 if err != nil { 15309 return types.Pselect6Time32Args{}, err 15310 } 15311 result.Exp = uintptr(dataExp) 15312 case 4: 15313 var dataTsp uint64 15314 err = decoder.DecodeUint64(&dataTsp) 15315 if err != nil { 15316 return types.Pselect6Time32Args{}, err 15317 } 15318 result.Tsp = uintptr(dataTsp) 15319 case 5: 15320 var dataSig uint64 15321 err = decoder.DecodeUint64(&dataSig) 15322 if err != nil { 15323 return types.Pselect6Time32Args{}, err 15324 } 15325 result.Sig = uintptr(dataSig) 15326 } 15327 } 15328 return result, nil 15329 } 15330 15331 func ParsePpollTime32Args(decoder *Decoder) (types.PpollTime32Args, error) { 15332 var result types.PpollTime32Args 15333 var err error 15334 15335 var numArgs uint8 15336 err = decoder.DecodeUint8(&numArgs) 15337 if err != nil { 15338 return types.PpollTime32Args{}, err 15339 } 15340 15341 for arg := 0; arg < int(numArgs); arg++ { 15342 var currArg uint8 15343 err = decoder.DecodeUint8(&currArg) 15344 if err != nil { 15345 return types.PpollTime32Args{}, err 15346 } 15347 15348 switch currArg { 15349 case 0: 15350 var dataUfds uint64 15351 err = decoder.DecodeUint64(&dataUfds) 15352 if err != nil { 15353 return types.PpollTime32Args{}, err 15354 } 15355 result.Ufds = uintptr(dataUfds) 15356 case 1: 15357 err = decoder.DecodeUint32(&result.Nfds) 15358 if err != nil { 15359 return types.PpollTime32Args{}, err 15360 } 15361 case 2: 15362 var dataTsp uint64 15363 err = decoder.DecodeUint64(&dataTsp) 15364 if err != nil { 15365 return types.PpollTime32Args{}, err 15366 } 15367 result.Tsp = uintptr(dataTsp) 15368 case 3: 15369 var dataSigmask uint64 15370 err = decoder.DecodeUint64(&dataSigmask) 15371 if err != nil { 15372 return types.PpollTime32Args{}, err 15373 } 15374 result.Sigmask = uintptr(dataSigmask) 15375 case 4: 15376 err = decoder.DecodeUint64(&result.Sigsetsize) 15377 if err != nil { 15378 return types.PpollTime32Args{}, err 15379 } 15380 } 15381 } 15382 return result, nil 15383 } 15384 15385 func ParseIoPgeteventsTime32Args(decoder *Decoder) (types.IoPgeteventsTime32Args, error) { 15386 return types.IoPgeteventsTime32Args{}, nil 15387 } 15388 15389 func ParseRecvmmsgTime32Args(decoder *Decoder) (types.RecvmmsgTime32Args, error) { 15390 var result types.RecvmmsgTime32Args 15391 var err error 15392 15393 var numArgs uint8 15394 err = decoder.DecodeUint8(&numArgs) 15395 if err != nil { 15396 return types.RecvmmsgTime32Args{}, err 15397 } 15398 15399 for arg := 0; arg < int(numArgs); arg++ { 15400 var currArg uint8 15401 err = decoder.DecodeUint8(&currArg) 15402 if err != nil { 15403 return types.RecvmmsgTime32Args{}, err 15404 } 15405 15406 switch currArg { 15407 case 0: 15408 err = decoder.DecodeInt32(&result.Fd) 15409 if err != nil { 15410 return types.RecvmmsgTime32Args{}, err 15411 } 15412 case 1: 15413 var dataMmsg uint64 15414 err = decoder.DecodeUint64(&dataMmsg) 15415 if err != nil { 15416 return types.RecvmmsgTime32Args{}, err 15417 } 15418 result.Mmsg = uintptr(dataMmsg) 15419 case 2: 15420 err = decoder.DecodeUint32(&result.Vlen) 15421 if err != nil { 15422 return types.RecvmmsgTime32Args{}, err 15423 } 15424 case 3: 15425 err = decoder.DecodeUint32(&result.Flags) 15426 if err != nil { 15427 return types.RecvmmsgTime32Args{}, err 15428 } 15429 case 4: 15430 var dataTimeout uint64 15431 err = decoder.DecodeUint64(&dataTimeout) 15432 if err != nil { 15433 return types.RecvmmsgTime32Args{}, err 15434 } 15435 result.Timeout = uintptr(dataTimeout) 15436 } 15437 } 15438 return result, nil 15439 } 15440 15441 func ParseMqTimedsendTime32Args(decoder *Decoder) (types.MqTimedsendTime32Args, error) { 15442 var result types.MqTimedsendTime32Args 15443 var err error 15444 15445 var numArgs uint8 15446 err = decoder.DecodeUint8(&numArgs) 15447 if err != nil { 15448 return types.MqTimedsendTime32Args{}, err 15449 } 15450 15451 for arg := 0; arg < int(numArgs); arg++ { 15452 var currArg uint8 15453 err = decoder.DecodeUint8(&currArg) 15454 if err != nil { 15455 return types.MqTimedsendTime32Args{}, err 15456 } 15457 15458 switch currArg { 15459 case 0: 15460 err = decoder.DecodeInt32(&result.Mqdes) 15461 if err != nil { 15462 return types.MqTimedsendTime32Args{}, err 15463 } 15464 case 1: 15465 result.UMsgPtr, err = decoder.ReadStringFromBuff() 15466 if err != nil { 15467 return types.MqTimedsendTime32Args{}, err 15468 } 15469 case 2: 15470 err = decoder.DecodeUint32(&result.MsgLen) 15471 if err != nil { 15472 return types.MqTimedsendTime32Args{}, err 15473 } 15474 case 3: 15475 err = decoder.DecodeUint32(&result.MsgPrio) 15476 if err != nil { 15477 return types.MqTimedsendTime32Args{}, err 15478 } 15479 case 4: 15480 var dataUAbsTimeout uint64 15481 err = decoder.DecodeUint64(&dataUAbsTimeout) 15482 if err != nil { 15483 return types.MqTimedsendTime32Args{}, err 15484 } 15485 result.UAbsTimeout = uintptr(dataUAbsTimeout) 15486 } 15487 } 15488 return result, nil 15489 } 15490 15491 func ParseMqTimedreceiveTime32Args(decoder *Decoder) (types.MqTimedreceiveTime32Args, error) { 15492 var result types.MqTimedreceiveTime32Args 15493 var err error 15494 15495 var numArgs uint8 15496 err = decoder.DecodeUint8(&numArgs) 15497 if err != nil { 15498 return types.MqTimedreceiveTime32Args{}, err 15499 } 15500 15501 for arg := 0; arg < int(numArgs); arg++ { 15502 var currArg uint8 15503 err = decoder.DecodeUint8(&currArg) 15504 if err != nil { 15505 return types.MqTimedreceiveTime32Args{}, err 15506 } 15507 15508 switch currArg { 15509 case 0: 15510 err = decoder.DecodeInt32(&result.Mqdes) 15511 if err != nil { 15512 return types.MqTimedreceiveTime32Args{}, err 15513 } 15514 case 1: 15515 result.UMsgPtr, err = decoder.ReadStringFromBuff() 15516 if err != nil { 15517 return types.MqTimedreceiveTime32Args{}, err 15518 } 15519 case 2: 15520 err = decoder.DecodeUint32(&result.MsgLen) 15521 if err != nil { 15522 return types.MqTimedreceiveTime32Args{}, err 15523 } 15524 case 3: 15525 var dataUMsgPrio uint64 15526 err = decoder.DecodeUint64(&dataUMsgPrio) 15527 if err != nil { 15528 return types.MqTimedreceiveTime32Args{}, err 15529 } 15530 result.UMsgPrio = uintptr(dataUMsgPrio) 15531 case 4: 15532 var dataUAbsTimeout uint64 15533 err = decoder.DecodeUint64(&dataUAbsTimeout) 15534 if err != nil { 15535 return types.MqTimedreceiveTime32Args{}, err 15536 } 15537 result.UAbsTimeout = uintptr(dataUAbsTimeout) 15538 } 15539 } 15540 return result, nil 15541 } 15542 15543 func ParseRtSigtimedwaitTime32Args(decoder *Decoder) (types.RtSigtimedwaitTime32Args, error) { 15544 var result types.RtSigtimedwaitTime32Args 15545 var err error 15546 15547 var numArgs uint8 15548 err = decoder.DecodeUint8(&numArgs) 15549 if err != nil { 15550 return types.RtSigtimedwaitTime32Args{}, err 15551 } 15552 15553 for arg := 0; arg < int(numArgs); arg++ { 15554 var currArg uint8 15555 err = decoder.DecodeUint8(&currArg) 15556 if err != nil { 15557 return types.RtSigtimedwaitTime32Args{}, err 15558 } 15559 15560 switch currArg { 15561 case 0: 15562 var dataUthese uint64 15563 err = decoder.DecodeUint64(&dataUthese) 15564 if err != nil { 15565 return types.RtSigtimedwaitTime32Args{}, err 15566 } 15567 result.Uthese = uintptr(dataUthese) 15568 case 1: 15569 var dataUinfo uint64 15570 err = decoder.DecodeUint64(&dataUinfo) 15571 if err != nil { 15572 return types.RtSigtimedwaitTime32Args{}, err 15573 } 15574 result.Uinfo = uintptr(dataUinfo) 15575 case 2: 15576 var dataUts uint64 15577 err = decoder.DecodeUint64(&dataUts) 15578 if err != nil { 15579 return types.RtSigtimedwaitTime32Args{}, err 15580 } 15581 result.Uts = uintptr(dataUts) 15582 case 3: 15583 err = decoder.DecodeUint64(&result.Sigsetsize) 15584 if err != nil { 15585 return types.RtSigtimedwaitTime32Args{}, err 15586 } 15587 } 15588 } 15589 return result, nil 15590 } 15591 15592 func ParseFutexTime32Args(decoder *Decoder) (types.FutexTime32Args, error) { 15593 var result types.FutexTime32Args 15594 var err error 15595 15596 var numArgs uint8 15597 err = decoder.DecodeUint8(&numArgs) 15598 if err != nil { 15599 return types.FutexTime32Args{}, err 15600 } 15601 15602 for arg := 0; arg < int(numArgs); arg++ { 15603 var currArg uint8 15604 err = decoder.DecodeUint8(&currArg) 15605 if err != nil { 15606 return types.FutexTime32Args{}, err 15607 } 15608 15609 switch currArg { 15610 case 0: 15611 var dataUaddr uint64 15612 err = decoder.DecodeUint64(&dataUaddr) 15613 if err != nil { 15614 return types.FutexTime32Args{}, err 15615 } 15616 result.Uaddr = uintptr(dataUaddr) 15617 case 1: 15618 err = decoder.DecodeInt32(&result.Op) 15619 if err != nil { 15620 return types.FutexTime32Args{}, err 15621 } 15622 case 2: 15623 err = decoder.DecodeUint32(&result.Val) 15624 if err != nil { 15625 return types.FutexTime32Args{}, err 15626 } 15627 case 3: 15628 var dataUtime uint64 15629 err = decoder.DecodeUint64(&dataUtime) 15630 if err != nil { 15631 return types.FutexTime32Args{}, err 15632 } 15633 result.Utime = uintptr(dataUtime) 15634 case 4: 15635 var dataUaddr2 uint64 15636 err = decoder.DecodeUint64(&dataUaddr2) 15637 if err != nil { 15638 return types.FutexTime32Args{}, err 15639 } 15640 result.Uaddr2 = uintptr(dataUaddr2) 15641 case 5: 15642 err = decoder.DecodeUint32(&result.Val3) 15643 if err != nil { 15644 return types.FutexTime32Args{}, err 15645 } 15646 } 15647 } 15648 return result, nil 15649 } 15650 15651 func ParseSchedRrGetInterval32Args(decoder *Decoder) (types.SchedRrGetInterval32Args, error) { 15652 var result types.SchedRrGetInterval32Args 15653 var err error 15654 15655 var numArgs uint8 15656 err = decoder.DecodeUint8(&numArgs) 15657 if err != nil { 15658 return types.SchedRrGetInterval32Args{}, err 15659 } 15660 15661 for arg := 0; arg < int(numArgs); arg++ { 15662 var currArg uint8 15663 err = decoder.DecodeUint8(&currArg) 15664 if err != nil { 15665 return types.SchedRrGetInterval32Args{}, err 15666 } 15667 15668 switch currArg { 15669 case 0: 15670 err = decoder.DecodeInt32(&result.Pid) 15671 if err != nil { 15672 return types.SchedRrGetInterval32Args{}, err 15673 } 15674 case 1: 15675 var dataInterval uint64 15676 err = decoder.DecodeUint64(&dataInterval) 15677 if err != nil { 15678 return types.SchedRrGetInterval32Args{}, err 15679 } 15680 result.Interval = uintptr(dataInterval) 15681 } 15682 } 15683 return result, nil 15684 } 15685 15686 func ParseSysEnterArgs(decoder *Decoder) (types.SysEnterArgs, error) { 15687 var result types.SysEnterArgs 15688 var err error 15689 15690 var numArgs uint8 15691 err = decoder.DecodeUint8(&numArgs) 15692 if err != nil { 15693 return types.SysEnterArgs{}, err 15694 } 15695 15696 for arg := 0; arg < int(numArgs); arg++ { 15697 var currArg uint8 15698 err = decoder.DecodeUint8(&currArg) 15699 if err != nil { 15700 return types.SysEnterArgs{}, err 15701 } 15702 15703 switch currArg { 15704 case 0: 15705 err = decoder.DecodeInt32(&result.Syscall) 15706 if err != nil { 15707 return types.SysEnterArgs{}, err 15708 } 15709 } 15710 } 15711 return result, nil 15712 } 15713 15714 func ParseSysExitArgs(decoder *Decoder) (types.SysExitArgs, error) { 15715 var result types.SysExitArgs 15716 var err error 15717 15718 var numArgs uint8 15719 err = decoder.DecodeUint8(&numArgs) 15720 if err != nil { 15721 return types.SysExitArgs{}, err 15722 } 15723 15724 for arg := 0; arg < int(numArgs); arg++ { 15725 var currArg uint8 15726 err = decoder.DecodeUint8(&currArg) 15727 if err != nil { 15728 return types.SysExitArgs{}, err 15729 } 15730 15731 switch currArg { 15732 case 0: 15733 err = decoder.DecodeInt32(&result.Syscall) 15734 if err != nil { 15735 return types.SysExitArgs{}, err 15736 } 15737 } 15738 } 15739 return result, nil 15740 } 15741 15742 func ParseSchedProcessForkArgs(decoder *Decoder) (types.SchedProcessForkArgs, error) { 15743 var result types.SchedProcessForkArgs 15744 var err error 15745 15746 var numArgs uint8 15747 err = decoder.DecodeUint8(&numArgs) 15748 if err != nil { 15749 return types.SchedProcessForkArgs{}, err 15750 } 15751 15752 for arg := 0; arg < int(numArgs); arg++ { 15753 var currArg uint8 15754 err = decoder.DecodeUint8(&currArg) 15755 if err != nil { 15756 return types.SchedProcessForkArgs{}, err 15757 } 15758 15759 switch currArg { 15760 case 0: 15761 err = decoder.DecodeInt32(&result.ParentTid) 15762 if err != nil { 15763 return types.SchedProcessForkArgs{}, err 15764 } 15765 case 1: 15766 err = decoder.DecodeInt32(&result.ParentNsTid) 15767 if err != nil { 15768 return types.SchedProcessForkArgs{}, err 15769 } 15770 case 2: 15771 err = decoder.DecodeInt32(&result.ParentPid) 15772 if err != nil { 15773 return types.SchedProcessForkArgs{}, err 15774 } 15775 case 3: 15776 err = decoder.DecodeInt32(&result.ParentNsPid) 15777 if err != nil { 15778 return types.SchedProcessForkArgs{}, err 15779 } 15780 case 4: 15781 err = decoder.DecodeInt32(&result.ChildTid) 15782 if err != nil { 15783 return types.SchedProcessForkArgs{}, err 15784 } 15785 case 5: 15786 err = decoder.DecodeInt32(&result.ChildNsTid) 15787 if err != nil { 15788 return types.SchedProcessForkArgs{}, err 15789 } 15790 case 6: 15791 err = decoder.DecodeInt32(&result.ChildPid) 15792 if err != nil { 15793 return types.SchedProcessForkArgs{}, err 15794 } 15795 case 7: 15796 err = decoder.DecodeInt32(&result.ChildNsPid) 15797 if err != nil { 15798 return types.SchedProcessForkArgs{}, err 15799 } 15800 case 8: 15801 err = decoder.DecodeUint64(&result.StartTime) 15802 if err != nil { 15803 return types.SchedProcessForkArgs{}, err 15804 } 15805 } 15806 } 15807 return result, nil 15808 } 15809 15810 func ParseSchedProcessExecArgs(decoder *Decoder) (types.SchedProcessExecArgs, error) { 15811 var result types.SchedProcessExecArgs 15812 var err error 15813 15814 var numArgs uint8 15815 err = decoder.DecodeUint8(&numArgs) 15816 if err != nil { 15817 return types.SchedProcessExecArgs{}, err 15818 } 15819 15820 for arg := 0; arg < int(numArgs); arg++ { 15821 var currArg uint8 15822 err = decoder.DecodeUint8(&currArg) 15823 if err != nil { 15824 return types.SchedProcessExecArgs{}, err 15825 } 15826 15827 switch currArg { 15828 case 0: 15829 result.Cmdpath, err = decoder.ReadStringFromBuff() 15830 if err != nil { 15831 return types.SchedProcessExecArgs{}, err 15832 } 15833 case 1: 15834 result.Pathname, err = decoder.ReadStringFromBuff() 15835 if err != nil { 15836 return types.SchedProcessExecArgs{}, err 15837 } 15838 case 2: 15839 err = decoder.DecodeUint32(&result.Dev) 15840 if err != nil { 15841 return types.SchedProcessExecArgs{}, err 15842 } 15843 case 3: 15844 err = decoder.DecodeUint64(&result.Inode) 15845 if err != nil { 15846 return types.SchedProcessExecArgs{}, err 15847 } 15848 case 4: 15849 err = decoder.DecodeUint64(&result.Ctime) 15850 if err != nil { 15851 return types.SchedProcessExecArgs{}, err 15852 } 15853 case 5: 15854 err = decoder.DecodeUint16(&result.InodeMode) 15855 if err != nil { 15856 return types.SchedProcessExecArgs{}, err 15857 } 15858 case 6: 15859 result.InterpreterPathname, err = decoder.ReadStringFromBuff() 15860 if err != nil { 15861 return types.SchedProcessExecArgs{}, err 15862 } 15863 case 7: 15864 err = decoder.DecodeUint32(&result.InterpreterDev) 15865 if err != nil { 15866 return types.SchedProcessExecArgs{}, err 15867 } 15868 case 8: 15869 err = decoder.DecodeUint64(&result.InterpreterInode) 15870 if err != nil { 15871 return types.SchedProcessExecArgs{}, err 15872 } 15873 case 9: 15874 err = decoder.DecodeUint64(&result.InterpreterCtime) 15875 if err != nil { 15876 return types.SchedProcessExecArgs{}, err 15877 } 15878 case 10: 15879 result.Argv, err = decoder.ReadArgsArrayFromBuff() 15880 if err != nil { 15881 return types.SchedProcessExecArgs{}, err 15882 } 15883 case 11: 15884 result.Interp, err = decoder.ReadStringFromBuff() 15885 if err != nil { 15886 return types.SchedProcessExecArgs{}, err 15887 } 15888 case 12: 15889 err = decoder.DecodeUint16(&result.StdinType) 15890 if err != nil { 15891 return types.SchedProcessExecArgs{}, err 15892 } 15893 case 13: 15894 result.StdinPath, err = decoder.ReadStringFromBuff() 15895 if err != nil { 15896 return types.SchedProcessExecArgs{}, err 15897 } 15898 case 14: 15899 err = decoder.DecodeInt32(&result.InvokedFromKernel) 15900 if err != nil { 15901 return types.SchedProcessExecArgs{}, err 15902 } 15903 case 15: 15904 result.Env, err = decoder.ReadArgsArrayFromBuff() 15905 if err != nil { 15906 return types.SchedProcessExecArgs{}, err 15907 } 15908 } 15909 } 15910 return result, nil 15911 } 15912 15913 func ParseSchedProcessExitArgs(decoder *Decoder) (types.SchedProcessExitArgs, error) { 15914 var result types.SchedProcessExitArgs 15915 var err error 15916 15917 var numArgs uint8 15918 err = decoder.DecodeUint8(&numArgs) 15919 if err != nil { 15920 return types.SchedProcessExitArgs{}, err 15921 } 15922 15923 for arg := 0; arg < int(numArgs); arg++ { 15924 var currArg uint8 15925 err = decoder.DecodeUint8(&currArg) 15926 if err != nil { 15927 return types.SchedProcessExitArgs{}, err 15928 } 15929 15930 switch currArg { 15931 case 0: 15932 err = decoder.DecodeInt64(&result.ExitCode) 15933 if err != nil { 15934 return types.SchedProcessExitArgs{}, err 15935 } 15936 case 1: 15937 err = decoder.DecodeBool(&result.ProcessGroupExit) 15938 if err != nil { 15939 return types.SchedProcessExitArgs{}, err 15940 } 15941 } 15942 } 15943 return result, nil 15944 } 15945 15946 func ParseSchedSwitchArgs(decoder *Decoder) (types.SchedSwitchArgs, error) { 15947 var result types.SchedSwitchArgs 15948 var err error 15949 15950 var numArgs uint8 15951 err = decoder.DecodeUint8(&numArgs) 15952 if err != nil { 15953 return types.SchedSwitchArgs{}, err 15954 } 15955 15956 for arg := 0; arg < int(numArgs); arg++ { 15957 var currArg uint8 15958 err = decoder.DecodeUint8(&currArg) 15959 if err != nil { 15960 return types.SchedSwitchArgs{}, err 15961 } 15962 15963 switch currArg { 15964 case 0: 15965 err = decoder.DecodeInt32(&result.Cpu) 15966 if err != nil { 15967 return types.SchedSwitchArgs{}, err 15968 } 15969 case 1: 15970 err = decoder.DecodeInt32(&result.PrevTid) 15971 if err != nil { 15972 return types.SchedSwitchArgs{}, err 15973 } 15974 case 2: 15975 result.PrevComm, err = decoder.ReadStringFromBuff() 15976 if err != nil { 15977 return types.SchedSwitchArgs{}, err 15978 } 15979 case 3: 15980 err = decoder.DecodeInt32(&result.NextTid) 15981 if err != nil { 15982 return types.SchedSwitchArgs{}, err 15983 } 15984 case 4: 15985 result.NextComm, err = decoder.ReadStringFromBuff() 15986 if err != nil { 15987 return types.SchedSwitchArgs{}, err 15988 } 15989 } 15990 } 15991 return result, nil 15992 } 15993 15994 func ParseProcessOomKilledArgs(decoder *Decoder) (types.ProcessOomKilledArgs, error) { 15995 var result types.ProcessOomKilledArgs 15996 var err error 15997 15998 var numArgs uint8 15999 err = decoder.DecodeUint8(&numArgs) 16000 if err != nil { 16001 return types.ProcessOomKilledArgs{}, err 16002 } 16003 16004 for arg := 0; arg < int(numArgs); arg++ { 16005 var currArg uint8 16006 err = decoder.DecodeUint8(&currArg) 16007 if err != nil { 16008 return types.ProcessOomKilledArgs{}, err 16009 } 16010 16011 switch currArg { 16012 case 0: 16013 err = decoder.DecodeInt64(&result.ExitCode) 16014 if err != nil { 16015 return types.ProcessOomKilledArgs{}, err 16016 } 16017 case 1: 16018 err = decoder.DecodeBool(&result.ProcessGroupExit) 16019 if err != nil { 16020 return types.ProcessOomKilledArgs{}, err 16021 } 16022 } 16023 } 16024 return result, nil 16025 } 16026 16027 func ParseDoExitArgs(decoder *Decoder) (types.DoExitArgs, error) { 16028 return types.DoExitArgs{}, nil 16029 } 16030 16031 func ParseCapCapableArgs(decoder *Decoder) (types.CapCapableArgs, error) { 16032 var result types.CapCapableArgs 16033 var err error 16034 16035 var numArgs uint8 16036 err = decoder.DecodeUint8(&numArgs) 16037 if err != nil { 16038 return types.CapCapableArgs{}, err 16039 } 16040 16041 for arg := 0; arg < int(numArgs); arg++ { 16042 var currArg uint8 16043 err = decoder.DecodeUint8(&currArg) 16044 if err != nil { 16045 return types.CapCapableArgs{}, err 16046 } 16047 16048 switch currArg { 16049 case 0: 16050 err = decoder.DecodeInt32(&result.Cap) 16051 if err != nil { 16052 return types.CapCapableArgs{}, err 16053 } 16054 } 16055 } 16056 return result, nil 16057 } 16058 16059 func ParseVfsWriteArgs(decoder *Decoder) (types.VfsWriteArgs, error) { 16060 var result types.VfsWriteArgs 16061 var err error 16062 16063 var numArgs uint8 16064 err = decoder.DecodeUint8(&numArgs) 16065 if err != nil { 16066 return types.VfsWriteArgs{}, err 16067 } 16068 16069 for arg := 0; arg < int(numArgs); arg++ { 16070 var currArg uint8 16071 err = decoder.DecodeUint8(&currArg) 16072 if err != nil { 16073 return types.VfsWriteArgs{}, err 16074 } 16075 16076 switch currArg { 16077 case 0: 16078 result.Pathname, err = decoder.ReadStringFromBuff() 16079 if err != nil { 16080 return types.VfsWriteArgs{}, err 16081 } 16082 case 1: 16083 err = decoder.DecodeUint32(&result.Dev) 16084 if err != nil { 16085 return types.VfsWriteArgs{}, err 16086 } 16087 case 2: 16088 err = decoder.DecodeUint64(&result.Inode) 16089 if err != nil { 16090 return types.VfsWriteArgs{}, err 16091 } 16092 case 3: 16093 err = decoder.DecodeUint64(&result.Count) 16094 if err != nil { 16095 return types.VfsWriteArgs{}, err 16096 } 16097 case 4: 16098 err = decoder.DecodeUint64(&result.Pos) 16099 if err != nil { 16100 return types.VfsWriteArgs{}, err 16101 } 16102 } 16103 } 16104 return result, nil 16105 } 16106 16107 func ParseVfsWritevArgs(decoder *Decoder) (types.VfsWritevArgs, error) { 16108 var result types.VfsWritevArgs 16109 var err error 16110 16111 var numArgs uint8 16112 err = decoder.DecodeUint8(&numArgs) 16113 if err != nil { 16114 return types.VfsWritevArgs{}, err 16115 } 16116 16117 for arg := 0; arg < int(numArgs); arg++ { 16118 var currArg uint8 16119 err = decoder.DecodeUint8(&currArg) 16120 if err != nil { 16121 return types.VfsWritevArgs{}, err 16122 } 16123 16124 switch currArg { 16125 case 0: 16126 result.Pathname, err = decoder.ReadStringFromBuff() 16127 if err != nil { 16128 return types.VfsWritevArgs{}, err 16129 } 16130 case 1: 16131 err = decoder.DecodeUint32(&result.Dev) 16132 if err != nil { 16133 return types.VfsWritevArgs{}, err 16134 } 16135 case 2: 16136 err = decoder.DecodeUint64(&result.Inode) 16137 if err != nil { 16138 return types.VfsWritevArgs{}, err 16139 } 16140 case 3: 16141 err = decoder.DecodeUint64(&result.Vlen) 16142 if err != nil { 16143 return types.VfsWritevArgs{}, err 16144 } 16145 case 4: 16146 err = decoder.DecodeUint64(&result.Pos) 16147 if err != nil { 16148 return types.VfsWritevArgs{}, err 16149 } 16150 } 16151 } 16152 return result, nil 16153 } 16154 16155 func ParseMemProtAlertArgs(decoder *Decoder) (types.MemProtAlertArgs, error) { 16156 var result types.MemProtAlertArgs 16157 var err error 16158 16159 var numArgs uint8 16160 err = decoder.DecodeUint8(&numArgs) 16161 if err != nil { 16162 return types.MemProtAlertArgs{}, err 16163 } 16164 16165 for arg := 0; arg < int(numArgs); arg++ { 16166 var currArg uint8 16167 err = decoder.DecodeUint8(&currArg) 16168 if err != nil { 16169 return types.MemProtAlertArgs{}, err 16170 } 16171 16172 switch currArg { 16173 case 0: 16174 err = decoder.DecodeUint32(&result.Alert) 16175 if err != nil { 16176 return types.MemProtAlertArgs{}, err 16177 } 16178 case 1: 16179 var dataAddr uint64 16180 err = decoder.DecodeUint64(&dataAddr) 16181 if err != nil { 16182 return types.MemProtAlertArgs{}, err 16183 } 16184 result.Addr = uintptr(dataAddr) 16185 case 2: 16186 err = decoder.DecodeUint64(&result.Len) 16187 if err != nil { 16188 return types.MemProtAlertArgs{}, err 16189 } 16190 case 3: 16191 err = decoder.DecodeInt32(&result.Prot) 16192 if err != nil { 16193 return types.MemProtAlertArgs{}, err 16194 } 16195 case 4: 16196 err = decoder.DecodeInt32(&result.PrevProt) 16197 if err != nil { 16198 return types.MemProtAlertArgs{}, err 16199 } 16200 case 5: 16201 result.Pathname, err = decoder.ReadStringFromBuff() 16202 if err != nil { 16203 return types.MemProtAlertArgs{}, err 16204 } 16205 case 6: 16206 err = decoder.DecodeUint32(&result.Dev) 16207 if err != nil { 16208 return types.MemProtAlertArgs{}, err 16209 } 16210 case 7: 16211 err = decoder.DecodeUint64(&result.Inode) 16212 if err != nil { 16213 return types.MemProtAlertArgs{}, err 16214 } 16215 case 8: 16216 err = decoder.DecodeUint64(&result.Ctime) 16217 if err != nil { 16218 return types.MemProtAlertArgs{}, err 16219 } 16220 } 16221 } 16222 return result, nil 16223 } 16224 16225 func ParseCommitCredsArgs(decoder *Decoder) (types.CommitCredsArgs, error) { 16226 var result types.CommitCredsArgs 16227 var err error 16228 16229 var numArgs uint8 16230 err = decoder.DecodeUint8(&numArgs) 16231 if err != nil { 16232 return types.CommitCredsArgs{}, err 16233 } 16234 16235 for arg := 0; arg < int(numArgs); arg++ { 16236 var currArg uint8 16237 err = decoder.DecodeUint8(&currArg) 16238 if err != nil { 16239 return types.CommitCredsArgs{}, err 16240 } 16241 16242 switch currArg { 16243 case 0: 16244 err = decoder.DecodeSlimCred(&result.OldCred) 16245 if err != nil { 16246 return types.CommitCredsArgs{}, err 16247 } 16248 case 1: 16249 err = decoder.DecodeSlimCred(&result.NewCred) 16250 if err != nil { 16251 return types.CommitCredsArgs{}, err 16252 } 16253 } 16254 } 16255 return result, nil 16256 } 16257 16258 func ParseSwitchTaskNSArgs(decoder *Decoder) (types.SwitchTaskNSArgs, error) { 16259 var result types.SwitchTaskNSArgs 16260 var err error 16261 16262 var numArgs uint8 16263 err = decoder.DecodeUint8(&numArgs) 16264 if err != nil { 16265 return types.SwitchTaskNSArgs{}, err 16266 } 16267 16268 for arg := 0; arg < int(numArgs); arg++ { 16269 var currArg uint8 16270 err = decoder.DecodeUint8(&currArg) 16271 if err != nil { 16272 return types.SwitchTaskNSArgs{}, err 16273 } 16274 16275 switch currArg { 16276 case 0: 16277 err = decoder.DecodeInt32(&result.Pid) 16278 if err != nil { 16279 return types.SwitchTaskNSArgs{}, err 16280 } 16281 case 1: 16282 err = decoder.DecodeUint32(&result.NewMnt) 16283 if err != nil { 16284 return types.SwitchTaskNSArgs{}, err 16285 } 16286 case 2: 16287 err = decoder.DecodeUint32(&result.NewPid) 16288 if err != nil { 16289 return types.SwitchTaskNSArgs{}, err 16290 } 16291 case 3: 16292 err = decoder.DecodeUint32(&result.NewUts) 16293 if err != nil { 16294 return types.SwitchTaskNSArgs{}, err 16295 } 16296 case 4: 16297 err = decoder.DecodeUint32(&result.NewIpc) 16298 if err != nil { 16299 return types.SwitchTaskNSArgs{}, err 16300 } 16301 case 5: 16302 err = decoder.DecodeUint32(&result.NewNet) 16303 if err != nil { 16304 return types.SwitchTaskNSArgs{}, err 16305 } 16306 case 6: 16307 err = decoder.DecodeUint32(&result.NewCgroup) 16308 if err != nil { 16309 return types.SwitchTaskNSArgs{}, err 16310 } 16311 } 16312 } 16313 return result, nil 16314 } 16315 16316 func ParseMagicWriteArgs(decoder *Decoder) (types.MagicWriteArgs, error) { 16317 var result types.MagicWriteArgs 16318 var err error 16319 16320 var numArgs uint8 16321 err = decoder.DecodeUint8(&numArgs) 16322 if err != nil { 16323 return types.MagicWriteArgs{}, err 16324 } 16325 16326 for arg := 0; arg < int(numArgs); arg++ { 16327 var currArg uint8 16328 err = decoder.DecodeUint8(&currArg) 16329 if err != nil { 16330 return types.MagicWriteArgs{}, err 16331 } 16332 16333 switch currArg { 16334 case 0: 16335 result.Pathname, err = decoder.ReadStringFromBuff() 16336 if err != nil { 16337 return types.MagicWriteArgs{}, err 16338 } 16339 case 1: 16340 result.Bytes, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.MagicWrite)) 16341 if err != nil { 16342 return types.MagicWriteArgs{}, err 16343 } 16344 case 2: 16345 err = decoder.DecodeUint32(&result.Dev) 16346 if err != nil { 16347 return types.MagicWriteArgs{}, err 16348 } 16349 case 3: 16350 err = decoder.DecodeUint64(&result.Inode) 16351 if err != nil { 16352 return types.MagicWriteArgs{}, err 16353 } 16354 } 16355 } 16356 return result, nil 16357 } 16358 16359 func ParseCgroupAttachTaskArgs(decoder *Decoder) (types.CgroupAttachTaskArgs, error) { 16360 var result types.CgroupAttachTaskArgs 16361 var err error 16362 16363 var numArgs uint8 16364 err = decoder.DecodeUint8(&numArgs) 16365 if err != nil { 16366 return types.CgroupAttachTaskArgs{}, err 16367 } 16368 16369 for arg := 0; arg < int(numArgs); arg++ { 16370 var currArg uint8 16371 err = decoder.DecodeUint8(&currArg) 16372 if err != nil { 16373 return types.CgroupAttachTaskArgs{}, err 16374 } 16375 16376 switch currArg { 16377 case 0: 16378 result.CgroupPath, err = decoder.ReadStringFromBuff() 16379 if err != nil { 16380 return types.CgroupAttachTaskArgs{}, err 16381 } 16382 case 1: 16383 result.Comm, err = decoder.ReadStringFromBuff() 16384 if err != nil { 16385 return types.CgroupAttachTaskArgs{}, err 16386 } 16387 case 2: 16388 err = decoder.DecodeInt32(&result.Pid) 16389 if err != nil { 16390 return types.CgroupAttachTaskArgs{}, err 16391 } 16392 } 16393 } 16394 return result, nil 16395 } 16396 16397 func ParseCgroupMkdirArgs(decoder *Decoder) (types.CgroupMkdirArgs, error) { 16398 var result types.CgroupMkdirArgs 16399 var err error 16400 16401 var numArgs uint8 16402 err = decoder.DecodeUint8(&numArgs) 16403 if err != nil { 16404 return types.CgroupMkdirArgs{}, err 16405 } 16406 16407 for arg := 0; arg < int(numArgs); arg++ { 16408 var currArg uint8 16409 err = decoder.DecodeUint8(&currArg) 16410 if err != nil { 16411 return types.CgroupMkdirArgs{}, err 16412 } 16413 16414 switch currArg { 16415 case 0: 16416 err = decoder.DecodeUint64(&result.CgroupId) 16417 if err != nil { 16418 return types.CgroupMkdirArgs{}, err 16419 } 16420 case 1: 16421 result.CgroupPath, err = decoder.ReadStringFromBuff() 16422 if err != nil { 16423 return types.CgroupMkdirArgs{}, err 16424 } 16425 case 2: 16426 err = decoder.DecodeUint32(&result.HierarchyId) 16427 if err != nil { 16428 return types.CgroupMkdirArgs{}, err 16429 } 16430 } 16431 } 16432 return result, nil 16433 } 16434 16435 func ParseCgroupRmdirArgs(decoder *Decoder) (types.CgroupRmdirArgs, error) { 16436 var result types.CgroupRmdirArgs 16437 var err error 16438 16439 var numArgs uint8 16440 err = decoder.DecodeUint8(&numArgs) 16441 if err != nil { 16442 return types.CgroupRmdirArgs{}, err 16443 } 16444 16445 for arg := 0; arg < int(numArgs); arg++ { 16446 var currArg uint8 16447 err = decoder.DecodeUint8(&currArg) 16448 if err != nil { 16449 return types.CgroupRmdirArgs{}, err 16450 } 16451 16452 switch currArg { 16453 case 0: 16454 err = decoder.DecodeUint64(&result.CgroupId) 16455 if err != nil { 16456 return types.CgroupRmdirArgs{}, err 16457 } 16458 case 1: 16459 result.CgroupPath, err = decoder.ReadStringFromBuff() 16460 if err != nil { 16461 return types.CgroupRmdirArgs{}, err 16462 } 16463 case 2: 16464 err = decoder.DecodeUint32(&result.HierarchyId) 16465 if err != nil { 16466 return types.CgroupRmdirArgs{}, err 16467 } 16468 } 16469 } 16470 return result, nil 16471 } 16472 16473 func ParseSecurityFileOpenArgs(decoder *Decoder) (types.SecurityFileOpenArgs, error) { 16474 var result types.SecurityFileOpenArgs 16475 var err error 16476 16477 var numArgs uint8 16478 err = decoder.DecodeUint8(&numArgs) 16479 if err != nil { 16480 return types.SecurityFileOpenArgs{}, err 16481 } 16482 16483 for arg := 0; arg < int(numArgs); arg++ { 16484 var currArg uint8 16485 err = decoder.DecodeUint8(&currArg) 16486 if err != nil { 16487 return types.SecurityFileOpenArgs{}, err 16488 } 16489 16490 switch currArg { 16491 case 0: 16492 result.Pathname, err = decoder.ReadStringFromBuff() 16493 if err != nil { 16494 return types.SecurityFileOpenArgs{}, err 16495 } 16496 case 1: 16497 err = decoder.DecodeInt32(&result.Flags) 16498 if err != nil { 16499 return types.SecurityFileOpenArgs{}, err 16500 } 16501 case 2: 16502 err = decoder.DecodeUint32(&result.Dev) 16503 if err != nil { 16504 return types.SecurityFileOpenArgs{}, err 16505 } 16506 case 3: 16507 err = decoder.DecodeUint64(&result.Inode) 16508 if err != nil { 16509 return types.SecurityFileOpenArgs{}, err 16510 } 16511 case 4: 16512 err = decoder.DecodeUint64(&result.Ctime) 16513 if err != nil { 16514 return types.SecurityFileOpenArgs{}, err 16515 } 16516 case 5: 16517 result.SyscallPathname, err = decoder.ReadStringFromBuff() 16518 if err != nil { 16519 return types.SecurityFileOpenArgs{}, err 16520 } 16521 } 16522 } 16523 return result, nil 16524 } 16525 16526 func ParseSecurityInodeUnlinkArgs(decoder *Decoder) (types.SecurityInodeUnlinkArgs, error) { 16527 var result types.SecurityInodeUnlinkArgs 16528 var err error 16529 16530 var numArgs uint8 16531 err = decoder.DecodeUint8(&numArgs) 16532 if err != nil { 16533 return types.SecurityInodeUnlinkArgs{}, err 16534 } 16535 16536 for arg := 0; arg < int(numArgs); arg++ { 16537 var currArg uint8 16538 err = decoder.DecodeUint8(&currArg) 16539 if err != nil { 16540 return types.SecurityInodeUnlinkArgs{}, err 16541 } 16542 16543 switch currArg { 16544 case 0: 16545 result.Pathname, err = decoder.ReadStringFromBuff() 16546 if err != nil { 16547 return types.SecurityInodeUnlinkArgs{}, err 16548 } 16549 case 1: 16550 err = decoder.DecodeUint64(&result.Inode) 16551 if err != nil { 16552 return types.SecurityInodeUnlinkArgs{}, err 16553 } 16554 case 2: 16555 err = decoder.DecodeUint32(&result.Dev) 16556 if err != nil { 16557 return types.SecurityInodeUnlinkArgs{}, err 16558 } 16559 case 3: 16560 err = decoder.DecodeUint64(&result.Ctime) 16561 if err != nil { 16562 return types.SecurityInodeUnlinkArgs{}, err 16563 } 16564 } 16565 } 16566 return result, nil 16567 } 16568 16569 func ParseSecuritySocketCreateArgs(decoder *Decoder) (types.SecuritySocketCreateArgs, error) { 16570 var result types.SecuritySocketCreateArgs 16571 var err error 16572 16573 var numArgs uint8 16574 err = decoder.DecodeUint8(&numArgs) 16575 if err != nil { 16576 return types.SecuritySocketCreateArgs{}, err 16577 } 16578 16579 for arg := 0; arg < int(numArgs); arg++ { 16580 var currArg uint8 16581 err = decoder.DecodeUint8(&currArg) 16582 if err != nil { 16583 return types.SecuritySocketCreateArgs{}, err 16584 } 16585 16586 switch currArg { 16587 case 0: 16588 err = decoder.DecodeInt32(&result.Family) 16589 if err != nil { 16590 return types.SecuritySocketCreateArgs{}, err 16591 } 16592 case 1: 16593 err = decoder.DecodeInt32(&result.Type) 16594 if err != nil { 16595 return types.SecuritySocketCreateArgs{}, err 16596 } 16597 case 2: 16598 err = decoder.DecodeInt32(&result.Protocol) 16599 if err != nil { 16600 return types.SecuritySocketCreateArgs{}, err 16601 } 16602 case 3: 16603 err = decoder.DecodeInt32(&result.Kern) 16604 if err != nil { 16605 return types.SecuritySocketCreateArgs{}, err 16606 } 16607 } 16608 } 16609 return result, nil 16610 } 16611 16612 func ParseSecuritySocketListenArgs(decoder *Decoder) (types.SecuritySocketListenArgs, error) { 16613 var result types.SecuritySocketListenArgs 16614 var err error 16615 16616 var numArgs uint8 16617 err = decoder.DecodeUint8(&numArgs) 16618 if err != nil { 16619 return types.SecuritySocketListenArgs{}, err 16620 } 16621 16622 for arg := 0; arg < int(numArgs); arg++ { 16623 var currArg uint8 16624 err = decoder.DecodeUint8(&currArg) 16625 if err != nil { 16626 return types.SecuritySocketListenArgs{}, err 16627 } 16628 16629 switch currArg { 16630 case 0: 16631 err = decoder.DecodeInt32(&result.Sockfd) 16632 if err != nil { 16633 return types.SecuritySocketListenArgs{}, err 16634 } 16635 case 1: 16636 result.LocalAddr, err = decoder.ReadSockaddrFromBuff() 16637 if err != nil { 16638 return types.SecuritySocketListenArgs{}, err 16639 } 16640 case 2: 16641 err = decoder.DecodeInt32(&result.Backlog) 16642 if err != nil { 16643 return types.SecuritySocketListenArgs{}, err 16644 } 16645 } 16646 } 16647 return result, nil 16648 } 16649 16650 func ParseSecuritySocketConnectArgs(decoder *Decoder) (types.SecuritySocketConnectArgs, error) { 16651 var result types.SecuritySocketConnectArgs 16652 var err error 16653 16654 var numArgs uint8 16655 err = decoder.DecodeUint8(&numArgs) 16656 if err != nil { 16657 return types.SecuritySocketConnectArgs{}, err 16658 } 16659 16660 for arg := 0; arg < int(numArgs); arg++ { 16661 var currArg uint8 16662 err = decoder.DecodeUint8(&currArg) 16663 if err != nil { 16664 return types.SecuritySocketConnectArgs{}, err 16665 } 16666 16667 switch currArg { 16668 case 0: 16669 err = decoder.DecodeInt32(&result.Sockfd) 16670 if err != nil { 16671 return types.SecuritySocketConnectArgs{}, err 16672 } 16673 case 1: 16674 err = decoder.DecodeInt32(&result.Type) 16675 if err != nil { 16676 return types.SecuritySocketConnectArgs{}, err 16677 } 16678 case 2: 16679 result.RemoteAddr, err = decoder.ReadSockaddrFromBuff() 16680 if err != nil { 16681 return types.SecuritySocketConnectArgs{}, err 16682 } 16683 } 16684 } 16685 return result, nil 16686 } 16687 16688 func ParseSecuritySocketAcceptArgs(decoder *Decoder) (types.SecuritySocketAcceptArgs, error) { 16689 var result types.SecuritySocketAcceptArgs 16690 var err error 16691 16692 var numArgs uint8 16693 err = decoder.DecodeUint8(&numArgs) 16694 if err != nil { 16695 return types.SecuritySocketAcceptArgs{}, err 16696 } 16697 16698 for arg := 0; arg < int(numArgs); arg++ { 16699 var currArg uint8 16700 err = decoder.DecodeUint8(&currArg) 16701 if err != nil { 16702 return types.SecuritySocketAcceptArgs{}, err 16703 } 16704 16705 switch currArg { 16706 case 0: 16707 err = decoder.DecodeInt32(&result.Sockfd) 16708 if err != nil { 16709 return types.SecuritySocketAcceptArgs{}, err 16710 } 16711 case 1: 16712 result.LocalAddr, err = decoder.ReadSockaddrFromBuff() 16713 if err != nil { 16714 return types.SecuritySocketAcceptArgs{}, err 16715 } 16716 } 16717 } 16718 return result, nil 16719 } 16720 16721 func ParseSecuritySocketBindArgs(decoder *Decoder) (types.SecuritySocketBindArgs, error) { 16722 var result types.SecuritySocketBindArgs 16723 var err error 16724 16725 var numArgs uint8 16726 err = decoder.DecodeUint8(&numArgs) 16727 if err != nil { 16728 return types.SecuritySocketBindArgs{}, err 16729 } 16730 16731 for arg := 0; arg < int(numArgs); arg++ { 16732 var currArg uint8 16733 err = decoder.DecodeUint8(&currArg) 16734 if err != nil { 16735 return types.SecuritySocketBindArgs{}, err 16736 } 16737 16738 switch currArg { 16739 case 0: 16740 err = decoder.DecodeInt32(&result.Sockfd) 16741 if err != nil { 16742 return types.SecuritySocketBindArgs{}, err 16743 } 16744 case 1: 16745 result.LocalAddr, err = decoder.ReadSockaddrFromBuff() 16746 if err != nil { 16747 return types.SecuritySocketBindArgs{}, err 16748 } 16749 } 16750 } 16751 return result, nil 16752 } 16753 16754 func ParseSecuritySocketSetsockoptArgs(decoder *Decoder) (types.SecuritySocketSetsockoptArgs, error) { 16755 var result types.SecuritySocketSetsockoptArgs 16756 var err error 16757 16758 var numArgs uint8 16759 err = decoder.DecodeUint8(&numArgs) 16760 if err != nil { 16761 return types.SecuritySocketSetsockoptArgs{}, err 16762 } 16763 16764 for arg := 0; arg < int(numArgs); arg++ { 16765 var currArg uint8 16766 err = decoder.DecodeUint8(&currArg) 16767 if err != nil { 16768 return types.SecuritySocketSetsockoptArgs{}, err 16769 } 16770 16771 switch currArg { 16772 case 0: 16773 err = decoder.DecodeInt32(&result.Sockfd) 16774 if err != nil { 16775 return types.SecuritySocketSetsockoptArgs{}, err 16776 } 16777 case 1: 16778 err = decoder.DecodeInt32(&result.Level) 16779 if err != nil { 16780 return types.SecuritySocketSetsockoptArgs{}, err 16781 } 16782 case 2: 16783 err = decoder.DecodeInt32(&result.Optname) 16784 if err != nil { 16785 return types.SecuritySocketSetsockoptArgs{}, err 16786 } 16787 case 3: 16788 result.LocalAddr, err = decoder.ReadSockaddrFromBuff() 16789 if err != nil { 16790 return types.SecuritySocketSetsockoptArgs{}, err 16791 } 16792 } 16793 } 16794 return result, nil 16795 } 16796 16797 func ParseSecuritySbMountArgs(decoder *Decoder) (types.SecuritySbMountArgs, error) { 16798 var result types.SecuritySbMountArgs 16799 var err error 16800 16801 var numArgs uint8 16802 err = decoder.DecodeUint8(&numArgs) 16803 if err != nil { 16804 return types.SecuritySbMountArgs{}, err 16805 } 16806 16807 for arg := 0; arg < int(numArgs); arg++ { 16808 var currArg uint8 16809 err = decoder.DecodeUint8(&currArg) 16810 if err != nil { 16811 return types.SecuritySbMountArgs{}, err 16812 } 16813 16814 switch currArg { 16815 case 0: 16816 result.DevName, err = decoder.ReadStringFromBuff() 16817 if err != nil { 16818 return types.SecuritySbMountArgs{}, err 16819 } 16820 case 1: 16821 result.Path, err = decoder.ReadStringFromBuff() 16822 if err != nil { 16823 return types.SecuritySbMountArgs{}, err 16824 } 16825 case 2: 16826 result.Type, err = decoder.ReadStringFromBuff() 16827 if err != nil { 16828 return types.SecuritySbMountArgs{}, err 16829 } 16830 case 3: 16831 err = decoder.DecodeUint64(&result.Flags) 16832 if err != nil { 16833 return types.SecuritySbMountArgs{}, err 16834 } 16835 } 16836 } 16837 return result, nil 16838 } 16839 16840 func ParseSecurityBPFArgs(decoder *Decoder) (types.SecurityBPFArgs, error) { 16841 var result types.SecurityBPFArgs 16842 var err error 16843 16844 var numArgs uint8 16845 err = decoder.DecodeUint8(&numArgs) 16846 if err != nil { 16847 return types.SecurityBPFArgs{}, err 16848 } 16849 16850 for arg := 0; arg < int(numArgs); arg++ { 16851 var currArg uint8 16852 err = decoder.DecodeUint8(&currArg) 16853 if err != nil { 16854 return types.SecurityBPFArgs{}, err 16855 } 16856 16857 switch currArg { 16858 case 0: 16859 err = decoder.DecodeInt32(&result.Cmd) 16860 if err != nil { 16861 return types.SecurityBPFArgs{}, err 16862 } 16863 } 16864 } 16865 return result, nil 16866 } 16867 16868 func ParseSecurityBPFMapArgs(decoder *Decoder) (types.SecurityBPFMapArgs, error) { 16869 var result types.SecurityBPFMapArgs 16870 var err error 16871 16872 var numArgs uint8 16873 err = decoder.DecodeUint8(&numArgs) 16874 if err != nil { 16875 return types.SecurityBPFMapArgs{}, err 16876 } 16877 16878 for arg := 0; arg < int(numArgs); arg++ { 16879 var currArg uint8 16880 err = decoder.DecodeUint8(&currArg) 16881 if err != nil { 16882 return types.SecurityBPFMapArgs{}, err 16883 } 16884 16885 switch currArg { 16886 case 0: 16887 err = decoder.DecodeUint32(&result.MapId) 16888 if err != nil { 16889 return types.SecurityBPFMapArgs{}, err 16890 } 16891 case 1: 16892 result.MapName, err = decoder.ReadStringFromBuff() 16893 if err != nil { 16894 return types.SecurityBPFMapArgs{}, err 16895 } 16896 } 16897 } 16898 return result, nil 16899 } 16900 16901 func ParseSecurityKernelReadFileArgs(decoder *Decoder) (types.SecurityKernelReadFileArgs, error) { 16902 var result types.SecurityKernelReadFileArgs 16903 var err error 16904 16905 var numArgs uint8 16906 err = decoder.DecodeUint8(&numArgs) 16907 if err != nil { 16908 return types.SecurityKernelReadFileArgs{}, err 16909 } 16910 16911 for arg := 0; arg < int(numArgs); arg++ { 16912 var currArg uint8 16913 err = decoder.DecodeUint8(&currArg) 16914 if err != nil { 16915 return types.SecurityKernelReadFileArgs{}, err 16916 } 16917 16918 switch currArg { 16919 case 0: 16920 result.Pathname, err = decoder.ReadStringFromBuff() 16921 if err != nil { 16922 return types.SecurityKernelReadFileArgs{}, err 16923 } 16924 case 1: 16925 err = decoder.DecodeUint32(&result.Dev) 16926 if err != nil { 16927 return types.SecurityKernelReadFileArgs{}, err 16928 } 16929 case 2: 16930 err = decoder.DecodeUint64(&result.Inode) 16931 if err != nil { 16932 return types.SecurityKernelReadFileArgs{}, err 16933 } 16934 case 3: 16935 err = decoder.DecodeInt32(&result.Type) 16936 if err != nil { 16937 return types.SecurityKernelReadFileArgs{}, err 16938 } 16939 case 4: 16940 err = decoder.DecodeUint64(&result.Ctime) 16941 if err != nil { 16942 return types.SecurityKernelReadFileArgs{}, err 16943 } 16944 } 16945 } 16946 return result, nil 16947 } 16948 16949 func ParseSecurityPostReadFileArgs(decoder *Decoder) (types.SecurityPostReadFileArgs, error) { 16950 var result types.SecurityPostReadFileArgs 16951 var err error 16952 16953 var numArgs uint8 16954 err = decoder.DecodeUint8(&numArgs) 16955 if err != nil { 16956 return types.SecurityPostReadFileArgs{}, err 16957 } 16958 16959 for arg := 0; arg < int(numArgs); arg++ { 16960 var currArg uint8 16961 err = decoder.DecodeUint8(&currArg) 16962 if err != nil { 16963 return types.SecurityPostReadFileArgs{}, err 16964 } 16965 16966 switch currArg { 16967 case 0: 16968 result.Pathname, err = decoder.ReadStringFromBuff() 16969 if err != nil { 16970 return types.SecurityPostReadFileArgs{}, err 16971 } 16972 case 1: 16973 err = decoder.DecodeInt64(&result.Size) 16974 if err != nil { 16975 return types.SecurityPostReadFileArgs{}, err 16976 } 16977 case 2: 16978 err = decoder.DecodeInt32(&result.Type) 16979 if err != nil { 16980 return types.SecurityPostReadFileArgs{}, err 16981 } 16982 } 16983 } 16984 return result, nil 16985 } 16986 16987 func ParseSecurityInodeMknodArgs(decoder *Decoder) (types.SecurityInodeMknodArgs, error) { 16988 var result types.SecurityInodeMknodArgs 16989 var err error 16990 16991 var numArgs uint8 16992 err = decoder.DecodeUint8(&numArgs) 16993 if err != nil { 16994 return types.SecurityInodeMknodArgs{}, err 16995 } 16996 16997 for arg := 0; arg < int(numArgs); arg++ { 16998 var currArg uint8 16999 err = decoder.DecodeUint8(&currArg) 17000 if err != nil { 17001 return types.SecurityInodeMknodArgs{}, err 17002 } 17003 17004 switch currArg { 17005 case 0: 17006 result.FileName, err = decoder.ReadStringFromBuff() 17007 if err != nil { 17008 return types.SecurityInodeMknodArgs{}, err 17009 } 17010 case 1: 17011 err = decoder.DecodeUint16(&result.Mode) 17012 if err != nil { 17013 return types.SecurityInodeMknodArgs{}, err 17014 } 17015 case 2: 17016 err = decoder.DecodeUint32(&result.Dev) 17017 if err != nil { 17018 return types.SecurityInodeMknodArgs{}, err 17019 } 17020 } 17021 } 17022 return result, nil 17023 } 17024 17025 func ParseSecurityInodeSymlinkEventIdArgs(decoder *Decoder) (types.SecurityInodeSymlinkEventIdArgs, error) { 17026 var result types.SecurityInodeSymlinkEventIdArgs 17027 var err error 17028 17029 var numArgs uint8 17030 err = decoder.DecodeUint8(&numArgs) 17031 if err != nil { 17032 return types.SecurityInodeSymlinkEventIdArgs{}, err 17033 } 17034 17035 for arg := 0; arg < int(numArgs); arg++ { 17036 var currArg uint8 17037 err = decoder.DecodeUint8(&currArg) 17038 if err != nil { 17039 return types.SecurityInodeSymlinkEventIdArgs{}, err 17040 } 17041 17042 switch currArg { 17043 case 0: 17044 result.Linkpath, err = decoder.ReadStringFromBuff() 17045 if err != nil { 17046 return types.SecurityInodeSymlinkEventIdArgs{}, err 17047 } 17048 case 1: 17049 result.Target, err = decoder.ReadStringFromBuff() 17050 if err != nil { 17051 return types.SecurityInodeSymlinkEventIdArgs{}, err 17052 } 17053 } 17054 } 17055 return result, nil 17056 } 17057 17058 func ParseSecurityMmapFileArgs(decoder *Decoder) (types.SecurityMmapFileArgs, error) { 17059 var result types.SecurityMmapFileArgs 17060 var err error 17061 17062 var numArgs uint8 17063 err = decoder.DecodeUint8(&numArgs) 17064 if err != nil { 17065 return types.SecurityMmapFileArgs{}, err 17066 } 17067 17068 for arg := 0; arg < int(numArgs); arg++ { 17069 var currArg uint8 17070 err = decoder.DecodeUint8(&currArg) 17071 if err != nil { 17072 return types.SecurityMmapFileArgs{}, err 17073 } 17074 17075 switch currArg { 17076 case 0: 17077 result.Pathname, err = decoder.ReadStringFromBuff() 17078 if err != nil { 17079 return types.SecurityMmapFileArgs{}, err 17080 } 17081 case 1: 17082 err = decoder.DecodeInt32(&result.Flags) 17083 if err != nil { 17084 return types.SecurityMmapFileArgs{}, err 17085 } 17086 case 2: 17087 err = decoder.DecodeUint32(&result.Dev) 17088 if err != nil { 17089 return types.SecurityMmapFileArgs{}, err 17090 } 17091 case 3: 17092 err = decoder.DecodeUint64(&result.Inode) 17093 if err != nil { 17094 return types.SecurityMmapFileArgs{}, err 17095 } 17096 case 4: 17097 err = decoder.DecodeUint64(&result.Ctime) 17098 if err != nil { 17099 return types.SecurityMmapFileArgs{}, err 17100 } 17101 case 5: 17102 err = decoder.DecodeUint64(&result.Prot) 17103 if err != nil { 17104 return types.SecurityMmapFileArgs{}, err 17105 } 17106 case 6: 17107 err = decoder.DecodeUint64(&result.MmapFlags) 17108 if err != nil { 17109 return types.SecurityMmapFileArgs{}, err 17110 } 17111 } 17112 } 17113 return result, nil 17114 } 17115 17116 func ParseDoMmapArgs(decoder *Decoder) (types.DoMmapArgs, error) { 17117 var result types.DoMmapArgs 17118 var err error 17119 17120 var numArgs uint8 17121 err = decoder.DecodeUint8(&numArgs) 17122 if err != nil { 17123 return types.DoMmapArgs{}, err 17124 } 17125 17126 for arg := 0; arg < int(numArgs); arg++ { 17127 var currArg uint8 17128 err = decoder.DecodeUint8(&currArg) 17129 if err != nil { 17130 return types.DoMmapArgs{}, err 17131 } 17132 17133 switch currArg { 17134 case 0: 17135 var dataAddr uint64 17136 err = decoder.DecodeUint64(&dataAddr) 17137 if err != nil { 17138 return types.DoMmapArgs{}, err 17139 } 17140 result.Addr = uintptr(dataAddr) 17141 case 1: 17142 result.Pathname, err = decoder.ReadStringFromBuff() 17143 if err != nil { 17144 return types.DoMmapArgs{}, err 17145 } 17146 case 2: 17147 err = decoder.DecodeUint32(&result.Flags) 17148 if err != nil { 17149 return types.DoMmapArgs{}, err 17150 } 17151 case 3: 17152 err = decoder.DecodeUint32(&result.Dev) 17153 if err != nil { 17154 return types.DoMmapArgs{}, err 17155 } 17156 case 4: 17157 err = decoder.DecodeUint64(&result.Inode) 17158 if err != nil { 17159 return types.DoMmapArgs{}, err 17160 } 17161 case 5: 17162 err = decoder.DecodeUint64(&result.Ctime) 17163 if err != nil { 17164 return types.DoMmapArgs{}, err 17165 } 17166 case 6: 17167 err = decoder.DecodeUint64(&result.Pgoff) 17168 if err != nil { 17169 return types.DoMmapArgs{}, err 17170 } 17171 case 7: 17172 err = decoder.DecodeUint64(&result.Len) 17173 if err != nil { 17174 return types.DoMmapArgs{}, err 17175 } 17176 case 8: 17177 err = decoder.DecodeUint64(&result.Prot) 17178 if err != nil { 17179 return types.DoMmapArgs{}, err 17180 } 17181 case 9: 17182 err = decoder.DecodeUint64(&result.MmapFlags) 17183 if err != nil { 17184 return types.DoMmapArgs{}, err 17185 } 17186 } 17187 } 17188 return result, nil 17189 } 17190 17191 func ParseSecurityFileMprotectArgs(decoder *Decoder) (types.SecurityFileMprotectArgs, error) { 17192 var result types.SecurityFileMprotectArgs 17193 var err error 17194 17195 var numArgs uint8 17196 err = decoder.DecodeUint8(&numArgs) 17197 if err != nil { 17198 return types.SecurityFileMprotectArgs{}, err 17199 } 17200 17201 for arg := 0; arg < int(numArgs); arg++ { 17202 var currArg uint8 17203 err = decoder.DecodeUint8(&currArg) 17204 if err != nil { 17205 return types.SecurityFileMprotectArgs{}, err 17206 } 17207 17208 switch currArg { 17209 case 0: 17210 result.Pathname, err = decoder.ReadStringFromBuff() 17211 if err != nil { 17212 return types.SecurityFileMprotectArgs{}, err 17213 } 17214 case 1: 17215 err = decoder.DecodeInt32(&result.Prot) 17216 if err != nil { 17217 return types.SecurityFileMprotectArgs{}, err 17218 } 17219 case 2: 17220 err = decoder.DecodeUint64(&result.Ctime) 17221 if err != nil { 17222 return types.SecurityFileMprotectArgs{}, err 17223 } 17224 case 3: 17225 err = decoder.DecodeInt32(&result.PrevProt) 17226 if err != nil { 17227 return types.SecurityFileMprotectArgs{}, err 17228 } 17229 case 4: 17230 var dataAddr uint64 17231 err = decoder.DecodeUint64(&dataAddr) 17232 if err != nil { 17233 return types.SecurityFileMprotectArgs{}, err 17234 } 17235 result.Addr = uintptr(dataAddr) 17236 case 5: 17237 err = decoder.DecodeUint64(&result.Len) 17238 if err != nil { 17239 return types.SecurityFileMprotectArgs{}, err 17240 } 17241 case 6: 17242 err = decoder.DecodeInt32(&result.Pkey) 17243 if err != nil { 17244 return types.SecurityFileMprotectArgs{}, err 17245 } 17246 } 17247 } 17248 return result, nil 17249 } 17250 17251 func ParseInitNamespacesArgs(decoder *Decoder) (types.InitNamespacesArgs, error) { 17252 var result types.InitNamespacesArgs 17253 var err error 17254 17255 var numArgs uint8 17256 err = decoder.DecodeUint8(&numArgs) 17257 if err != nil { 17258 return types.InitNamespacesArgs{}, err 17259 } 17260 17261 for arg := 0; arg < int(numArgs); arg++ { 17262 var currArg uint8 17263 err = decoder.DecodeUint8(&currArg) 17264 if err != nil { 17265 return types.InitNamespacesArgs{}, err 17266 } 17267 17268 switch currArg { 17269 case 0: 17270 err = decoder.DecodeUint32(&result.Cgroup) 17271 if err != nil { 17272 return types.InitNamespacesArgs{}, err 17273 } 17274 case 1: 17275 err = decoder.DecodeUint32(&result.Ipc) 17276 if err != nil { 17277 return types.InitNamespacesArgs{}, err 17278 } 17279 case 2: 17280 err = decoder.DecodeUint32(&result.Mnt) 17281 if err != nil { 17282 return types.InitNamespacesArgs{}, err 17283 } 17284 case 3: 17285 err = decoder.DecodeUint32(&result.Net) 17286 if err != nil { 17287 return types.InitNamespacesArgs{}, err 17288 } 17289 case 4: 17290 err = decoder.DecodeUint32(&result.Pid) 17291 if err != nil { 17292 return types.InitNamespacesArgs{}, err 17293 } 17294 case 5: 17295 err = decoder.DecodeUint32(&result.PidForChildren) 17296 if err != nil { 17297 return types.InitNamespacesArgs{}, err 17298 } 17299 case 6: 17300 err = decoder.DecodeUint32(&result.Time) 17301 if err != nil { 17302 return types.InitNamespacesArgs{}, err 17303 } 17304 case 7: 17305 err = decoder.DecodeUint32(&result.TimeForChildren) 17306 if err != nil { 17307 return types.InitNamespacesArgs{}, err 17308 } 17309 case 8: 17310 err = decoder.DecodeUint32(&result.User) 17311 if err != nil { 17312 return types.InitNamespacesArgs{}, err 17313 } 17314 case 9: 17315 err = decoder.DecodeUint32(&result.Uts) 17316 if err != nil { 17317 return types.InitNamespacesArgs{}, err 17318 } 17319 } 17320 } 17321 return result, nil 17322 } 17323 17324 func ParseSocketDupArgs(decoder *Decoder) (types.SocketDupArgs, error) { 17325 var result types.SocketDupArgs 17326 var err error 17327 17328 var numArgs uint8 17329 err = decoder.DecodeUint8(&numArgs) 17330 if err != nil { 17331 return types.SocketDupArgs{}, err 17332 } 17333 17334 for arg := 0; arg < int(numArgs); arg++ { 17335 var currArg uint8 17336 err = decoder.DecodeUint8(&currArg) 17337 if err != nil { 17338 return types.SocketDupArgs{}, err 17339 } 17340 17341 switch currArg { 17342 case 0: 17343 err = decoder.DecodeInt32(&result.Oldfd) 17344 if err != nil { 17345 return types.SocketDupArgs{}, err 17346 } 17347 case 1: 17348 err = decoder.DecodeInt32(&result.Newfd) 17349 if err != nil { 17350 return types.SocketDupArgs{}, err 17351 } 17352 case 2: 17353 result.RemoteAddr, err = decoder.ReadSockaddrFromBuff() 17354 if err != nil { 17355 return types.SocketDupArgs{}, err 17356 } 17357 } 17358 } 17359 return result, nil 17360 } 17361 17362 func ParseHiddenInodesArgs(decoder *Decoder) (types.HiddenInodesArgs, error) { 17363 var result types.HiddenInodesArgs 17364 var err error 17365 17366 var numArgs uint8 17367 err = decoder.DecodeUint8(&numArgs) 17368 if err != nil { 17369 return types.HiddenInodesArgs{}, err 17370 } 17371 17372 for arg := 0; arg < int(numArgs); arg++ { 17373 var currArg uint8 17374 err = decoder.DecodeUint8(&currArg) 17375 if err != nil { 17376 return types.HiddenInodesArgs{}, err 17377 } 17378 17379 switch currArg { 17380 case 0: 17381 result.HiddenProcess, err = decoder.ReadStringFromBuff() 17382 if err != nil { 17383 return types.HiddenInodesArgs{}, err 17384 } 17385 } 17386 } 17387 return result, nil 17388 } 17389 17390 func ParseKernelWriteArgs(decoder *Decoder) (types.KernelWriteArgs, error) { 17391 var result types.KernelWriteArgs 17392 var err error 17393 17394 var numArgs uint8 17395 err = decoder.DecodeUint8(&numArgs) 17396 if err != nil { 17397 return types.KernelWriteArgs{}, err 17398 } 17399 17400 for arg := 0; arg < int(numArgs); arg++ { 17401 var currArg uint8 17402 err = decoder.DecodeUint8(&currArg) 17403 if err != nil { 17404 return types.KernelWriteArgs{}, err 17405 } 17406 17407 switch currArg { 17408 case 0: 17409 result.Pathname, err = decoder.ReadStringFromBuff() 17410 if err != nil { 17411 return types.KernelWriteArgs{}, err 17412 } 17413 case 1: 17414 err = decoder.DecodeUint32(&result.Dev) 17415 if err != nil { 17416 return types.KernelWriteArgs{}, err 17417 } 17418 case 2: 17419 err = decoder.DecodeUint64(&result.Inode) 17420 if err != nil { 17421 return types.KernelWriteArgs{}, err 17422 } 17423 case 3: 17424 err = decoder.DecodeUint64(&result.Count) 17425 if err != nil { 17426 return types.KernelWriteArgs{}, err 17427 } 17428 case 4: 17429 err = decoder.DecodeUint64(&result.Pos) 17430 if err != nil { 17431 return types.KernelWriteArgs{}, err 17432 } 17433 } 17434 } 17435 return result, nil 17436 } 17437 17438 func ParseDirtyPipeSpliceArgs(decoder *Decoder) (types.DirtyPipeSpliceArgs, error) { 17439 var result types.DirtyPipeSpliceArgs 17440 var err error 17441 17442 var numArgs uint8 17443 err = decoder.DecodeUint8(&numArgs) 17444 if err != nil { 17445 return types.DirtyPipeSpliceArgs{}, err 17446 } 17447 17448 for arg := 0; arg < int(numArgs); arg++ { 17449 var currArg uint8 17450 err = decoder.DecodeUint8(&currArg) 17451 if err != nil { 17452 return types.DirtyPipeSpliceArgs{}, err 17453 } 17454 17455 switch currArg { 17456 case 0: 17457 err = decoder.DecodeUint64(&result.InodeIn) 17458 if err != nil { 17459 return types.DirtyPipeSpliceArgs{}, err 17460 } 17461 case 1: 17462 err = decoder.DecodeUint16(&result.InFileType) 17463 if err != nil { 17464 return types.DirtyPipeSpliceArgs{}, err 17465 } 17466 case 2: 17467 result.InFilePath, err = decoder.ReadStringFromBuff() 17468 if err != nil { 17469 return types.DirtyPipeSpliceArgs{}, err 17470 } 17471 case 3: 17472 err = decoder.DecodeUint64(&result.ExposedDataStartOffset) 17473 if err != nil { 17474 return types.DirtyPipeSpliceArgs{}, err 17475 } 17476 case 4: 17477 err = decoder.DecodeUint64(&result.ExposedDataLen) 17478 if err != nil { 17479 return types.DirtyPipeSpliceArgs{}, err 17480 } 17481 case 5: 17482 err = decoder.DecodeUint64(&result.InodeOut) 17483 if err != nil { 17484 return types.DirtyPipeSpliceArgs{}, err 17485 } 17486 case 6: 17487 err = decoder.DecodeUint32(&result.OutPipeLastBufferFlags) 17488 if err != nil { 17489 return types.DirtyPipeSpliceArgs{}, err 17490 } 17491 } 17492 } 17493 return result, nil 17494 } 17495 17496 func ParseContainerCreateArgs(decoder *Decoder) (types.ContainerCreateArgs, error) { 17497 var result types.ContainerCreateArgs 17498 var err error 17499 17500 var numArgs uint8 17501 err = decoder.DecodeUint8(&numArgs) 17502 if err != nil { 17503 return types.ContainerCreateArgs{}, err 17504 } 17505 17506 for arg := 0; arg < int(numArgs); arg++ { 17507 var currArg uint8 17508 err = decoder.DecodeUint8(&currArg) 17509 if err != nil { 17510 return types.ContainerCreateArgs{}, err 17511 } 17512 17513 switch currArg { 17514 case 0: 17515 result.Runtime, err = decoder.ReadStringFromBuff() 17516 if err != nil { 17517 return types.ContainerCreateArgs{}, err 17518 } 17519 case 1: 17520 result.ContainerId, err = decoder.ReadStringFromBuff() 17521 if err != nil { 17522 return types.ContainerCreateArgs{}, err 17523 } 17524 case 2: 17525 err = decoder.DecodeUint64(&result.Ctime) 17526 if err != nil { 17527 return types.ContainerCreateArgs{}, err 17528 } 17529 case 3: 17530 result.ContainerImage, err = decoder.ReadStringFromBuff() 17531 if err != nil { 17532 return types.ContainerCreateArgs{}, err 17533 } 17534 case 4: 17535 result.ContainerImageDigest, err = decoder.ReadStringFromBuff() 17536 if err != nil { 17537 return types.ContainerCreateArgs{}, err 17538 } 17539 case 5: 17540 result.ContainerName, err = decoder.ReadStringFromBuff() 17541 if err != nil { 17542 return types.ContainerCreateArgs{}, err 17543 } 17544 case 6: 17545 result.PodName, err = decoder.ReadStringFromBuff() 17546 if err != nil { 17547 return types.ContainerCreateArgs{}, err 17548 } 17549 case 7: 17550 result.PodNamespace, err = decoder.ReadStringFromBuff() 17551 if err != nil { 17552 return types.ContainerCreateArgs{}, err 17553 } 17554 case 8: 17555 result.PodUid, err = decoder.ReadStringFromBuff() 17556 if err != nil { 17557 return types.ContainerCreateArgs{}, err 17558 } 17559 case 9: 17560 err = decoder.DecodeBool(&result.PodSandbox) 17561 if err != nil { 17562 return types.ContainerCreateArgs{}, err 17563 } 17564 } 17565 } 17566 return result, nil 17567 } 17568 17569 func ParseContainerRemoveArgs(decoder *Decoder) (types.ContainerRemoveArgs, error) { 17570 var result types.ContainerRemoveArgs 17571 var err error 17572 17573 var numArgs uint8 17574 err = decoder.DecodeUint8(&numArgs) 17575 if err != nil { 17576 return types.ContainerRemoveArgs{}, err 17577 } 17578 17579 for arg := 0; arg < int(numArgs); arg++ { 17580 var currArg uint8 17581 err = decoder.DecodeUint8(&currArg) 17582 if err != nil { 17583 return types.ContainerRemoveArgs{}, err 17584 } 17585 17586 switch currArg { 17587 case 0: 17588 result.Runtime, err = decoder.ReadStringFromBuff() 17589 if err != nil { 17590 return types.ContainerRemoveArgs{}, err 17591 } 17592 case 1: 17593 result.ContainerId, err = decoder.ReadStringFromBuff() 17594 if err != nil { 17595 return types.ContainerRemoveArgs{}, err 17596 } 17597 } 17598 } 17599 return result, nil 17600 } 17601 17602 func ParseExistingContainerArgs(decoder *Decoder) (types.ExistingContainerArgs, error) { 17603 var result types.ExistingContainerArgs 17604 var err error 17605 17606 var numArgs uint8 17607 err = decoder.DecodeUint8(&numArgs) 17608 if err != nil { 17609 return types.ExistingContainerArgs{}, err 17610 } 17611 17612 for arg := 0; arg < int(numArgs); arg++ { 17613 var currArg uint8 17614 err = decoder.DecodeUint8(&currArg) 17615 if err != nil { 17616 return types.ExistingContainerArgs{}, err 17617 } 17618 17619 switch currArg { 17620 case 0: 17621 result.Runtime, err = decoder.ReadStringFromBuff() 17622 if err != nil { 17623 return types.ExistingContainerArgs{}, err 17624 } 17625 case 1: 17626 result.ContainerId, err = decoder.ReadStringFromBuff() 17627 if err != nil { 17628 return types.ExistingContainerArgs{}, err 17629 } 17630 case 2: 17631 err = decoder.DecodeUint64(&result.Ctime) 17632 if err != nil { 17633 return types.ExistingContainerArgs{}, err 17634 } 17635 case 3: 17636 result.ContainerImage, err = decoder.ReadStringFromBuff() 17637 if err != nil { 17638 return types.ExistingContainerArgs{}, err 17639 } 17640 case 4: 17641 result.ContainerImageDigest, err = decoder.ReadStringFromBuff() 17642 if err != nil { 17643 return types.ExistingContainerArgs{}, err 17644 } 17645 case 5: 17646 result.ContainerName, err = decoder.ReadStringFromBuff() 17647 if err != nil { 17648 return types.ExistingContainerArgs{}, err 17649 } 17650 case 6: 17651 result.PodName, err = decoder.ReadStringFromBuff() 17652 if err != nil { 17653 return types.ExistingContainerArgs{}, err 17654 } 17655 case 7: 17656 result.PodNamespace, err = decoder.ReadStringFromBuff() 17657 if err != nil { 17658 return types.ExistingContainerArgs{}, err 17659 } 17660 case 8: 17661 result.PodUid, err = decoder.ReadStringFromBuff() 17662 if err != nil { 17663 return types.ExistingContainerArgs{}, err 17664 } 17665 case 9: 17666 err = decoder.DecodeBool(&result.PodSandbox) 17667 if err != nil { 17668 return types.ExistingContainerArgs{}, err 17669 } 17670 } 17671 } 17672 return result, nil 17673 } 17674 17675 func ParseProcCreateArgs(decoder *Decoder) (types.ProcCreateArgs, error) { 17676 var result types.ProcCreateArgs 17677 var err error 17678 17679 var numArgs uint8 17680 err = decoder.DecodeUint8(&numArgs) 17681 if err != nil { 17682 return types.ProcCreateArgs{}, err 17683 } 17684 17685 for arg := 0; arg < int(numArgs); arg++ { 17686 var currArg uint8 17687 err = decoder.DecodeUint8(&currArg) 17688 if err != nil { 17689 return types.ProcCreateArgs{}, err 17690 } 17691 17692 switch currArg { 17693 case 0: 17694 result.Name, err = decoder.ReadStringFromBuff() 17695 if err != nil { 17696 return types.ProcCreateArgs{}, err 17697 } 17698 case 1: 17699 var dataProcOpsAddr uint64 17700 err = decoder.DecodeUint64(&dataProcOpsAddr) 17701 if err != nil { 17702 return types.ProcCreateArgs{}, err 17703 } 17704 result.ProcOpsAddr = uintptr(dataProcOpsAddr) 17705 } 17706 } 17707 return result, nil 17708 } 17709 17710 func ParseKprobeAttachArgs(decoder *Decoder) (types.KprobeAttachArgs, error) { 17711 var result types.KprobeAttachArgs 17712 var err error 17713 17714 var numArgs uint8 17715 err = decoder.DecodeUint8(&numArgs) 17716 if err != nil { 17717 return types.KprobeAttachArgs{}, err 17718 } 17719 17720 for arg := 0; arg < int(numArgs); arg++ { 17721 var currArg uint8 17722 err = decoder.DecodeUint8(&currArg) 17723 if err != nil { 17724 return types.KprobeAttachArgs{}, err 17725 } 17726 17727 switch currArg { 17728 case 0: 17729 result.SymbolName, err = decoder.ReadStringFromBuff() 17730 if err != nil { 17731 return types.KprobeAttachArgs{}, err 17732 } 17733 case 1: 17734 var dataPreHandlerAddr uint64 17735 err = decoder.DecodeUint64(&dataPreHandlerAddr) 17736 if err != nil { 17737 return types.KprobeAttachArgs{}, err 17738 } 17739 result.PreHandlerAddr = uintptr(dataPreHandlerAddr) 17740 case 2: 17741 var dataPostHandlerAddr uint64 17742 err = decoder.DecodeUint64(&dataPostHandlerAddr) 17743 if err != nil { 17744 return types.KprobeAttachArgs{}, err 17745 } 17746 result.PostHandlerAddr = uintptr(dataPostHandlerAddr) 17747 } 17748 } 17749 return result, nil 17750 } 17751 17752 func ParseCallUsermodeHelperArgs(decoder *Decoder) (types.CallUsermodeHelperArgs, error) { 17753 var result types.CallUsermodeHelperArgs 17754 var err error 17755 17756 var numArgs uint8 17757 err = decoder.DecodeUint8(&numArgs) 17758 if err != nil { 17759 return types.CallUsermodeHelperArgs{}, err 17760 } 17761 17762 for arg := 0; arg < int(numArgs); arg++ { 17763 var currArg uint8 17764 err = decoder.DecodeUint8(&currArg) 17765 if err != nil { 17766 return types.CallUsermodeHelperArgs{}, err 17767 } 17768 17769 switch currArg { 17770 case 0: 17771 result.Pathname, err = decoder.ReadStringFromBuff() 17772 if err != nil { 17773 return types.CallUsermodeHelperArgs{}, err 17774 } 17775 case 1: 17776 result.Argv, err = decoder.ReadStringArrayFromBuff() 17777 if err != nil { 17778 return types.CallUsermodeHelperArgs{}, err 17779 } 17780 case 2: 17781 result.Envp, err = decoder.ReadStringArrayFromBuff() 17782 if err != nil { 17783 return types.CallUsermodeHelperArgs{}, err 17784 } 17785 case 3: 17786 err = decoder.DecodeInt32(&result.Wait) 17787 if err != nil { 17788 return types.CallUsermodeHelperArgs{}, err 17789 } 17790 } 17791 } 17792 return result, nil 17793 } 17794 17795 func ParseDebugfsCreateFileArgs(decoder *Decoder) (types.DebugfsCreateFileArgs, error) { 17796 var result types.DebugfsCreateFileArgs 17797 var err error 17798 17799 var numArgs uint8 17800 err = decoder.DecodeUint8(&numArgs) 17801 if err != nil { 17802 return types.DebugfsCreateFileArgs{}, err 17803 } 17804 17805 for arg := 0; arg < int(numArgs); arg++ { 17806 var currArg uint8 17807 err = decoder.DecodeUint8(&currArg) 17808 if err != nil { 17809 return types.DebugfsCreateFileArgs{}, err 17810 } 17811 17812 switch currArg { 17813 case 0: 17814 result.FileName, err = decoder.ReadStringFromBuff() 17815 if err != nil { 17816 return types.DebugfsCreateFileArgs{}, err 17817 } 17818 case 1: 17819 result.Path, err = decoder.ReadStringFromBuff() 17820 if err != nil { 17821 return types.DebugfsCreateFileArgs{}, err 17822 } 17823 case 2: 17824 err = decoder.DecodeUint32(&result.Mode) 17825 if err != nil { 17826 return types.DebugfsCreateFileArgs{}, err 17827 } 17828 case 3: 17829 var dataProcOpsAddr uint64 17830 err = decoder.DecodeUint64(&dataProcOpsAddr) 17831 if err != nil { 17832 return types.DebugfsCreateFileArgs{}, err 17833 } 17834 result.ProcOpsAddr = uintptr(dataProcOpsAddr) 17835 } 17836 } 17837 return result, nil 17838 } 17839 17840 func ParsePrintSyscallTableArgs(decoder *Decoder) (types.PrintSyscallTableArgs, error) { 17841 var result types.PrintSyscallTableArgs 17842 var err error 17843 17844 var numArgs uint8 17845 err = decoder.DecodeUint8(&numArgs) 17846 if err != nil { 17847 return types.PrintSyscallTableArgs{}, err 17848 } 17849 17850 for arg := 0; arg < int(numArgs); arg++ { 17851 var currArg uint8 17852 err = decoder.DecodeUint8(&currArg) 17853 if err != nil { 17854 return types.PrintSyscallTableArgs{}, err 17855 } 17856 17857 switch currArg { 17858 case 0: 17859 err = decoder.DecodeUint64Array(&result.SyscallsAddresses) 17860 if err != nil { 17861 return types.PrintSyscallTableArgs{}, err 17862 } 17863 case 1: 17864 err = decoder.DecodeUint64(&result.CallerContextId) 17865 if err != nil { 17866 return types.PrintSyscallTableArgs{}, err 17867 } 17868 } 17869 } 17870 return result, nil 17871 } 17872 17873 func ParseHiddenKernelModuleArgs(decoder *Decoder) (types.HiddenKernelModuleArgs, error) { 17874 var result types.HiddenKernelModuleArgs 17875 var err error 17876 17877 var numArgs uint8 17878 err = decoder.DecodeUint8(&numArgs) 17879 if err != nil { 17880 return types.HiddenKernelModuleArgs{}, err 17881 } 17882 17883 for arg := 0; arg < int(numArgs); arg++ { 17884 var currArg uint8 17885 err = decoder.DecodeUint8(&currArg) 17886 if err != nil { 17887 return types.HiddenKernelModuleArgs{}, err 17888 } 17889 17890 switch currArg { 17891 case 0: 17892 result.Address, err = decoder.ReadStringFromBuff() 17893 if err != nil { 17894 return types.HiddenKernelModuleArgs{}, err 17895 } 17896 case 1: 17897 result.Name, err = decoder.ReadStringFromBuff() 17898 if err != nil { 17899 return types.HiddenKernelModuleArgs{}, err 17900 } 17901 case 2: 17902 result.Srcversion, err = decoder.ReadStringFromBuff() 17903 if err != nil { 17904 return types.HiddenKernelModuleArgs{}, err 17905 } 17906 } 17907 } 17908 return result, nil 17909 } 17910 17911 func ParseHiddenKernelModuleSeekerArgs(decoder *Decoder) (types.HiddenKernelModuleSeekerArgs, error) { 17912 var result types.HiddenKernelModuleSeekerArgs 17913 var err error 17914 17915 var numArgs uint8 17916 err = decoder.DecodeUint8(&numArgs) 17917 if err != nil { 17918 return types.HiddenKernelModuleSeekerArgs{}, err 17919 } 17920 17921 for arg := 0; arg < int(numArgs); arg++ { 17922 var currArg uint8 17923 err = decoder.DecodeUint8(&currArg) 17924 if err != nil { 17925 return types.HiddenKernelModuleSeekerArgs{}, err 17926 } 17927 17928 switch currArg { 17929 case 0: 17930 err = decoder.DecodeUint64(&result.Address) 17931 if err != nil { 17932 return types.HiddenKernelModuleSeekerArgs{}, err 17933 } 17934 case 1: 17935 result.Name, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.HiddenKernelModuleSeeker)) 17936 if err != nil { 17937 return types.HiddenKernelModuleSeekerArgs{}, err 17938 } 17939 case 2: 17940 err = decoder.DecodeUint32(&result.Flags) 17941 if err != nil { 17942 return types.HiddenKernelModuleSeekerArgs{}, err 17943 } 17944 case 3: 17945 result.Srcversion, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.HiddenKernelModuleSeeker)) 17946 if err != nil { 17947 return types.HiddenKernelModuleSeekerArgs{}, err 17948 } 17949 } 17950 } 17951 return result, nil 17952 } 17953 17954 func ParseHookedSyscallsArgs(decoder *Decoder) (types.HookedSyscallsArgs, error) { 17955 var result types.HookedSyscallsArgs 17956 var err error 17957 17958 var numArgs uint8 17959 err = decoder.DecodeUint8(&numArgs) 17960 if err != nil { 17961 return types.HookedSyscallsArgs{}, err 17962 } 17963 17964 for arg := 0; arg < int(numArgs); arg++ { 17965 var currArg uint8 17966 err = decoder.DecodeUint8(&currArg) 17967 if err != nil { 17968 return types.HookedSyscallsArgs{}, err 17969 } 17970 17971 switch currArg { 17972 case 0: 17973 var dataCheckSyscalls uint64 17974 err = decoder.DecodeUint64(&dataCheckSyscalls) 17975 if err != nil { 17976 return types.HookedSyscallsArgs{}, err 17977 } 17978 result.CheckSyscalls = uintptr(dataCheckSyscalls) 17979 case 1: 17980 var dataHookedSyscalls uint64 17981 err = decoder.DecodeUint64(&dataHookedSyscalls) 17982 if err != nil { 17983 return types.HookedSyscallsArgs{}, err 17984 } 17985 result.HookedSyscalls = uintptr(dataHookedSyscalls) 17986 } 17987 } 17988 return result, nil 17989 } 17990 17991 func ParseDebugfsCreateDirArgs(decoder *Decoder) (types.DebugfsCreateDirArgs, error) { 17992 var result types.DebugfsCreateDirArgs 17993 var err error 17994 17995 var numArgs uint8 17996 err = decoder.DecodeUint8(&numArgs) 17997 if err != nil { 17998 return types.DebugfsCreateDirArgs{}, err 17999 } 18000 18001 for arg := 0; arg < int(numArgs); arg++ { 18002 var currArg uint8 18003 err = decoder.DecodeUint8(&currArg) 18004 if err != nil { 18005 return types.DebugfsCreateDirArgs{}, err 18006 } 18007 18008 switch currArg { 18009 case 0: 18010 result.Name, err = decoder.ReadStringFromBuff() 18011 if err != nil { 18012 return types.DebugfsCreateDirArgs{}, err 18013 } 18014 case 1: 18015 result.Path, err = decoder.ReadStringFromBuff() 18016 if err != nil { 18017 return types.DebugfsCreateDirArgs{}, err 18018 } 18019 } 18020 } 18021 return result, nil 18022 } 18023 18024 func ParseDeviceAddArgs(decoder *Decoder) (types.DeviceAddArgs, error) { 18025 var result types.DeviceAddArgs 18026 var err error 18027 18028 var numArgs uint8 18029 err = decoder.DecodeUint8(&numArgs) 18030 if err != nil { 18031 return types.DeviceAddArgs{}, err 18032 } 18033 18034 for arg := 0; arg < int(numArgs); arg++ { 18035 var currArg uint8 18036 err = decoder.DecodeUint8(&currArg) 18037 if err != nil { 18038 return types.DeviceAddArgs{}, err 18039 } 18040 18041 switch currArg { 18042 case 0: 18043 result.Name, err = decoder.ReadStringFromBuff() 18044 if err != nil { 18045 return types.DeviceAddArgs{}, err 18046 } 18047 case 1: 18048 result.ParentName, err = decoder.ReadStringFromBuff() 18049 if err != nil { 18050 return types.DeviceAddArgs{}, err 18051 } 18052 } 18053 } 18054 return result, nil 18055 } 18056 18057 func ParseRegisterChrdevArgs(decoder *Decoder) (types.RegisterChrdevArgs, error) { 18058 var result types.RegisterChrdevArgs 18059 var err error 18060 18061 var numArgs uint8 18062 err = decoder.DecodeUint8(&numArgs) 18063 if err != nil { 18064 return types.RegisterChrdevArgs{}, err 18065 } 18066 18067 for arg := 0; arg < int(numArgs); arg++ { 18068 var currArg uint8 18069 err = decoder.DecodeUint8(&currArg) 18070 if err != nil { 18071 return types.RegisterChrdevArgs{}, err 18072 } 18073 18074 switch currArg { 18075 case 0: 18076 err = decoder.DecodeUint32(&result.RequestedMajorNumber) 18077 if err != nil { 18078 return types.RegisterChrdevArgs{}, err 18079 } 18080 case 1: 18081 err = decoder.DecodeUint32(&result.GrantedMajorNumber) 18082 if err != nil { 18083 return types.RegisterChrdevArgs{}, err 18084 } 18085 case 2: 18086 result.CharDeviceName, err = decoder.ReadStringFromBuff() 18087 if err != nil { 18088 return types.RegisterChrdevArgs{}, err 18089 } 18090 case 3: 18091 var dataCharDeviceFops uint64 18092 err = decoder.DecodeUint64(&dataCharDeviceFops) 18093 if err != nil { 18094 return types.RegisterChrdevArgs{}, err 18095 } 18096 result.CharDeviceFops = uintptr(dataCharDeviceFops) 18097 } 18098 } 18099 return result, nil 18100 } 18101 18102 func ParseSharedObjectLoadedArgs(decoder *Decoder) (types.SharedObjectLoadedArgs, error) { 18103 var result types.SharedObjectLoadedArgs 18104 var err error 18105 18106 var numArgs uint8 18107 err = decoder.DecodeUint8(&numArgs) 18108 if err != nil { 18109 return types.SharedObjectLoadedArgs{}, err 18110 } 18111 18112 for arg := 0; arg < int(numArgs); arg++ { 18113 var currArg uint8 18114 err = decoder.DecodeUint8(&currArg) 18115 if err != nil { 18116 return types.SharedObjectLoadedArgs{}, err 18117 } 18118 18119 switch currArg { 18120 case 0: 18121 result.Pathname, err = decoder.ReadStringFromBuff() 18122 if err != nil { 18123 return types.SharedObjectLoadedArgs{}, err 18124 } 18125 case 1: 18126 err = decoder.DecodeInt32(&result.Flags) 18127 if err != nil { 18128 return types.SharedObjectLoadedArgs{}, err 18129 } 18130 case 2: 18131 err = decoder.DecodeUint32(&result.Dev) 18132 if err != nil { 18133 return types.SharedObjectLoadedArgs{}, err 18134 } 18135 case 3: 18136 err = decoder.DecodeUint64(&result.Inode) 18137 if err != nil { 18138 return types.SharedObjectLoadedArgs{}, err 18139 } 18140 case 4: 18141 err = decoder.DecodeUint64(&result.Ctime) 18142 if err != nil { 18143 return types.SharedObjectLoadedArgs{}, err 18144 } 18145 } 18146 } 18147 return result, nil 18148 } 18149 18150 func ParseSymbolsLoadedArgs(decoder *Decoder) (types.SymbolsLoadedArgs, error) { 18151 var result types.SymbolsLoadedArgs 18152 var err error 18153 18154 var numArgs uint8 18155 err = decoder.DecodeUint8(&numArgs) 18156 if err != nil { 18157 return types.SymbolsLoadedArgs{}, err 18158 } 18159 18160 for arg := 0; arg < int(numArgs); arg++ { 18161 var currArg uint8 18162 err = decoder.DecodeUint8(&currArg) 18163 if err != nil { 18164 return types.SymbolsLoadedArgs{}, err 18165 } 18166 18167 switch currArg { 18168 case 0: 18169 result.LibraryPath, err = decoder.ReadStringFromBuff() 18170 if err != nil { 18171 return types.SymbolsLoadedArgs{}, err 18172 } 18173 case 1: 18174 result.Symbols, err = decoder.ReadStringArrayFromBuff() 18175 if err != nil { 18176 return types.SymbolsLoadedArgs{}, err 18177 } 18178 } 18179 } 18180 return result, nil 18181 } 18182 18183 func ParseSymbolsCollisionArgs(decoder *Decoder) (types.SymbolsCollisionArgs, error) { 18184 var result types.SymbolsCollisionArgs 18185 var err error 18186 18187 var numArgs uint8 18188 err = decoder.DecodeUint8(&numArgs) 18189 if err != nil { 18190 return types.SymbolsCollisionArgs{}, err 18191 } 18192 18193 for arg := 0; arg < int(numArgs); arg++ { 18194 var currArg uint8 18195 err = decoder.DecodeUint8(&currArg) 18196 if err != nil { 18197 return types.SymbolsCollisionArgs{}, err 18198 } 18199 18200 switch currArg { 18201 case 0: 18202 result.LoadedPath, err = decoder.ReadStringFromBuff() 18203 if err != nil { 18204 return types.SymbolsCollisionArgs{}, err 18205 } 18206 case 1: 18207 result.CollisionPath, err = decoder.ReadStringFromBuff() 18208 if err != nil { 18209 return types.SymbolsCollisionArgs{}, err 18210 } 18211 case 2: 18212 result.Symbols, err = decoder.ReadStringArrayFromBuff() 18213 if err != nil { 18214 return types.SymbolsCollisionArgs{}, err 18215 } 18216 } 18217 } 18218 return result, nil 18219 } 18220 18221 func ParseCaptureFileWriteArgs(decoder *Decoder) (types.CaptureFileWriteArgs, error) { 18222 return types.CaptureFileWriteArgs{}, nil 18223 } 18224 18225 func ParseCaptureFileReadArgs(decoder *Decoder) (types.CaptureFileReadArgs, error) { 18226 return types.CaptureFileReadArgs{}, nil 18227 } 18228 18229 func ParseCaptureExecArgs(decoder *Decoder) (types.CaptureExecArgs, error) { 18230 return types.CaptureExecArgs{}, nil 18231 } 18232 18233 func ParseCaptureModuleArgs(decoder *Decoder) (types.CaptureModuleArgs, error) { 18234 return types.CaptureModuleArgs{}, nil 18235 } 18236 18237 func ParseCaptureMemArgs(decoder *Decoder) (types.CaptureMemArgs, error) { 18238 return types.CaptureMemArgs{}, nil 18239 } 18240 18241 func ParseCaptureBpfArgs(decoder *Decoder) (types.CaptureBpfArgs, error) { 18242 return types.CaptureBpfArgs{}, nil 18243 } 18244 18245 func ParseDoInitModuleArgs(decoder *Decoder) (types.DoInitModuleArgs, error) { 18246 var result types.DoInitModuleArgs 18247 var err error 18248 18249 var numArgs uint8 18250 err = decoder.DecodeUint8(&numArgs) 18251 if err != nil { 18252 return types.DoInitModuleArgs{}, err 18253 } 18254 18255 for arg := 0; arg < int(numArgs); arg++ { 18256 var currArg uint8 18257 err = decoder.DecodeUint8(&currArg) 18258 if err != nil { 18259 return types.DoInitModuleArgs{}, err 18260 } 18261 18262 switch currArg { 18263 case 0: 18264 result.Name, err = decoder.ReadStringFromBuff() 18265 if err != nil { 18266 return types.DoInitModuleArgs{}, err 18267 } 18268 case 1: 18269 result.Version, err = decoder.ReadStringFromBuff() 18270 if err != nil { 18271 return types.DoInitModuleArgs{}, err 18272 } 18273 case 2: 18274 result.SrcVersion, err = decoder.ReadStringFromBuff() 18275 if err != nil { 18276 return types.DoInitModuleArgs{}, err 18277 } 18278 } 18279 } 18280 return result, nil 18281 } 18282 18283 func ParseModuleLoadArgs(decoder *Decoder) (types.ModuleLoadArgs, error) { 18284 var result types.ModuleLoadArgs 18285 var err error 18286 18287 var numArgs uint8 18288 err = decoder.DecodeUint8(&numArgs) 18289 if err != nil { 18290 return types.ModuleLoadArgs{}, err 18291 } 18292 18293 for arg := 0; arg < int(numArgs); arg++ { 18294 var currArg uint8 18295 err = decoder.DecodeUint8(&currArg) 18296 if err != nil { 18297 return types.ModuleLoadArgs{}, err 18298 } 18299 18300 switch currArg { 18301 case 0: 18302 result.Name, err = decoder.ReadStringFromBuff() 18303 if err != nil { 18304 return types.ModuleLoadArgs{}, err 18305 } 18306 case 1: 18307 result.Version, err = decoder.ReadStringFromBuff() 18308 if err != nil { 18309 return types.ModuleLoadArgs{}, err 18310 } 18311 case 2: 18312 result.SrcVersion, err = decoder.ReadStringFromBuff() 18313 if err != nil { 18314 return types.ModuleLoadArgs{}, err 18315 } 18316 } 18317 } 18318 return result, nil 18319 } 18320 18321 func ParseModuleFreeArgs(decoder *Decoder) (types.ModuleFreeArgs, error) { 18322 var result types.ModuleFreeArgs 18323 var err error 18324 18325 var numArgs uint8 18326 err = decoder.DecodeUint8(&numArgs) 18327 if err != nil { 18328 return types.ModuleFreeArgs{}, err 18329 } 18330 18331 for arg := 0; arg < int(numArgs); arg++ { 18332 var currArg uint8 18333 err = decoder.DecodeUint8(&currArg) 18334 if err != nil { 18335 return types.ModuleFreeArgs{}, err 18336 } 18337 18338 switch currArg { 18339 case 0: 18340 result.Name, err = decoder.ReadStringFromBuff() 18341 if err != nil { 18342 return types.ModuleFreeArgs{}, err 18343 } 18344 case 1: 18345 result.Version, err = decoder.ReadStringFromBuff() 18346 if err != nil { 18347 return types.ModuleFreeArgs{}, err 18348 } 18349 case 2: 18350 result.SrcVersion, err = decoder.ReadStringFromBuff() 18351 if err != nil { 18352 return types.ModuleFreeArgs{}, err 18353 } 18354 } 18355 } 18356 return result, nil 18357 } 18358 18359 func ParseSocketAcceptArgs(decoder *Decoder) (types.SocketAcceptArgs, error) { 18360 var result types.SocketAcceptArgs 18361 var err error 18362 18363 var numArgs uint8 18364 err = decoder.DecodeUint8(&numArgs) 18365 if err != nil { 18366 return types.SocketAcceptArgs{}, err 18367 } 18368 18369 for arg := 0; arg < int(numArgs); arg++ { 18370 var currArg uint8 18371 err = decoder.DecodeUint8(&currArg) 18372 if err != nil { 18373 return types.SocketAcceptArgs{}, err 18374 } 18375 18376 switch currArg { 18377 case 0: 18378 err = decoder.DecodeInt32(&result.Sockfd) 18379 if err != nil { 18380 return types.SocketAcceptArgs{}, err 18381 } 18382 case 1: 18383 result.LocalAddr, err = decoder.ReadSockaddrFromBuff() 18384 if err != nil { 18385 return types.SocketAcceptArgs{}, err 18386 } 18387 case 2: 18388 result.RemoteAddr, err = decoder.ReadSockaddrFromBuff() 18389 if err != nil { 18390 return types.SocketAcceptArgs{}, err 18391 } 18392 } 18393 } 18394 return result, nil 18395 } 18396 18397 func ParseLoadElfPhdrsArgs(decoder *Decoder) (types.LoadElfPhdrsArgs, error) { 18398 var result types.LoadElfPhdrsArgs 18399 var err error 18400 18401 var numArgs uint8 18402 err = decoder.DecodeUint8(&numArgs) 18403 if err != nil { 18404 return types.LoadElfPhdrsArgs{}, err 18405 } 18406 18407 for arg := 0; arg < int(numArgs); arg++ { 18408 var currArg uint8 18409 err = decoder.DecodeUint8(&currArg) 18410 if err != nil { 18411 return types.LoadElfPhdrsArgs{}, err 18412 } 18413 18414 switch currArg { 18415 case 0: 18416 result.Pathname, err = decoder.ReadStringFromBuff() 18417 if err != nil { 18418 return types.LoadElfPhdrsArgs{}, err 18419 } 18420 case 1: 18421 err = decoder.DecodeUint32(&result.Dev) 18422 if err != nil { 18423 return types.LoadElfPhdrsArgs{}, err 18424 } 18425 case 2: 18426 err = decoder.DecodeUint64(&result.Inode) 18427 if err != nil { 18428 return types.LoadElfPhdrsArgs{}, err 18429 } 18430 } 18431 } 18432 return result, nil 18433 } 18434 18435 func ParsePrintNetSeqOpsArgs(decoder *Decoder) (types.PrintNetSeqOpsArgs, error) { 18436 var result types.PrintNetSeqOpsArgs 18437 var err error 18438 18439 var numArgs uint8 18440 err = decoder.DecodeUint8(&numArgs) 18441 if err != nil { 18442 return types.PrintNetSeqOpsArgs{}, err 18443 } 18444 18445 for arg := 0; arg < int(numArgs); arg++ { 18446 var currArg uint8 18447 err = decoder.DecodeUint8(&currArg) 18448 if err != nil { 18449 return types.PrintNetSeqOpsArgs{}, err 18450 } 18451 18452 switch currArg { 18453 case 0: 18454 err = decoder.DecodeUint64Array(&result.NetSeqOps) 18455 if err != nil { 18456 return types.PrintNetSeqOpsArgs{}, err 18457 } 18458 case 1: 18459 err = decoder.DecodeUint64(&result.CallerContextId) 18460 if err != nil { 18461 return types.PrintNetSeqOpsArgs{}, err 18462 } 18463 } 18464 } 18465 return result, nil 18466 } 18467 18468 func ParseHookedSeqOpsArgs(decoder *Decoder) (types.HookedSeqOpsArgs, error) { 18469 var result types.HookedSeqOpsArgs 18470 var err error 18471 18472 var numArgs uint8 18473 err = decoder.DecodeUint8(&numArgs) 18474 if err != nil { 18475 return types.HookedSeqOpsArgs{}, err 18476 } 18477 18478 for arg := 0; arg < int(numArgs); arg++ { 18479 var currArg uint8 18480 err = decoder.DecodeUint8(&currArg) 18481 if err != nil { 18482 return types.HookedSeqOpsArgs{}, err 18483 } 18484 18485 switch currArg { 18486 case 0: 18487 var dataHookedSeqOps uint64 18488 err = decoder.DecodeUint64(&dataHookedSeqOps) 18489 if err != nil { 18490 return types.HookedSeqOpsArgs{}, err 18491 } 18492 result.HookedSeqOps = uintptr(dataHookedSeqOps) 18493 } 18494 } 18495 return result, nil 18496 } 18497 18498 func ParseTaskRenameArgs(decoder *Decoder) (types.TaskRenameArgs, error) { 18499 var result types.TaskRenameArgs 18500 var err error 18501 18502 var numArgs uint8 18503 err = decoder.DecodeUint8(&numArgs) 18504 if err != nil { 18505 return types.TaskRenameArgs{}, err 18506 } 18507 18508 for arg := 0; arg < int(numArgs); arg++ { 18509 var currArg uint8 18510 err = decoder.DecodeUint8(&currArg) 18511 if err != nil { 18512 return types.TaskRenameArgs{}, err 18513 } 18514 18515 switch currArg { 18516 case 0: 18517 result.OldName, err = decoder.ReadStringFromBuff() 18518 if err != nil { 18519 return types.TaskRenameArgs{}, err 18520 } 18521 case 1: 18522 result.NewName, err = decoder.ReadStringFromBuff() 18523 if err != nil { 18524 return types.TaskRenameArgs{}, err 18525 } 18526 } 18527 } 18528 return result, nil 18529 } 18530 18531 func ParseSecurityInodeRenameArgs(decoder *Decoder) (types.SecurityInodeRenameArgs, error) { 18532 var result types.SecurityInodeRenameArgs 18533 var err error 18534 18535 var numArgs uint8 18536 err = decoder.DecodeUint8(&numArgs) 18537 if err != nil { 18538 return types.SecurityInodeRenameArgs{}, err 18539 } 18540 18541 for arg := 0; arg < int(numArgs); arg++ { 18542 var currArg uint8 18543 err = decoder.DecodeUint8(&currArg) 18544 if err != nil { 18545 return types.SecurityInodeRenameArgs{}, err 18546 } 18547 18548 switch currArg { 18549 case 0: 18550 result.OldPath, err = decoder.ReadStringFromBuff() 18551 if err != nil { 18552 return types.SecurityInodeRenameArgs{}, err 18553 } 18554 case 1: 18555 result.NewPath, err = decoder.ReadStringFromBuff() 18556 if err != nil { 18557 return types.SecurityInodeRenameArgs{}, err 18558 } 18559 } 18560 } 18561 return result, nil 18562 } 18563 18564 func ParseDoSigactionArgs(decoder *Decoder) (types.DoSigactionArgs, error) { 18565 var result types.DoSigactionArgs 18566 var err error 18567 18568 var numArgs uint8 18569 err = decoder.DecodeUint8(&numArgs) 18570 if err != nil { 18571 return types.DoSigactionArgs{}, err 18572 } 18573 18574 for arg := 0; arg < int(numArgs); arg++ { 18575 var currArg uint8 18576 err = decoder.DecodeUint8(&currArg) 18577 if err != nil { 18578 return types.DoSigactionArgs{}, err 18579 } 18580 18581 switch currArg { 18582 case 0: 18583 err = decoder.DecodeInt32(&result.Sig) 18584 if err != nil { 18585 return types.DoSigactionArgs{}, err 18586 } 18587 case 1: 18588 err = decoder.DecodeBool(&result.IsSaInitialized) 18589 if err != nil { 18590 return types.DoSigactionArgs{}, err 18591 } 18592 case 2: 18593 err = decoder.DecodeUint64(&result.SaFlags) 18594 if err != nil { 18595 return types.DoSigactionArgs{}, err 18596 } 18597 case 3: 18598 err = decoder.DecodeUint64(&result.SaMask) 18599 if err != nil { 18600 return types.DoSigactionArgs{}, err 18601 } 18602 case 4: 18603 err = decoder.DecodeUint8(&result.SaHandleMethod) 18604 if err != nil { 18605 return types.DoSigactionArgs{}, err 18606 } 18607 case 5: 18608 var dataSaHandler uint64 18609 err = decoder.DecodeUint64(&dataSaHandler) 18610 if err != nil { 18611 return types.DoSigactionArgs{}, err 18612 } 18613 result.SaHandler = uintptr(dataSaHandler) 18614 case 6: 18615 err = decoder.DecodeBool(&result.IsOldSaInitialized) 18616 if err != nil { 18617 return types.DoSigactionArgs{}, err 18618 } 18619 case 7: 18620 err = decoder.DecodeUint64(&result.OldSaFlags) 18621 if err != nil { 18622 return types.DoSigactionArgs{}, err 18623 } 18624 case 8: 18625 err = decoder.DecodeUint64(&result.OldSaMask) 18626 if err != nil { 18627 return types.DoSigactionArgs{}, err 18628 } 18629 case 9: 18630 err = decoder.DecodeUint8(&result.OldSaHandleMethod) 18631 if err != nil { 18632 return types.DoSigactionArgs{}, err 18633 } 18634 case 10: 18635 var dataOldSaHandler uint64 18636 err = decoder.DecodeUint64(&dataOldSaHandler) 18637 if err != nil { 18638 return types.DoSigactionArgs{}, err 18639 } 18640 result.OldSaHandler = uintptr(dataOldSaHandler) 18641 } 18642 } 18643 return result, nil 18644 } 18645 18646 func ParseBpfAttachArgs(decoder *Decoder) (types.BpfAttachArgs, error) { 18647 var result types.BpfAttachArgs 18648 var err error 18649 18650 var numArgs uint8 18651 err = decoder.DecodeUint8(&numArgs) 18652 if err != nil { 18653 return types.BpfAttachArgs{}, err 18654 } 18655 18656 for arg := 0; arg < int(numArgs); arg++ { 18657 var currArg uint8 18658 err = decoder.DecodeUint8(&currArg) 18659 if err != nil { 18660 return types.BpfAttachArgs{}, err 18661 } 18662 18663 switch currArg { 18664 case 0: 18665 err = decoder.DecodeInt32(&result.ProgType) 18666 if err != nil { 18667 return types.BpfAttachArgs{}, err 18668 } 18669 case 1: 18670 result.ProgName, err = decoder.ReadStringFromBuff() 18671 if err != nil { 18672 return types.BpfAttachArgs{}, err 18673 } 18674 case 2: 18675 err = decoder.DecodeUint32(&result.ProgId) 18676 if err != nil { 18677 return types.BpfAttachArgs{}, err 18678 } 18679 case 3: 18680 err = decoder.DecodeUint64Array(&result.ProgHelpers) 18681 if err != nil { 18682 return types.BpfAttachArgs{}, err 18683 } 18684 case 4: 18685 result.SymbolName, err = decoder.ReadStringFromBuff() 18686 if err != nil { 18687 return types.BpfAttachArgs{}, err 18688 } 18689 case 5: 18690 err = decoder.DecodeUint64(&result.SymbolAddr) 18691 if err != nil { 18692 return types.BpfAttachArgs{}, err 18693 } 18694 case 6: 18695 err = decoder.DecodeInt32(&result.AttachType) 18696 if err != nil { 18697 return types.BpfAttachArgs{}, err 18698 } 18699 } 18700 } 18701 return result, nil 18702 } 18703 18704 func ParseKallsymsLookupNameArgs(decoder *Decoder) (types.KallsymsLookupNameArgs, error) { 18705 var result types.KallsymsLookupNameArgs 18706 var err error 18707 18708 var numArgs uint8 18709 err = decoder.DecodeUint8(&numArgs) 18710 if err != nil { 18711 return types.KallsymsLookupNameArgs{}, err 18712 } 18713 18714 for arg := 0; arg < int(numArgs); arg++ { 18715 var currArg uint8 18716 err = decoder.DecodeUint8(&currArg) 18717 if err != nil { 18718 return types.KallsymsLookupNameArgs{}, err 18719 } 18720 18721 switch currArg { 18722 case 0: 18723 result.SymbolName, err = decoder.ReadStringFromBuff() 18724 if err != nil { 18725 return types.KallsymsLookupNameArgs{}, err 18726 } 18727 case 1: 18728 var dataSymbolAddress uint64 18729 err = decoder.DecodeUint64(&dataSymbolAddress) 18730 if err != nil { 18731 return types.KallsymsLookupNameArgs{}, err 18732 } 18733 result.SymbolAddress = uintptr(dataSymbolAddress) 18734 } 18735 } 18736 return result, nil 18737 } 18738 18739 func ParsePrintMemDumpArgs(decoder *Decoder) (types.PrintMemDumpArgs, error) { 18740 var result types.PrintMemDumpArgs 18741 var err error 18742 18743 var numArgs uint8 18744 err = decoder.DecodeUint8(&numArgs) 18745 if err != nil { 18746 return types.PrintMemDumpArgs{}, err 18747 } 18748 18749 for arg := 0; arg < int(numArgs); arg++ { 18750 var currArg uint8 18751 err = decoder.DecodeUint8(&currArg) 18752 if err != nil { 18753 return types.PrintMemDumpArgs{}, err 18754 } 18755 18756 switch currArg { 18757 case 0: 18758 result.Bytes, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.PrintMemDump)) 18759 if err != nil { 18760 return types.PrintMemDumpArgs{}, err 18761 } 18762 case 1: 18763 var dataAddress uint64 18764 err = decoder.DecodeUint64(&dataAddress) 18765 if err != nil { 18766 return types.PrintMemDumpArgs{}, err 18767 } 18768 result.Address = uintptr(dataAddress) 18769 case 2: 18770 err = decoder.DecodeUint64(&result.Length) 18771 if err != nil { 18772 return types.PrintMemDumpArgs{}, err 18773 } 18774 case 3: 18775 err = decoder.DecodeUint64(&result.CallerContextId) 18776 if err != nil { 18777 return types.PrintMemDumpArgs{}, err 18778 } 18779 case 4: 18780 result.Arch, err = decoder.ReadStringFromBuff() 18781 if err != nil { 18782 return types.PrintMemDumpArgs{}, err 18783 } 18784 case 5: 18785 result.SymbolName, err = decoder.ReadStringFromBuff() 18786 if err != nil { 18787 return types.PrintMemDumpArgs{}, err 18788 } 18789 case 6: 18790 result.SymbolOwner, err = decoder.ReadStringFromBuff() 18791 if err != nil { 18792 return types.PrintMemDumpArgs{}, err 18793 } 18794 } 18795 } 18796 return result, nil 18797 } 18798 18799 func ParseVfsReadArgs(decoder *Decoder) (types.VfsReadArgs, error) { 18800 var result types.VfsReadArgs 18801 var err error 18802 18803 var numArgs uint8 18804 err = decoder.DecodeUint8(&numArgs) 18805 if err != nil { 18806 return types.VfsReadArgs{}, err 18807 } 18808 18809 for arg := 0; arg < int(numArgs); arg++ { 18810 var currArg uint8 18811 err = decoder.DecodeUint8(&currArg) 18812 if err != nil { 18813 return types.VfsReadArgs{}, err 18814 } 18815 18816 switch currArg { 18817 case 0: 18818 result.Pathname, err = decoder.ReadStringFromBuff() 18819 if err != nil { 18820 return types.VfsReadArgs{}, err 18821 } 18822 case 1: 18823 err = decoder.DecodeUint32(&result.Dev) 18824 if err != nil { 18825 return types.VfsReadArgs{}, err 18826 } 18827 case 2: 18828 err = decoder.DecodeUint64(&result.Inode) 18829 if err != nil { 18830 return types.VfsReadArgs{}, err 18831 } 18832 case 3: 18833 err = decoder.DecodeUint64(&result.Count) 18834 if err != nil { 18835 return types.VfsReadArgs{}, err 18836 } 18837 case 4: 18838 err = decoder.DecodeUint64(&result.Pos) 18839 if err != nil { 18840 return types.VfsReadArgs{}, err 18841 } 18842 } 18843 } 18844 return result, nil 18845 } 18846 18847 func ParseVfsReadvArgs(decoder *Decoder) (types.VfsReadvArgs, error) { 18848 var result types.VfsReadvArgs 18849 var err error 18850 18851 var numArgs uint8 18852 err = decoder.DecodeUint8(&numArgs) 18853 if err != nil { 18854 return types.VfsReadvArgs{}, err 18855 } 18856 18857 for arg := 0; arg < int(numArgs); arg++ { 18858 var currArg uint8 18859 err = decoder.DecodeUint8(&currArg) 18860 if err != nil { 18861 return types.VfsReadvArgs{}, err 18862 } 18863 18864 switch currArg { 18865 case 0: 18866 result.Pathname, err = decoder.ReadStringFromBuff() 18867 if err != nil { 18868 return types.VfsReadvArgs{}, err 18869 } 18870 case 1: 18871 err = decoder.DecodeUint32(&result.Dev) 18872 if err != nil { 18873 return types.VfsReadvArgs{}, err 18874 } 18875 case 2: 18876 err = decoder.DecodeUint64(&result.Inode) 18877 if err != nil { 18878 return types.VfsReadvArgs{}, err 18879 } 18880 case 3: 18881 err = decoder.DecodeUint64(&result.Vlen) 18882 if err != nil { 18883 return types.VfsReadvArgs{}, err 18884 } 18885 case 4: 18886 err = decoder.DecodeUint64(&result.Pos) 18887 if err != nil { 18888 return types.VfsReadvArgs{}, err 18889 } 18890 } 18891 } 18892 return result, nil 18893 } 18894 18895 func ParseVfsUtimesArgs(decoder *Decoder) (types.VfsUtimesArgs, error) { 18896 var result types.VfsUtimesArgs 18897 var err error 18898 18899 var numArgs uint8 18900 err = decoder.DecodeUint8(&numArgs) 18901 if err != nil { 18902 return types.VfsUtimesArgs{}, err 18903 } 18904 18905 for arg := 0; arg < int(numArgs); arg++ { 18906 var currArg uint8 18907 err = decoder.DecodeUint8(&currArg) 18908 if err != nil { 18909 return types.VfsUtimesArgs{}, err 18910 } 18911 18912 switch currArg { 18913 case 0: 18914 result.Pathname, err = decoder.ReadStringFromBuff() 18915 if err != nil { 18916 return types.VfsUtimesArgs{}, err 18917 } 18918 case 1: 18919 err = decoder.DecodeUint32(&result.Dev) 18920 if err != nil { 18921 return types.VfsUtimesArgs{}, err 18922 } 18923 case 2: 18924 err = decoder.DecodeUint64(&result.Inode) 18925 if err != nil { 18926 return types.VfsUtimesArgs{}, err 18927 } 18928 case 3: 18929 err = decoder.DecodeUint64(&result.Atime) 18930 if err != nil { 18931 return types.VfsUtimesArgs{}, err 18932 } 18933 case 4: 18934 err = decoder.DecodeUint64(&result.Mtime) 18935 if err != nil { 18936 return types.VfsUtimesArgs{}, err 18937 } 18938 } 18939 } 18940 return result, nil 18941 } 18942 18943 func ParseDoTruncateArgs(decoder *Decoder) (types.DoTruncateArgs, error) { 18944 var result types.DoTruncateArgs 18945 var err error 18946 18947 var numArgs uint8 18948 err = decoder.DecodeUint8(&numArgs) 18949 if err != nil { 18950 return types.DoTruncateArgs{}, err 18951 } 18952 18953 for arg := 0; arg < int(numArgs); arg++ { 18954 var currArg uint8 18955 err = decoder.DecodeUint8(&currArg) 18956 if err != nil { 18957 return types.DoTruncateArgs{}, err 18958 } 18959 18960 switch currArg { 18961 case 0: 18962 result.Pathname, err = decoder.ReadStringFromBuff() 18963 if err != nil { 18964 return types.DoTruncateArgs{}, err 18965 } 18966 case 1: 18967 err = decoder.DecodeUint64(&result.Inode) 18968 if err != nil { 18969 return types.DoTruncateArgs{}, err 18970 } 18971 case 2: 18972 err = decoder.DecodeUint32(&result.Dev) 18973 if err != nil { 18974 return types.DoTruncateArgs{}, err 18975 } 18976 case 3: 18977 err = decoder.DecodeUint64(&result.Length) 18978 if err != nil { 18979 return types.DoTruncateArgs{}, err 18980 } 18981 } 18982 } 18983 return result, nil 18984 } 18985 18986 func ParseFileModificationArgs(decoder *Decoder) (types.FileModificationArgs, error) { 18987 var result types.FileModificationArgs 18988 var err error 18989 18990 var numArgs uint8 18991 err = decoder.DecodeUint8(&numArgs) 18992 if err != nil { 18993 return types.FileModificationArgs{}, err 18994 } 18995 18996 for arg := 0; arg < int(numArgs); arg++ { 18997 var currArg uint8 18998 err = decoder.DecodeUint8(&currArg) 18999 if err != nil { 19000 return types.FileModificationArgs{}, err 19001 } 19002 19003 switch currArg { 19004 case 0: 19005 result.FilePath, err = decoder.ReadStringFromBuff() 19006 if err != nil { 19007 return types.FileModificationArgs{}, err 19008 } 19009 case 1: 19010 err = decoder.DecodeUint32(&result.Dev) 19011 if err != nil { 19012 return types.FileModificationArgs{}, err 19013 } 19014 case 2: 19015 err = decoder.DecodeUint64(&result.Inode) 19016 if err != nil { 19017 return types.FileModificationArgs{}, err 19018 } 19019 case 3: 19020 err = decoder.DecodeUint64(&result.OldCtime) 19021 if err != nil { 19022 return types.FileModificationArgs{}, err 19023 } 19024 case 4: 19025 err = decoder.DecodeUint64(&result.NewCtime) 19026 if err != nil { 19027 return types.FileModificationArgs{}, err 19028 } 19029 } 19030 } 19031 return result, nil 19032 } 19033 19034 func ParseInotifyWatchArgs(decoder *Decoder) (types.InotifyWatchArgs, error) { 19035 var result types.InotifyWatchArgs 19036 var err error 19037 19038 var numArgs uint8 19039 err = decoder.DecodeUint8(&numArgs) 19040 if err != nil { 19041 return types.InotifyWatchArgs{}, err 19042 } 19043 19044 for arg := 0; arg < int(numArgs); arg++ { 19045 var currArg uint8 19046 err = decoder.DecodeUint8(&currArg) 19047 if err != nil { 19048 return types.InotifyWatchArgs{}, err 19049 } 19050 19051 switch currArg { 19052 case 0: 19053 result.Pathname, err = decoder.ReadStringFromBuff() 19054 if err != nil { 19055 return types.InotifyWatchArgs{}, err 19056 } 19057 case 1: 19058 err = decoder.DecodeUint64(&result.Inode) 19059 if err != nil { 19060 return types.InotifyWatchArgs{}, err 19061 } 19062 case 2: 19063 err = decoder.DecodeUint32(&result.Dev) 19064 if err != nil { 19065 return types.InotifyWatchArgs{}, err 19066 } 19067 } 19068 } 19069 return result, nil 19070 } 19071 19072 func ParseProcessExecuteFailedArgs(decoder *Decoder) (types.ProcessExecuteFailedArgs, error) { 19073 var result types.ProcessExecuteFailedArgs 19074 var err error 19075 19076 var numArgs uint8 19077 err = decoder.DecodeUint8(&numArgs) 19078 if err != nil { 19079 return types.ProcessExecuteFailedArgs{}, err 19080 } 19081 19082 for arg := 0; arg < int(numArgs); arg++ { 19083 var currArg uint8 19084 err = decoder.DecodeUint8(&currArg) 19085 if err != nil { 19086 return types.ProcessExecuteFailedArgs{}, err 19087 } 19088 19089 switch currArg { 19090 case 0: 19091 result.Path, err = decoder.ReadStringFromBuff() 19092 if err != nil { 19093 return types.ProcessExecuteFailedArgs{}, err 19094 } 19095 case 1: 19096 result.BinaryPath, err = decoder.ReadStringFromBuff() 19097 if err != nil { 19098 return types.ProcessExecuteFailedArgs{}, err 19099 } 19100 case 2: 19101 err = decoder.DecodeUint32(&result.BinaryDeviceId) 19102 if err != nil { 19103 return types.ProcessExecuteFailedArgs{}, err 19104 } 19105 case 3: 19106 err = decoder.DecodeUint64(&result.BinaryInodeNumber) 19107 if err != nil { 19108 return types.ProcessExecuteFailedArgs{}, err 19109 } 19110 case 4: 19111 err = decoder.DecodeUint64(&result.BinaryCtime) 19112 if err != nil { 19113 return types.ProcessExecuteFailedArgs{}, err 19114 } 19115 case 5: 19116 err = decoder.DecodeUint16(&result.BinaryInodeMode) 19117 if err != nil { 19118 return types.ProcessExecuteFailedArgs{}, err 19119 } 19120 case 6: 19121 result.InterpreterPath, err = decoder.ReadStringFromBuff() 19122 if err != nil { 19123 return types.ProcessExecuteFailedArgs{}, err 19124 } 19125 case 7: 19126 err = decoder.DecodeUint16(&result.StdinType) 19127 if err != nil { 19128 return types.ProcessExecuteFailedArgs{}, err 19129 } 19130 case 8: 19131 result.StdinPath, err = decoder.ReadStringFromBuff() 19132 if err != nil { 19133 return types.ProcessExecuteFailedArgs{}, err 19134 } 19135 case 9: 19136 err = decoder.DecodeInt32(&result.KernelInvoked) 19137 if err != nil { 19138 return types.ProcessExecuteFailedArgs{}, err 19139 } 19140 case 10: 19141 result.BinaryArguments, err = decoder.ReadStringArrayFromBuff() 19142 if err != nil { 19143 return types.ProcessExecuteFailedArgs{}, err 19144 } 19145 case 11: 19146 result.Environment, err = decoder.ReadStringArrayFromBuff() 19147 if err != nil { 19148 return types.ProcessExecuteFailedArgs{}, err 19149 } 19150 } 19151 } 19152 return result, nil 19153 } 19154 19155 func ParseTtyOpenArgs(decoder *Decoder) (types.TtyOpenArgs, error) { 19156 var result types.TtyOpenArgs 19157 var err error 19158 19159 var numArgs uint8 19160 err = decoder.DecodeUint8(&numArgs) 19161 if err != nil { 19162 return types.TtyOpenArgs{}, err 19163 } 19164 19165 for arg := 0; arg < int(numArgs); arg++ { 19166 var currArg uint8 19167 err = decoder.DecodeUint8(&currArg) 19168 if err != nil { 19169 return types.TtyOpenArgs{}, err 19170 } 19171 19172 switch currArg { 19173 case 0: 19174 result.Path, err = decoder.ReadStringFromBuff() 19175 if err != nil { 19176 return types.TtyOpenArgs{}, err 19177 } 19178 case 1: 19179 err = decoder.DecodeUint64(&result.Inode) 19180 if err != nil { 19181 return types.TtyOpenArgs{}, err 19182 } 19183 case 2: 19184 err = decoder.DecodeUint16(&result.InodeMode) 19185 if err != nil { 19186 return types.TtyOpenArgs{}, err 19187 } 19188 case 3: 19189 err = decoder.DecodeUint32(&result.Dev) 19190 if err != nil { 19191 return types.TtyOpenArgs{}, err 19192 } 19193 } 19194 } 19195 return result, nil 19196 } 19197 19198 func ParseNetPacketBaseArgs(decoder *Decoder) (types.NetPacketBaseArgs, error) { 19199 return types.NetPacketBaseArgs{}, nil 19200 } 19201 19202 func ParseNetPacketIPBaseArgs(decoder *Decoder) (types.NetPacketIPBaseArgs, error) { 19203 var result types.NetPacketIPBaseArgs 19204 var err error 19205 19206 var numArgs uint8 19207 err = decoder.DecodeUint8(&numArgs) 19208 if err != nil { 19209 return types.NetPacketIPBaseArgs{}, err 19210 } 19211 19212 for arg := 0; arg < int(numArgs); arg++ { 19213 var currArg uint8 19214 err = decoder.DecodeUint8(&currArg) 19215 if err != nil { 19216 return types.NetPacketIPBaseArgs{}, err 19217 } 19218 19219 switch currArg { 19220 case 0: 19221 result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketIPBase)) 19222 if err != nil { 19223 return types.NetPacketIPBaseArgs{}, err 19224 } 19225 } 19226 } 19227 return result, nil 19228 } 19229 19230 func ParseNetPacketIPv4Args(decoder *Decoder) (types.NetPacketIPv4Args, error) { 19231 var result types.NetPacketIPv4Args 19232 var err error 19233 19234 var numArgs uint8 19235 err = decoder.DecodeUint8(&numArgs) 19236 if err != nil { 19237 return types.NetPacketIPv4Args{}, err 19238 } 19239 19240 for arg := 0; arg < int(numArgs); arg++ { 19241 var currArg uint8 19242 err = decoder.DecodeUint8(&currArg) 19243 if err != nil { 19244 return types.NetPacketIPv4Args{}, err 19245 } 19246 19247 switch currArg { 19248 case 0: 19249 result.Src, err = decoder.ReadStringFromBuff() 19250 if err != nil { 19251 return types.NetPacketIPv4Args{}, err 19252 } 19253 case 1: 19254 result.Dst, err = decoder.ReadStringFromBuff() 19255 if err != nil { 19256 return types.NetPacketIPv4Args{}, err 19257 } 19258 case 2: 19259 var dataProtoIpv4 uint64 19260 err = decoder.DecodeUint64(&dataProtoIpv4) 19261 if err != nil { 19262 return types.NetPacketIPv4Args{}, err 19263 } 19264 result.ProtoIpv4 = uintptr(dataProtoIpv4) 19265 } 19266 } 19267 return result, nil 19268 } 19269 19270 func ParseNetPacketIPv6Args(decoder *Decoder) (types.NetPacketIPv6Args, error) { 19271 var result types.NetPacketIPv6Args 19272 var err error 19273 19274 var numArgs uint8 19275 err = decoder.DecodeUint8(&numArgs) 19276 if err != nil { 19277 return types.NetPacketIPv6Args{}, err 19278 } 19279 19280 for arg := 0; arg < int(numArgs); arg++ { 19281 var currArg uint8 19282 err = decoder.DecodeUint8(&currArg) 19283 if err != nil { 19284 return types.NetPacketIPv6Args{}, err 19285 } 19286 19287 switch currArg { 19288 case 0: 19289 result.Src, err = decoder.ReadStringFromBuff() 19290 if err != nil { 19291 return types.NetPacketIPv6Args{}, err 19292 } 19293 case 1: 19294 result.Dst, err = decoder.ReadStringFromBuff() 19295 if err != nil { 19296 return types.NetPacketIPv6Args{}, err 19297 } 19298 case 2: 19299 var dataProtoIpv6 uint64 19300 err = decoder.DecodeUint64(&dataProtoIpv6) 19301 if err != nil { 19302 return types.NetPacketIPv6Args{}, err 19303 } 19304 result.ProtoIpv6 = uintptr(dataProtoIpv6) 19305 } 19306 } 19307 return result, nil 19308 } 19309 19310 func ParseNetPacketTCPBaseArgs(decoder *Decoder) (types.NetPacketTCPBaseArgs, error) { 19311 var result types.NetPacketTCPBaseArgs 19312 var err error 19313 19314 var numArgs uint8 19315 err = decoder.DecodeUint8(&numArgs) 19316 if err != nil { 19317 return types.NetPacketTCPBaseArgs{}, err 19318 } 19319 19320 for arg := 0; arg < int(numArgs); arg++ { 19321 var currArg uint8 19322 err = decoder.DecodeUint8(&currArg) 19323 if err != nil { 19324 return types.NetPacketTCPBaseArgs{}, err 19325 } 19326 19327 switch currArg { 19328 case 0: 19329 result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketTCPBase)) 19330 if err != nil { 19331 return types.NetPacketTCPBaseArgs{}, err 19332 } 19333 } 19334 } 19335 return result, nil 19336 } 19337 19338 func ParseNetPacketTCPArgs(decoder *Decoder) (types.NetPacketTCPArgs, error) { 19339 var result types.NetPacketTCPArgs 19340 var err error 19341 19342 var numArgs uint8 19343 err = decoder.DecodeUint8(&numArgs) 19344 if err != nil { 19345 return types.NetPacketTCPArgs{}, err 19346 } 19347 19348 for arg := 0; arg < int(numArgs); arg++ { 19349 var currArg uint8 19350 err = decoder.DecodeUint8(&currArg) 19351 if err != nil { 19352 return types.NetPacketTCPArgs{}, err 19353 } 19354 19355 switch currArg { 19356 case 0: 19357 result.Src, err = decoder.ReadStringFromBuff() 19358 if err != nil { 19359 return types.NetPacketTCPArgs{}, err 19360 } 19361 case 1: 19362 result.Dst, err = decoder.ReadStringFromBuff() 19363 if err != nil { 19364 return types.NetPacketTCPArgs{}, err 19365 } 19366 case 2: 19367 err = decoder.DecodeUint16(&result.SrcPort) 19368 if err != nil { 19369 return types.NetPacketTCPArgs{}, err 19370 } 19371 case 3: 19372 err = decoder.DecodeUint16(&result.DstPort) 19373 if err != nil { 19374 return types.NetPacketTCPArgs{}, err 19375 } 19376 case 4: 19377 var dataProtoTcp uint64 19378 err = decoder.DecodeUint64(&dataProtoTcp) 19379 if err != nil { 19380 return types.NetPacketTCPArgs{}, err 19381 } 19382 result.ProtoTcp = uintptr(dataProtoTcp) 19383 } 19384 } 19385 return result, nil 19386 } 19387 19388 func ParseNetPacketUDPBaseArgs(decoder *Decoder) (types.NetPacketUDPBaseArgs, error) { 19389 var result types.NetPacketUDPBaseArgs 19390 var err error 19391 19392 var numArgs uint8 19393 err = decoder.DecodeUint8(&numArgs) 19394 if err != nil { 19395 return types.NetPacketUDPBaseArgs{}, err 19396 } 19397 19398 for arg := 0; arg < int(numArgs); arg++ { 19399 var currArg uint8 19400 err = decoder.DecodeUint8(&currArg) 19401 if err != nil { 19402 return types.NetPacketUDPBaseArgs{}, err 19403 } 19404 19405 switch currArg { 19406 case 0: 19407 result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketUDPBase)) 19408 if err != nil { 19409 return types.NetPacketUDPBaseArgs{}, err 19410 } 19411 } 19412 } 19413 return result, nil 19414 } 19415 19416 func ParseNetPacketUDPArgs(decoder *Decoder) (types.NetPacketUDPArgs, error) { 19417 var result types.NetPacketUDPArgs 19418 var err error 19419 19420 var numArgs uint8 19421 err = decoder.DecodeUint8(&numArgs) 19422 if err != nil { 19423 return types.NetPacketUDPArgs{}, err 19424 } 19425 19426 for arg := 0; arg < int(numArgs); arg++ { 19427 var currArg uint8 19428 err = decoder.DecodeUint8(&currArg) 19429 if err != nil { 19430 return types.NetPacketUDPArgs{}, err 19431 } 19432 19433 switch currArg { 19434 case 0: 19435 result.Src, err = decoder.ReadStringFromBuff() 19436 if err != nil { 19437 return types.NetPacketUDPArgs{}, err 19438 } 19439 case 1: 19440 result.Dst, err = decoder.ReadStringFromBuff() 19441 if err != nil { 19442 return types.NetPacketUDPArgs{}, err 19443 } 19444 case 2: 19445 err = decoder.DecodeUint16(&result.SrcPort) 19446 if err != nil { 19447 return types.NetPacketUDPArgs{}, err 19448 } 19449 case 3: 19450 err = decoder.DecodeUint16(&result.DstPort) 19451 if err != nil { 19452 return types.NetPacketUDPArgs{}, err 19453 } 19454 case 4: 19455 var dataProtoUdp uint64 19456 err = decoder.DecodeUint64(&dataProtoUdp) 19457 if err != nil { 19458 return types.NetPacketUDPArgs{}, err 19459 } 19460 result.ProtoUdp = uintptr(dataProtoUdp) 19461 } 19462 } 19463 return result, nil 19464 } 19465 19466 func ParseNetPacketICMPBaseArgs(decoder *Decoder) (types.NetPacketICMPBaseArgs, error) { 19467 var result types.NetPacketICMPBaseArgs 19468 var err error 19469 19470 var numArgs uint8 19471 err = decoder.DecodeUint8(&numArgs) 19472 if err != nil { 19473 return types.NetPacketICMPBaseArgs{}, err 19474 } 19475 19476 for arg := 0; arg < int(numArgs); arg++ { 19477 var currArg uint8 19478 err = decoder.DecodeUint8(&currArg) 19479 if err != nil { 19480 return types.NetPacketICMPBaseArgs{}, err 19481 } 19482 19483 switch currArg { 19484 case 0: 19485 result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketICMPBase)) 19486 if err != nil { 19487 return types.NetPacketICMPBaseArgs{}, err 19488 } 19489 } 19490 } 19491 return result, nil 19492 } 19493 19494 func ParseNetPacketICMPArgs(decoder *Decoder) (types.NetPacketICMPArgs, error) { 19495 var result types.NetPacketICMPArgs 19496 var err error 19497 19498 var numArgs uint8 19499 err = decoder.DecodeUint8(&numArgs) 19500 if err != nil { 19501 return types.NetPacketICMPArgs{}, err 19502 } 19503 19504 for arg := 0; arg < int(numArgs); arg++ { 19505 var currArg uint8 19506 err = decoder.DecodeUint8(&currArg) 19507 if err != nil { 19508 return types.NetPacketICMPArgs{}, err 19509 } 19510 19511 switch currArg { 19512 case 0: 19513 result.Src, err = decoder.ReadStringFromBuff() 19514 if err != nil { 19515 return types.NetPacketICMPArgs{}, err 19516 } 19517 case 1: 19518 result.Dst, err = decoder.ReadStringFromBuff() 19519 if err != nil { 19520 return types.NetPacketICMPArgs{}, err 19521 } 19522 case 2: 19523 var dataProtoIcmp uint64 19524 err = decoder.DecodeUint64(&dataProtoIcmp) 19525 if err != nil { 19526 return types.NetPacketICMPArgs{}, err 19527 } 19528 result.ProtoIcmp = uintptr(dataProtoIcmp) 19529 } 19530 } 19531 return result, nil 19532 } 19533 19534 func ParseNetPacketICMPv6BaseArgs(decoder *Decoder) (types.NetPacketICMPv6BaseArgs, error) { 19535 var result types.NetPacketICMPv6BaseArgs 19536 var err error 19537 19538 var numArgs uint8 19539 err = decoder.DecodeUint8(&numArgs) 19540 if err != nil { 19541 return types.NetPacketICMPv6BaseArgs{}, err 19542 } 19543 19544 for arg := 0; arg < int(numArgs); arg++ { 19545 var currArg uint8 19546 err = decoder.DecodeUint8(&currArg) 19547 if err != nil { 19548 return types.NetPacketICMPv6BaseArgs{}, err 19549 } 19550 19551 switch currArg { 19552 case 0: 19553 result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketICMPv6Base)) 19554 if err != nil { 19555 return types.NetPacketICMPv6BaseArgs{}, err 19556 } 19557 } 19558 } 19559 return result, nil 19560 } 19561 19562 func ParseNetPacketICMPv6Args(decoder *Decoder) (types.NetPacketICMPv6Args, error) { 19563 var result types.NetPacketICMPv6Args 19564 var err error 19565 19566 var numArgs uint8 19567 err = decoder.DecodeUint8(&numArgs) 19568 if err != nil { 19569 return types.NetPacketICMPv6Args{}, err 19570 } 19571 19572 for arg := 0; arg < int(numArgs); arg++ { 19573 var currArg uint8 19574 err = decoder.DecodeUint8(&currArg) 19575 if err != nil { 19576 return types.NetPacketICMPv6Args{}, err 19577 } 19578 19579 switch currArg { 19580 case 0: 19581 result.Src, err = decoder.ReadStringFromBuff() 19582 if err != nil { 19583 return types.NetPacketICMPv6Args{}, err 19584 } 19585 case 1: 19586 result.Dst, err = decoder.ReadStringFromBuff() 19587 if err != nil { 19588 return types.NetPacketICMPv6Args{}, err 19589 } 19590 case 2: 19591 var dataProtoIcmpv6 uint64 19592 err = decoder.DecodeUint64(&dataProtoIcmpv6) 19593 if err != nil { 19594 return types.NetPacketICMPv6Args{}, err 19595 } 19596 result.ProtoIcmpv6 = uintptr(dataProtoIcmpv6) 19597 } 19598 } 19599 return result, nil 19600 } 19601 19602 func ParseNetPacketDNSBaseArgs(decoder *Decoder) (types.NetPacketDNSBaseArgs, error) { 19603 var result types.NetPacketDNSBaseArgs 19604 var err error 19605 19606 var numArgs uint8 19607 err = decoder.DecodeUint8(&numArgs) 19608 if err != nil { 19609 return types.NetPacketDNSBaseArgs{}, err 19610 } 19611 19612 for arg := 0; arg < int(numArgs); arg++ { 19613 var currArg uint8 19614 err = decoder.DecodeUint8(&currArg) 19615 if err != nil { 19616 return types.NetPacketDNSBaseArgs{}, err 19617 } 19618 19619 switch currArg { 19620 case 0: 19621 result.Payload, err = decoder.ReadProtoDNS() 19622 if err != nil { 19623 return types.NetPacketDNSBaseArgs{}, err 19624 } 19625 } 19626 } 19627 return result, nil 19628 } 19629 19630 func ParseNetPacketDNSArgs(decoder *Decoder) (types.NetPacketDNSArgs, error) { 19631 var result types.NetPacketDNSArgs 19632 var err error 19633 19634 var numArgs uint8 19635 err = decoder.DecodeUint8(&numArgs) 19636 if err != nil { 19637 return types.NetPacketDNSArgs{}, err 19638 } 19639 19640 for arg := 0; arg < int(numArgs); arg++ { 19641 var currArg uint8 19642 err = decoder.DecodeUint8(&currArg) 19643 if err != nil { 19644 return types.NetPacketDNSArgs{}, err 19645 } 19646 19647 switch currArg { 19648 case 0: 19649 result.Src, err = decoder.ReadStringFromBuff() 19650 if err != nil { 19651 return types.NetPacketDNSArgs{}, err 19652 } 19653 case 1: 19654 result.Dst, err = decoder.ReadStringFromBuff() 19655 if err != nil { 19656 return types.NetPacketDNSArgs{}, err 19657 } 19658 case 2: 19659 err = decoder.DecodeUint16(&result.SrcPort) 19660 if err != nil { 19661 return types.NetPacketDNSArgs{}, err 19662 } 19663 case 3: 19664 err = decoder.DecodeUint16(&result.DstPort) 19665 if err != nil { 19666 return types.NetPacketDNSArgs{}, err 19667 } 19668 case 4: 19669 var dataProtoDns uint64 19670 err = decoder.DecodeUint64(&dataProtoDns) 19671 if err != nil { 19672 return types.NetPacketDNSArgs{}, err 19673 } 19674 result.ProtoDns = uintptr(dataProtoDns) 19675 } 19676 } 19677 return result, nil 19678 } 19679 19680 func ParseNetPacketDNSRequestArgs(decoder *Decoder) (types.NetPacketDNSRequestArgs, error) { 19681 var result types.NetPacketDNSRequestArgs 19682 var err error 19683 19684 var numArgs uint8 19685 err = decoder.DecodeUint8(&numArgs) 19686 if err != nil { 19687 return types.NetPacketDNSRequestArgs{}, err 19688 } 19689 19690 for arg := 0; arg < int(numArgs); arg++ { 19691 var currArg uint8 19692 err = decoder.DecodeUint8(&currArg) 19693 if err != nil { 19694 return types.NetPacketDNSRequestArgs{}, err 19695 } 19696 19697 switch currArg { 19698 case 0: 19699 var dataMetadata uint64 19700 err = decoder.DecodeUint64(&dataMetadata) 19701 if err != nil { 19702 return types.NetPacketDNSRequestArgs{}, err 19703 } 19704 result.Metadata = uintptr(dataMetadata) 19705 case 1: 19706 var dataDnsQuestions uint64 19707 err = decoder.DecodeUint64(&dataDnsQuestions) 19708 if err != nil { 19709 return types.NetPacketDNSRequestArgs{}, err 19710 } 19711 result.DnsQuestions = uintptr(dataDnsQuestions) 19712 } 19713 } 19714 return result, nil 19715 } 19716 19717 func ParseNetPacketDNSResponseArgs(decoder *Decoder) (types.NetPacketDNSResponseArgs, error) { 19718 var result types.NetPacketDNSResponseArgs 19719 var err error 19720 19721 var numArgs uint8 19722 err = decoder.DecodeUint8(&numArgs) 19723 if err != nil { 19724 return types.NetPacketDNSResponseArgs{}, err 19725 } 19726 19727 for arg := 0; arg < int(numArgs); arg++ { 19728 var currArg uint8 19729 err = decoder.DecodeUint8(&currArg) 19730 if err != nil { 19731 return types.NetPacketDNSResponseArgs{}, err 19732 } 19733 19734 switch currArg { 19735 case 0: 19736 var dataMetadata uint64 19737 err = decoder.DecodeUint64(&dataMetadata) 19738 if err != nil { 19739 return types.NetPacketDNSResponseArgs{}, err 19740 } 19741 result.Metadata = uintptr(dataMetadata) 19742 case 1: 19743 var dataDnsResponse uint64 19744 err = decoder.DecodeUint64(&dataDnsResponse) 19745 if err != nil { 19746 return types.NetPacketDNSResponseArgs{}, err 19747 } 19748 result.DnsResponse = uintptr(dataDnsResponse) 19749 } 19750 } 19751 return result, nil 19752 } 19753 19754 func ParseNetPacketHTTPBaseArgs(decoder *Decoder) (types.NetPacketHTTPBaseArgs, error) { 19755 var result types.NetPacketHTTPBaseArgs 19756 var err error 19757 19758 var numArgs uint8 19759 err = decoder.DecodeUint8(&numArgs) 19760 if err != nil { 19761 return types.NetPacketHTTPBaseArgs{}, err 19762 } 19763 19764 for arg := 0; arg < int(numArgs); arg++ { 19765 var currArg uint8 19766 err = decoder.DecodeUint8(&currArg) 19767 if err != nil { 19768 return types.NetPacketHTTPBaseArgs{}, err 19769 } 19770 19771 switch currArg { 19772 case 0: 19773 result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketHTTPBase)) 19774 if err != nil { 19775 return types.NetPacketHTTPBaseArgs{}, err 19776 } 19777 } 19778 } 19779 return result, nil 19780 } 19781 19782 func ParseNetPacketHTTPArgs(decoder *Decoder) (types.NetPacketHTTPArgs, error) { 19783 var result types.NetPacketHTTPArgs 19784 var err error 19785 19786 var numArgs uint8 19787 err = decoder.DecodeUint8(&numArgs) 19788 if err != nil { 19789 return types.NetPacketHTTPArgs{}, err 19790 } 19791 19792 for arg := 0; arg < int(numArgs); arg++ { 19793 var currArg uint8 19794 err = decoder.DecodeUint8(&currArg) 19795 if err != nil { 19796 return types.NetPacketHTTPArgs{}, err 19797 } 19798 19799 switch currArg { 19800 case 0: 19801 result.Src, err = decoder.ReadStringFromBuff() 19802 if err != nil { 19803 return types.NetPacketHTTPArgs{}, err 19804 } 19805 case 1: 19806 result.Dst, err = decoder.ReadStringFromBuff() 19807 if err != nil { 19808 return types.NetPacketHTTPArgs{}, err 19809 } 19810 case 2: 19811 err = decoder.DecodeUint16(&result.SrcPort) 19812 if err != nil { 19813 return types.NetPacketHTTPArgs{}, err 19814 } 19815 case 3: 19816 err = decoder.DecodeUint16(&result.DstPort) 19817 if err != nil { 19818 return types.NetPacketHTTPArgs{}, err 19819 } 19820 case 4: 19821 var dataProtoHttp uint64 19822 err = decoder.DecodeUint64(&dataProtoHttp) 19823 if err != nil { 19824 return types.NetPacketHTTPArgs{}, err 19825 } 19826 result.ProtoHttp = uintptr(dataProtoHttp) 19827 } 19828 } 19829 return result, nil 19830 } 19831 19832 func ParseNetPacketHTTPRequestArgs(decoder *Decoder) (types.NetPacketHTTPRequestArgs, error) { 19833 var result types.NetPacketHTTPRequestArgs 19834 var err error 19835 19836 var numArgs uint8 19837 err = decoder.DecodeUint8(&numArgs) 19838 if err != nil { 19839 return types.NetPacketHTTPRequestArgs{}, err 19840 } 19841 19842 for arg := 0; arg < int(numArgs); arg++ { 19843 var currArg uint8 19844 err = decoder.DecodeUint8(&currArg) 19845 if err != nil { 19846 return types.NetPacketHTTPRequestArgs{}, err 19847 } 19848 19849 switch currArg { 19850 case 0: 19851 var dataMetadata uint64 19852 err = decoder.DecodeUint64(&dataMetadata) 19853 if err != nil { 19854 return types.NetPacketHTTPRequestArgs{}, err 19855 } 19856 result.Metadata = uintptr(dataMetadata) 19857 case 1: 19858 var dataHttpRequest uint64 19859 err = decoder.DecodeUint64(&dataHttpRequest) 19860 if err != nil { 19861 return types.NetPacketHTTPRequestArgs{}, err 19862 } 19863 result.HttpRequest = uintptr(dataHttpRequest) 19864 } 19865 } 19866 return result, nil 19867 } 19868 19869 func ParseNetPacketHTTPResponseArgs(decoder *Decoder) (types.NetPacketHTTPResponseArgs, error) { 19870 var result types.NetPacketHTTPResponseArgs 19871 var err error 19872 19873 var numArgs uint8 19874 err = decoder.DecodeUint8(&numArgs) 19875 if err != nil { 19876 return types.NetPacketHTTPResponseArgs{}, err 19877 } 19878 19879 for arg := 0; arg < int(numArgs); arg++ { 19880 var currArg uint8 19881 err = decoder.DecodeUint8(&currArg) 19882 if err != nil { 19883 return types.NetPacketHTTPResponseArgs{}, err 19884 } 19885 19886 switch currArg { 19887 case 0: 19888 var dataMetadata uint64 19889 err = decoder.DecodeUint64(&dataMetadata) 19890 if err != nil { 19891 return types.NetPacketHTTPResponseArgs{}, err 19892 } 19893 result.Metadata = uintptr(dataMetadata) 19894 case 1: 19895 var dataHttpResponse uint64 19896 err = decoder.DecodeUint64(&dataHttpResponse) 19897 if err != nil { 19898 return types.NetPacketHTTPResponseArgs{}, err 19899 } 19900 result.HttpResponse = uintptr(dataHttpResponse) 19901 } 19902 } 19903 return result, nil 19904 } 19905 19906 func ParseNetPacketSOCKS5BaseArgs(decoder *Decoder) (types.NetPacketSOCKS5BaseArgs, error) { 19907 var result types.NetPacketSOCKS5BaseArgs 19908 var err error 19909 19910 var numArgs uint8 19911 err = decoder.DecodeUint8(&numArgs) 19912 if err != nil { 19913 return types.NetPacketSOCKS5BaseArgs{}, err 19914 } 19915 19916 for arg := 0; arg < int(numArgs); arg++ { 19917 var currArg uint8 19918 err = decoder.DecodeUint8(&currArg) 19919 if err != nil { 19920 return types.NetPacketSOCKS5BaseArgs{}, err 19921 } 19922 19923 switch currArg { 19924 case 0: 19925 result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketSOCKS5Base)) 19926 if err != nil { 19927 return types.NetPacketSOCKS5BaseArgs{}, err 19928 } 19929 } 19930 } 19931 return result, nil 19932 } 19933 19934 func ParseNetPacketCaptureArgs(decoder *Decoder) (types.NetPacketCaptureArgs, error) { 19935 var result types.NetPacketCaptureArgs 19936 var err error 19937 19938 var numArgs uint8 19939 err = decoder.DecodeUint8(&numArgs) 19940 if err != nil { 19941 return types.NetPacketCaptureArgs{}, err 19942 } 19943 19944 for arg := 0; arg < int(numArgs); arg++ { 19945 var currArg uint8 19946 err = decoder.DecodeUint8(&currArg) 19947 if err != nil { 19948 return types.NetPacketCaptureArgs{}, err 19949 } 19950 19951 switch currArg { 19952 case 0: 19953 result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketCapture)) 19954 if err != nil { 19955 return types.NetPacketCaptureArgs{}, err 19956 } 19957 } 19958 } 19959 return result, nil 19960 } 19961 19962 func ParseCaptureNetPacketArgs(decoder *Decoder) (types.CaptureNetPacketArgs, error) { 19963 return types.CaptureNetPacketArgs{}, nil 19964 } 19965 19966 func ParseSockSetStateArgs(decoder *Decoder) (types.SockSetStateArgs, error) { 19967 var result types.SockSetStateArgs 19968 var err error 19969 19970 var numArgs uint8 19971 err = decoder.DecodeUint8(&numArgs) 19972 if err != nil { 19973 return types.SockSetStateArgs{}, err 19974 } 19975 19976 for arg := 0; arg < int(numArgs); arg++ { 19977 var currArg uint8 19978 err = decoder.DecodeUint8(&currArg) 19979 if err != nil { 19980 return types.SockSetStateArgs{}, err 19981 } 19982 19983 switch currArg { 19984 case 0: 19985 err = decoder.DecodeUint32(&result.OldState) 19986 if err != nil { 19987 return types.SockSetStateArgs{}, err 19988 } 19989 case 1: 19990 err = decoder.DecodeUint32(&result.NewState) 19991 if err != nil { 19992 return types.SockSetStateArgs{}, err 19993 } 19994 case 2: 19995 result.Tuple, err = decoder.ReadAddrTuple() 19996 if err != nil { 19997 return types.SockSetStateArgs{}, err 19998 } 19999 } 20000 } 20001 return result, nil 20002 } 20003 20004 func ParseTrackSyscallStatsArgs(decoder *Decoder) (types.TrackSyscallStatsArgs, error) { 20005 return types.TrackSyscallStatsArgs{}, nil 20006 } 20007 20008 func ParseTestEventArgs(decoder *Decoder) (types.TestEventArgs, error) { 20009 return types.TestEventArgs{}, nil 20010 } 20011 20012 func ParseSignalCgroupMkdirArgs(decoder *Decoder) (types.SignalCgroupMkdirArgs, error) { 20013 var result types.SignalCgroupMkdirArgs 20014 var err error 20015 20016 var numArgs uint8 20017 err = decoder.DecodeUint8(&numArgs) 20018 if err != nil { 20019 return types.SignalCgroupMkdirArgs{}, err 20020 } 20021 20022 for arg := 0; arg < int(numArgs); arg++ { 20023 var currArg uint8 20024 err = decoder.DecodeUint8(&currArg) 20025 if err != nil { 20026 return types.SignalCgroupMkdirArgs{}, err 20027 } 20028 20029 switch currArg { 20030 case 0: 20031 err = decoder.DecodeUint64(&result.CgroupId) 20032 if err != nil { 20033 return types.SignalCgroupMkdirArgs{}, err 20034 } 20035 case 1: 20036 result.CgroupPath, err = decoder.ReadStringFromBuff() 20037 if err != nil { 20038 return types.SignalCgroupMkdirArgs{}, err 20039 } 20040 case 2: 20041 err = decoder.DecodeUint32(&result.HierarchyId) 20042 if err != nil { 20043 return types.SignalCgroupMkdirArgs{}, err 20044 } 20045 } 20046 } 20047 return result, nil 20048 } 20049 20050 func ParseSignalCgroupRmdirArgs(decoder *Decoder) (types.SignalCgroupRmdirArgs, error) { 20051 var result types.SignalCgroupRmdirArgs 20052 var err error 20053 20054 var numArgs uint8 20055 err = decoder.DecodeUint8(&numArgs) 20056 if err != nil { 20057 return types.SignalCgroupRmdirArgs{}, err 20058 } 20059 20060 for arg := 0; arg < int(numArgs); arg++ { 20061 var currArg uint8 20062 err = decoder.DecodeUint8(&currArg) 20063 if err != nil { 20064 return types.SignalCgroupRmdirArgs{}, err 20065 } 20066 20067 switch currArg { 20068 case 0: 20069 err = decoder.DecodeUint64(&result.CgroupId) 20070 if err != nil { 20071 return types.SignalCgroupRmdirArgs{}, err 20072 } 20073 case 1: 20074 result.CgroupPath, err = decoder.ReadStringFromBuff() 20075 if err != nil { 20076 return types.SignalCgroupRmdirArgs{}, err 20077 } 20078 case 2: 20079 err = decoder.DecodeUint32(&result.HierarchyId) 20080 if err != nil { 20081 return types.SignalCgroupRmdirArgs{}, err 20082 } 20083 } 20084 } 20085 return result, nil 20086 } 20087 20088 func ParseNetFlowBaseArgs(decoder *Decoder) (types.NetFlowBaseArgs, error) { 20089 var result types.NetFlowBaseArgs 20090 var err error 20091 20092 var numArgs uint8 20093 err = decoder.DecodeUint8(&numArgs) 20094 if err != nil { 20095 return types.NetFlowBaseArgs{}, err 20096 } 20097 20098 for arg := 0; arg < int(numArgs); arg++ { 20099 var currArg uint8 20100 err = decoder.DecodeUint8(&currArg) 20101 if err != nil { 20102 return types.NetFlowBaseArgs{}, err 20103 } 20104 20105 switch currArg { 20106 case 0: 20107 err = decoder.DecodeUint8(&result.Proto) 20108 if err != nil { 20109 return types.NetFlowBaseArgs{}, err 20110 } 20111 case 1: 20112 err = decoder.DecodeUint8(&result.Direction) 20113 if err != nil { 20114 return types.NetFlowBaseArgs{}, err 20115 } 20116 case 2: 20117 result.Tuple, err = decoder.ReadAddrTuple() 20118 if err != nil { 20119 return types.NetFlowBaseArgs{}, err 20120 } 20121 case 3: 20122 err = decoder.DecodeUint64(&result.TxBytes) 20123 if err != nil { 20124 return types.NetFlowBaseArgs{}, err 20125 } 20126 case 4: 20127 err = decoder.DecodeUint64(&result.RxBytes) 20128 if err != nil { 20129 return types.NetFlowBaseArgs{}, err 20130 } 20131 case 5: 20132 err = decoder.DecodeUint64(&result.TxPackets) 20133 if err != nil { 20134 return types.NetFlowBaseArgs{}, err 20135 } 20136 case 6: 20137 err = decoder.DecodeUint64(&result.RxPackets) 20138 if err != nil { 20139 return types.NetFlowBaseArgs{}, err 20140 } 20141 } 20142 } 20143 return result, nil 20144 } 20145 20146 func ParseArgs(decoder *Decoder, event events.ID) (types.Args, error) { 20147 switch event { 20148 case events.Read: 20149 return ParseReadArgs(decoder) 20150 case events.Write: 20151 return ParseWriteArgs(decoder) 20152 case events.Open: 20153 return ParseOpenArgs(decoder) 20154 case events.Close: 20155 return ParseCloseArgs(decoder) 20156 case events.Stat: 20157 return ParseStatArgs(decoder) 20158 case events.Fstat: 20159 return ParseFstatArgs(decoder) 20160 case events.Lstat: 20161 return ParseLstatArgs(decoder) 20162 case events.Poll: 20163 return ParsePollArgs(decoder) 20164 case events.Lseek: 20165 return ParseLseekArgs(decoder) 20166 case events.Mmap: 20167 return ParseMmapArgs(decoder) 20168 case events.Mprotect: 20169 return ParseMprotectArgs(decoder) 20170 case events.Munmap: 20171 return ParseMunmapArgs(decoder) 20172 case events.Brk: 20173 return ParseBrkArgs(decoder) 20174 case events.RtSigaction: 20175 return ParseRtSigactionArgs(decoder) 20176 case events.RtSigprocmask: 20177 return ParseRtSigprocmaskArgs(decoder) 20178 case events.RtSigreturn: 20179 return ParseRtSigreturnArgs(decoder) 20180 case events.Ioctl: 20181 return ParseIoctlArgs(decoder) 20182 case events.Pread64: 20183 return ParsePread64Args(decoder) 20184 case events.Pwrite64: 20185 return ParsePwrite64Args(decoder) 20186 case events.Readv: 20187 return ParseReadvArgs(decoder) 20188 case events.Writev: 20189 return ParseWritevArgs(decoder) 20190 case events.Access: 20191 return ParseAccessArgs(decoder) 20192 case events.Pipe: 20193 return ParsePipeArgs(decoder) 20194 case events.Select: 20195 return ParseSelectArgs(decoder) 20196 case events.SchedYield: 20197 return ParseSchedYieldArgs(decoder) 20198 case events.Mremap: 20199 return ParseMremapArgs(decoder) 20200 case events.Msync: 20201 return ParseMsyncArgs(decoder) 20202 case events.Mincore: 20203 return ParseMincoreArgs(decoder) 20204 case events.Madvise: 20205 return ParseMadviseArgs(decoder) 20206 case events.Shmget: 20207 return ParseShmgetArgs(decoder) 20208 case events.Shmat: 20209 return ParseShmatArgs(decoder) 20210 case events.Shmctl: 20211 return ParseShmctlArgs(decoder) 20212 case events.Dup: 20213 return ParseDupArgs(decoder) 20214 case events.Dup2: 20215 return ParseDup2Args(decoder) 20216 case events.Pause: 20217 return ParsePauseArgs(decoder) 20218 case events.Nanosleep: 20219 return ParseNanosleepArgs(decoder) 20220 case events.Getitimer: 20221 return ParseGetitimerArgs(decoder) 20222 case events.Alarm: 20223 return ParseAlarmArgs(decoder) 20224 case events.Setitimer: 20225 return ParseSetitimerArgs(decoder) 20226 case events.Getpid: 20227 return ParseGetpidArgs(decoder) 20228 case events.Sendfile: 20229 return ParseSendfileArgs(decoder) 20230 case events.Socket: 20231 return ParseSocketArgs(decoder) 20232 case events.Connect: 20233 return ParseConnectArgs(decoder) 20234 case events.Accept: 20235 return ParseAcceptArgs(decoder) 20236 case events.Sendto: 20237 return ParseSendtoArgs(decoder) 20238 case events.Recvfrom: 20239 return ParseRecvfromArgs(decoder) 20240 case events.Sendmsg: 20241 return ParseSendmsgArgs(decoder) 20242 case events.Recvmsg: 20243 return ParseRecvmsgArgs(decoder) 20244 case events.Shutdown: 20245 return ParseShutdownArgs(decoder) 20246 case events.Bind: 20247 return ParseBindArgs(decoder) 20248 case events.Listen: 20249 return ParseListenArgs(decoder) 20250 case events.Getsockname: 20251 return ParseGetsocknameArgs(decoder) 20252 case events.Getpeername: 20253 return ParseGetpeernameArgs(decoder) 20254 case events.Socketpair: 20255 return ParseSocketpairArgs(decoder) 20256 case events.Setsockopt: 20257 return ParseSetsockoptArgs(decoder) 20258 case events.Getsockopt: 20259 return ParseGetsockoptArgs(decoder) 20260 case events.Clone: 20261 return ParseCloneArgs(decoder) 20262 case events.Fork: 20263 return ParseForkArgs(decoder) 20264 case events.Vfork: 20265 return ParseVforkArgs(decoder) 20266 case events.Execve: 20267 return ParseExecveArgs(decoder) 20268 case events.Exit: 20269 return ParseExitArgs(decoder) 20270 case events.Wait4: 20271 return ParseWait4Args(decoder) 20272 case events.Kill: 20273 return ParseKillArgs(decoder) 20274 case events.Uname: 20275 return ParseUnameArgs(decoder) 20276 case events.Semget: 20277 return ParseSemgetArgs(decoder) 20278 case events.Semop: 20279 return ParseSemopArgs(decoder) 20280 case events.Semctl: 20281 return ParseSemctlArgs(decoder) 20282 case events.Shmdt: 20283 return ParseShmdtArgs(decoder) 20284 case events.Msgget: 20285 return ParseMsggetArgs(decoder) 20286 case events.Msgsnd: 20287 return ParseMsgsndArgs(decoder) 20288 case events.Msgrcv: 20289 return ParseMsgrcvArgs(decoder) 20290 case events.Msgctl: 20291 return ParseMsgctlArgs(decoder) 20292 case events.Fcntl: 20293 return ParseFcntlArgs(decoder) 20294 case events.Flock: 20295 return ParseFlockArgs(decoder) 20296 case events.Fsync: 20297 return ParseFsyncArgs(decoder) 20298 case events.Fdatasync: 20299 return ParseFdatasyncArgs(decoder) 20300 case events.Truncate: 20301 return ParseTruncateArgs(decoder) 20302 case events.Ftruncate: 20303 return ParseFtruncateArgs(decoder) 20304 case events.Getdents: 20305 return ParseGetdentsArgs(decoder) 20306 case events.Getcwd: 20307 return ParseGetcwdArgs(decoder) 20308 case events.Chdir: 20309 return ParseChdirArgs(decoder) 20310 case events.Fchdir: 20311 return ParseFchdirArgs(decoder) 20312 case events.Rename: 20313 return ParseRenameArgs(decoder) 20314 case events.Mkdir: 20315 return ParseMkdirArgs(decoder) 20316 case events.Rmdir: 20317 return ParseRmdirArgs(decoder) 20318 case events.Creat: 20319 return ParseCreatArgs(decoder) 20320 case events.Link: 20321 return ParseLinkArgs(decoder) 20322 case events.Unlink: 20323 return ParseUnlinkArgs(decoder) 20324 case events.Symlink: 20325 return ParseSymlinkArgs(decoder) 20326 case events.Readlink: 20327 return ParseReadlinkArgs(decoder) 20328 case events.Chmod: 20329 return ParseChmodArgs(decoder) 20330 case events.Fchmod: 20331 return ParseFchmodArgs(decoder) 20332 case events.Chown: 20333 return ParseChownArgs(decoder) 20334 case events.Fchown: 20335 return ParseFchownArgs(decoder) 20336 case events.Lchown: 20337 return ParseLchownArgs(decoder) 20338 case events.Umask: 20339 return ParseUmaskArgs(decoder) 20340 case events.Gettimeofday: 20341 return ParseGettimeofdayArgs(decoder) 20342 case events.Getrlimit: 20343 return ParseGetrlimitArgs(decoder) 20344 case events.Getrusage: 20345 return ParseGetrusageArgs(decoder) 20346 case events.Sysinfo: 20347 return ParseSysinfoArgs(decoder) 20348 case events.Times: 20349 return ParseTimesArgs(decoder) 20350 case events.Ptrace: 20351 return ParsePtraceArgs(decoder) 20352 case events.Getuid: 20353 return ParseGetuidArgs(decoder) 20354 case events.Syslog: 20355 return ParseSyslogArgs(decoder) 20356 case events.Getgid: 20357 return ParseGetgidArgs(decoder) 20358 case events.Setuid: 20359 return ParseSetuidArgs(decoder) 20360 case events.Setgid: 20361 return ParseSetgidArgs(decoder) 20362 case events.Geteuid: 20363 return ParseGeteuidArgs(decoder) 20364 case events.Getegid: 20365 return ParseGetegidArgs(decoder) 20366 case events.Setpgid: 20367 return ParseSetpgidArgs(decoder) 20368 case events.Getppid: 20369 return ParseGetppidArgs(decoder) 20370 case events.Getpgrp: 20371 return ParseGetpgrpArgs(decoder) 20372 case events.Setsid: 20373 return ParseSetsidArgs(decoder) 20374 case events.Setreuid: 20375 return ParseSetreuidArgs(decoder) 20376 case events.Setregid: 20377 return ParseSetregidArgs(decoder) 20378 case events.Getgroups: 20379 return ParseGetgroupsArgs(decoder) 20380 case events.Setgroups: 20381 return ParseSetgroupsArgs(decoder) 20382 case events.Setresuid: 20383 return ParseSetresuidArgs(decoder) 20384 case events.Getresuid: 20385 return ParseGetresuidArgs(decoder) 20386 case events.Setresgid: 20387 return ParseSetresgidArgs(decoder) 20388 case events.Getresgid: 20389 return ParseGetresgidArgs(decoder) 20390 case events.Getpgid: 20391 return ParseGetpgidArgs(decoder) 20392 case events.Setfsuid: 20393 return ParseSetfsuidArgs(decoder) 20394 case events.Setfsgid: 20395 return ParseSetfsgidArgs(decoder) 20396 case events.Getsid: 20397 return ParseGetsidArgs(decoder) 20398 case events.Capget: 20399 return ParseCapgetArgs(decoder) 20400 case events.Capset: 20401 return ParseCapsetArgs(decoder) 20402 case events.RtSigpending: 20403 return ParseRtSigpendingArgs(decoder) 20404 case events.RtSigtimedwait: 20405 return ParseRtSigtimedwaitArgs(decoder) 20406 case events.RtSigqueueinfo: 20407 return ParseRtSigqueueinfoArgs(decoder) 20408 case events.RtSigsuspend: 20409 return ParseRtSigsuspendArgs(decoder) 20410 case events.Sigaltstack: 20411 return ParseSigaltstackArgs(decoder) 20412 case events.Utime: 20413 return ParseUtimeArgs(decoder) 20414 case events.Mknod: 20415 return ParseMknodArgs(decoder) 20416 case events.Uselib: 20417 return ParseUselibArgs(decoder) 20418 case events.Personality: 20419 return ParsePersonalityArgs(decoder) 20420 case events.Ustat: 20421 return ParseUstatArgs(decoder) 20422 case events.Statfs: 20423 return ParseStatfsArgs(decoder) 20424 case events.Fstatfs: 20425 return ParseFstatfsArgs(decoder) 20426 case events.Sysfs: 20427 return ParseSysfsArgs(decoder) 20428 case events.Getpriority: 20429 return ParseGetpriorityArgs(decoder) 20430 case events.Setpriority: 20431 return ParseSetpriorityArgs(decoder) 20432 case events.SchedSetparam: 20433 return ParseSchedSetparamArgs(decoder) 20434 case events.SchedGetparam: 20435 return ParseSchedGetparamArgs(decoder) 20436 case events.SchedSetscheduler: 20437 return ParseSchedSetschedulerArgs(decoder) 20438 case events.SchedGetscheduler: 20439 return ParseSchedGetschedulerArgs(decoder) 20440 case events.SchedGetPriorityMax: 20441 return ParseSchedGetPriorityMaxArgs(decoder) 20442 case events.SchedGetPriorityMin: 20443 return ParseSchedGetPriorityMinArgs(decoder) 20444 case events.SchedRrGetInterval: 20445 return ParseSchedRrGetIntervalArgs(decoder) 20446 case events.Mlock: 20447 return ParseMlockArgs(decoder) 20448 case events.Munlock: 20449 return ParseMunlockArgs(decoder) 20450 case events.Mlockall: 20451 return ParseMlockallArgs(decoder) 20452 case events.Munlockall: 20453 return ParseMunlockallArgs(decoder) 20454 case events.Vhangup: 20455 return ParseVhangupArgs(decoder) 20456 case events.ModifyLdt: 20457 return ParseModifyLdtArgs(decoder) 20458 case events.PivotRoot: 20459 return ParsePivotRootArgs(decoder) 20460 case events.Sysctl: 20461 return ParseSysctlArgs(decoder) 20462 case events.Prctl: 20463 return ParsePrctlArgs(decoder) 20464 case events.ArchPrctl: 20465 return ParseArchPrctlArgs(decoder) 20466 case events.Adjtimex: 20467 return ParseAdjtimexArgs(decoder) 20468 case events.Setrlimit: 20469 return ParseSetrlimitArgs(decoder) 20470 case events.Chroot: 20471 return ParseChrootArgs(decoder) 20472 case events.Sync: 20473 return ParseSyncArgs(decoder) 20474 case events.Acct: 20475 return ParseAcctArgs(decoder) 20476 case events.Settimeofday: 20477 return ParseSettimeofdayArgs(decoder) 20478 case events.Mount: 20479 return ParseMountArgs(decoder) 20480 case events.Umount2: 20481 return ParseUmount2Args(decoder) 20482 case events.Swapon: 20483 return ParseSwaponArgs(decoder) 20484 case events.Swapoff: 20485 return ParseSwapoffArgs(decoder) 20486 case events.Reboot: 20487 return ParseRebootArgs(decoder) 20488 case events.Sethostname: 20489 return ParseSethostnameArgs(decoder) 20490 case events.Setdomainname: 20491 return ParseSetdomainnameArgs(decoder) 20492 case events.Iopl: 20493 return ParseIoplArgs(decoder) 20494 case events.Ioperm: 20495 return ParseIopermArgs(decoder) 20496 case events.CreateModule: 20497 return ParseCreateModuleArgs(decoder) 20498 case events.InitModule: 20499 return ParseInitModuleArgs(decoder) 20500 case events.DeleteModule: 20501 return ParseDeleteModuleArgs(decoder) 20502 case events.GetKernelSyms: 20503 return ParseGetKernelSymsArgs(decoder) 20504 case events.QueryModule: 20505 return ParseQueryModuleArgs(decoder) 20506 case events.Quotactl: 20507 return ParseQuotactlArgs(decoder) 20508 case events.Nfsservctl: 20509 return ParseNfsservctlArgs(decoder) 20510 case events.Getpmsg: 20511 return ParseGetpmsgArgs(decoder) 20512 case events.Putpmsg: 20513 return ParsePutpmsgArgs(decoder) 20514 case events.Afs: 20515 return ParseAfsArgs(decoder) 20516 case events.Tuxcall: 20517 return ParseTuxcallArgs(decoder) 20518 case events.Security: 20519 return ParseSecurityArgs(decoder) 20520 case events.Gettid: 20521 return ParseGettidArgs(decoder) 20522 case events.Readahead: 20523 return ParseReadaheadArgs(decoder) 20524 case events.Setxattr: 20525 return ParseSetxattrArgs(decoder) 20526 case events.Lsetxattr: 20527 return ParseLsetxattrArgs(decoder) 20528 case events.Fsetxattr: 20529 return ParseFsetxattrArgs(decoder) 20530 case events.Getxattr: 20531 return ParseGetxattrArgs(decoder) 20532 case events.Lgetxattr: 20533 return ParseLgetxattrArgs(decoder) 20534 case events.Fgetxattr: 20535 return ParseFgetxattrArgs(decoder) 20536 case events.Listxattr: 20537 return ParseListxattrArgs(decoder) 20538 case events.Llistxattr: 20539 return ParseLlistxattrArgs(decoder) 20540 case events.Flistxattr: 20541 return ParseFlistxattrArgs(decoder) 20542 case events.Removexattr: 20543 return ParseRemovexattrArgs(decoder) 20544 case events.Lremovexattr: 20545 return ParseLremovexattrArgs(decoder) 20546 case events.Fremovexattr: 20547 return ParseFremovexattrArgs(decoder) 20548 case events.Tkill: 20549 return ParseTkillArgs(decoder) 20550 case events.Time: 20551 return ParseTimeArgs(decoder) 20552 case events.Futex: 20553 return ParseFutexArgs(decoder) 20554 case events.SchedSetaffinity: 20555 return ParseSchedSetaffinityArgs(decoder) 20556 case events.SchedGetaffinity: 20557 return ParseSchedGetaffinityArgs(decoder) 20558 case events.SetThreadArea: 20559 return ParseSetThreadAreaArgs(decoder) 20560 case events.IoSetup: 20561 return ParseIoSetupArgs(decoder) 20562 case events.IoDestroy: 20563 return ParseIoDestroyArgs(decoder) 20564 case events.IoGetevents: 20565 return ParseIoGeteventsArgs(decoder) 20566 case events.IoSubmit: 20567 return ParseIoSubmitArgs(decoder) 20568 case events.IoCancel: 20569 return ParseIoCancelArgs(decoder) 20570 case events.GetThreadArea: 20571 return ParseGetThreadAreaArgs(decoder) 20572 case events.LookupDcookie: 20573 return ParseLookupDcookieArgs(decoder) 20574 case events.EpollCreate: 20575 return ParseEpollCreateArgs(decoder) 20576 case events.EpollCtlOld: 20577 return ParseEpollCtlOldArgs(decoder) 20578 case events.EpollWaitOld: 20579 return ParseEpollWaitOldArgs(decoder) 20580 case events.RemapFilePages: 20581 return ParseRemapFilePagesArgs(decoder) 20582 case events.Getdents64: 20583 return ParseGetdents64Args(decoder) 20584 case events.SetTidAddress: 20585 return ParseSetTidAddressArgs(decoder) 20586 case events.RestartSyscall: 20587 return ParseRestartSyscallArgs(decoder) 20588 case events.Semtimedop: 20589 return ParseSemtimedopArgs(decoder) 20590 case events.Fadvise64: 20591 return ParseFadvise64Args(decoder) 20592 case events.TimerCreate: 20593 return ParseTimerCreateArgs(decoder) 20594 case events.TimerSettime: 20595 return ParseTimerSettimeArgs(decoder) 20596 case events.TimerGettime: 20597 return ParseTimerGettimeArgs(decoder) 20598 case events.TimerGetoverrun: 20599 return ParseTimerGetoverrunArgs(decoder) 20600 case events.TimerDelete: 20601 return ParseTimerDeleteArgs(decoder) 20602 case events.ClockSettime: 20603 return ParseClockSettimeArgs(decoder) 20604 case events.ClockGettime: 20605 return ParseClockGettimeArgs(decoder) 20606 case events.ClockGetres: 20607 return ParseClockGetresArgs(decoder) 20608 case events.ClockNanosleep: 20609 return ParseClockNanosleepArgs(decoder) 20610 case events.ExitGroup: 20611 return ParseExitGroupArgs(decoder) 20612 case events.EpollWait: 20613 return ParseEpollWaitArgs(decoder) 20614 case events.EpollCtl: 20615 return ParseEpollCtlArgs(decoder) 20616 case events.Tgkill: 20617 return ParseTgkillArgs(decoder) 20618 case events.Utimes: 20619 return ParseUtimesArgs(decoder) 20620 case events.Vserver: 20621 return ParseVserverArgs(decoder) 20622 case events.Mbind: 20623 return ParseMbindArgs(decoder) 20624 case events.SetMempolicy: 20625 return ParseSetMempolicyArgs(decoder) 20626 case events.GetMempolicy: 20627 return ParseGetMempolicyArgs(decoder) 20628 case events.MqOpen: 20629 return ParseMqOpenArgs(decoder) 20630 case events.MqUnlink: 20631 return ParseMqUnlinkArgs(decoder) 20632 case events.MqTimedsend: 20633 return ParseMqTimedsendArgs(decoder) 20634 case events.MqTimedreceive: 20635 return ParseMqTimedreceiveArgs(decoder) 20636 case events.MqNotify: 20637 return ParseMqNotifyArgs(decoder) 20638 case events.MqGetsetattr: 20639 return ParseMqGetsetattrArgs(decoder) 20640 case events.KexecLoad: 20641 return ParseKexecLoadArgs(decoder) 20642 case events.Waitid: 20643 return ParseWaitidArgs(decoder) 20644 case events.AddKey: 20645 return ParseAddKeyArgs(decoder) 20646 case events.RequestKey: 20647 return ParseRequestKeyArgs(decoder) 20648 case events.Keyctl: 20649 return ParseKeyctlArgs(decoder) 20650 case events.IoprioSet: 20651 return ParseIoprioSetArgs(decoder) 20652 case events.IoprioGet: 20653 return ParseIoprioGetArgs(decoder) 20654 case events.InotifyInit: 20655 return ParseInotifyInitArgs(decoder) 20656 case events.InotifyAddWatch: 20657 return ParseInotifyAddWatchArgs(decoder) 20658 case events.InotifyRmWatch: 20659 return ParseInotifyRmWatchArgs(decoder) 20660 case events.MigratePages: 20661 return ParseMigratePagesArgs(decoder) 20662 case events.Openat: 20663 return ParseOpenatArgs(decoder) 20664 case events.Mkdirat: 20665 return ParseMkdiratArgs(decoder) 20666 case events.Mknodat: 20667 return ParseMknodatArgs(decoder) 20668 case events.Fchownat: 20669 return ParseFchownatArgs(decoder) 20670 case events.Futimesat: 20671 return ParseFutimesatArgs(decoder) 20672 case events.Newfstatat: 20673 return ParseNewfstatatArgs(decoder) 20674 case events.Unlinkat: 20675 return ParseUnlinkatArgs(decoder) 20676 case events.Renameat: 20677 return ParseRenameatArgs(decoder) 20678 case events.Linkat: 20679 return ParseLinkatArgs(decoder) 20680 case events.Symlinkat: 20681 return ParseSymlinkatArgs(decoder) 20682 case events.Readlinkat: 20683 return ParseReadlinkatArgs(decoder) 20684 case events.Fchmodat: 20685 return ParseFchmodatArgs(decoder) 20686 case events.Faccessat: 20687 return ParseFaccessatArgs(decoder) 20688 case events.Pselect6: 20689 return ParsePselect6Args(decoder) 20690 case events.Ppoll: 20691 return ParsePpollArgs(decoder) 20692 case events.Unshare: 20693 return ParseUnshareArgs(decoder) 20694 case events.SetRobustList: 20695 return ParseSetRobustListArgs(decoder) 20696 case events.GetRobustList: 20697 return ParseGetRobustListArgs(decoder) 20698 case events.Splice: 20699 return ParseSpliceArgs(decoder) 20700 case events.Tee: 20701 return ParseTeeArgs(decoder) 20702 case events.SyncFileRange: 20703 return ParseSyncFileRangeArgs(decoder) 20704 case events.Vmsplice: 20705 return ParseVmspliceArgs(decoder) 20706 case events.MovePages: 20707 return ParseMovePagesArgs(decoder) 20708 case events.Utimensat: 20709 return ParseUtimensatArgs(decoder) 20710 case events.EpollPwait: 20711 return ParseEpollPwaitArgs(decoder) 20712 case events.Signalfd: 20713 return ParseSignalfdArgs(decoder) 20714 case events.TimerfdCreate: 20715 return ParseTimerfdCreateArgs(decoder) 20716 case events.Eventfd: 20717 return ParseEventfdArgs(decoder) 20718 case events.Fallocate: 20719 return ParseFallocateArgs(decoder) 20720 case events.TimerfdSettime: 20721 return ParseTimerfdSettimeArgs(decoder) 20722 case events.TimerfdGettime: 20723 return ParseTimerfdGettimeArgs(decoder) 20724 case events.Accept4: 20725 return ParseAccept4Args(decoder) 20726 case events.Signalfd4: 20727 return ParseSignalfd4Args(decoder) 20728 case events.Eventfd2: 20729 return ParseEventfd2Args(decoder) 20730 case events.EpollCreate1: 20731 return ParseEpollCreate1Args(decoder) 20732 case events.Dup3: 20733 return ParseDup3Args(decoder) 20734 case events.Pipe2: 20735 return ParsePipe2Args(decoder) 20736 case events.InotifyInit1: 20737 return ParseInotifyInit1Args(decoder) 20738 case events.Preadv: 20739 return ParsePreadvArgs(decoder) 20740 case events.Pwritev: 20741 return ParsePwritevArgs(decoder) 20742 case events.RtTgsigqueueinfo: 20743 return ParseRtTgsigqueueinfoArgs(decoder) 20744 case events.PerfEventOpen: 20745 return ParsePerfEventOpenArgs(decoder) 20746 case events.Recvmmsg: 20747 return ParseRecvmmsgArgs(decoder) 20748 case events.FanotifyInit: 20749 return ParseFanotifyInitArgs(decoder) 20750 case events.FanotifyMark: 20751 return ParseFanotifyMarkArgs(decoder) 20752 case events.Prlimit64: 20753 return ParsePrlimit64Args(decoder) 20754 case events.NameToHandleAt: 20755 return ParseNameToHandleAtArgs(decoder) 20756 case events.OpenByHandleAt: 20757 return ParseOpenByHandleAtArgs(decoder) 20758 case events.ClockAdjtime: 20759 return ParseClockAdjtimeArgs(decoder) 20760 case events.Syncfs: 20761 return ParseSyncfsArgs(decoder) 20762 case events.Sendmmsg: 20763 return ParseSendmmsgArgs(decoder) 20764 case events.Setns: 20765 return ParseSetnsArgs(decoder) 20766 case events.Getcpu: 20767 return ParseGetcpuArgs(decoder) 20768 case events.ProcessVmReadv: 20769 return ParseProcessVmReadvArgs(decoder) 20770 case events.ProcessVmWritev: 20771 return ParseProcessVmWritevArgs(decoder) 20772 case events.Kcmp: 20773 return ParseKcmpArgs(decoder) 20774 case events.FinitModule: 20775 return ParseFinitModuleArgs(decoder) 20776 case events.SchedSetattr: 20777 return ParseSchedSetattrArgs(decoder) 20778 case events.SchedGetattr: 20779 return ParseSchedGetattrArgs(decoder) 20780 case events.Renameat2: 20781 return ParseRenameat2Args(decoder) 20782 case events.Seccomp: 20783 return ParseSeccompArgs(decoder) 20784 case events.Getrandom: 20785 return ParseGetrandomArgs(decoder) 20786 case events.MemfdCreate: 20787 return ParseMemfdCreateArgs(decoder) 20788 case events.KexecFileLoad: 20789 return ParseKexecFileLoadArgs(decoder) 20790 case events.Bpf: 20791 return ParseBpfArgs(decoder) 20792 case events.Execveat: 20793 return ParseExecveatArgs(decoder) 20794 case events.Userfaultfd: 20795 return ParseUserfaultfdArgs(decoder) 20796 case events.Membarrier: 20797 return ParseMembarrierArgs(decoder) 20798 case events.Mlock2: 20799 return ParseMlock2Args(decoder) 20800 case events.CopyFileRange: 20801 return ParseCopyFileRangeArgs(decoder) 20802 case events.Preadv2: 20803 return ParsePreadv2Args(decoder) 20804 case events.Pwritev2: 20805 return ParsePwritev2Args(decoder) 20806 case events.PkeyMprotect: 20807 return ParsePkeyMprotectArgs(decoder) 20808 case events.PkeyAlloc: 20809 return ParsePkeyAllocArgs(decoder) 20810 case events.PkeyFree: 20811 return ParsePkeyFreeArgs(decoder) 20812 case events.Statx: 20813 return ParseStatxArgs(decoder) 20814 case events.IoPgetevents: 20815 return ParseIoPgeteventsArgs(decoder) 20816 case events.Rseq: 20817 return ParseRseqArgs(decoder) 20818 case events.PidfdSendSignal: 20819 return ParsePidfdSendSignalArgs(decoder) 20820 case events.IoUringSetup: 20821 return ParseIoUringSetupArgs(decoder) 20822 case events.IoUringEnter: 20823 return ParseIoUringEnterArgs(decoder) 20824 case events.IoUringRegister: 20825 return ParseIoUringRegisterArgs(decoder) 20826 case events.OpenTree: 20827 return ParseOpenTreeArgs(decoder) 20828 case events.MoveMount: 20829 return ParseMoveMountArgs(decoder) 20830 case events.Fsopen: 20831 return ParseFsopenArgs(decoder) 20832 case events.Fsconfig: 20833 return ParseFsconfigArgs(decoder) 20834 case events.Fsmount: 20835 return ParseFsmountArgs(decoder) 20836 case events.Fspick: 20837 return ParseFspickArgs(decoder) 20838 case events.PidfdOpen: 20839 return ParsePidfdOpenArgs(decoder) 20840 case events.Clone3: 20841 return ParseClone3Args(decoder) 20842 case events.CloseRange: 20843 return ParseCloseRangeArgs(decoder) 20844 case events.Openat2: 20845 return ParseOpenat2Args(decoder) 20846 case events.PidfdGetfd: 20847 return ParsePidfdGetfdArgs(decoder) 20848 case events.Faccessat2: 20849 return ParseFaccessat2Args(decoder) 20850 case events.ProcessMadvise: 20851 return ParseProcessMadviseArgs(decoder) 20852 case events.EpollPwait2: 20853 return ParseEpollPwait2Args(decoder) 20854 case events.MountSetatt: 20855 return ParseMountSetattArgs(decoder) 20856 case events.QuotactlFd: 20857 return ParseQuotactlFdArgs(decoder) 20858 case events.LandlockCreateRuleset: 20859 return ParseLandlockCreateRulesetArgs(decoder) 20860 case events.LandlockAddRule: 20861 return ParseLandlockAddRuleArgs(decoder) 20862 case events.LandloclRestrictSet: 20863 return ParseLandloclRestrictSetArgs(decoder) 20864 case events.MemfdSecret: 20865 return ParseMemfdSecretArgs(decoder) 20866 case events.ProcessMrelease: 20867 return ParseProcessMreleaseArgs(decoder) 20868 case events.Waitpid: 20869 return ParseWaitpidArgs(decoder) 20870 case events.Oldfstat: 20871 return ParseOldfstatArgs(decoder) 20872 case events.Break: 20873 return ParseBreakArgs(decoder) 20874 case events.Oldstat: 20875 return ParseOldstatArgs(decoder) 20876 case events.Umount: 20877 return ParseUmountArgs(decoder) 20878 case events.Stime: 20879 return ParseStimeArgs(decoder) 20880 case events.Stty: 20881 return ParseSttyArgs(decoder) 20882 case events.Gtty: 20883 return ParseGttyArgs(decoder) 20884 case events.Nice: 20885 return ParseNiceArgs(decoder) 20886 case events.Ftime: 20887 return ParseFtimeArgs(decoder) 20888 case events.Prof: 20889 return ParseProfArgs(decoder) 20890 case events.Signal: 20891 return ParseSignalArgs(decoder) 20892 case events.Lock: 20893 return ParseLockArgs(decoder) 20894 case events.Mpx: 20895 return ParseMpxArgs(decoder) 20896 case events.Ulimit: 20897 return ParseUlimitArgs(decoder) 20898 case events.Oldolduname: 20899 return ParseOldoldunameArgs(decoder) 20900 case events.Sigaction: 20901 return ParseSigactionArgs(decoder) 20902 case events.Sgetmask: 20903 return ParseSgetmaskArgs(decoder) 20904 case events.Ssetmask: 20905 return ParseSsetmaskArgs(decoder) 20906 case events.Sigsuspend: 20907 return ParseSigsuspendArgs(decoder) 20908 case events.Sigpending: 20909 return ParseSigpendingArgs(decoder) 20910 case events.Oldlstat: 20911 return ParseOldlstatArgs(decoder) 20912 case events.Readdir: 20913 return ParseReaddirArgs(decoder) 20914 case events.Profil: 20915 return ParseProfilArgs(decoder) 20916 case events.Socketcall: 20917 return ParseSocketcallArgs(decoder) 20918 case events.Olduname: 20919 return ParseOldunameArgs(decoder) 20920 case events.Idle: 20921 return ParseIdleArgs(decoder) 20922 case events.Vm86old: 20923 return ParseVm86oldArgs(decoder) 20924 case events.Ipc: 20925 return ParseIpcArgs(decoder) 20926 case events.Sigreturn: 20927 return ParseSigreturnArgs(decoder) 20928 case events.Sigprocmask: 20929 return ParseSigprocmaskArgs(decoder) 20930 case events.Bdflush: 20931 return ParseBdflushArgs(decoder) 20932 case events.Afs_syscall: 20933 return ParseAfs_syscallArgs(decoder) 20934 case events.Llseek: 20935 return ParseLlseekArgs(decoder) 20936 case events.OldSelect: 20937 return ParseOldSelectArgs(decoder) 20938 case events.Vm86: 20939 return ParseVm86Args(decoder) 20940 case events.OldGetrlimit: 20941 return ParseOldGetrlimitArgs(decoder) 20942 case events.Mmap2: 20943 return ParseMmap2Args(decoder) 20944 case events.Truncate64: 20945 return ParseTruncate64Args(decoder) 20946 case events.Ftruncate64: 20947 return ParseFtruncate64Args(decoder) 20948 case events.Stat64: 20949 return ParseStat64Args(decoder) 20950 case events.Lstat64: 20951 return ParseLstat64Args(decoder) 20952 case events.Fstat64: 20953 return ParseFstat64Args(decoder) 20954 case events.Lchown16: 20955 return ParseLchown16Args(decoder) 20956 case events.Getuid16: 20957 return ParseGetuid16Args(decoder) 20958 case events.Getgid16: 20959 return ParseGetgid16Args(decoder) 20960 case events.Geteuid16: 20961 return ParseGeteuid16Args(decoder) 20962 case events.Getegid16: 20963 return ParseGetegid16Args(decoder) 20964 case events.Setreuid16: 20965 return ParseSetreuid16Args(decoder) 20966 case events.Setregid16: 20967 return ParseSetregid16Args(decoder) 20968 case events.Getgroups16: 20969 return ParseGetgroups16Args(decoder) 20970 case events.Setgroups16: 20971 return ParseSetgroups16Args(decoder) 20972 case events.Fchown16: 20973 return ParseFchown16Args(decoder) 20974 case events.Setresuid16: 20975 return ParseSetresuid16Args(decoder) 20976 case events.Getresuid16: 20977 return ParseGetresuid16Args(decoder) 20978 case events.Setresgid16: 20979 return ParseSetresgid16Args(decoder) 20980 case events.Getresgid16: 20981 return ParseGetresgid16Args(decoder) 20982 case events.Chown16: 20983 return ParseChown16Args(decoder) 20984 case events.Setuid16: 20985 return ParseSetuid16Args(decoder) 20986 case events.Setgid16: 20987 return ParseSetgid16Args(decoder) 20988 case events.Setfsuid16: 20989 return ParseSetfsuid16Args(decoder) 20990 case events.Setfsgid16: 20991 return ParseSetfsgid16Args(decoder) 20992 case events.Fcntl64: 20993 return ParseFcntl64Args(decoder) 20994 case events.Sendfile32: 20995 return ParseSendfile32Args(decoder) 20996 case events.Statfs64: 20997 return ParseStatfs64Args(decoder) 20998 case events.Fstatfs64: 20999 return ParseFstatfs64Args(decoder) 21000 case events.Fadvise64_64: 21001 return ParseFadvise64_64Args(decoder) 21002 case events.ClockGettime32: 21003 return ParseClockGettime32Args(decoder) 21004 case events.ClockSettime32: 21005 return ParseClockSettime32Args(decoder) 21006 case events.ClockAdjtime64: 21007 return ParseClockAdjtime64Args(decoder) 21008 case events.ClockGetresTime32: 21009 return ParseClockGetresTime32Args(decoder) 21010 case events.ClockNanosleepTime32: 21011 return ParseClockNanosleepTime32Args(decoder) 21012 case events.TimerGettime32: 21013 return ParseTimerGettime32Args(decoder) 21014 case events.TimerSettime32: 21015 return ParseTimerSettime32Args(decoder) 21016 case events.TimerfdGettime32: 21017 return ParseTimerfdGettime32Args(decoder) 21018 case events.TimerfdSettime32: 21019 return ParseTimerfdSettime32Args(decoder) 21020 case events.UtimensatTime32: 21021 return ParseUtimensatTime32Args(decoder) 21022 case events.Pselect6Time32: 21023 return ParsePselect6Time32Args(decoder) 21024 case events.PpollTime32: 21025 return ParsePpollTime32Args(decoder) 21026 case events.IoPgeteventsTime32: 21027 return ParseIoPgeteventsTime32Args(decoder) 21028 case events.RecvmmsgTime32: 21029 return ParseRecvmmsgTime32Args(decoder) 21030 case events.MqTimedsendTime32: 21031 return ParseMqTimedsendTime32Args(decoder) 21032 case events.MqTimedreceiveTime32: 21033 return ParseMqTimedreceiveTime32Args(decoder) 21034 case events.RtSigtimedwaitTime32: 21035 return ParseRtSigtimedwaitTime32Args(decoder) 21036 case events.FutexTime32: 21037 return ParseFutexTime32Args(decoder) 21038 case events.SchedRrGetInterval32: 21039 return ParseSchedRrGetInterval32Args(decoder) 21040 case events.SysEnter: 21041 return ParseSysEnterArgs(decoder) 21042 case events.SysExit: 21043 return ParseSysExitArgs(decoder) 21044 case events.SchedProcessFork: 21045 return ParseSchedProcessForkArgs(decoder) 21046 case events.SchedProcessExec: 21047 return ParseSchedProcessExecArgs(decoder) 21048 case events.SchedProcessExit: 21049 return ParseSchedProcessExitArgs(decoder) 21050 case events.SchedSwitch: 21051 return ParseSchedSwitchArgs(decoder) 21052 case events.ProcessOomKilled: 21053 return ParseProcessOomKilledArgs(decoder) 21054 case events.DoExit: 21055 return ParseDoExitArgs(decoder) 21056 case events.CapCapable: 21057 return ParseCapCapableArgs(decoder) 21058 case events.VfsWrite: 21059 return ParseVfsWriteArgs(decoder) 21060 case events.VfsWritev: 21061 return ParseVfsWritevArgs(decoder) 21062 case events.MemProtAlert: 21063 return ParseMemProtAlertArgs(decoder) 21064 case events.CommitCreds: 21065 return ParseCommitCredsArgs(decoder) 21066 case events.SwitchTaskNS: 21067 return ParseSwitchTaskNSArgs(decoder) 21068 case events.MagicWrite: 21069 return ParseMagicWriteArgs(decoder) 21070 case events.CgroupAttachTask: 21071 return ParseCgroupAttachTaskArgs(decoder) 21072 case events.CgroupMkdir: 21073 return ParseCgroupMkdirArgs(decoder) 21074 case events.CgroupRmdir: 21075 return ParseCgroupRmdirArgs(decoder) 21076 case events.SecurityFileOpen: 21077 return ParseSecurityFileOpenArgs(decoder) 21078 case events.SecurityInodeUnlink: 21079 return ParseSecurityInodeUnlinkArgs(decoder) 21080 case events.SecuritySocketCreate: 21081 return ParseSecuritySocketCreateArgs(decoder) 21082 case events.SecuritySocketListen: 21083 return ParseSecuritySocketListenArgs(decoder) 21084 case events.SecuritySocketConnect: 21085 return ParseSecuritySocketConnectArgs(decoder) 21086 case events.SecuritySocketAccept: 21087 return ParseSecuritySocketAcceptArgs(decoder) 21088 case events.SecuritySocketBind: 21089 return ParseSecuritySocketBindArgs(decoder) 21090 case events.SecuritySocketSetsockopt: 21091 return ParseSecuritySocketSetsockoptArgs(decoder) 21092 case events.SecuritySbMount: 21093 return ParseSecuritySbMountArgs(decoder) 21094 case events.SecurityBPF: 21095 return ParseSecurityBPFArgs(decoder) 21096 case events.SecurityBPFMap: 21097 return ParseSecurityBPFMapArgs(decoder) 21098 case events.SecurityKernelReadFile: 21099 return ParseSecurityKernelReadFileArgs(decoder) 21100 case events.SecurityPostReadFile: 21101 return ParseSecurityPostReadFileArgs(decoder) 21102 case events.SecurityInodeMknod: 21103 return ParseSecurityInodeMknodArgs(decoder) 21104 case events.SecurityInodeSymlinkEventId: 21105 return ParseSecurityInodeSymlinkEventIdArgs(decoder) 21106 case events.SecurityMmapFile: 21107 return ParseSecurityMmapFileArgs(decoder) 21108 case events.DoMmap: 21109 return ParseDoMmapArgs(decoder) 21110 case events.SecurityFileMprotect: 21111 return ParseSecurityFileMprotectArgs(decoder) 21112 case events.InitNamespaces: 21113 return ParseInitNamespacesArgs(decoder) 21114 case events.SocketDup: 21115 return ParseSocketDupArgs(decoder) 21116 case events.HiddenInodes: 21117 return ParseHiddenInodesArgs(decoder) 21118 case events.KernelWrite: 21119 return ParseKernelWriteArgs(decoder) 21120 case events.DirtyPipeSplice: 21121 return ParseDirtyPipeSpliceArgs(decoder) 21122 case events.ContainerCreate: 21123 return ParseContainerCreateArgs(decoder) 21124 case events.ContainerRemove: 21125 return ParseContainerRemoveArgs(decoder) 21126 case events.ExistingContainer: 21127 return ParseExistingContainerArgs(decoder) 21128 case events.ProcCreate: 21129 return ParseProcCreateArgs(decoder) 21130 case events.KprobeAttach: 21131 return ParseKprobeAttachArgs(decoder) 21132 case events.CallUsermodeHelper: 21133 return ParseCallUsermodeHelperArgs(decoder) 21134 case events.DebugfsCreateFile: 21135 return ParseDebugfsCreateFileArgs(decoder) 21136 case events.PrintSyscallTable: 21137 return ParsePrintSyscallTableArgs(decoder) 21138 case events.HiddenKernelModule: 21139 return ParseHiddenKernelModuleArgs(decoder) 21140 case events.HiddenKernelModuleSeeker: 21141 return ParseHiddenKernelModuleSeekerArgs(decoder) 21142 case events.HookedSyscalls: 21143 return ParseHookedSyscallsArgs(decoder) 21144 case events.DebugfsCreateDir: 21145 return ParseDebugfsCreateDirArgs(decoder) 21146 case events.DeviceAdd: 21147 return ParseDeviceAddArgs(decoder) 21148 case events.RegisterChrdev: 21149 return ParseRegisterChrdevArgs(decoder) 21150 case events.SharedObjectLoaded: 21151 return ParseSharedObjectLoadedArgs(decoder) 21152 case events.SymbolsLoaded: 21153 return ParseSymbolsLoadedArgs(decoder) 21154 case events.SymbolsCollision: 21155 return ParseSymbolsCollisionArgs(decoder) 21156 case events.CaptureFileWrite: 21157 return ParseCaptureFileWriteArgs(decoder) 21158 case events.CaptureFileRead: 21159 return ParseCaptureFileReadArgs(decoder) 21160 case events.CaptureExec: 21161 return ParseCaptureExecArgs(decoder) 21162 case events.CaptureModule: 21163 return ParseCaptureModuleArgs(decoder) 21164 case events.CaptureMem: 21165 return ParseCaptureMemArgs(decoder) 21166 case events.CaptureBpf: 21167 return ParseCaptureBpfArgs(decoder) 21168 case events.DoInitModule: 21169 return ParseDoInitModuleArgs(decoder) 21170 case events.ModuleLoad: 21171 return ParseModuleLoadArgs(decoder) 21172 case events.ModuleFree: 21173 return ParseModuleFreeArgs(decoder) 21174 case events.SocketAccept: 21175 return ParseSocketAcceptArgs(decoder) 21176 case events.LoadElfPhdrs: 21177 return ParseLoadElfPhdrsArgs(decoder) 21178 case events.PrintNetSeqOps: 21179 return ParsePrintNetSeqOpsArgs(decoder) 21180 case events.HookedSeqOps: 21181 return ParseHookedSeqOpsArgs(decoder) 21182 case events.TaskRename: 21183 return ParseTaskRenameArgs(decoder) 21184 case events.SecurityInodeRename: 21185 return ParseSecurityInodeRenameArgs(decoder) 21186 case events.DoSigaction: 21187 return ParseDoSigactionArgs(decoder) 21188 case events.BpfAttach: 21189 return ParseBpfAttachArgs(decoder) 21190 case events.KallsymsLookupName: 21191 return ParseKallsymsLookupNameArgs(decoder) 21192 case events.PrintMemDump: 21193 return ParsePrintMemDumpArgs(decoder) 21194 case events.VfsRead: 21195 return ParseVfsReadArgs(decoder) 21196 case events.VfsReadv: 21197 return ParseVfsReadvArgs(decoder) 21198 case events.VfsUtimes: 21199 return ParseVfsUtimesArgs(decoder) 21200 case events.DoTruncate: 21201 return ParseDoTruncateArgs(decoder) 21202 case events.FileModification: 21203 return ParseFileModificationArgs(decoder) 21204 case events.InotifyWatch: 21205 return ParseInotifyWatchArgs(decoder) 21206 case events.ProcessExecuteFailed: 21207 return ParseProcessExecuteFailedArgs(decoder) 21208 case events.TtyOpen: 21209 return ParseTtyOpenArgs(decoder) 21210 case events.NetPacketBase: 21211 return ParseNetPacketBaseArgs(decoder) 21212 case events.NetPacketIPBase: 21213 return ParseNetPacketIPBaseArgs(decoder) 21214 case events.NetPacketIPv4: 21215 return ParseNetPacketIPv4Args(decoder) 21216 case events.NetPacketIPv6: 21217 return ParseNetPacketIPv6Args(decoder) 21218 case events.NetPacketTCPBase: 21219 return ParseNetPacketTCPBaseArgs(decoder) 21220 case events.NetPacketTCP: 21221 return ParseNetPacketTCPArgs(decoder) 21222 case events.NetPacketUDPBase: 21223 return ParseNetPacketUDPBaseArgs(decoder) 21224 case events.NetPacketUDP: 21225 return ParseNetPacketUDPArgs(decoder) 21226 case events.NetPacketICMPBase: 21227 return ParseNetPacketICMPBaseArgs(decoder) 21228 case events.NetPacketICMP: 21229 return ParseNetPacketICMPArgs(decoder) 21230 case events.NetPacketICMPv6Base: 21231 return ParseNetPacketICMPv6BaseArgs(decoder) 21232 case events.NetPacketICMPv6: 21233 return ParseNetPacketICMPv6Args(decoder) 21234 case events.NetPacketDNSBase: 21235 return ParseNetPacketDNSBaseArgs(decoder) 21236 case events.NetPacketDNS: 21237 return ParseNetPacketDNSArgs(decoder) 21238 case events.NetPacketDNSRequest: 21239 return ParseNetPacketDNSRequestArgs(decoder) 21240 case events.NetPacketDNSResponse: 21241 return ParseNetPacketDNSResponseArgs(decoder) 21242 case events.NetPacketHTTPBase: 21243 return ParseNetPacketHTTPBaseArgs(decoder) 21244 case events.NetPacketHTTP: 21245 return ParseNetPacketHTTPArgs(decoder) 21246 case events.NetPacketHTTPRequest: 21247 return ParseNetPacketHTTPRequestArgs(decoder) 21248 case events.NetPacketHTTPResponse: 21249 return ParseNetPacketHTTPResponseArgs(decoder) 21250 case events.NetPacketSOCKS5Base: 21251 return ParseNetPacketSOCKS5BaseArgs(decoder) 21252 case events.NetPacketCapture: 21253 return ParseNetPacketCaptureArgs(decoder) 21254 case events.CaptureNetPacket: 21255 return ParseCaptureNetPacketArgs(decoder) 21256 case events.SockSetState: 21257 return ParseSockSetStateArgs(decoder) 21258 case events.TrackSyscallStats: 21259 return ParseTrackSyscallStatsArgs(decoder) 21260 case events.TestEvent: 21261 return ParseTestEventArgs(decoder) 21262 case events.SignalCgroupMkdir: 21263 return ParseSignalCgroupMkdirArgs(decoder) 21264 case events.SignalCgroupRmdir: 21265 return ParseSignalCgroupRmdirArgs(decoder) 21266 case events.NetFlowBase: 21267 return ParseNetFlowBaseArgs(decoder) 21268 } 21269 21270 return nil, ErrUnknownArgsType 21271 }