1 /* $NetBSD: xdr.c,v 1.22 2000/07/06 03:10:35 christos Exp $ */ 2 3 /* 4 * Sun RPC is a product of Sun Microsystems, Inc. and is provided for 5 * unrestricted use provided that this legend is included on all tape 6 * media and as a part of the software program in whole or part. Users 7 * may copy or modify Sun RPC without charge, but are not authorized 8 * to license or distribute it to anyone else except as part of a product or 9 * program developed by the user. 10 * 11 * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE 12 * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR 13 * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE. 14 * 15 * Sun RPC is provided with no support and without any obligation on the 16 * part of Sun Microsystems, Inc. to assist in its use, correction, 17 * modification or enhancement. 18 * 19 * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE 20 * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC 21 * OR ANY PART THEREOF. 22 * 23 * In no event will Sun Microsystems, Inc. be liable for any lost revenue 24 * or profits or other special, indirect and consequential damages, even if 25 * Sun has been advised of the possibility of such damages. 26 * 27 * Sun Microsystems, Inc. 28 * 2550 Garcia Avenue 29 * Mountain View, California 94043 30 */ 31 32 #if defined(LIBC_SCCS) && !defined(lint) 33 static char *sccsid2 = "@(#)xdr.c 1.35 87/08/12"; 34 static char *sccsid = "@(#)xdr.c 2.1 88/07/29 4.0 RPCSRC"; 35 #endif 36 #include <sys/cdefs.h> 37 /* 38 * xdr.c, Generic XDR routines implementation. 39 * 40 * Copyright (C) 1986, Sun Microsystems, Inc. 41 * 42 * These are the "generic" xdr routines used to serialize and de-serialize 43 * most common data items. See xdr.h for more info on the interface to 44 * xdr. 45 */ 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/kernel.h> 50 #include <sys/malloc.h> 51 #include <sys/module.h> 52 53 #include <rpc/rpc.h> 54 #include <rpc/rpc_com.h> 55 #include <rpc/types.h> 56 #include <rpc/xdr.h> 57 58 typedef quad_t longlong_t; /* ANSI long long type */ 59 typedef u_quad_t u_longlong_t; /* ANSI unsigned long long type */ 60 61 /* 62 * constants specific to the xdr "protocol" 63 */ 64 #define XDR_FALSE ((long) 0) 65 #define XDR_TRUE ((long) 1) 66 67 MALLOC_DEFINE(M_RPC, "rpc", "Remote Procedure Call"); 68 69 /* 70 * for unit alignment 71 */ 72 static const char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 }; 73 74 /* 75 * Free a data structure using XDR 76 * Not a filter, but a convenient utility nonetheless 77 */ 78 void 79 xdr_free(xdrproc_t proc, void *objp) 80 { 81 XDR x; 82 83 x.x_op = XDR_FREE; 84 (*proc)(&x, objp); 85 } 86 87 /* 88 * XDR nothing 89 */ 90 bool_t 91 xdr_void(void) 92 { 93 94 return (TRUE); 95 } 96 97 /* 98 * XDR integers 99 */ 100 bool_t 101 xdr_int(XDR *xdrs, int *ip) 102 { 103 long l; 104 105 switch (xdrs->x_op) { 106 case XDR_ENCODE: 107 l = (long) *ip; 108 return (XDR_PUTLONG(xdrs, &l)); 109 110 case XDR_DECODE: 111 if (!XDR_GETLONG(xdrs, &l)) { 112 return (FALSE); 113 } 114 *ip = (int) l; 115 return (TRUE); 116 117 case XDR_FREE: 118 return (TRUE); 119 } 120 /* NOTREACHED */ 121 return (FALSE); 122 } 123 124 /* 125 * XDR unsigned integers 126 */ 127 bool_t 128 xdr_u_int(XDR *xdrs, u_int *up) 129 { 130 u_long l; 131 132 switch (xdrs->x_op) { 133 case XDR_ENCODE: 134 l = (u_long) *up; 135 return (XDR_PUTLONG(xdrs, (long *)&l)); 136 137 case XDR_DECODE: 138 if (!XDR_GETLONG(xdrs, (long *)&l)) { 139 return (FALSE); 140 } 141 *up = (u_int) l; 142 return (TRUE); 143 144 case XDR_FREE: 145 return (TRUE); 146 } 147 /* NOTREACHED */ 148 return (FALSE); 149 } 150 151 /* 152 * XDR long integers 153 * same as xdr_u_long - open coded to save a proc call! 154 */ 155 bool_t 156 xdr_long(XDR *xdrs, long *lp) 157 { 158 switch (xdrs->x_op) { 159 case XDR_ENCODE: 160 return (XDR_PUTLONG(xdrs, lp)); 161 case XDR_DECODE: 162 return (XDR_GETLONG(xdrs, lp)); 163 case XDR_FREE: 164 return (TRUE); 165 } 166 /* NOTREACHED */ 167 return (FALSE); 168 } 169 170 /* 171 * XDR unsigned long integers 172 * same as xdr_long - open coded to save a proc call! 173 */ 174 bool_t 175 xdr_u_long(XDR *xdrs, u_long *ulp) 176 { 177 switch (xdrs->x_op) { 178 case XDR_ENCODE: 179 return (XDR_PUTLONG(xdrs, (long *)ulp)); 180 case XDR_DECODE: 181 return (XDR_GETLONG(xdrs, (long *)ulp)); 182 case XDR_FREE: 183 return (TRUE); 184 } 185 /* NOTREACHED */ 186 return (FALSE); 187 } 188 189 /* 190 * XDR 32-bit integers 191 * same as xdr_uint32_t - open coded to save a proc call! 192 */ 193 bool_t 194 xdr_int32_t(XDR *xdrs, int32_t *int32_p) 195 { 196 long l; 197 198 switch (xdrs->x_op) { 199 case XDR_ENCODE: 200 l = (long) *int32_p; 201 return (XDR_PUTLONG(xdrs, &l)); 202 203 case XDR_DECODE: 204 if (!XDR_GETLONG(xdrs, &l)) { 205 return (FALSE); 206 } 207 *int32_p = (int32_t) l; 208 return (TRUE); 209 210 case XDR_FREE: 211 return (TRUE); 212 } 213 /* NOTREACHED */ 214 return (FALSE); 215 } 216 217 /* 218 * XDR unsigned 32-bit integers 219 * same as xdr_int32_t - open coded to save a proc call! 220 */ 221 bool_t 222 xdr_uint32_t(XDR *xdrs, uint32_t *uint32_p) 223 { 224 u_long l; 225 226 switch (xdrs->x_op) { 227 case XDR_ENCODE: 228 l = (u_long) *uint32_p; 229 return (XDR_PUTLONG(xdrs, (long *)&l)); 230 231 case XDR_DECODE: 232 if (!XDR_GETLONG(xdrs, (long *)&l)) { 233 return (FALSE); 234 } 235 *uint32_p = (uint32_t) l; 236 return (TRUE); 237 238 case XDR_FREE: 239 return (TRUE); 240 } 241 /* NOTREACHED */ 242 return (FALSE); 243 } 244 245 /* 246 * XDR short integers 247 */ 248 bool_t 249 xdr_short(XDR *xdrs, short *sp) 250 { 251 long l; 252 253 switch (xdrs->x_op) { 254 case XDR_ENCODE: 255 l = (long) *sp; 256 return (XDR_PUTLONG(xdrs, &l)); 257 258 case XDR_DECODE: 259 if (!XDR_GETLONG(xdrs, &l)) { 260 return (FALSE); 261 } 262 *sp = (short) l; 263 return (TRUE); 264 265 case XDR_FREE: 266 return (TRUE); 267 } 268 /* NOTREACHED */ 269 return (FALSE); 270 } 271 272 /* 273 * XDR unsigned short integers 274 */ 275 bool_t 276 xdr_u_short(XDR *xdrs, u_short *usp) 277 { 278 u_long l; 279 280 switch (xdrs->x_op) { 281 case XDR_ENCODE: 282 l = (u_long) *usp; 283 return (XDR_PUTLONG(xdrs, (long *)&l)); 284 285 case XDR_DECODE: 286 if (!XDR_GETLONG(xdrs, (long *)&l)) { 287 return (FALSE); 288 } 289 *usp = (u_short) l; 290 return (TRUE); 291 292 case XDR_FREE: 293 return (TRUE); 294 } 295 /* NOTREACHED */ 296 return (FALSE); 297 } 298 299 /* 300 * XDR 16-bit integers 301 */ 302 bool_t 303 xdr_int16_t(XDR *xdrs, int16_t *int16_p) 304 { 305 long l; 306 307 switch (xdrs->x_op) { 308 case XDR_ENCODE: 309 l = (long) *int16_p; 310 return (XDR_PUTLONG(xdrs, &l)); 311 312 case XDR_DECODE: 313 if (!XDR_GETLONG(xdrs, &l)) { 314 return (FALSE); 315 } 316 *int16_p = (int16_t) l; 317 return (TRUE); 318 319 case XDR_FREE: 320 return (TRUE); 321 } 322 /* NOTREACHED */ 323 return (FALSE); 324 } 325 326 /* 327 * XDR unsigned 16-bit integers 328 */ 329 bool_t 330 xdr_uint16_t(XDR *xdrs, uint16_t *uint16_p) 331 { 332 u_long l; 333 334 switch (xdrs->x_op) { 335 case XDR_ENCODE: 336 l = (u_long) *uint16_p; 337 return (XDR_PUTLONG(xdrs, (long *)&l)); 338 339 case XDR_DECODE: 340 if (!XDR_GETLONG(xdrs, (long *)&l)) { 341 return (FALSE); 342 } 343 *uint16_p = (uint16_t) l; 344 return (TRUE); 345 346 case XDR_FREE: 347 return (TRUE); 348 } 349 /* NOTREACHED */ 350 return (FALSE); 351 } 352 353 /* 354 * XDR a char 355 */ 356 bool_t 357 xdr_char(XDR *xdrs, char *cp) 358 { 359 u_int i; 360 361 i = *((unsigned char *)cp); 362 if (!xdr_u_int(xdrs, &i)) { 363 return (FALSE); 364 } 365 *((unsigned char *)cp) = i; 366 return (TRUE); 367 } 368 369 /* 370 * XDR an unsigned char 371 */ 372 bool_t 373 xdr_u_char(XDR *xdrs, u_char *cp) 374 { 375 u_int u; 376 377 u = (*cp); 378 if (!xdr_u_int(xdrs, &u)) { 379 return (FALSE); 380 } 381 *cp = u; 382 return (TRUE); 383 } 384 385 /* 386 * XDR booleans 387 */ 388 bool_t 389 xdr_bool(XDR *xdrs, bool_t *bp) 390 { 391 long lb; 392 393 switch (xdrs->x_op) { 394 case XDR_ENCODE: 395 lb = *bp ? XDR_TRUE : XDR_FALSE; 396 return (XDR_PUTLONG(xdrs, &lb)); 397 398 case XDR_DECODE: 399 if (!XDR_GETLONG(xdrs, &lb)) { 400 return (FALSE); 401 } 402 *bp = (lb == XDR_FALSE) ? FALSE : TRUE; 403 return (TRUE); 404 405 case XDR_FREE: 406 return (TRUE); 407 } 408 /* NOTREACHED */ 409 return (FALSE); 410 } 411 412 /* 413 * XDR enumerations 414 */ 415 bool_t 416 xdr_enum(XDR *xdrs, enum_t *ep) 417 { 418 enum sizecheck { SIZEVAL }; /* used to find the size of an enum */ 419 420 /* 421 * enums are treated as ints 422 */ 423 /* LINTED */ if (sizeof (enum sizecheck) == sizeof (long)) { 424 return (xdr_long(xdrs, (long *)(void *)ep)); 425 } else /* LINTED */ if (sizeof (enum sizecheck) == sizeof (int)) { 426 return (xdr_int(xdrs, (int *)(void *)ep)); 427 } else /* LINTED */ if (sizeof (enum sizecheck) == sizeof (short)) { 428 return (xdr_short(xdrs, (short *)(void *)ep)); 429 } else { 430 return (FALSE); 431 } 432 } 433 434 /* 435 * XDR opaque data 436 * Allows the specification of a fixed size sequence of opaque bytes. 437 * cp points to the opaque object and cnt gives the byte length. 438 */ 439 bool_t 440 xdr_opaque(XDR *xdrs, caddr_t cp, u_int cnt) 441 { 442 u_int rndup; 443 static int crud[BYTES_PER_XDR_UNIT]; 444 445 /* 446 * if no data we are done 447 */ 448 if (cnt == 0) 449 return (TRUE); 450 451 /* 452 * round byte count to full xdr units 453 */ 454 rndup = cnt % BYTES_PER_XDR_UNIT; 455 if (rndup > 0) 456 rndup = BYTES_PER_XDR_UNIT - rndup; 457 458 if (xdrs->x_op == XDR_DECODE) { 459 if (!XDR_GETBYTES(xdrs, cp, cnt)) { 460 return (FALSE); 461 } 462 if (rndup == 0) 463 return (TRUE); 464 return (XDR_GETBYTES(xdrs, (caddr_t)(void *)crud, rndup)); 465 } 466 467 if (xdrs->x_op == XDR_ENCODE) { 468 if (!XDR_PUTBYTES(xdrs, cp, cnt)) { 469 return (FALSE); 470 } 471 if (rndup == 0) 472 return (TRUE); 473 return (XDR_PUTBYTES(xdrs, xdr_zero, rndup)); 474 } 475 476 if (xdrs->x_op == XDR_FREE) { 477 return (TRUE); 478 } 479 480 return (FALSE); 481 } 482 483 /* 484 * XDR counted bytes 485 * *cpp is a pointer to the bytes, *sizep is the count. 486 * If *cpp is NULL maxsize bytes are allocated 487 */ 488 bool_t 489 xdr_bytes(XDR *xdrs, char **cpp, u_int *sizep, u_int maxsize) 490 { 491 char *sp = *cpp; /* sp is the actual string pointer */ 492 u_int nodesize; 493 bool_t ret, allocated = FALSE; 494 495 /* 496 * first deal with the length since xdr bytes are counted 497 */ 498 if (! xdr_u_int(xdrs, sizep)) { 499 return (FALSE); 500 } 501 nodesize = *sizep; 502 if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) { 503 return (FALSE); 504 } 505 506 /* 507 * now deal with the actual bytes 508 */ 509 switch (xdrs->x_op) { 510 case XDR_DECODE: 511 if (nodesize == 0) { 512 return (TRUE); 513 } 514 if (sp == NULL) { 515 *cpp = sp = mem_alloc(nodesize); 516 allocated = TRUE; 517 } 518 if (sp == NULL) { 519 printf("xdr_bytes: out of memory"); 520 return (FALSE); 521 } 522 /* FALLTHROUGH */ 523 524 case XDR_ENCODE: 525 ret = xdr_opaque(xdrs, sp, nodesize); 526 if ((xdrs->x_op == XDR_DECODE) && (ret == FALSE)) { 527 if (allocated == TRUE) { 528 mem_free(sp, nodesize); 529 *cpp = NULL; 530 } 531 } 532 return (ret); 533 534 case XDR_FREE: 535 if (sp != NULL) { 536 mem_free(sp, nodesize); 537 *cpp = NULL; 538 } 539 return (TRUE); 540 } 541 /* NOTREACHED */ 542 return (FALSE); 543 } 544 545 /* 546 * Implemented here due to commonality of the object. 547 */ 548 bool_t 549 xdr_netobj(XDR *xdrs, struct netobj *np) 550 { 551 552 return (xdr_bytes(xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ)); 553 } 554 555 /* 556 * XDR a descriminated union 557 * Support routine for discriminated unions. 558 * You create an array of xdrdiscrim structures, terminated with 559 * an entry with a null procedure pointer. The routine gets 560 * the discriminant value and then searches the array of xdrdiscrims 561 * looking for that value. It calls the procedure given in the xdrdiscrim 562 * to handle the discriminant. If there is no specific routine a default 563 * routine may be called. 564 * If there is no specific or default routine an error is returned. 565 */ 566 bool_t 567 xdr_union(XDR *xdrs, 568 enum_t *dscmp, /* enum to decide which arm to work on */ 569 char *unp, /* the union itself */ 570 const struct xdr_discrim *choices, /* [value, xdr proc] for each arm */ 571 xdrproc_t dfault) /* default xdr routine */ 572 { 573 enum_t dscm; 574 575 /* 576 * we deal with the discriminator; it's an enum 577 */ 578 if (! xdr_enum(xdrs, dscmp)) { 579 return (FALSE); 580 } 581 dscm = *dscmp; 582 583 /* 584 * search choices for a value that matches the discriminator. 585 * if we find one, execute the xdr routine for that value. 586 */ 587 for (; choices->proc != NULL_xdrproc_t; choices++) { 588 if (choices->value == dscm) 589 return ((*(choices->proc))(xdrs, unp)); 590 } 591 592 /* 593 * no match - execute the default xdr routine if there is one 594 */ 595 return ((dfault == NULL_xdrproc_t) ? FALSE : 596 (*dfault)(xdrs, unp)); 597 } 598 599 /* 600 * Non-portable xdr primitives. 601 * Care should be taken when moving these routines to new architectures. 602 */ 603 604 /* 605 * XDR null terminated ASCII strings 606 * xdr_string deals with "C strings" - arrays of bytes that are 607 * terminated by a NULL character. The parameter cpp references a 608 * pointer to storage; If the pointer is null, then the necessary 609 * storage is allocated. The last parameter is the max allowed length 610 * of the string as specified by a protocol. 611 */ 612 bool_t 613 xdr_string(XDR *xdrs, char **cpp, u_int maxsize) 614 { 615 char *sp = *cpp; /* sp is the actual string pointer */ 616 u_int size; 617 u_int nodesize; 618 bool_t ret, allocated = FALSE; 619 620 /* 621 * first deal with the length since xdr strings are counted-strings 622 */ 623 switch (xdrs->x_op) { 624 case XDR_FREE: 625 if (sp == NULL) { 626 return(TRUE); /* already free */ 627 } 628 /* FALLTHROUGH */ 629 case XDR_ENCODE: 630 size = strlen(sp); 631 break; 632 case XDR_DECODE: 633 break; 634 } 635 if (! xdr_u_int(xdrs, &size)) { 636 return (FALSE); 637 } 638 if (size > maxsize) { 639 return (FALSE); 640 } 641 nodesize = size + 1; 642 643 /* 644 * now deal with the actual bytes 645 */ 646 switch (xdrs->x_op) { 647 case XDR_DECODE: 648 if (nodesize == 0) { 649 return (TRUE); 650 } 651 if (sp == NULL) { 652 *cpp = sp = mem_alloc(nodesize); 653 allocated = TRUE; 654 } 655 if (sp == NULL) { 656 printf("xdr_string: out of memory"); 657 return (FALSE); 658 } 659 sp[size] = 0; 660 /* FALLTHROUGH */ 661 662 case XDR_ENCODE: 663 ret = xdr_opaque(xdrs, sp, size); 664 if ((xdrs->x_op == XDR_DECODE) && (ret == FALSE)) { 665 if (allocated == TRUE) { 666 mem_free(sp, nodesize); 667 *cpp = NULL; 668 } 669 } 670 return (ret); 671 672 case XDR_FREE: 673 mem_free(sp, nodesize); 674 *cpp = NULL; 675 return (TRUE); 676 } 677 /* NOTREACHED */ 678 return (FALSE); 679 } 680 681 /* 682 * Wrapper for xdr_string that can be called directly from 683 * routines like clnt_call 684 */ 685 bool_t 686 xdr_wrapstring(XDR *xdrs, char **cpp) 687 { 688 return xdr_string(xdrs, cpp, RPC_MAXDATASIZE); 689 } 690 691 /* 692 * NOTE: xdr_hyper(), xdr_u_hyper(), xdr_longlong_t(), and xdr_u_longlong_t() 693 * are in the "non-portable" section because they require that a `long long' 694 * be a 64-bit type. 695 * 696 * --thorpej@netbsd.org, November 30, 1999 697 */ 698 699 /* 700 * XDR 64-bit integers 701 */ 702 bool_t 703 xdr_int64_t(XDR *xdrs, int64_t *llp) 704 { 705 u_long ul[2]; 706 707 switch (xdrs->x_op) { 708 case XDR_ENCODE: 709 ul[0] = (u_long)((uint64_t)*llp >> 32) & 0xffffffff; 710 ul[1] = (u_long)((uint64_t)*llp) & 0xffffffff; 711 if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE) 712 return (FALSE); 713 return (XDR_PUTLONG(xdrs, (long *)&ul[1])); 714 case XDR_DECODE: 715 if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE) 716 return (FALSE); 717 if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE) 718 return (FALSE); 719 *llp = (int64_t) 720 (((uint64_t)ul[0] << 32) | ((uint64_t)ul[1])); 721 return (TRUE); 722 case XDR_FREE: 723 return (TRUE); 724 } 725 /* NOTREACHED */ 726 return (FALSE); 727 } 728 729 /* 730 * XDR unsigned 64-bit integers 731 */ 732 bool_t 733 xdr_uint64_t(XDR *xdrs, uint64_t *ullp) 734 { 735 u_long ul[2]; 736 737 switch (xdrs->x_op) { 738 case XDR_ENCODE: 739 ul[0] = (u_long)(*ullp >> 32) & 0xffffffff; 740 ul[1] = (u_long)(*ullp) & 0xffffffff; 741 if (XDR_PUTLONG(xdrs, (long *)&ul[0]) == FALSE) 742 return (FALSE); 743 return (XDR_PUTLONG(xdrs, (long *)&ul[1])); 744 case XDR_DECODE: 745 if (XDR_GETLONG(xdrs, (long *)&ul[0]) == FALSE) 746 return (FALSE); 747 if (XDR_GETLONG(xdrs, (long *)&ul[1]) == FALSE) 748 return (FALSE); 749 *ullp = (uint64_t) 750 (((uint64_t)ul[0] << 32) | ((uint64_t)ul[1])); 751 return (TRUE); 752 case XDR_FREE: 753 return (TRUE); 754 } 755 /* NOTREACHED */ 756 return (FALSE); 757 } 758 759 /* 760 * XDR hypers 761 */ 762 bool_t 763 xdr_hyper(XDR *xdrs, longlong_t *llp) 764 { 765 766 /* 767 * Don't bother open-coding this; it's a fair amount of code. Just 768 * call xdr_int64_t(). 769 */ 770 return (xdr_int64_t(xdrs, (int64_t *)llp)); 771 } 772 773 /* 774 * XDR unsigned hypers 775 */ 776 bool_t 777 xdr_u_hyper(XDR *xdrs, u_longlong_t *ullp) 778 { 779 780 /* 781 * Don't bother open-coding this; it's a fair amount of code. Just 782 * call xdr_uint64_t(). 783 */ 784 return (xdr_uint64_t(xdrs, (uint64_t *)ullp)); 785 } 786 787 /* 788 * XDR longlong_t's 789 */ 790 bool_t 791 xdr_longlong_t(XDR *xdrs, longlong_t *llp) 792 { 793 794 /* 795 * Don't bother open-coding this; it's a fair amount of code. Just 796 * call xdr_int64_t(). 797 */ 798 return (xdr_int64_t(xdrs, (int64_t *)llp)); 799 } 800 801 /* 802 * XDR u_longlong_t's 803 */ 804 bool_t 805 xdr_u_longlong_t(XDR *xdrs, u_longlong_t *ullp) 806 { 807 808 /* 809 * Don't bother open-coding this; it's a fair amount of code. Just 810 * call xdr_uint64_t(). 811 */ 812 return (xdr_uint64_t(xdrs, (uint64_t *)ullp)); 813 } 814 815 /* 816 * Kernel module glue 817 */ 818 static int 819 xdr_modevent(module_t mod, int type, void *data) 820 { 821 822 return (0); 823 } 824 static moduledata_t xdr_mod = { 825 "xdr", 826 xdr_modevent, 827 NULL, 828 }; 829 DECLARE_MODULE(xdr, xdr_mod, SI_SUB_VFS, SI_ORDER_ANY); 830 MODULE_VERSION(xdr, 1); 831