![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to server.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / mig|
Return to server.c CVS log | Up to [GnuMach] / Gnu-Mach / mig |
1.1 ! root 1: /* ! 2: * Mach Operating System ! 3: * Copyright (c) 1991,1990 Carnegie Mellon University ! 4: * All Rights Reserved. ! 5: * ! 6: * Permission to use, copy, modify and distribute this software and its ! 7: * documentation is hereby granted, provided that both the copyright ! 8: * notice and this permission notice appear in all copies of the ! 9: * software, derivative works or modified versions, and any portions ! 10: * thereof, and that both notices appear in supporting documentation. ! 11: * ! 12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 15: * ! 16: * Carnegie Mellon requests users of this software to return to ! 17: * ! 18: * Software Distribution Coordinator or [email protected] ! 19: * School of Computer Science ! 20: * Carnegie Mellon University ! 21: * Pittsburgh PA 15213-3890 ! 22: * ! 23: * any improvements or extensions that they make and grant Carnegie Mellon ! 24: * the rights to redistribute these changes. ! 25: */ ! 26: ! 27: #include <assert.h> ! 28: ! 29: #include "write.h" ! 30: #include "utils.h" ! 31: #include "global.h" ! 32: #include "error.h" ! 33: #include "cpu.h" ! 34: ! 35: static void ! 36: WriteIncludes(FILE *file) ! 37: { ! 38: fprintf(file, "#define EXPORT_BOOLEAN\n"); ! 39: fprintf(file, "#include <mach/boolean.h>\n"); ! 40: fprintf(file, "#include <mach/kern_return.h>\n"); ! 41: fprintf(file, "#include <mach/message.h>\n"); ! 42: fprintf(file, "#include <mach/mig_errors.h>\n"); ! 43: fprintf(file, "#include <mach/mig_support.h>\n"); ! 44: if (IsKernelServer) ! 45: fprintf(file, "#include <ipc/ipc_port.h>\n"); ! 46: fprintf(file, "\n"); ! 47: } ! 48: ! 49: static void ! 50: WriteGlobalDecls(FILE *file) ! 51: { ! 52: if (RCSId != strNULL) ! 53: WriteRCSDecl(file, strconcat(SubsystemName, "_server"), RCSId); ! 54: ! 55: /* Used for locations in the request message, *not* reply message. ! 56: Reply message locations aren't dependent on IsKernelServer. */ ! 57: ! 58: if (IsKernelServer) ! 59: { ! 60: fprintf(file, "#define msgh_request_port\tmsgh_remote_port\n"); ! 61: fprintf(file, "#define MACH_MSGH_BITS_REQUEST(bits)"); ! 62: fprintf(file, "\tMACH_MSGH_BITS_REMOTE(bits)\n"); ! 63: fprintf(file, "#define msgh_reply_port\t\tmsgh_local_port\n"); ! 64: fprintf(file, "#define MACH_MSGH_BITS_REPLY(bits)"); ! 65: fprintf(file, "\tMACH_MSGH_BITS_LOCAL(bits)\n"); ! 66: } ! 67: else ! 68: { ! 69: fprintf(file, "#define msgh_request_port\tmsgh_local_port\n"); ! 70: fprintf(file, "#define MACH_MSGH_BITS_REQUEST(bits)"); ! 71: fprintf(file, "\tMACH_MSGH_BITS_LOCAL(bits)\n"); ! 72: fprintf(file, "#define msgh_reply_port\t\tmsgh_remote_port\n"); ! 73: fprintf(file, "#define MACH_MSGH_BITS_REPLY(bits)"); ! 74: fprintf(file, "\tMACH_MSGH_BITS_REMOTE(bits)\n"); ! 75: } ! 76: fprintf(file, "\n"); ! 77: } ! 78: ! 79: static void ! 80: WriteProlog(FILE *file) ! 81: { ! 82: fprintf(file, "/* Module %s */\n", SubsystemName); ! 83: fprintf(file, "\n"); ! 84: ! 85: WriteIncludes(file); ! 86: WriteBogusDefines(file); ! 87: WriteGlobalDecls(file); ! 88: } ! 89: ! 90: ! 91: static void ! 92: WriteSymTabEntries(FILE *file, const statement_t *stats) ! 93: { ! 94: register const statement_t *stat; ! 95: register u_int current = 0; ! 96: ! 97: for (stat = stats; stat != stNULL; stat = stat->stNext) ! 98: if (stat->stKind == skRoutine) { ! 99: register num = stat->stRoutine->rtNumber; ! 100: const char *name = stat->stRoutine->rtName; ! 101: ! 102: while (++current <= num) ! 103: fprintf(file,"\t\t\t{ \"\", 0, 0 },\n"); ! 104: fprintf(file, "\t{ \"%s\", %d, _X%s },\n", ! 105: name, ! 106: SubsystemBase + current - 1, ! 107: name); ! 108: } ! 109: while (++current <= rtNumber) ! 110: fprintf(file,"\t{ \"\", 0, 0 },\n"); ! 111: } ! 112: ! 113: static void ! 114: WriteArrayEntries(FILE *file, const statement_t *stats) ! 115: { ! 116: register u_int current = 0; ! 117: register const statement_t *stat; ! 118: ! 119: for (stat = stats; stat != stNULL; stat = stat->stNext) ! 120: if (stat->stKind == skRoutine) ! 121: { ! 122: register const routine_t *rt = stat->stRoutine; ! 123: ! 124: while (current++ < rt->rtNumber) ! 125: fprintf(file, "\t\t0,\n"); ! 126: fprintf(file, "\t\t_X%s,\n", rt->rtName); ! 127: } ! 128: while (current++ < rtNumber) ! 129: fprintf(file, "\t\t\t0,\n"); ! 130: } ! 131: ! 132: static void ! 133: WriteEpilog(FILE *file, const statement_t *stats) ! 134: { ! 135: fprintf(file, "\n"); ! 136: ! 137: /* ! 138: * First, the symbol table ! 139: */ ! 140: fprintf(file, "static mig_routine_t %s_routines[] = {\n", ServerDemux); ! 141: ! 142: WriteArrayEntries(file, stats); ! 143: ! 144: fprintf(file, "};\n"); ! 145: fprintf(file, "\n"); ! 146: ! 147: /* ! 148: * Then, the server routine ! 149: */ ! 150: fprintf(file, "mig_external boolean_t %s\n", ServerDemux); ! 151: fprintf(file, "\t(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)\n"); ! 152: ! 153: fprintf(file, "{\n"); ! 154: fprintf(file, "\tregister mach_msg_header_t *InP = InHeadP;\n"); ! 155: ! 156: fprintf(file, "\tregister mig_reply_header_t *OutP = (mig_reply_header_t *) OutHeadP;\n"); ! 157: ! 158: fprintf(file, "\n"); ! 159: ! 160: WriteStaticDecl(file, itRetCodeType, ! 161: itRetCodeType->itDeallocate, itRetCodeType->itLongForm, ! 162: !IsKernelServer, "RetCodeType"); ! 163: fprintf(file, "\n"); ! 164: ! 165: fprintf(file, "\tregister mig_routine_t routine;\n"); ! 166: fprintf(file, "\n"); ! 167: ! 168: fprintf(file, "\tOutP->Head.msgh_bits = "); ! 169: fprintf(file, "MACH_MSGH_BITS(MACH_MSGH_BITS_REPLY(InP->msgh_bits), 0);\n"); ! 170: fprintf(file, "\tOutP->Head.msgh_size = sizeof *OutP;\n"); ! 171: fprintf(file, "\tOutP->Head.msgh_remote_port = InP->msgh_reply_port;\n"); ! 172: fprintf(file, "\tOutP->Head.msgh_local_port = MACH_PORT_NULL;\n"); ! 173: fprintf(file, "\tOutP->Head.msgh_seqno = 0;\n"); ! 174: fprintf(file, "\tOutP->Head.msgh_id = InP->msgh_id + 100;\n"); ! 175: fprintf(file, "\n"); ! 176: WritePackMsgType(file, itRetCodeType, ! 177: itRetCodeType->itDeallocate, itRetCodeType->itLongForm, ! 178: !IsKernelServer, "OutP->RetCodeType", "RetCodeType"); ! 179: fprintf(file, "\n"); ! 180: ! 181: fprintf(file, "\tif ((InP->msgh_id > %d) || (InP->msgh_id < %d) ||\n", ! 182: SubsystemBase + rtNumber - 1, SubsystemBase); ! 183: fprintf(file, "\t ((routine = %s_routines[InP->msgh_id - %d]) == 0)) {\n", ! 184: ServerDemux, SubsystemBase); ! 185: fprintf(file, "\t\tOutP->RetCode = MIG_BAD_ID;\n"); ! 186: fprintf(file, "\t\treturn FALSE;\n"); ! 187: fprintf(file, "\t}\n"); ! 188: ! 189: /* Call appropriate routine */ ! 190: fprintf(file, "\t(*routine) (InP, &OutP->Head);\n"); ! 191: fprintf(file, "\treturn TRUE;\n"); ! 192: fprintf(file, "}\n"); ! 193: fprintf(file, "\n"); ! 194: ! 195: /* ! 196: * Then, the <subsystem>_server_routine routine ! 197: */ ! 198: fprintf(file, "mig_external mig_routine_t %s_routine\n", ServerDemux); ! 199: fprintf(file, "\t(const mach_msg_header_t *InHeadP)\n"); ! 200: ! 201: fprintf(file, "{\n"); ! 202: fprintf(file, "\tregister int msgh_id;\n"); ! 203: fprintf(file, "\n"); ! 204: fprintf(file, "\tmsgh_id = InHeadP->msgh_id - %d;\n", SubsystemBase); ! 205: fprintf(file, "\n"); ! 206: fprintf(file, "\tif ((msgh_id > %d) || (msgh_id < 0))\n", ! 207: rtNumber - 1); ! 208: fprintf(file, "\t\treturn 0;\n"); ! 209: fprintf(file, "\n"); ! 210: fprintf(file, "\treturn %s_routines[msgh_id];\n", ServerDemux); ! 211: fprintf(file, "}\n"); ! 212: fprintf(file, "\n"); ! 213: ! 214: /* symtab */ ! 215: ! 216: if (GenSymTab) { ! 217: fprintf(file,"\nmig_symtab_t _%sSymTab[] = {\n",SubsystemName); ! 218: WriteSymTabEntries(file,stats); ! 219: fprintf(file,"};\n"); ! 220: fprintf(file,"int _%sSymTabBase = %d;\n",SubsystemName,SubsystemBase); ! 221: fprintf(file,"int _%sSymTabEnd = %d;\n",SubsystemName,SubsystemBase+rtNumber); ! 222: } ! 223: } ! 224: ! 225: /* ! 226: * Returns the return type of the server-side work function. ! 227: * Suitable for "extern %s serverfunc()". ! 228: */ ! 229: static const char * ! 230: ServerSideType(const routine_t *rt) ! 231: { ! 232: if (rt->rtServerReturn == argNULL) ! 233: return "void"; ! 234: else ! 235: return rt->rtServerReturn->argType->itTransType; ! 236: } ! 237: ! 238: static void ! 239: WriteLocalVarDecl(FILE *file, register const argument_t *arg) ! 240: { ! 241: register const ipc_type_t *it = arg->argType; ! 242: ! 243: if (it->itInLine && it->itVarArray) ! 244: { ! 245: register const ipc_type_t *btype = it->itElement; ! 246: ! 247: fprintf(file, "\t%s %s[%d]", btype->itTransType, ! 248: arg->argVarName, it->itNumber/btype->itNumber); ! 249: } ! 250: else ! 251: fprintf(file, "\t%s %s", it->itTransType, arg->argVarName); ! 252: } ! 253: ! 254: static void ! 255: WriteLocalPtrDecl(FILE *file, register const argument_t *arg) ! 256: { ! 257: fprintf(file, "\t%s *%sP", ! 258: FetchServerType(arg->argType->itElement), ! 259: arg->argVarName); ! 260: } ! 261: ! 262: static void ! 263: WriteServerArgDecl(FILE *file, const argument_t *arg) ! 264: { ! 265: fprintf(file, "%s %s%s", ! 266: arg->argType->itTransType, ! 267: arg->argByReferenceServer ? "*" : "", ! 268: arg->argVarName); ! 269: } ! 270: ! 271: /* ! 272: * Writes the local variable declarations which are always ! 273: * present: InP, OutP, the server-side work function. ! 274: */ ! 275: static void ! 276: WriteVarDecls(FILE *file, const routine_t *rt) ! 277: { ! 278: int i; ! 279: boolean_t NeedMsghSize = FALSE; ! 280: boolean_t NeedMsghSizeDelta = FALSE; ! 281: ! 282: fprintf(file, "\tregister Request *In0P = (Request *) InHeadP;\n"); ! 283: for (i = 1; i <= rt->rtMaxRequestPos; i++) ! 284: fprintf(file, "\tregister Request *In%dP;\n", i); ! 285: fprintf(file, "\tregister Reply *OutP = (Reply *) OutHeadP;\n"); ! 286: ! 287: fprintf(file, "\tmig_external %s %s\n", ! 288: ServerSideType(rt), rt->rtServerName); ! 289: fprintf(file, "\t\t("); ! 290: WriteList(file, rt->rtArgs, WriteServerArgDecl, akbServerArg, ", ", ""); ! 291: fprintf(file, ");\n"); ! 292: fprintf(file, "\n"); ! 293: ! 294: if (!rt->rtSimpleFixedReply) ! 295: fprintf(file, "\tboolean_t msgh_simple;\n"); ! 296: else if (!rt->rtSimpleCheckRequest) ! 297: { ! 298: fprintf(file, "#if\tTypeCheck\n"); ! 299: fprintf(file, "\tboolean_t msgh_simple;\n"); ! 300: fprintf(file, "#endif\t/* TypeCheck */\n"); ! 301: fprintf(file, "\n"); ! 302: } ! 303: ! 304: /* if either request or reply is variable, we may need ! 305: msgh_size_delta and msgh_size */ ! 306: ! 307: if (rt->rtNumRequestVar > 0) ! 308: NeedMsghSize = TRUE; ! 309: if (rt->rtMaxRequestPos > 0) ! 310: NeedMsghSizeDelta = TRUE; ! 311: ! 312: if (rt->rtNumReplyVar > 1) ! 313: NeedMsghSize = TRUE; ! 314: if (rt->rtMaxReplyPos > 0) ! 315: NeedMsghSizeDelta = TRUE; ! 316: ! 317: if (NeedMsghSize) ! 318: fprintf(file, "\tunsigned int msgh_size;\n"); ! 319: if (NeedMsghSizeDelta) ! 320: fprintf(file, "\tunsigned int msgh_size_delta;\n"); ! 321: ! 322: if (NeedMsghSize || NeedMsghSizeDelta) ! 323: fprintf(file, "\n"); ! 324: } ! 325: ! 326: static void ! 327: WriteMsgError(FILE *file, const char *error_msg) ! 328: { ! 329: fprintf(file, "\t\t{ OutP->RetCode = %s; return; }\n", error_msg); ! 330: } ! 331: ! 332: static void ! 333: WriteReplyInit(FILE *file, const routine_t *rt) ! 334: { ! 335: boolean_t printed_nl = FALSE; ! 336: ! 337: if (rt->rtSimpleFixedReply) ! 338: { ! 339: if (!rt->rtSimpleSendReply) /* complex reply message */ ! 340: { ! 341: printed_nl = TRUE; ! 342: fprintf(file, "\n"); ! 343: fprintf(file, ! 344: "\tOutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;\n"); ! 345: } ! 346: } ! 347: else ! 348: { ! 349: printed_nl = TRUE; ! 350: fprintf(file, "\n"); ! 351: fprintf(file, "\tmsgh_simple = %s;\n", ! 352: strbool(rt->rtSimpleSendReply)); ! 353: } ! 354: ! 355: if (rt->rtNumReplyVar == 0) ! 356: { ! 357: if (!printed_nl) ! 358: fprintf(file, "\n"); ! 359: fprintf(file, "\tOutP->Head.msgh_size = %d;\n", rt->rtReplySize); ! 360: } ! 361: } ! 362: ! 363: static void ! 364: WriteReplyHead(FILE *file, const routine_t *rt) ! 365: { ! 366: if ((!rt->rtSimpleFixedReply) || ! 367: (rt->rtNumReplyVar > 1)) ! 368: { ! 369: fprintf(file, "\n"); ! 370: if (rt->rtMaxReplyPos > 0) ! 371: fprintf(file, "\tOutP = (Reply *) OutHeadP;\n"); ! 372: } ! 373: ! 374: if (!rt->rtSimpleFixedReply) ! 375: { ! 376: fprintf(file, "\tif (!msgh_simple)\n"); ! 377: fprintf(file, ! 378: "\t\tOutP->Head.msgh_bits |= MACH_MSGH_BITS_COMPLEX;\n"); ! 379: } ! 380: if (rt->rtNumReplyVar > 1) ! 381: fprintf(file, "\tOutP->Head.msgh_size = msgh_size;\n"); ! 382: } ! 383: ! 384: static void ! 385: WriteCheckHead(FILE *file, const routine_t *rt) ! 386: { ! 387: fprintf(file, "#if\tTypeCheck\n"); ! 388: if (rt->rtNumRequestVar > 0) ! 389: fprintf(file, "\tmsgh_size = In0P->Head.msgh_size;\n"); ! 390: if (!rt->rtSimpleCheckRequest) ! 391: fprintf(file, "\tmsgh_simple = !(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);\n"); ! 392: ! 393: if (rt->rtNumRequestVar > 0) ! 394: fprintf(file, "\tif ((msgh_size < %d)", ! 395: rt->rtRequestSize); ! 396: else ! 397: fprintf(file, "\tif ((In0P->Head.msgh_size != %d)", ! 398: rt->rtRequestSize); ! 399: ! 400: if (rt->rtSimpleCheckRequest) ! 401: fprintf(file, " ||\n\t %s(In0P->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX)", ! 402: rt->rtSimpleReceiveRequest ? "" : "!"); ! 403: fprintf(file, ")\n"); ! 404: WriteMsgError(file, "MIG_BAD_ARGUMENTS"); ! 405: fprintf(file, "#endif\t/* TypeCheck */\n"); ! 406: fprintf(file, "\n"); ! 407: } ! 408: ! 409: static void ! 410: WriteTypeCheck(FILE *file, register const argument_t *arg) ! 411: { ! 412: register const ipc_type_t *it = arg->argType; ! 413: register const routine_t *rt = arg->argRoutine; ! 414: ! 415: fprintf(file, "#if\tTypeCheck\n"); ! 416: if (akCheck(arg->argKind, akbRequestQC)) ! 417: fprintf(file, "\tif (* (int *) &In%dP->%s != * (int *) &%sCheck)\n", ! 418: arg->argRequestPos, arg->argTTName, arg->argVarName); ! 419: else ! 420: { ! 421: fprintf(file, "\tif ("); ! 422: if (!it->itIndefinite) { ! 423: fprintf(file, "(In%dP->%s%s.msgt_inline != %s) ||\n\t ", ! 424: arg->argRequestPos, arg->argTTName, ! 425: arg->argLongForm ? ".msgtl_header" : "", ! 426: strbool(it->itInLine)); ! 427: } ! 428: fprintf(file, "(In%dP->%s%s.msgt_longform != %s) ||\n", ! 429: arg->argRequestPos, arg->argTTName, ! 430: arg->argLongForm ? ".msgtl_header" : "", ! 431: strbool(arg->argLongForm)); ! 432: if (it->itOutName == MACH_MSG_TYPE_POLYMORPHIC) ! 433: { ! 434: if (!rt->rtSimpleCheckRequest) ! 435: fprintf(file, "\t (MACH_MSG_TYPE_PORT_ANY(In%dP->%s.msgt%s_name) && msgh_simple) ||\n", ! 436: arg->argRequestPos, arg->argTTName, ! 437: arg->argLongForm ? "l" : ""); ! 438: } ! 439: else ! 440: fprintf(file, "\t (In%dP->%s.msgt%s_name != %s) ||\n", ! 441: arg->argRequestPos, arg->argTTName, ! 442: arg->argLongForm ? "l" : "", ! 443: it->itOutNameStr); ! 444: if (!it->itVarArray) ! 445: fprintf(file, "\t (In%dP->%s.msgt%s_number != %d) ||\n", ! 446: arg->argRequestPos, arg->argTTName, ! 447: arg->argLongForm ? "l" : "", ! 448: it->itNumber); ! 449: fprintf(file, "\t (In%dP->%s.msgt%s_size != %d))\n", ! 450: arg->argRequestPos, arg->argTTName, ! 451: arg->argLongForm ? "l" : "", ! 452: it->itSize); ! 453: } ! 454: WriteMsgError(file, "MIG_BAD_ARGUMENTS"); ! 455: fprintf(file, "#endif\t/* TypeCheck */\n"); ! 456: fprintf(file, "\n"); ! 457: } ! 458: ! 459: static void ! 460: WriteCheckArgSize(FILE *file, register const argument_t *arg) ! 461: { ! 462: register const ipc_type_t *ptype = arg->argType; ! 463: register const ipc_type_t *btype = ptype->itElement; ! 464: const argument_t *count = arg->argCount; ! 465: int multiplier = btype->itTypeSize / btype->itNumber; ! 466: ! 467: if (ptype->itIndefinite) { ! 468: /* ! 469: * Check descriptor. If out-of-line, use standard size. ! 470: */ ! 471: fprintf(file, "(In%dP->%s%s.msgt_inline) ? ", ! 472: arg->argRequestPos, ! 473: arg->argTTName, ! 474: arg->argLongForm ? ".msgtl_header" : ""); ! 475: } ! 476: ! 477: if (btype->itTypeSize % 4 != 0) ! 478: fprintf(file, "("); ! 479: ! 480: if (multiplier > 1) ! 481: fprintf(file, "%d * ", multiplier); ! 482: ! 483: fprintf(file, "In%dP->%s", arg->argRequestPos, count->argMsgField); ! 484: ! 485: /* If the base type size of the data field isn`t a multiple of 4, ! 486: we have to round up. */ ! 487: if (btype->itTypeSize % 4 != 0) ! 488: fprintf(file, " + 3) & ~3"); ! 489: ! 490: if (ptype->itIndefinite) { ! 491: fprintf(file, " : sizeof(%s *)", FetchServerType(btype)); ! 492: } ! 493: } ! 494: ! 495: static void ! 496: WriteCheckMsgSize(FILE *file, register const argument_t *arg) ! 497: { ! 498: register const routine_t *rt = arg->argRoutine; ! 499: ! 500: /* If there aren't any more In args after this, then ! 501: we can use the msgh_size_delta value directly in ! 502: the TypeCheck conditional. */ ! 503: ! 504: if (arg->argRequestPos == rt->rtMaxRequestPos) ! 505: { ! 506: fprintf(file, "#if\tTypeCheck\n"); ! 507: fprintf(file, "\tif (msgh_size != %d + (", rt->rtRequestSize); ! 508: WriteCheckArgSize(file, arg); ! 509: fprintf(file, "))\n"); ! 510: ! 511: WriteMsgError(file, "MIG_BAD_ARGUMENTS"); ! 512: fprintf(file, "#endif\t/* TypeCheck */\n"); ! 513: } ! 514: else ! 515: { ! 516: /* If there aren't any more variable-sized arguments after this, ! 517: then we must check for exact msg-size and we don't need to ! 518: update msgh_size. */ ! 519: ! 520: boolean_t LastVarArg = arg->argRequestPos+1 == rt->rtNumRequestVar; ! 521: ! 522: /* calculate the actual size in bytes of the data field. note ! 523: that this quantity must be a multiple of four. hence, if ! 524: the base type size isn't a multiple of four, we have to ! 525: round up. note also that btype->itNumber must ! 526: divide btype->itTypeSize (see itCalculateSizeInfo). */ ! 527: ! 528: fprintf(file, "\tmsgh_size_delta = "); ! 529: WriteCheckArgSize(file, arg); ! 530: fprintf(file, ";\n"); ! 531: fprintf(file, "#if\tTypeCheck\n"); ! 532: ! 533: /* Don't decrement msgh_size until we've checked that ! 534: it won't underflow. */ ! 535: ! 536: if (LastVarArg) ! 537: fprintf(file, "\tif (msgh_size != %d + msgh_size_delta)\n", ! 538: rt->rtRequestSize); ! 539: else ! 540: fprintf(file, "\tif (msgh_size < %d + msgh_size_delta)\n", ! 541: rt->rtRequestSize); ! 542: WriteMsgError(file, "MIG_BAD_ARGUMENTS"); ! 543: ! 544: if (!LastVarArg) ! 545: fprintf(file, "\tmsgh_size -= msgh_size_delta;\n"); ! 546: ! 547: fprintf(file, "#endif\t/* TypeCheck */\n"); ! 548: } ! 549: fprintf(file, "\n"); ! 550: } ! 551: ! 552: static const char * ! 553: InArgMsgField(register const argument_t *arg) ! 554: { ! 555: static char buffer[100]; ! 556: ! 557: /* ! 558: * Inside the kernel, the request and reply port fields ! 559: * really hold ipc_port_t values, not mach_port_t values. ! 560: * Hence we must cast the values. ! 561: */ ! 562: ! 563: if (IsKernelServer && ! 564: ((akIdent(arg->argKind) == akeRequestPort) || ! 565: (akIdent(arg->argKind) == akeReplyPort))) ! 566: sprintf(buffer, "(ipc_port_t) In%dP->%s", ! 567: arg->argRequestPos, arg->argMsgField); ! 568: else ! 569: sprintf(buffer, "In%dP->%s", ! 570: arg->argRequestPos, arg->argMsgField); ! 571: ! 572: return buffer; ! 573: } ! 574: ! 575: static void ! 576: WriteExtractArgValue(FILE *file, register const argument_t *arg) ! 577: { ! 578: register const ipc_type_t *it = arg->argType; ! 579: ! 580: if (arg->argMultiplier > 1) ! 581: WriteCopyType(file, it, "%s", "/* %s */ %s / %d", ! 582: arg->argVarName, InArgMsgField(arg), arg->argMultiplier); ! 583: else if (it->itInTrans != strNULL) ! 584: WriteCopyType(file, it, "%s", "/* %s */ %s(%s)", ! 585: arg->argVarName, it->itInTrans, InArgMsgField(arg)); ! 586: else ! 587: WriteCopyType(file, it, "%s", "/* %s */ %s", ! 588: arg->argVarName, InArgMsgField(arg)); ! 589: fprintf(file, "\n"); ! 590: } ! 591: ! 592: static void ! 593: WriteInitializeCount(FILE *file, register const argument_t *arg) ! 594: { ! 595: register const ipc_type_t *ptype = arg->argParent->argType; ! 596: register const ipc_type_t *btype = ptype->itElement; ! 597: ! 598: /* ! 599: * Initialize 'count' argument for variable-length inline OUT parameter ! 600: * with maximum allowed number of elements. ! 601: */ ! 602: ! 603: fprintf(file, "\t%s = %d;\n", arg->argVarName, ! 604: ptype->itNumber/btype->itNumber); ! 605: ! 606: /* ! 607: * If the user passed in a count, then we use the minimum. ! 608: * We can't let the user completely override our maximum, ! 609: * or the user might convince the server to overwrite the buffer. ! 610: */ ! 611: ! 612: if (arg->argCInOut != argNULL) { ! 613: const char *msgfield = InArgMsgField(arg->argCInOut); ! 614: ! 615: fprintf(file, "\tif (%s < %s)\n", msgfield, arg->argVarName); ! 616: fprintf(file, "\t\t%s = %s;\n", arg->argVarName, msgfield); ! 617: } ! 618: ! 619: fprintf(file, "\n"); ! 620: } ! 621: ! 622: static void ! 623: WriteInitializePtr(FILE *file, register const argument_t *arg) ! 624: { ! 625: if (akCheck(arg->argKind, akbVarNeeded)) ! 626: fprintf(file, "\t%sP = %s;\n", ! 627: arg->argVarName, arg->argVarName); ! 628: else ! 629: fprintf(file, "\t%sP = OutP->%s;\n", ! 630: arg->argVarName, arg->argMsgField); ! 631: } ! 632: ! 633: static void ! 634: WriteTypeCheckArg(FILE *file, register const argument_t *arg) ! 635: { ! 636: if (akCheck(arg->argKind, akbRequest)) { ! 637: WriteTypeCheck(file, arg); ! 638: ! 639: if (akCheck(arg->argKind, akbVariable)) ! 640: WriteCheckMsgSize(file, arg); ! 641: } ! 642: } ! 643: ! 644: static void ! 645: WriteAdjustRequestMsgPtr(FILE *file, register const argument_t *arg) ! 646: { ! 647: register const ipc_type_t *ptype = arg->argType; ! 648: ! 649: fprintf(file, ! 650: "\tIn%dP = (Request *) ((char *) In%dP + msgh_size_delta - %d);\n\n", ! 651: arg->argRequestPos+1, arg->argRequestPos, ! 652: ptype->itTypeSize + ptype->itPadSize); ! 653: } ! 654: ! 655: static void ! 656: WriteTypeCheckRequestArgs(FILE *file, register const routine_t *rt) ! 657: { ! 658: register const argument_t *arg; ! 659: register const argument_t *lastVarArg; ! 660: ! 661: lastVarArg = argNULL; ! 662: for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) { ! 663: ! 664: /* ! 665: * Advance message pointer if the last request argument was ! 666: * variable-length and the request position will change. ! 667: */ ! 668: if (lastVarArg != argNULL && ! 669: lastVarArg->argRequestPos < arg->argRequestPos) ! 670: { ! 671: WriteAdjustRequestMsgPtr(file, lastVarArg); ! 672: lastVarArg = argNULL; ! 673: } ! 674: ! 675: /* ! 676: * Type-check the argument. ! 677: */ ! 678: WriteTypeCheckArg(file, arg); ! 679: ! 680: /* ! 681: * Remember whether this was variable-length. ! 682: */ ! 683: if (akCheckAll(arg->argKind, akbVariable|akbRequest)) ! 684: lastVarArg = arg; ! 685: } ! 686: } ! 687: ! 688: static void ! 689: WriteExtractArg(FILE *file, register const argument_t *arg) ! 690: { ! 691: if (akCheckAll(arg->argKind, akbSendRcv|akbVarNeeded)) ! 692: WriteExtractArgValue(file, arg); ! 693: ! 694: if ((akIdent(arg->argKind) == akeCount) && ! 695: akCheck(arg->argKind, akbReturnSnd)) ! 696: { ! 697: register ipc_type_t *ptype = arg->argParent->argType; ! 698: ! 699: if (ptype->itInLine && ptype->itVarArray) ! 700: WriteInitializeCount(file, arg); ! 701: } ! 702: ! 703: if (akCheckAll(arg->argKind, akbReturnSnd|akbPointer)) ! 704: WriteInitializePtr(file, arg); ! 705: } ! 706: ! 707: static void ! 708: WriteServerCallArg(FILE *file, register const argument_t *arg) ! 709: { ! 710: const ipc_type_t *it = arg->argType; ! 711: boolean_t NeedClose = FALSE; ! 712: ! 713: if (arg->argByReferenceServer) ! 714: fprintf(file, "&"); ! 715: ! 716: if ((it->itInTrans != strNULL) && ! 717: akCheck(arg->argKind, akbSendRcv) && ! 718: !akCheck(arg->argKind, akbVarNeeded)) ! 719: { ! 720: fprintf(file, "%s(", it->itInTrans); ! 721: NeedClose = TRUE; ! 722: } ! 723: ! 724: if (akCheck(arg->argKind, akbPointer)) ! 725: fprintf(file, "%sP", arg->argVarName); ! 726: else if (akCheck(arg->argKind, akbVarNeeded)) ! 727: fprintf(file, "%s", arg->argVarName); ! 728: else if (akCheck(arg->argKind, akbSendRcv)) { ! 729: if (akCheck(arg->argKind, akbIndefinite)) { ! 730: fprintf(file, "(In%dP->%s%s.msgt_inline) ", ! 731: arg->argRequestPos, ! 732: arg->argTTName, ! 733: arg->argLongForm ? ".msgtl_header" : ""); ! 734: fprintf(file, "? %s ", InArgMsgField(arg)); ! 735: fprintf(file, ": *((%s **)%s)", ! 736: FetchServerType(arg->argType->itElement), ! 737: InArgMsgField(arg)); ! 738: } ! 739: else ! 740: fprintf(file, "%s", InArgMsgField(arg)); ! 741: } ! 742: else ! 743: fprintf(file, "OutP->%s", arg->argMsgField); ! 744: ! 745: if (NeedClose) ! 746: fprintf(file, ")"); ! 747: ! 748: if (!arg->argByReferenceServer && (arg->argMultiplier > 1)) ! 749: fprintf(file, " / %d", arg->argMultiplier); ! 750: } ! 751: ! 752: static void ! 753: WriteDestroyArg(FILE *file, register const argument_t *arg) ! 754: { ! 755: register const ipc_type_t *it = arg->argType; ! 756: ! 757: if (akCheck(arg->argKind, akbIndefinite)) { ! 758: /* ! 759: * Deallocate only if out-of-line. ! 760: */ ! 761: argument_t *count = arg->argCount; ! 762: ipc_type_t *btype = it->itElement; ! 763: int multiplier = btype->itTypeSize / btype->itNumber; ! 764: ! 765: fprintf(file, "\tif (!In%dP->%s%s.msgt_inline)\n", ! 766: arg->argRequestPos, ! 767: arg->argTTName, ! 768: arg->argLongForm ? ".msgtl_header" : ""); ! 769: fprintf(file, "\t\t%smig_deallocate(* (vm_offset_t *) %s, ", ! 770: SubrPrefix, InArgMsgField(arg)); ! 771: if (multiplier > 1) ! 772: fprintf(file, "%d * ", multiplier); ! 773: fprintf(file, " %s);\n", InArgMsgField(count)); ! 774: } else { ! 775: if (akCheck(arg->argKind, akbVarNeeded)) ! 776: fprintf(file, "\t%s(%s);\n", it->itDestructor, arg->argVarName); ! 777: else ! 778: fprintf(file, "\t%s(%s);\n", it->itDestructor, ! 779: InArgMsgField(arg)); ! 780: } ! 781: } ! 782: ! 783: static void ! 784: WriteDestroyPortArg(FILE *file, register const argument_t *arg) ! 785: { ! 786: register const ipc_type_t *it = arg->argType; ! 787: ! 788: /* ! 789: * If a translated port argument occurs in the body of a request ! 790: * message, and the message is successfully processed, then the ! 791: * port right should be deallocated. However, the called function ! 792: * didn't see the port right; it saw the translation. So we have ! 793: * to release the port right for it. ! 794: */ ! 795: ! 796: if ((it->itInTrans != strNULL) && ! 797: (it->itOutName == MACH_MSG_TYPE_PORT_SEND)) ! 798: { ! 799: fprintf(file, "\n"); ! 800: fprintf(file, "\tif (IP_VALID(%s))\n", InArgMsgField(arg)); ! 801: fprintf(file, "\t\t%sipc_port_release_send(%s);\n", ! 802: SubrPrefix, InArgMsgField(arg)); ! 803: } ! 804: } ! 805: ! 806: /* ! 807: * Check whether WriteDestroyPortArg would generate any code for arg. ! 808: */ ! 809: static boolean_t ! 810: CheckDestroyPortArg(register const argument_t *arg) ! 811: { ! 812: register const ipc_type_t *it = arg->argType; ! 813: ! 814: if ((it->itInTrans != strNULL) && ! 815: (it->itOutName == MACH_MSG_TYPE_PORT_SEND)) ! 816: { ! 817: return TRUE; ! 818: } ! 819: return FALSE; ! 820: } ! 821: ! 822: static void ! 823: WriteServerCall(FILE *file, const routine_t *rt) ! 824: { ! 825: boolean_t NeedClose = FALSE; ! 826: ! 827: fprintf(file, "\t"); ! 828: if (rt->rtServerReturn != argNULL) ! 829: { ! 830: const argument_t *arg = rt->rtServerReturn; ! 831: const ipc_type_t *it = arg->argType; ! 832: ! 833: fprintf(file, "OutP->%s = ", arg->argMsgField); ! 834: if (it->itOutTrans != strNULL) ! 835: { ! 836: fprintf(file, "%s(", it->itOutTrans); ! 837: NeedClose = TRUE; ! 838: } ! 839: } ! 840: fprintf(file, "%s(", rt->rtServerName); ! 841: WriteList(file, rt->rtArgs, WriteServerCallArg, akbServerArg, ", ", ""); ! 842: if (NeedClose) ! 843: fprintf(file, ")"); ! 844: fprintf(file, ");\n"); ! 845: } ! 846: ! 847: static void ! 848: WriteGetReturnValue(FILE *file, register const routine_t *rt) ! 849: { ! 850: if (rt->rtServerReturn != rt->rtRetCode) ! 851: fprintf(file, "\tOutP->%s = KERN_SUCCESS;\n", ! 852: rt->rtRetCode->argMsgField); ! 853: } ! 854: ! 855: static void ! 856: WriteCheckReturnValue(FILE *file, register const routine_t *rt) ! 857: { ! 858: if (rt->rtServerReturn == rt->rtRetCode) ! 859: { ! 860: fprintf(file, "\tif (OutP->%s != KERN_SUCCESS)\n", ! 861: rt->rtRetCode->argMsgField); ! 862: fprintf(file, "\t\treturn;\n"); ! 863: } ! 864: } ! 865: ! 866: static void ! 867: WritePackArgType(FILE *file, register const argument_t *arg) ! 868: { ! 869: fprintf(file, "\n"); ! 870: ! 871: WritePackMsgType(file, arg->argType, ! 872: arg->argType->itIndefinite ? d_NO : arg->argDeallocate, ! 873: arg->argLongForm, !IsKernelServer, ! 874: "OutP->%s", "%s", arg->argTTName); ! 875: } ! 876: ! 877: static void ! 878: WritePackArgValue(FILE *file, register const argument_t *arg) ! 879: { ! 880: register const ipc_type_t *it = arg->argType; ! 881: ! 882: fprintf(file, "\n"); ! 883: ! 884: if (it->itInLine && it->itVarArray) { ! 885: ! 886: if (it->itString) { ! 887: /* ! 888: * Copy variable-size C string with mig_strncpy. ! 889: * Save the string length (+ 1 for trailing 0) ! 890: * in the argument`s count field. ! 891: */ ! 892: fprintf(file, ! 893: "\tOutP->%s = %smig_strncpy(OutP->%s, %s, %d);\n", ! 894: arg->argCount->argMsgField, ! 895: SubrPrefix, ! 896: arg->argMsgField, ! 897: arg->argVarName, ! 898: it->itNumber); ! 899: } ! 900: else { ! 901: register argument_t *count = arg->argCount; ! 902: register ipc_type_t *btype = it->itElement; ! 903: ! 904: /* Note btype->itNumber == count->argMultiplier */ ! 905: ! 906: if (it->itIndefinite) { ! 907: /* ! 908: * If we are packing argument, it must be from ! 909: * a local variable. ! 910: */ ! 911: fprintf(file, "\tif (%sP != %s) {\n", ! 912: arg->argVarName, ! 913: arg->argVarName); ! 914: fprintf(file, "\t\tOutP->%s%s.msgt_inline = FALSE;\n", ! 915: arg->argTTName, ! 916: arg->argLongForm ? ".msgtl_header" : ""); ! 917: if (arg->argDeallocate == d_YES) ! 918: fprintf(file, "\t\tOutP->%s%s.msgt_deallocate = TRUE;\n", ! 919: arg->argTTName, ! 920: arg->argLongForm ? ".msgtl_header" : ""); ! 921: else if (arg->argDeallocate == d_MAYBE) ! 922: fprintf(file, "\t\tOutP->%s%s.msgt_deallocate = %s;\n", ! 923: arg->argTTName, ! 924: arg->argLongForm ? ".msgtl_header" : "", ! 925: arg->argDealloc->argVarName); ! 926: fprintf(file, "\t\t*((%s **)OutP->%s) = %sP;\n", ! 927: FetchServerType(btype), ! 928: arg->argMsgField, ! 929: arg->argVarName); ! 930: if (!arg->argRoutine->rtSimpleFixedReply) ! 931: fprintf(file, "\t\tmsgh_simple = FALSE;\n"); ! 932: fprintf(file, "\t}\n\telse {\n\t"); ! 933: } ! 934: fprintf(file, "\tmemcpy(OutP->%s, %s, ", ! 935: arg->argMsgField, arg->argVarName); ! 936: if (btype->itTypeSize > 1) ! 937: fprintf(file, "%d * ", ! 938: btype->itTypeSize); ! 939: fprintf(file, "%s);\n", ! 940: count->argVarName); ! 941: if (it->itIndefinite) ! 942: fprintf(file, "\t}\n"); ! 943: } ! 944: } ! 945: else if (arg->argMultiplier > 1) ! 946: WriteCopyType(file, it, "OutP->%s", "/* %s */ %d * %s", ! 947: arg->argMsgField, ! 948: arg->argMultiplier, ! 949: arg->argVarName); ! 950: else if (it->itOutTrans != strNULL) ! 951: WriteCopyType(file, it, "OutP->%s", "/* %s */ %s(%s)", ! 952: arg->argMsgField, it->itOutTrans, arg->argVarName); ! 953: else ! 954: WriteCopyType(file, it, "OutP->%s", "/* %s */ %s", ! 955: arg->argMsgField, arg->argVarName); ! 956: } ! 957: ! 958: static void ! 959: WriteCopyArgValue(FILE *file, register const argument_t *arg) ! 960: { ! 961: fprintf(file, "\n"); ! 962: WriteCopyType(file, arg->argType, "/* %d */ OutP->%s", "In%dP->%s", ! 963: arg->argRequestPos, arg->argMsgField); ! 964: } ! 965: ! 966: static void ! 967: WriteAdjustMsgSimple(FILE *file, register const argument_t *arg) ! 968: { ! 969: /* akbVarNeeded must be on */ ! 970: ! 971: if (!arg->argRoutine->rtSimpleFixedReply) ! 972: { ! 973: fprintf(file, "\n"); ! 974: fprintf(file, "\tif (MACH_MSG_TYPE_PORT_ANY(%s))\n", arg->argVarName); ! 975: fprintf(file, "\t\tmsgh_simple = FALSE;\n"); ! 976: } ! 977: } ! 978: ! 979: static void ! 980: WriteAdjustMsgCircular(FILE *file, register const argument_t *arg) ! 981: { ! 982: fprintf(file, "\n"); ! 983: ! 984: if (arg->argType->itOutName == MACH_MSG_TYPE_POLYMORPHIC) ! 985: fprintf(file, "\tif (%s == MACH_MSG_TYPE_PORT_RECEIVE)\n", ! 986: arg->argPoly->argVarName); ! 987: ! 988: /* ! 989: * The carried port right can be accessed in OutP->XXXX. Normally ! 990: * the server function stuffs it directly there. If it is InOut, ! 991: * then it has already been copied into the reply message. ! 992: * If the server function deposited it into a variable (perhaps ! 993: * because the reply message is variable-sized) then it has already ! 994: * been copied into the reply message. Note we must use InHeadP ! 995: * (or In0P->Head) and OutHeadP to access the message headers, ! 996: * because of the variable-sized messages. ! 997: */ ! 998: ! 999: fprintf(file, "\tif (IP_VALID((ipc_port_t) InHeadP->msgh_reply_port) &&\n"); ! 1000: fprintf(file, "\t IP_VALID((ipc_port_t) OutP->%s) &&\n", arg->argMsgField); ! 1001: fprintf(file, "\t %sipc_port_check_circularity((ipc_port_t) OutP->%s, (ipc_port_t) InHeadP->msgh_reply_port))\n", ! 1002: SubrPrefix, arg->argMsgField); ! 1003: fprintf(file, "\t\tOutHeadP->msgh_bits |= MACH_MSGH_BITS_CIRCULAR;\n"); ! 1004: } ! 1005: ! 1006: /* ! 1007: * Calculate the size of a variable-length message field. ! 1008: */ ! 1009: static void ! 1010: WriteArgSize(FILE *file, register const argument_t *arg) ! 1011: { ! 1012: register const ipc_type_t *ptype = arg->argType; ! 1013: register int bsize = ptype->itElement->itTypeSize; ! 1014: register const argument_t *count = arg->argCount; ! 1015: ! 1016: if (ptype->itIndefinite) { ! 1017: /* ! 1018: * Check descriptor. If out-of-line, use standard size. ! 1019: */ ! 1020: fprintf(file, "(OutP->%s%s.msgt_inline) ? ", ! 1021: arg->argTTName, ! 1022: arg->argLongForm ? ".msgtl_header" : ""); ! 1023: } ! 1024: ! 1025: if (bsize % 4 != 0) ! 1026: fprintf(file, "("); ! 1027: ! 1028: if (bsize > 1) ! 1029: fprintf(file, "%d * ", bsize); ! 1030: if (ptype->itString) ! 1031: /* get count from descriptor in message */ ! 1032: fprintf(file, "OutP->%s", count->argMsgField); ! 1033: else ! 1034: /* get count from argument */ ! 1035: fprintf(file, "%s", count->argVarName); ! 1036: ! 1037: /* ! 1038: * If the base type size is not a multiple of sizeof(int) [4], ! 1039: * we have to round up. ! 1040: */ ! 1041: if (bsize % 4 != 0) ! 1042: fprintf(file, " + 3) & ~3"); ! 1043: ! 1044: if (ptype->itIndefinite) { ! 1045: fprintf(file, " : sizeof(%s *)", ! 1046: FetchServerType(ptype->itElement)); ! 1047: } ! 1048: } ! 1049: ! 1050: /* ! 1051: * Adjust message size and advance reply pointer. ! 1052: * Called after packing a variable-length argument that ! 1053: * has more arguments following. ! 1054: */ ! 1055: static void ! 1056: WriteAdjustMsgSize(FILE *file, register const argument_t *arg) ! 1057: { ! 1058: register routine_t *rt = arg->argRoutine; ! 1059: register ipc_type_t *ptype = arg->argType; ! 1060: ! 1061: /* There are more Out arguments. We need to adjust msgh_size ! 1062: and advance OutP, so we save the size of the current field ! 1063: in msgh_size_delta. */ ! 1064: ! 1065: fprintf(file, "\tmsgh_size_delta = "); ! 1066: WriteArgSize(file, arg); ! 1067: fprintf(file, ";\n"); ! 1068: ! 1069: if (rt->rtNumReplyVar == 1) ! 1070: /* We can still address the message header directly. Fill ! 1071: in the size field. */ ! 1072: ! 1073: fprintf(file, "\tOutP->Head.msgh_size = %d + msgh_size_delta;\n", ! 1074: rt->rtReplySize); ! 1075: else ! 1076: if (arg->argReplyPos == 0) ! 1077: /* First variable-length argument. The previous msgh_size value ! 1078: is the minimum reply size. */ ! 1079: ! 1080: fprintf(file, "\tmsgh_size = %d + msgh_size_delta;\n", ! 1081: rt->rtReplySize); ! 1082: else ! 1083: fprintf(file, "\tmsgh_size += msgh_size_delta;\n"); ! 1084: ! 1085: fprintf(file, ! 1086: "\tOutP = (Reply *) ((char *) OutP + msgh_size_delta - %d);\n", ! 1087: ptype->itTypeSize + ptype->itPadSize); ! 1088: } ! 1089: ! 1090: /* ! 1091: * Calculate the size of the message. Called after the ! 1092: * last argument has been packed. ! 1093: */ ! 1094: static void ! 1095: WriteFinishMsgSize(FILE *file, register const argument_t *arg) ! 1096: { ! 1097: /* No more Out arguments. If this is the only variable Out ! 1098: argument, we can assign to msgh_size directly. */ ! 1099: ! 1100: if (arg->argReplyPos == 0) { ! 1101: fprintf(file, "\tOutP->Head.msgh_size = %d + (", ! 1102: arg->argRoutine->rtReplySize); ! 1103: WriteArgSize(file, arg); ! 1104: fprintf(file, ");\n"); ! 1105: } ! 1106: else { ! 1107: fprintf(file, "\tmsgh_size += "); ! 1108: WriteArgSize(file, arg); ! 1109: fprintf(file, ";\n"); ! 1110: } ! 1111: } ! 1112: ! 1113: static void ! 1114: WritePackArg(FILE *file, register const argument_t *arg) ! 1115: { ! 1116: if (akCheck(arg->argKind, akbReplyInit)) ! 1117: WritePackArgType(file, arg); ! 1118: ! 1119: if ((akIdent(arg->argKind) == akePoly) && ! 1120: akCheck(arg->argKind, akbReturnSnd)) ! 1121: WriteAdjustMsgSimple(file, arg); ! 1122: ! 1123: if (akCheckAll(arg->argKind, akbReturnSnd|akbVarNeeded)) ! 1124: WritePackArgValue(file, arg); ! 1125: else if (akCheckAll(arg->argKind, akbReturnSnd|akbVariable)) { ! 1126: register const ipc_type_t *it = arg->argType; ! 1127: ! 1128: if (it->itString) { ! 1129: /* Need to call strlen to calculate the size of the argument. */ ! 1130: fprintf(file, "\tOutP->%s = strlen(OutP->%s) + 1;\n", ! 1131: arg->argCount->argMsgField, arg->argMsgField); ! 1132: } else if (it->itIndefinite) { ! 1133: /* ! 1134: * We know that array is in reply message. ! 1135: */ ! 1136: fprintf(file, "\tif (%sP != OutP->%s) {\n", ! 1137: arg->argVarName, ! 1138: arg->argMsgField); ! 1139: fprintf(file, "\t\tOutP->%s%s.msgt_inline = FALSE;\n", ! 1140: arg->argTTName, ! 1141: arg->argLongForm ? ".msgtl_header" : ""); ! 1142: if (arg->argDeallocate == d_YES) ! 1143: fprintf(file, "\t\tOutP->%s%s.msgt_deallocate = TRUE;\n", ! 1144: arg->argTTName, ! 1145: arg->argLongForm ? ".msgtl_header" : ""); ! 1146: else if (arg->argDeallocate == d_MAYBE) ! 1147: fprintf(file, "\t\tOutP->%s%s.msgt_deallocate = %s;\n", ! 1148: arg->argTTName, ! 1149: arg->argLongForm ? ".msgtl_header" : "", ! 1150: arg->argDealloc->argVarName); ! 1151: fprintf(file, "\t\t*((%s **)OutP->%s) = %sP;\n", ! 1152: FetchServerType(it->itElement), ! 1153: arg->argMsgField, ! 1154: arg->argVarName); ! 1155: if (!arg->argRoutine->rtSimpleFixedReply) ! 1156: fprintf(file, "\t\tmsgh_simple = FALSE;\n"); ! 1157: fprintf(file, "\t}\n"); ! 1158: } ! 1159: } ! 1160: ! 1161: if (akCheck(arg->argKind, akbReplyCopy)) ! 1162: WriteCopyArgValue(file, arg); ! 1163: ! 1164: /* ! 1165: * If this is a KernelServer, and the reply message contains ! 1166: * a receive right, we must check for the possibility of a ! 1167: * port/message circularity. If queueing the reply message ! 1168: * would cause a circularity, we mark the reply message ! 1169: * with the circular bit. ! 1170: */ ! 1171: ! 1172: if (IsKernelServer && ! 1173: akCheck(arg->argKind, akbReturnSnd) && ! 1174: ((arg->argType->itOutName == MACH_MSG_TYPE_PORT_RECEIVE) || ! 1175: (arg->argType->itOutName == MACH_MSG_TYPE_POLYMORPHIC))) ! 1176: WriteAdjustMsgCircular(file, arg); ! 1177: } ! 1178: ! 1179: /* ! 1180: * Handle reply arguments - fill in message types and copy arguments ! 1181: * that need to be copied. ! 1182: */ ! 1183: static void ! 1184: WritePackReplyArgs(FILE *file, register const routine_t *rt) ! 1185: { ! 1186: register const argument_t *arg; ! 1187: register const argument_t *lastVarArg; ! 1188: ! 1189: lastVarArg = argNULL; ! 1190: for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) { ! 1191: ! 1192: /* ! 1193: * Adjust message size and advance message pointer if ! 1194: * the last reply argument was variable-length and the ! 1195: * request position will change. ! 1196: */ ! 1197: if (lastVarArg != argNULL && ! 1198: lastVarArg->argReplyPos < arg->argReplyPos) ! 1199: { ! 1200: WriteAdjustMsgSize(file, lastVarArg); ! 1201: lastVarArg = argNULL; ! 1202: } ! 1203: ! 1204: /* ! 1205: * Copy the argument ! 1206: */ ! 1207: WritePackArg(file, arg); ! 1208: ! 1209: /* ! 1210: * Remember whether this was variable-length. ! 1211: */ ! 1212: if (akCheckAll(arg->argKind, akbReturnSnd|akbVariable)) ! 1213: lastVarArg = arg; ! 1214: } ! 1215: ! 1216: /* ! 1217: * Finish the message size. ! 1218: */ ! 1219: if (lastVarArg != argNULL) ! 1220: WriteFinishMsgSize(file, lastVarArg); ! 1221: } ! 1222: ! 1223: static void ! 1224: WriteFieldDecl(FILE *file, const argument_t *arg) ! 1225: { ! 1226: WriteFieldDeclPrim(file, arg, FetchServerType); ! 1227: } ! 1228: ! 1229: static void ! 1230: WriteRoutine(FILE *file, register const routine_t *rt) ! 1231: { ! 1232: fprintf(file, "\n"); ! 1233: ! 1234: fprintf(file, "/* %s %s */\n", rtRoutineKindToStr(rt->rtKind), rt->rtName); ! 1235: fprintf(file, "mig_internal void _X%s\n", rt->rtName); ! 1236: fprintf(file, "\t(mach_msg_header_t *InHeadP, mach_msg_header_t *OutHeadP)\n"); ! 1237: ! 1238: fprintf(file, "{\n"); ! 1239: WriteStructDecl(file, rt->rtArgs, WriteFieldDecl, akbRequest, "Request"); ! 1240: WriteStructDecl(file, rt->rtArgs, WriteFieldDecl, akbReply, "Reply"); ! 1241: ! 1242: WriteVarDecls(file, rt); ! 1243: ! 1244: WriteList(file, rt->rtArgs, WriteCheckDecl, akbRequestQC, "\n", "\n"); ! 1245: WriteList(file, rt->rtArgs, ! 1246: IsKernelServer ? WriteTypeDeclOut : WriteTypeDeclIn, ! 1247: akbReplyInit, "\n", "\n"); ! 1248: ! 1249: WriteList(file, rt->rtArgs, WriteLocalVarDecl, ! 1250: akbVarNeeded, ";\n", ";\n\n"); ! 1251: WriteList(file, rt->rtArgs, WriteLocalPtrDecl, ! 1252: akbPointer, ";\n", ";\n\n"); ! 1253: ! 1254: WriteCheckHead(file, rt); ! 1255: ! 1256: WriteTypeCheckRequestArgs(file, rt); ! 1257: WriteList(file, rt->rtArgs, WriteExtractArg, akbNone, "", ""); ! 1258: ! 1259: WriteServerCall(file, rt); ! 1260: WriteGetReturnValue(file, rt); ! 1261: ! 1262: WriteReverseList(file, rt->rtArgs, WriteDestroyArg, akbDestroy, "", ""); ! 1263: ! 1264: /* ! 1265: * For one-way routines, it doesn`t make sense to check the return ! 1266: * code, because we return immediately afterwards. However, ! 1267: * kernel servers may want to deallocate port arguments - and the ! 1268: * deallocation must not be done if the return code is not KERN_SUCCESS. ! 1269: */ ! 1270: if (rt->rtOneWay || rt->rtNoReplyArgs) ! 1271: { ! 1272: if (IsKernelServer) ! 1273: { ! 1274: if (rtCheckMaskFunction(rt->rtArgs, akbSendBody|akbSendRcv, ! 1275: CheckDestroyPortArg)) ! 1276: { ! 1277: WriteCheckReturnValue(file, rt); ! 1278: } ! 1279: WriteReverseList(file, rt->rtArgs, WriteDestroyPortArg, ! 1280: akbSendBody|akbSendRcv, "", ""); ! 1281: } ! 1282: } ! 1283: else ! 1284: { ! 1285: WriteCheckReturnValue(file, rt); ! 1286: ! 1287: if (IsKernelServer) ! 1288: WriteReverseList(file, rt->rtArgs, WriteDestroyPortArg, ! 1289: akbSendBody|akbSendRcv, "", ""); ! 1290: ! 1291: WriteReplyInit(file, rt); ! 1292: WritePackReplyArgs(file, rt); ! 1293: WriteReplyHead(file, rt); ! 1294: } ! 1295: ! 1296: fprintf(file, "}\n"); ! 1297: } ! 1298: ! 1299: void ! 1300: WriteServer(FILE *file, const statement_t *stats) ! 1301: { ! 1302: register const statement_t *stat; ! 1303: ! 1304: WriteProlog(file); ! 1305: for (stat = stats; stat != stNULL; stat = stat->stNext) ! 1306: switch (stat->stKind) ! 1307: { ! 1308: case skRoutine: ! 1309: WriteRoutine(file, stat->stRoutine); ! 1310: break; ! 1311: case skImport: ! 1312: case skSImport: ! 1313: WriteImport(file, stat->stFileName); ! 1314: break; ! 1315: case skUImport: ! 1316: break; ! 1317: default: ! 1318: fatal("WriteServer(): bad statement_kind_t (%d)", ! 1319: (int) stat->stKind); ! 1320: } ! 1321: WriteEpilog(file, stats); ! 1322: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.