![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to user.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 user.c CVS log | Up to [GnuMach] / Gnu-Mach / mig |
1.1 ! root 1: /* ! 2: * Mach Operating System ! 3: * Copyright (c) 1992,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 ! 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 the ! 24: * rights to redistribute these changes. ! 25: */ ! 26: ! 27: #include <assert.h> ! 28: ! 29: #include "write.h" ! 30: #include "error.h" ! 31: #include "utils.h" ! 32: #include "global.h" ! 33: #include "mig_string.h" ! 34: #include "cpu.h" ! 35: ! 36: /************************************************************* ! 37: * Writes the standard includes. The subsystem specific ! 38: * includes are in <SubsystemName>.h and writen by ! 39: * header:WriteHeader. Called by WriteProlog. ! 40: *************************************************************/ ! 41: static void ! 42: WriteIncludes(FILE *file) ! 43: { ! 44: if (IsKernelServer) ! 45: { ! 46: /* ! 47: * We want to get the user-side definitions of types ! 48: * like task_t, ipc_space_t, etc. in mach/mach_types.h. ! 49: */ ! 50: ! 51: fprintf(file, "#undef\tKERNEL\n"); ! 52: ! 53: if (InternalHeaderFileName != strNULL) ! 54: { ! 55: register char *cp; ! 56: ! 57: /* Strip any leading path from InternalHeaderFileName. */ ! 58: cp = strrchr(InternalHeaderFileName, '/'); ! 59: if (cp == 0) ! 60: cp = InternalHeaderFileName; ! 61: else ! 62: cp++; /* skip '/' */ ! 63: fprintf(file, "#include \"%s\"\n", cp); ! 64: } ! 65: } ! 66: ! 67: if (UserHeaderFileName != strNULL) ! 68: { ! 69: register char *cp; ! 70: ! 71: /* Strip any leading path from UserHeaderFileName. */ ! 72: cp = strrchr(UserHeaderFileName, '/'); ! 73: if (cp == 0) ! 74: cp = UserHeaderFileName; ! 75: else ! 76: cp++; /* skip '/' */ ! 77: fprintf(file, "#include \"%s\"\n", cp); ! 78: } ! 79: ! 80: fprintf(file, "#define EXPORT_BOOLEAN\n"); ! 81: fprintf(file, "#include <mach/boolean.h>\n"); ! 82: fprintf(file, "#include <mach/kern_return.h>\n"); ! 83: fprintf(file, "#include <mach/message.h>\n"); ! 84: fprintf(file, "#include <mach/notify.h>\n"); ! 85: fprintf(file, "#include <mach/mach_types.h>\n"); ! 86: fprintf(file, "#include <mach/mig_errors.h>\n"); ! 87: fprintf(file, "#include <mach/mig_support.h>\n"); ! 88: fprintf(file, "#include <mach/msg_type.h>\n"); ! 89: fprintf(file, "/* LINTLIBRARY */\n"); ! 90: fprintf(file, "\n"); ! 91: } ! 92: ! 93: static void ! 94: WriteGlobalDecls(FILE *file) ! 95: { ! 96: if (RCSId != strNULL) ! 97: WriteRCSDecl(file, strconcat(SubsystemName, "_user"), RCSId); ! 98: ! 99: fprintf(file, "#define msgh_request_port\tmsgh_remote_port\n"); ! 100: fprintf(file, "#define msgh_reply_port\t\tmsgh_local_port\n"); ! 101: fprintf(file, "\n"); ! 102: } ! 103: ! 104: /************************************************************* ! 105: * Writes the standard #includes, #defines, and ! 106: * RCS declaration. Called by WriteUser. ! 107: *************************************************************/ ! 108: static void ! 109: WriteProlog(FILE *file) ! 110: { ! 111: WriteIncludes(file); ! 112: WriteBogusDefines(file); ! 113: WriteGlobalDecls(file); ! 114: } ! 115: ! 116: /*ARGSUSED*/ ! 117: static void ! 118: WriteEpilog(FILE *file) ! 119: { ! 120: } ! 121: ! 122: static const_string_t ! 123: WriteHeaderPortType(const argument_t *arg) ! 124: { ! 125: if (arg->argType->itInName == MACH_MSG_TYPE_POLYMORPHIC) ! 126: return arg->argPoly->argVarName; ! 127: else ! 128: return arg->argType->itInNameStr; ! 129: } ! 130: ! 131: static void ! 132: WriteRequestHead(FILE *file, const routine_t *rt) ! 133: { ! 134: if (rt->rtMaxRequestPos > 0) ! 135: fprintf(file, "\tInP = &Mess.In;\n"); ! 136: ! 137: if (rt->rtSimpleFixedRequest) { ! 138: fprintf(file, "\tInP->Head.msgh_bits ="); ! 139: if (!rt->rtSimpleSendRequest) ! 140: fprintf(file, " MACH_MSGH_BITS_COMPLEX|"); ! 141: fprintf(file, "\n"); ! 142: fprintf(file, "\t\tMACH_MSGH_BITS(%s, %s);\n", ! 143: WriteHeaderPortType(rt->rtRequestPort), ! 144: WriteHeaderPortType(rt->rtUReplyPort)); ! 145: } else { ! 146: fprintf(file, "\tInP->Head.msgh_bits = msgh_simple ?\n"); ! 147: fprintf(file, "\t\tMACH_MSGH_BITS(%s, %s) :\n", ! 148: WriteHeaderPortType(rt->rtRequestPort), ! 149: WriteHeaderPortType(rt->rtUReplyPort)); ! 150: fprintf(file, "\t\t(MACH_MSGH_BITS_COMPLEX|\n"); ! 151: fprintf(file, "\t\t MACH_MSGH_BITS(%s, %s));\n", ! 152: WriteHeaderPortType(rt->rtRequestPort), ! 153: WriteHeaderPortType(rt->rtUReplyPort)); ! 154: } ! 155: ! 156: fprintf(file, "\t/* msgh_size passed as argument */\n"); ! 157: ! 158: /* ! 159: * KernelUser stubs need to cast the request and reply ports ! 160: * from ipc_port_t to mach_port_t. ! 161: */ ! 162: ! 163: if (IsKernelUser) ! 164: fprintf(file, "\tInP->%s = (mach_port_t) %s;\n", ! 165: rt->rtRequestPort->argMsgField, ! 166: rt->rtRequestPort->argVarName); ! 167: else ! 168: fprintf(file, "\tInP->%s = %s;\n", ! 169: rt->rtRequestPort->argMsgField, ! 170: rt->rtRequestPort->argVarName); ! 171: ! 172: if (akCheck(rt->rtUReplyPort->argKind, akbUserArg)) { ! 173: if (IsKernelUser) ! 174: fprintf(file, "\tInP->%s = (mach_port_t) %s;\n", ! 175: rt->rtUReplyPort->argMsgField, ! 176: rt->rtUReplyPort->argVarName); ! 177: else ! 178: fprintf(file, "\tInP->%s = %s;\n", ! 179: rt->rtUReplyPort->argMsgField, ! 180: rt->rtUReplyPort->argVarName); ! 181: } else if (rt->rtOneWay || IsKernelUser) ! 182: fprintf(file, "\tInP->%s = MACH_PORT_NULL;\n", ! 183: rt->rtUReplyPort->argMsgField); ! 184: else ! 185: fprintf(file, "\tInP->%s = %smig_get_reply_port();\n", ! 186: rt->rtUReplyPort->argMsgField, SubrPrefix); ! 187: ! 188: fprintf(file, "\tInP->Head.msgh_seqno = 0;\n"); ! 189: fprintf(file, "\tInP->Head.msgh_id = %d;\n", rt->rtNumber + SubsystemBase); ! 190: } ! 191: ! 192: /************************************************************* ! 193: * Writes declarations for the message types, variables ! 194: * and return variable if needed. Called by WriteRoutine. ! 195: *************************************************************/ ! 196: static void ! 197: WriteVarDecls(FILE *file, const routine_t *rt) ! 198: { ! 199: fprintf(file, "\tunion {\n"); ! 200: fprintf(file, "\t\tRequest In;\n"); ! 201: if (!rt->rtOneWay) ! 202: fprintf(file, "\t\tReply Out;\n"); ! 203: fprintf(file, "\t} Mess;\n"); ! 204: fprintf(file, "\n"); ! 205: ! 206: fprintf(file, "\tregister Request *InP = &Mess.In;\n"); ! 207: if (!rt->rtOneWay) ! 208: fprintf(file, "\tregister Reply *OutP = &Mess.Out;\n"); ! 209: fprintf(file, "\n"); ! 210: ! 211: if (!rt->rtOneWay || rt->rtProcedure) ! 212: fprintf(file, "\tmach_msg_return_t msg_result;\n"); ! 213: ! 214: if (!rt->rtSimpleFixedRequest) ! 215: fprintf(file, "\tboolean_t msgh_simple = %s;\n", ! 216: strbool(rt->rtSimpleSendRequest)); ! 217: else if (!rt->rtOneWay && ! 218: !(rt->rtSimpleCheckReply && rt->rtSimpleReceiveReply)) { ! 219: fprintf(file, "#if\tTypeCheck\n"); ! 220: fprintf(file, "\tboolean_t msgh_simple;\n"); ! 221: fprintf(file, "#endif\t/* TypeCheck */\n"); ! 222: } ! 223: ! 224: if (rt->rtNumRequestVar > 0) ! 225: fprintf(file, "\tunsigned int msgh_size;\n"); ! 226: else if (!rt->rtOneWay && !rt->rtNoReplyArgs) ! 227: { ! 228: fprintf(file, "#if\tTypeCheck\n"); ! 229: fprintf(file, "\tunsigned int msgh_size;\n"); ! 230: fprintf(file, "#endif\t/* TypeCheck */\n"); ! 231: } ! 232: ! 233: /* if either request or reply is variable, we need msgh_size_delta */ ! 234: if ((rt->rtMaxRequestPos > 0) || ! 235: (rt->rtMaxReplyPos > 0)) ! 236: fprintf(file, "\tunsigned int msgh_size_delta;\n"); ! 237: ! 238: fprintf(file, "\n"); ! 239: } ! 240: ! 241: /************************************************************* ! 242: * Writes code to call the user provided error procedure ! 243: * when a MIG error occurs. Called by WriteMsgSend, ! 244: * WriteMsgCheckReceive, WriteMsgSendReceive, WriteCheckIdentity, ! 245: * WriteRetCodeCheck, WriteTypeCheck, WritePackArgValue. ! 246: *************************************************************/ ! 247: static void ! 248: WriteMsgError(FILE *file, const routine_t *rt, const char *error_msg) ! 249: { ! 250: if (rt->rtProcedure) ! 251: fprintf(file, "\t\t{ %s(%s); return; }\n", rt->rtErrorName, error_msg); ! 252: else if (rt->rtReturn != rt->rtRetCode) ! 253: { ! 254: fprintf(file, "\t\t{ %s(%s); ", rt->rtErrorName, error_msg); ! 255: if (rt->rtNumReplyVar > 0) ! 256: fprintf(file, "OutP = &Mess.Out; "); ! 257: fprintf(file, "return OutP->%s; }\n", rt->rtReturn->argMsgField); ! 258: } ! 259: else ! 260: fprintf(file, "\t\treturn %s;\n", error_msg); ! 261: } ! 262: ! 263: /************************************************************* ! 264: * Writes the send call when there is to be no subsequent ! 265: * receive. Called by WriteRoutine for SimpleProcedures ! 266: * or SimpleRoutines ! 267: *************************************************************/ ! 268: static void ! 269: WriteMsgSend(FILE *file, const routine_t *rt) ! 270: { ! 271: const char *MsgResult = (rt->rtProcedure) ! 272: ? "msg_result =" ! 273: : "return"; ! 274: ! 275: char SendSize[24]; ! 276: ! 277: if (rt->rtNumRequestVar == 0) ! 278: sprintf(SendSize, "%d", rt->rtRequestSize); ! 279: else ! 280: strcpy(SendSize, "msgh_size"); ! 281: ! 282: if (IsKernelUser) ! 283: { ! 284: fprintf(file, "\t%s %smach_msg_send_from_kernel(", ! 285: MsgResult, SubrPrefix); ! 286: fprintf(file, "&InP->Head, %s);\n", SendSize); ! 287: } ! 288: else ! 289: { ! 290: fprintf(file, "\t%s %smach_msg(&InP->Head, MACH_SEND_MSG|%s, %s, 0,", ! 291: MsgResult, ! 292: SubrPrefix, ! 293: rt->rtMsgOption->argVarName, ! 294: SendSize); ! 295: fprintf(file, ! 296: " MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);\n" ! 297: ); ! 298: } ! 299: ! 300: if (rt->rtProcedure) ! 301: { ! 302: fprintf(file, "\tif (msg_result != MACH_MSG_SUCCESS)\n"); ! 303: WriteMsgError(file, rt, "msg_result"); ! 304: } ! 305: } ! 306: ! 307: /************************************************************* ! 308: * Writes to code to check for error returns from receive. ! 309: * Called by WriteMsgSendReceive and WriteMsgRPC ! 310: *************************************************************/ ! 311: static void ! 312: WriteMsgCheckReceive(FILE *file, const routine_t *rt, const char *success) ! 313: { ! 314: fprintf(file, "\tif (msg_result != %s) {\n", success); ! 315: if (!akCheck(rt->rtUReplyPort->argKind, akbUserArg) && !IsKernelUser) ! 316: { ! 317: /* If we aren't using a user-supplied reply port, ! 318: then deallocate the reply port on any message transmission ! 319: errors. */ ! 320: fprintf(file, "\t\t%smig_dealloc_reply_port(%s);\n", ! 321: SubrPrefix, "InP->Head.msgh_reply_port"); ! 322: } ! 323: WriteMsgError(file, rt, "msg_result"); ! 324: fprintf(file, "\t}\n"); ! 325: ! 326: /* ! 327: * If not using a user supplied reply port, tell the port ! 328: * allocator we're done with the port. ! 329: */ ! 330: if (!akCheck(rt->rtUReplyPort->argKind, akbUserArg) && !IsKernelUser) ! 331: { ! 332: fprintf(file, "\t%smig_put_reply_port(InP->Head.msgh_reply_port);\n", ! 333: SubrPrefix); ! 334: } ! 335: } ! 336: ! 337: /************************************************************* ! 338: * Writes the send and receive calls and code to check ! 339: * for errors. Normally the rpc code is generated instead ! 340: * although, the subsytem can be compiled with the -R option ! 341: * which will cause this code to be generated. Called by ! 342: * WriteRoutine if UseMsgRPC option is false. ! 343: *************************************************************/ ! 344: static void ! 345: WriteMsgSendReceive(FILE *file, const routine_t *rt) ! 346: { ! 347: char SendSize[24]; ! 348: ! 349: if (rt->rtNumRequestVar == 0) ! 350: sprintf(SendSize, "%d", rt->rtRequestSize); ! 351: else ! 352: strcpy(SendSize, "msgh_size"); ! 353: ! 354: fprintf(file, "\tmsg_result = %smach_msg(&InP->Head, MACH_SEND_MSG|%s, %s, 0, MACH_PORT_NULL, MACH_MSG_TIMEOUT_NONE, MACH_PORT_NULL);\n", ! 355: SubrPrefix, ! 356: rt->rtMsgOption->argVarName, ! 357: SendSize); ! 358: ! 359: fprintf(file, "\tif (msg_result != MACH_MSG_SUCCESS)\n"); ! 360: WriteMsgError(file, rt, "msg_result"); ! 361: fprintf(file, "\n"); ! 362: ! 363: fprintf(file, "\tmsg_result = %smach_msg(&OutP->Head, MACH_RCV_MSG|%s%s, 0, sizeof(Reply), InP->Head.msgh_local_port, %s, MACH_PORT_NULL);\n", ! 364: SubrPrefix, ! 365: rt->rtMsgOption->argVarName, ! 366: rt->rtWaitTime != argNULL ? "|MACH_RCV_TIMEOUT" : "", ! 367: rt->rtWaitTime != argNULL ? rt->rtWaitTime->argVarName : "MACH_MSG_TIMEOUT_NONE"); ! 368: WriteMsgCheckReceive(file, rt, "MACH_MSG_SUCCESS"); ! 369: fprintf(file, "\n"); ! 370: } ! 371: ! 372: /************************************************************* ! 373: * Writes the rpc call and the code to check for errors. ! 374: * This is the default code to be generated. Called by WriteRoutine ! 375: * for all routine types except SimpleProcedure and SimpleRoutine. ! 376: *************************************************************/ ! 377: static void ! 378: WriteMsgRPC(FILE *file, const routine_t *rt) ! 379: { ! 380: char SendSize[24]; ! 381: ! 382: if (rt->rtNumRequestVar == 0) ! 383: sprintf(SendSize, "%d", rt->rtRequestSize); ! 384: else ! 385: strcpy(SendSize, "msgh_size"); ! 386: ! 387: if (IsKernelUser) ! 388: fprintf(file, "\tmsg_result = %smach_msg_rpc_from_kernel(&InP->Head, %s, sizeof(Reply));\n", ! 389: SubrPrefix, ! 390: SendSize); ! 391: else ! 392: fprintf(file, "\tmsg_result = %smach_msg(&InP->Head, MACH_SEND_MSG|MACH_RCV_MSG|%s%s, %s, sizeof(Reply), InP->Head.msgh_reply_port, %s, MACH_PORT_NULL);\n", ! 393: SubrPrefix, ! 394: rt->rtMsgOption->argVarName, ! 395: rt->rtWaitTime != argNULL ? "|MACH_RCV_TIMEOUT" : "", ! 396: SendSize, ! 397: rt->rtWaitTime != argNULL? rt->rtWaitTime->argVarName : "MACH_MSG_TIMEOUT_NONE"); ! 398: WriteMsgCheckReceive(file, rt, "MACH_MSG_SUCCESS"); ! 399: fprintf(file, "\n"); ! 400: } ! 401: ! 402: /************************************************************* ! 403: * Sets the correct value of the dealloc flag and calls ! 404: * Utils:WritePackMsgType to fill in the ipc msg type word(s) ! 405: * in the request message. Called by WriteRoutine for each ! 406: * argument that is to be sent in the request message. ! 407: *************************************************************/ ! 408: static void ! 409: WritePackArgType(FILE *file, const argument_t *arg) ! 410: { ! 411: WritePackMsgType(file, arg->argType, ! 412: arg->argType->itIndefinite ? d_NO : arg->argDeallocate, ! 413: arg->argLongForm, TRUE, ! 414: "InP->%s", "%s", arg->argTTName); ! 415: fprintf(file, "\n"); ! 416: } ! 417: ! 418: /************************************************************* ! 419: * Writes code to copy an argument into the request message. ! 420: * Called by WriteRoutine for each argument that is to placed ! 421: * in the request message. ! 422: *************************************************************/ ! 423: static void ! 424: WritePackArgValue(FILE *file, register const argument_t *arg) ! 425: { ! 426: register const ipc_type_t *it = arg->argType; ! 427: register const char *ref = arg->argByReferenceUser ? "*" : ""; ! 428: ! 429: if (it->itInLine && it->itVarArray) { ! 430: ! 431: if (it->itString) { ! 432: /* ! 433: * Copy variable-size C string with mig_strncpy. ! 434: * Save the string length (+ 1 for trailing 0) ! 435: * in the argument`s count field. ! 436: */ ! 437: fprintf(file, ! 438: "\tInP->%s = %smig_strncpy(InP->%s, %s, %d);\n", ! 439: arg->argCount->argMsgField, ! 440: SubrPrefix, ! 441: arg->argMsgField, ! 442: arg->argVarName, ! 443: it->itNumber); ! 444: } ! 445: else { ! 446: ! 447: /* ! 448: * Copy in variable-size inline array with memcpy, ! 449: * after checking that number of elements doesn`t ! 450: * exceed declared maximum. ! 451: */ ! 452: register const argument_t *count = arg->argCount; ! 453: register const char *countRef = count->argByReferenceUser ? "*" :""; ! 454: register const ipc_type_t *btype = it->itElement; ! 455: ! 456: /* Note btype->itNumber == count->argMultiplier */ ! 457: ! 458: fprintf(file, "\tif (%s%s > %d) {\n", ! 459: countRef, count->argVarName, ! 460: it->itNumber/btype->itNumber); ! 461: if (it->itIndefinite) { ! 462: fprintf(file, "\t\tInP->%s%s.msgt_inline = FALSE;\n", ! 463: arg->argTTName, ! 464: arg->argLongForm ? ".msgtl_header" : ""); ! 465: if (arg->argDeallocate == d_YES) ! 466: fprintf(file, "\t\tInP->%s%s.msgt_deallocate = TRUE;\n", ! 467: arg->argTTName, ! 468: arg->argLongForm ? ".msgtl_header" : ""); ! 469: else if (arg->argDeallocate == d_MAYBE) ! 470: fprintf(file, "\t\tInP->%s%s.msgt_deallocate = %s%s;\n", ! 471: arg->argTTName, ! 472: arg->argLongForm ? ".msgtl_header" : "", ! 473: arg->argDealloc->argByReferenceUser ? "*" : "", ! 474: arg->argDealloc->argVarName); ! 475: fprintf(file, "\t\t*((%s **)InP->%s) = %s%s;\n", ! 476: FetchUserType(btype), ! 477: arg->argMsgField, ! 478: ref, arg->argVarName); ! 479: if (!arg->argRoutine->rtSimpleFixedRequest) ! 480: fprintf(file, "\t\tmsgh_simple = FALSE;\n"); ! 481: } ! 482: else ! 483: WriteMsgError(file, arg->argRoutine, "MIG_ARRAY_TOO_LARGE"); ! 484: ! 485: fprintf(file, "\t}\n\telse {\n"); ! 486: ! 487: fprintf(file, "\t\tmemcpy(InP->%s, %s%s, ", arg->argMsgField, ! 488: ref, arg->argVarName); ! 489: if (btype->itTypeSize > 1) ! 490: fprintf(file, "%d * ", btype->itTypeSize); ! 491: fprintf(file, "%s%s);\n", ! 492: countRef, count->argVarName); ! 493: fprintf(file, "\t}\n"); ! 494: } ! 495: } ! 496: else if (arg->argMultiplier > 1) ! 497: WriteCopyType(file, it, "InP->%s", "/* %s */ %d * %s%s", ! 498: arg->argMsgField, arg->argMultiplier, ! 499: ref, arg->argVarName); ! 500: else ! 501: WriteCopyType(file, it, "InP->%s", "/* %s */ %s%s", ! 502: arg->argMsgField, ref, arg->argVarName); ! 503: fprintf(file, "\n"); ! 504: } ! 505: ! 506: static void ! 507: WriteAdjustMsgSimple(FILE *file, register const argument_t *arg) ! 508: { ! 509: if (!arg->argRoutine->rtSimpleFixedRequest) ! 510: { ! 511: register const char *ref = arg->argByReferenceUser ? "*" : ""; ! 512: ! 513: fprintf(file, "\tif (MACH_MSG_TYPE_PORT_ANY(%s%s))\n", ! 514: ref, arg->argVarName); ! 515: fprintf(file, "\t\tmsgh_simple = FALSE;\n"); ! 516: fprintf(file, "\n"); ! 517: } ! 518: } ! 519: ! 520: /* ! 521: * Calculate the size of a variable-length message field. ! 522: */ ! 523: static void ! 524: WriteArgSize(FILE *file, register const argument_t *arg) ! 525: { ! 526: register const ipc_type_t *ptype = arg->argType; ! 527: register int bsize = ptype->itElement->itTypeSize; ! 528: register const argument_t *count = arg->argCount; ! 529: ! 530: if (ptype->itIndefinite) { ! 531: /* ! 532: * Check descriptor. If out-of-line, use standard size. ! 533: */ ! 534: fprintf(file, "(InP->%s%s.msgt_inline) ? ", ! 535: arg->argTTName, arg->argLongForm ? ".msgtl_header" : ""); ! 536: } ! 537: if (bsize % 4 != 0) ! 538: fprintf(file, "("); ! 539: ! 540: if (bsize > 1) ! 541: fprintf(file, "%d * ", bsize); ! 542: ! 543: if (ptype->itString) ! 544: /* get count from descriptor in message */ ! 545: fprintf(file, "InP->%s", count->argMsgField); ! 546: else ! 547: /* get count from argument */ ! 548: fprintf(file, "%s%s", ! 549: count->argByReferenceUser ? "*" : "", ! 550: count->argVarName); ! 551: ! 552: /* ! 553: * If the base type size is not a multiple of sizeof(int) [4], ! 554: * we have to round up. ! 555: */ ! 556: if (bsize % 4 != 0) ! 557: fprintf(file, " + 3) & ~3"); ! 558: ! 559: if (ptype->itIndefinite) { ! 560: fprintf(file, " : sizeof(%s *)", ! 561: FetchUserType(ptype->itElement)); ! 562: } ! 563: } ! 564: ! 565: /* ! 566: * Adjust message size and advance request pointer. ! 567: * Called after packing a variable-length argument that ! 568: * has more arguments following. ! 569: */ ! 570: static void ! 571: WriteAdjustMsgSize(FILE *file, register const argument_t *arg) ! 572: { ! 573: register const ipc_type_t *ptype = arg->argType; ! 574: ! 575: /* There are more In arguments. We need to adjust msgh_size ! 576: and advance InP, so we save the size of the current field ! 577: in msgh_size_delta. */ ! 578: ! 579: fprintf(file, "\tmsgh_size_delta = "); ! 580: WriteArgSize(file, arg); ! 581: fprintf(file, ";\n"); ! 582: ! 583: if (arg->argRequestPos == 0) ! 584: /* First variable-length argument. The previous msgh_size value ! 585: is the minimum request size. */ ! 586: ! 587: fprintf(file, "\tmsgh_size = %d + msgh_size_delta;\n", ! 588: arg->argRoutine->rtRequestSize); ! 589: else ! 590: fprintf(file, "\tmsgh_size += msgh_size_delta;\n"); ! 591: ! 592: fprintf(file, ! 593: "\tInP = (Request *) ((char *) InP + msgh_size_delta - %d);\n", ! 594: ptype->itTypeSize + ptype->itPadSize); ! 595: } ! 596: ! 597: /* ! 598: * Calculate the size of the message. Called after the ! 599: * last argument has been packed. ! 600: */ ! 601: static void ! 602: WriteFinishMsgSize(FILE *file, register const argument_t *arg) ! 603: { ! 604: /* No more In arguments. If this is the only variable In ! 605: argument, the previous msgh_size value is the minimum ! 606: request size. */ ! 607: ! 608: if (arg->argRequestPos == 0) { ! 609: fprintf(file, "\tmsgh_size = %d + (", ! 610: arg->argRoutine->rtRequestSize); ! 611: WriteArgSize(file, arg); ! 612: fprintf(file, ");\n"); ! 613: } ! 614: else { ! 615: fprintf(file, "\tmsgh_size += "); ! 616: WriteArgSize(file, arg); ! 617: fprintf(file, ";\n"); ! 618: } ! 619: } ! 620: ! 621: static void ! 622: WriteInitializeCount(FILE *file, register const argument_t *arg) ! 623: { ! 624: register const ipc_type_t *ptype = arg->argCInOut->argParent->argType; ! 625: register const ipc_type_t *btype = ptype->itElement; ! 626: ! 627: fprintf(file, "\tif (%s%s < %d)\n", ! 628: arg->argByReferenceUser ? "*" : "", ! 629: arg->argVarName, ! 630: ptype->itNumber/btype->itNumber); ! 631: fprintf(file, "\t\tInP->%s = %s%s;\n", ! 632: arg->argMsgField, ! 633: arg->argByReferenceUser ? "*" : "", ! 634: arg->argVarName); ! 635: fprintf(file, "\telse\n"); ! 636: fprintf(file, "\t\tInP->%s = %d;\n", ! 637: arg->argMsgField, ptype->itNumber/btype->itNumber); ! 638: fprintf(file, "\n"); ! 639: } ! 640: ! 641: /* ! 642: * Called for every argument. Responsible for packing that ! 643: * argument into the request message. ! 644: */ ! 645: static void ! 646: WritePackArg(FILE *file, register const argument_t *arg) ! 647: { ! 648: if (akCheck(arg->argKind, akbRequest)) ! 649: WritePackArgType(file, arg); ! 650: ! 651: if ((akIdent(arg->argKind) == akePoly) && ! 652: akCheckAll(arg->argKind, akbSendSnd|akbUserArg)) ! 653: WriteAdjustMsgSimple(file, arg); ! 654: ! 655: if ((akIdent(arg->argKind) == akeCountInOut) && ! 656: akCheck(arg->argKind, akbSendSnd)) ! 657: WriteInitializeCount(file, arg); ! 658: else if (akCheckAll(arg->argKind, akbSendSnd|akbSendBody)) ! 659: WritePackArgValue(file, arg); ! 660: } ! 661: ! 662: /* ! 663: * Generate code to fill in all of the request arguments and their ! 664: * message types. ! 665: */ ! 666: static void ! 667: WriteRequestArgs(FILE *file, register const routine_t *rt) ! 668: { ! 669: register const argument_t *arg; ! 670: register const argument_t *lastVarArg; ! 671: ! 672: lastVarArg = argNULL; ! 673: for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) ! 674: { ! 675: /* ! 676: * Adjust message size and advance message pointer if ! 677: * the last request argument was variable-length and the ! 678: * request position will change. ! 679: */ ! 680: if (lastVarArg != argNULL && ! 681: lastVarArg->argRequestPos < arg->argRequestPos) ! 682: { ! 683: WriteAdjustMsgSize(file, lastVarArg); ! 684: lastVarArg = argNULL; ! 685: } ! 686: ! 687: /* ! 688: * Copy the argument ! 689: */ ! 690: WritePackArg(file, arg); ! 691: ! 692: /* ! 693: * Remember whether this was variable-length. ! 694: */ ! 695: if (akCheckAll(arg->argKind, akbSendSnd|akbSendBody|akbVariable)) ! 696: lastVarArg = arg; ! 697: } ! 698: ! 699: /* ! 700: * Finish the message size. ! 701: */ ! 702: if (lastVarArg != argNULL) ! 703: WriteFinishMsgSize(file, lastVarArg); ! 704: } ! 705: ! 706: /************************************************************* ! 707: * Writes code to check that the return msgh_id is correct and that ! 708: * the size of the return message is correct. Called by ! 709: * WriteRoutine. ! 710: *************************************************************/ ! 711: static void ! 712: WriteCheckIdentity(FILE *file, const routine_t *rt) ! 713: { ! 714: fprintf(file, "\tif (OutP->Head.msgh_id != %d) {\n", ! 715: rt->rtNumber + SubsystemBase + 100); ! 716: fprintf(file, "\t\tif (OutP->Head.msgh_id == MACH_NOTIFY_SEND_ONCE)\n"); ! 717: WriteMsgError(file, rt, "MIG_SERVER_DIED"); ! 718: fprintf(file, "\t\telse {\n"); ! 719: fprintf(file, "\t\t\t%smig_dealloc_reply_port(%s);\n\t", ! 720: SubrPrefix,"InP->Head.msgh_reply_port"); ! 721: WriteMsgError(file, rt, "MIG_REPLY_MISMATCH"); ! 722: fprintf(file, "\t\t}\n\t}\n"); ! 723: fprintf(file, "\n"); ! 724: fprintf(file, "#if\tTypeCheck\n"); ! 725: ! 726: if (rt->rtSimpleCheckReply && rt->rtSimpleReceiveReply) ! 727: { ! 728: /* Expecting a simple message. We can factor out the check for ! 729: a simple message, since the error reply message is also simple. ! 730: */ ! 731: ! 732: if (!rt->rtNoReplyArgs) ! 733: fprintf(file, "\tmsgh_size = OutP->Head.msgh_size;\n\n"); ! 734: ! 735: fprintf(file, ! 736: "\tif ((OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX) ||\n"); ! 737: if (rt->rtNoReplyArgs) ! 738: fprintf(file, "\t (OutP->Head.msgh_size != %d))\n", ! 739: rt->rtReplySize); ! 740: else { ! 741: fprintf(file, "\t ((msgh_size %s %d) &&\n", ! 742: (rt->rtNumReplyVar > 0) ? "<" : "!=", ! 743: rt->rtReplySize); ! 744: fprintf(file, "\t ((msgh_size != sizeof(mig_reply_header_t)) ||\n"); ! 745: fprintf(file, "\t (OutP->RetCode == KERN_SUCCESS))))\n"); ! 746: } ! 747: } ! 748: else { ! 749: /* Expecting a complex message, or may vary at run time. */ ! 750: ! 751: fprintf(file, "\tmsgh_size = OutP->Head.msgh_size;\n"); ! 752: fprintf(file, "\tmsgh_simple = !(OutP->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX);\n"); ! 753: fprintf(file, "\n"); ! 754: ! 755: fprintf(file, "\tif (((msgh_size %s %d)", ! 756: (rt->rtNumReplyVar > 0) ? "<" : "!=", ! 757: rt->rtReplySize); ! 758: ! 759: if (rt->rtSimpleCheckReply) ! 760: /* if rtSimpleReceiveReply was true, then we would have ! 761: executed the code above. So we know that the message ! 762: is complex. */ ! 763: fprintf(file, " || msgh_simple"); ! 764: fprintf(file, ") &&\n"); ! 765: ! 766: fprintf(file, "\t ((msgh_size != sizeof(mig_reply_header_t)) ||\n"); ! 767: fprintf(file, "\t !msgh_simple ||\n"); ! 768: fprintf(file, "\t (OutP->RetCode == KERN_SUCCESS)))\n"); ! 769: } ! 770: WriteMsgError(file, rt, "MIG_TYPE_ERROR"); ! 771: fprintf(file, "#endif\t/* TypeCheck */\n"); ! 772: fprintf(file, "\n"); ! 773: } ! 774: ! 775: /************************************************************* ! 776: * Write code to generate error handling code if the RetCode ! 777: * argument of a Routine is not KERN_SUCCESS. ! 778: *************************************************************/ ! 779: static void ! 780: WriteRetCodeCheck(FILE *file, const routine_t *rt) ! 781: { ! 782: fprintf(file, "\tif (OutP->RetCode != KERN_SUCCESS)\n"); ! 783: WriteMsgError(file, rt, "OutP->RetCode"); ! 784: fprintf(file, "\n"); ! 785: } ! 786: ! 787: /************************************************************* ! 788: * Writes code to check that the type of each of the arguments ! 789: * in the reply message is what is expected. Called by ! 790: * WriteRoutine for each argument in the reply message. ! 791: *************************************************************/ ! 792: static void ! 793: WriteTypeCheck(FILE *file, register const argument_t *arg) ! 794: { ! 795: register const ipc_type_t *it = arg->argType; ! 796: register const routine_t *rt = arg->argRoutine; ! 797: ! 798: fprintf(file, "#if\tTypeCheck\n"); ! 799: if (akCheck(arg->argKind, akbReplyQC)) ! 800: { ! 801: fprintf(file, "\tif (* (int *) &OutP->%s != * (int *) &%sCheck)\n", ! 802: arg->argTTName, arg->argVarName); ! 803: } ! 804: else ! 805: { ! 806: fprintf(file, "\tif ("); ! 807: if (!it->itIndefinite) { ! 808: fprintf(file, "(OutP->%s%s.msgt_inline != %s) ||\n\t ", ! 809: arg->argTTName, ! 810: arg->argLongForm ? ".msgtl_header" : "", ! 811: strbool(it->itInLine)); ! 812: } ! 813: fprintf(file, "(OutP->%s%s.msgt_longform != %s) ||\n", ! 814: arg->argTTName, ! 815: arg->argLongForm ? ".msgtl_header" : "", ! 816: strbool(arg->argLongForm)); ! 817: if (it->itOutName == MACH_MSG_TYPE_POLYMORPHIC) ! 818: { ! 819: if (!rt->rtSimpleCheckReply) ! 820: fprintf(file, "\t (MACH_MSG_TYPE_PORT_ANY(OutP->%s.msgt%s_name) && msgh_simple) ||\n", ! 821: arg->argTTName, ! 822: arg->argLongForm ? "l" : ""); ! 823: } ! 824: else ! 825: fprintf(file, "\t (OutP->%s.msgt%s_name != %s) ||\n", ! 826: arg->argTTName, ! 827: arg->argLongForm ? "l" : "", ! 828: it->itOutNameStr); ! 829: if (!it->itVarArray) ! 830: fprintf(file, "\t (OutP->%s.msgt%s_number != %d) ||\n", ! 831: arg->argTTName, ! 832: arg->argLongForm ? "l" : "", ! 833: it->itNumber); ! 834: fprintf(file, "\t (OutP->%s.msgt%s_size != %d))\n", ! 835: arg->argTTName, ! 836: arg->argLongForm ? "l" : "", ! 837: it->itSize); ! 838: } ! 839: WriteMsgError(file, rt, "MIG_TYPE_ERROR"); ! 840: fprintf(file, "#endif\t/* TypeCheck */\n"); ! 841: fprintf(file, "\n"); ! 842: } ! 843: ! 844: static void ! 845: WriteCheckArgSize(FILE *file, register const argument_t *arg) ! 846: { ! 847: register const ipc_type_t *ptype = arg->argType; ! 848: register const ipc_type_t *btype = ptype->itElement; ! 849: const argument_t *count = arg->argCount; ! 850: int multiplier = btype->itTypeSize / btype->itNumber; ! 851: ! 852: if (ptype->itIndefinite) { ! 853: /* ! 854: * Check descriptor. If out-of-line, use standard size. ! 855: */ ! 856: fprintf(file, "(OutP->%s%s.msgt_inline) ? ", ! 857: arg->argTTName, arg->argLongForm ? ".msgtl_header" : ""); ! 858: } ! 859: ! 860: if (btype->itTypeSize % 4 != 0) ! 861: fprintf(file, "("); ! 862: ! 863: if (multiplier > 1) ! 864: fprintf(file, "%d * ", multiplier); ! 865: ! 866: fprintf(file, "OutP->%s", count->argMsgField); ! 867: ! 868: /* If the base type size of the data field isn`t a multiple of 4, ! 869: we have to round up. */ ! 870: if (btype->itTypeSize % 4 != 0) ! 871: fprintf(file, " + 3) & ~3"); ! 872: ! 873: if (ptype->itIndefinite) ! 874: fprintf(file, " : sizeof(%s *)", FetchUserType(btype)); ! 875: } ! 876: ! 877: static void ! 878: WriteCheckMsgSize(FILE *file, register const argument_t *arg) ! 879: { ! 880: register const routine_t *rt = arg->argRoutine; ! 881: ! 882: /* If there aren't any more Out args after this, then ! 883: we can use the msgh_size_delta value directly in ! 884: the TypeCheck conditional. */ ! 885: ! 886: if (arg->argReplyPos == rt->rtMaxReplyPos) ! 887: { ! 888: fprintf(file, "#if\tTypeCheck\n"); ! 889: fprintf(file, "\tif (msgh_size != %d + (", ! 890: rt->rtReplySize); ! 891: WriteCheckArgSize(file, arg); ! 892: fprintf(file, "))\n"); ! 893: ! 894: WriteMsgError(file, rt, "MIG_TYPE_ERROR"); ! 895: fprintf(file, "#endif\t/* TypeCheck */\n"); ! 896: } ! 897: else ! 898: { ! 899: /* If there aren't any more variable-sized arguments after this, ! 900: then we must check for exact msg-size and we don't need ! 901: to update msgh_size. */ ! 902: ! 903: boolean_t LastVarArg = arg->argReplyPos+1 == rt->rtNumReplyVar; ! 904: ! 905: /* calculate the actual size in bytes of the data field. note ! 906: that this quantity must be a multiple of four. hence, if ! 907: the base type size isn't a multiple of four, we have to ! 908: round up. note also that btype->itNumber must ! 909: divide btype->itTypeSize (see itCalculateSizeInfo). */ ! 910: ! 911: fprintf(file, "\tmsgh_size_delta = "); ! 912: WriteCheckArgSize(file, arg); ! 913: fprintf(file, ";\n"); ! 914: fprintf(file, "#if\tTypeCheck\n"); ! 915: ! 916: /* Don't decrement msgh_size until we've checked that ! 917: it won't underflow. */ ! 918: ! 919: if (LastVarArg) ! 920: fprintf(file, "\tif (msgh_size != %d + msgh_size_delta)\n", ! 921: rt->rtReplySize); ! 922: else ! 923: fprintf(file, "\tif (msgh_size < %d + msgh_size_delta)\n", ! 924: rt->rtReplySize); ! 925: WriteMsgError(file, rt, "MIG_TYPE_ERROR"); ! 926: ! 927: if (!LastVarArg) ! 928: fprintf(file, "\tmsgh_size -= msgh_size_delta;\n"); ! 929: ! 930: fprintf(file, "#endif\t/* TypeCheck */\n"); ! 931: } ! 932: fprintf(file, "\n"); ! 933: } ! 934: ! 935: /************************************************************* ! 936: * Write code to copy an argument from the reply message ! 937: * to the parameter. Called by WriteRoutine for each argument ! 938: * in the reply message. ! 939: *************************************************************/ ! 940: static void ! 941: WriteExtractArgValue(FILE *file, register const argument_t *arg) ! 942: { ! 943: register const ipc_type_t *argType = arg->argType; ! 944: register const char *ref = arg->argByReferenceUser ? "*" : ""; ! 945: ! 946: if (argType->itInLine && argType->itVarArray) { ! 947: ! 948: if (argType->itString) { ! 949: /* ! 950: * Copy out variable-size C string with mig_strncpy. ! 951: */ ! 952: fprintf(file, "\t(void) %smig_strncpy(%s%s, OutP->%s, %d);\n", ! 953: SubrPrefix, ! 954: ref, ! 955: arg->argVarName, ! 956: arg->argMsgField, ! 957: argType->itNumber); ! 958: } ! 959: else if (argType->itIndefinite) { ! 960: /* ! 961: * If data was returned out-of-line, ! 962: * change user`s pointer to point to it. ! 963: * If data was returned in-line but doesn`t fit, ! 964: * allocate a new buffer, copy the data to it, ! 965: * and change user`s pointer to point to it. ! 966: * If data was returned in-line and fits, ! 967: * copy to buffer. ! 968: */ ! 969: const argument_t *count = arg->argCount; ! 970: const char *countRef = count->argByReferenceUser ? "*" : ""; ! 971: const ipc_type_t *btype = argType->itElement; ! 972: ! 973: fprintf(file, "\tif (!OutP->%s%s.msgt_inline)\n", ! 974: arg->argTTName, ! 975: arg->argLongForm ? ".msgtl_header" : ""); ! 976: fprintf(file, "\t %s%s = *((%s **)OutP->%s);\n", ! 977: ref, arg->argVarName, ! 978: FetchUserType(btype), arg->argMsgField); ! 979: fprintf(file, "\telse if (OutP->%s", count->argMsgField); ! 980: if (btype->itNumber > 1) ! 981: fprintf(file, " / %d", btype->itNumber); ! 982: fprintf(file, " > %s%s) {\n", countRef, count->argVarName); ! 983: fprintf(file, "\t %smig_allocate((vm_offset_t *)%s,\n\t\t", ! 984: SubrPrefix, arg->argVarName); /* no ref! */ ! 985: if (btype->itTypeSize != btype->itNumber) ! 986: fprintf(file, "%d * ", btype->itTypeSize/btype->itNumber); ! 987: fprintf(file, "OutP->%s);\n", count->argMsgField); ! 988: fprintf(file, "\t memcpy(%s%s, OutP->%s, ", ref, arg->argVarName, ! 989: arg->argMsgField); ! 990: if (btype->itTypeSize != btype->itNumber) ! 991: fprintf(file, "%d * ", btype->itTypeSize/btype->itNumber); ! 992: fprintf(file, "OutP->%s);\n", count->argMsgField); ! 993: fprintf(file, "\t}\n"); ! 994: fprintf(file, "\telse {\n"); ! 995: ! 996: fprintf(file, "\t memcpy(%s%s, OutP->%s, ", ref, arg->argVarName, ! 997: arg->argMsgField); ! 998: if (btype->itTypeSize != btype->itNumber) ! 999: fprintf(file, "%d * ", btype->itTypeSize/btype->itNumber); ! 1000: fprintf(file, "OutP->%s);\n", count->argMsgField); ! 1001: fprintf(file, "\t}\n"); ! 1002: } ! 1003: else { ! 1004: ! 1005: /* ! 1006: * Copy out variable-size inline array with memcpy, ! 1007: * after checking that number of elements doesn`t ! 1008: * exceed user`s maximum. ! 1009: */ ! 1010: register const argument_t *count = arg->argCount; ! 1011: register const char *countRef = count->argByReferenceUser ? "*" :""; ! 1012: register const ipc_type_t *btype = argType->itElement; ! 1013: ! 1014: /* Note count->argMultiplier == btype->itNumber */ ! 1015: ! 1016: fprintf(file, "\tif (OutP->%s", count->argMsgField); ! 1017: if (btype->itNumber > 1) ! 1018: fprintf(file, " / %d", btype->itNumber); ! 1019: fprintf(file, " > %s%s) {\n", ! 1020: countRef, count->argVarName); ! 1021: ! 1022: /* ! 1023: * If number of elements is too many for user receiving area, ! 1024: * fill user`s area as much as possible. Return the correct ! 1025: * number of elements. ! 1026: */ ! 1027: fprintf(file, "\t\tmemcpy(%s%s, OutP->%s, ", ref, arg->argVarName, ! 1028: arg->argMsgField); ! 1029: if (btype->itTypeSize > 1) ! 1030: fprintf(file, "%d * ", btype->itTypeSize); ! 1031: fprintf(file, "%s%s);\n", ! 1032: countRef, count->argVarName); ! 1033: ! 1034: fprintf(file, "\t\t%s%s = OutP->%s", ! 1035: countRef, count->argVarName, count->argMsgField); ! 1036: if (btype->itNumber > 1) ! 1037: fprintf(file, " / %d", btype->itNumber); ! 1038: fprintf(file, ";\n"); ! 1039: WriteMsgError(file,arg->argRoutine, "MIG_ARRAY_TOO_LARGE"); ! 1040: ! 1041: fprintf(file, "\t}\n\telse {\n"); ! 1042: ! 1043: fprintf(file, "\t\tmemcpy(%s%s, OutP->%s, ", ref, arg->argVarName, ! 1044: arg->argMsgField); ! 1045: if (btype->itTypeSize != btype->itNumber) ! 1046: fprintf(file, "%d * ", btype->itTypeSize/btype->itNumber); ! 1047: fprintf(file, "OutP->%s);\n", count->argMsgField); ! 1048: fprintf(file, "\t}\n"); ! 1049: } ! 1050: } ! 1051: else if (arg->argMultiplier > 1) ! 1052: WriteCopyType(file, argType, ! 1053: "%s%s", "/* %s%s */ OutP->%s / %d", ! 1054: ref, arg->argVarName, arg->argMsgField, ! 1055: arg->argMultiplier); ! 1056: else ! 1057: WriteCopyType(file, argType, ! 1058: "%s%s", "/* %s%s */ OutP->%s", ! 1059: ref, arg->argVarName, arg->argMsgField); ! 1060: fprintf(file, "\n"); ! 1061: } ! 1062: ! 1063: static void ! 1064: WriteExtractArg(FILE *file, register const argument_t *arg) ! 1065: { ! 1066: register const routine_t *rt = arg->argRoutine; ! 1067: ! 1068: if (akCheck(arg->argKind, akbReply)) ! 1069: WriteTypeCheck(file, arg); ! 1070: ! 1071: if (akCheckAll(arg->argKind, akbVariable|akbReply)) ! 1072: WriteCheckMsgSize(file, arg); ! 1073: ! 1074: /* Now that the RetCode is type-checked, check its value. ! 1075: Must abort immediately if it isn't KERN_SUCCESS, because ! 1076: in that case the reply message is truncated. */ ! 1077: ! 1078: if (arg == rt->rtRetCode) ! 1079: WriteRetCodeCheck(file, rt); ! 1080: ! 1081: if (akCheckAll(arg->argKind, akbReturnRcv)) ! 1082: WriteExtractArgValue(file, arg); ! 1083: } ! 1084: ! 1085: static void ! 1086: WriteAdjustReplyMsgPtr(FILE *file, register const argument_t *arg) ! 1087: { ! 1088: register const ipc_type_t *ptype = arg->argType; ! 1089: ! 1090: fprintf(file, ! 1091: "\tOutP = (Reply *) ((char *) OutP + msgh_size_delta - %d);\n\n", ! 1092: ptype->itTypeSize + ptype->itPadSize); ! 1093: } ! 1094: ! 1095: static void ! 1096: WriteReplyArgs(FILE *file, register const routine_t *rt) ! 1097: { ! 1098: register const argument_t *arg; ! 1099: register const argument_t *lastVarArg; ! 1100: ! 1101: lastVarArg = argNULL; ! 1102: for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) { ! 1103: ! 1104: /* ! 1105: * Advance message pointer if the last reply argument was ! 1106: * variable-length and the reply position will change. ! 1107: */ ! 1108: if (lastVarArg != argNULL && ! 1109: lastVarArg->argReplyPos < arg->argReplyPos) ! 1110: { ! 1111: WriteAdjustReplyMsgPtr(file, lastVarArg); ! 1112: lastVarArg = argNULL; ! 1113: } ! 1114: ! 1115: /* ! 1116: * Copy the argument ! 1117: */ ! 1118: WriteExtractArg(file, arg); ! 1119: ! 1120: /* ! 1121: * Remember whether this was variable-length. ! 1122: */ ! 1123: if (akCheckAll(arg->argKind, akbReturnRcv|akbVariable)) ! 1124: lastVarArg = arg; ! 1125: } ! 1126: } ! 1127: ! 1128: /************************************************************* ! 1129: * Writes code to return the return value. Called by WriteRoutine ! 1130: * for routines and functions. ! 1131: *************************************************************/ ! 1132: static void ! 1133: WriteReturnValue(FILE *file, const routine_t *rt) ! 1134: { ! 1135: if (rt->rtReturn == rt->rtRetCode) ! 1136: /* If returning RetCode, we have already checked that it is ! 1137: KERN_SUCCESS */ ! 1138: fprintf(file, "\treturn KERN_SUCCESS;\n"); ! 1139: ! 1140: else ! 1141: { ! 1142: if (rt->rtNumReplyVar > 0) ! 1143: fprintf(file, "\tOutP = &Mess.Out;\n"); ! 1144: ! 1145: fprintf(file, "\treturn OutP->%s;\n", rt->rtReturn->argMsgField); ! 1146: } ! 1147: } ! 1148: ! 1149: /************************************************************* ! 1150: * Writes the elements of the message type declaration: the ! 1151: * msg_type structure, the argument itself and any padding ! 1152: * that is required to make the argument a multiple of 4 bytes. ! 1153: * Called by WriteRoutine for all the arguments in the request ! 1154: * message first and then the reply message. ! 1155: *************************************************************/ ! 1156: static void ! 1157: WriteFieldDecl(FILE *file, const argument_t *arg) ! 1158: { ! 1159: WriteFieldDeclPrim(file, arg, FetchUserType); ! 1160: } ! 1161: ! 1162: static void ! 1163: WriteStubDecl(FILE *file, register const routine_t *rt) ! 1164: { ! 1165: fprintf(file, "\n"); ! 1166: fprintf(file, "/* %s %s */\n", rtRoutineKindToStr(rt->rtKind), rt->rtName); ! 1167: fprintf(file, "mig_external %s %s\n", ReturnTypeStr(rt), rt->rtUserName); ! 1168: fprintf(file, "(\n"); ! 1169: WriteList(file, rt->rtArgs, WriteUserVarDecl, akbUserArg, ",\n", "\n"); ! 1170: fprintf(file, ")\n"); ! 1171: fprintf(file, "{\n"); ! 1172: } ! 1173: ! 1174: /************************************************************* ! 1175: * Writes all the code comprising a routine body. Called by ! 1176: * WriteUser for each routine. ! 1177: *************************************************************/ ! 1178: static void ! 1179: WriteRoutine(FILE *file, register const routine_t *rt) ! 1180: { ! 1181: /* write the stub's declaration */ ! 1182: ! 1183: WriteStubDecl(file, rt); ! 1184: ! 1185: /* typedef of structure for Request and Reply messages */ ! 1186: ! 1187: WriteStructDecl(file, rt->rtArgs, WriteFieldDecl, akbRequest, "Request"); ! 1188: if (!rt->rtOneWay) ! 1189: WriteStructDecl(file, rt->rtArgs, WriteFieldDecl, akbReply, "Reply"); ! 1190: ! 1191: /* declarations for local vars: Union of Request and Reply messages, ! 1192: InP, OutP and return value */ ! 1193: ! 1194: WriteVarDecls(file, rt); ! 1195: ! 1196: /* declarations and initializations of the mach_msg_type_t variables ! 1197: for each argument */ ! 1198: ! 1199: WriteList(file, rt->rtArgs, WriteTypeDeclIn, akbRequest, "\n", "\n"); ! 1200: if (!rt->rtOneWay) ! 1201: WriteList(file, rt->rtArgs, WriteCheckDecl, akbReplyQC, "\n", "\n"); ! 1202: ! 1203: /* fill in all the request message types and then arguments */ ! 1204: ! 1205: WriteRequestArgs(file, rt); ! 1206: ! 1207: /* fill in request message head */ ! 1208: ! 1209: WriteRequestHead(file, rt); ! 1210: fprintf(file, "\n"); ! 1211: ! 1212: /* Write the send/receive or rpc call */ ! 1213: ! 1214: if (rt->rtOneWay) ! 1215: WriteMsgSend(file, rt); ! 1216: else ! 1217: { ! 1218: if (UseMsgRPC) ! 1219: WriteMsgRPC(file, rt); ! 1220: else ! 1221: WriteMsgSendReceive(file, rt); ! 1222: ! 1223: /* Check the values that are returned in the reply message */ ! 1224: ! 1225: WriteCheckIdentity(file, rt); ! 1226: ! 1227: /* If the reply message has no Out parameters or return values ! 1228: other than the return code, we can type-check it and ! 1229: return it directly. */ ! 1230: ! 1231: if (rt->rtNoReplyArgs) ! 1232: { ! 1233: WriteTypeCheck(file, rt->rtRetCode); ! 1234: ! 1235: fprintf(file, "\treturn OutP->RetCode;\n"); ! 1236: } ! 1237: else { ! 1238: WriteReplyArgs(file, rt); ! 1239: ! 1240: /* return the return value, if any */ ! 1241: ! 1242: if (rt->rtProcedure) ! 1243: fprintf(file, "\t/* Procedure - no return needed */\n"); ! 1244: else ! 1245: WriteReturnValue(file, rt); ! 1246: } ! 1247: } ! 1248: ! 1249: fprintf(file, "}\n"); ! 1250: } ! 1251: ! 1252: /************************************************************* ! 1253: * Writes out the xxxUser.c file. Called by mig.c ! 1254: *************************************************************/ ! 1255: void ! 1256: WriteUser(FILE *file, const statement_t *stats) ! 1257: { ! 1258: register const statement_t *stat; ! 1259: ! 1260: WriteProlog(file); ! 1261: for (stat = stats; stat != stNULL; stat = stat->stNext) ! 1262: switch (stat->stKind) ! 1263: { ! 1264: case skRoutine: ! 1265: WriteRoutine(file, stat->stRoutine); ! 1266: break; ! 1267: case skImport: ! 1268: case skUImport: ! 1269: WriteImport(file, stat->stFileName); ! 1270: break; ! 1271: case skSImport: ! 1272: break; ! 1273: default: ! 1274: fatal("WriteUser(): bad statement_kind_t (%d)", ! 1275: (int) stat->stKind); ! 1276: } ! 1277: WriteEpilog(file); ! 1278: } ! 1279: ! 1280: /************************************************************* ! 1281: * Writes out individual .c user files for each routine. Called by mig.c ! 1282: *************************************************************/ ! 1283: void ! 1284: WriteUserIndividual(const statement_t *stats) ! 1285: { ! 1286: register const statement_t *stat; ! 1287: ! 1288: for (stat = stats; stat != stNULL; stat = stat->stNext) ! 1289: switch (stat->stKind) ! 1290: { ! 1291: case skRoutine: ! 1292: { ! 1293: FILE *file; ! 1294: register char *filename; ! 1295: ! 1296: filename = strconcat(UserFilePrefix, ! 1297: strconcat(stat->stRoutine->rtName, ".c")); ! 1298: file = fopen(filename, "w"); ! 1299: if (file == NULL) ! 1300: fatal("fopen(%s): %s", filename, ! 1301: unix_error_string(errno)); ! 1302: WriteProlog(file); ! 1303: ! 1304: { ! 1305: /* Write all the imports. */ ! 1306: const statement_t *s; ! 1307: for (s = stats; s != stNULL; s = s->stNext) ! 1308: switch (s->stKind) ! 1309: { ! 1310: case skImport: ! 1311: case skUImport: ! 1312: WriteImport(file, s->stFileName); ! 1313: break; ! 1314: } ! 1315: } ! 1316: ! 1317: WriteRoutine(file, stat->stRoutine); ! 1318: WriteEpilog(file); ! 1319: fclose(file); ! 1320: strfree(filename); ! 1321: } ! 1322: break; ! 1323: case skImport: ! 1324: case skUImport: ! 1325: break; ! 1326: case skSImport: ! 1327: break; ! 1328: default: ! 1329: fatal("WriteUserIndividual(): bad statement_kind_t (%d)", ! 1330: (int) stat->stKind); ! 1331: } ! 1332: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.