bootstrap_cmds/migcom.tproj/routine.c

bootstrap_cmds source @ c71d2d7 2025-04-30 · 1892 lines · view on GitHub
1/*
* Copyright (c) 1999-2018 Apple Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
23/*
* Mach Operating System
* Copyright (c) 1991,1990 Carnegie Mellon University
* All Rights Reserved.
*
* Permission to use, copy, modify and distribute this software and its
* documentation is hereby granted, provided that both the copyright
* notice and this permission notice appear in all copies of the
* software, derivative works or modified versions, and any portions
* thereof, and that both notices appear in supporting documentation.
*
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
* CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
* ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
*
* Carnegie Mellon requests users of this software to return to
*
*  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
*  School of Computer Science
*  Carnegie Mellon University
*  Pittsburgh PA 15213-3890
*
* any improvements or extensions that they make and grant Carnegie Mellon
* the rights to redistribute these changes.
*/
48
49#include "type.h"
50
51#include <mach/message.h>
52#include <mach/kern_return.h>
53#include "mig_machine.h"
54#include "error.h"
55#include "alloc.h"
56#include "global.h"
57#include "routine.h"
58#include "write.h"
59
60u_int rtNumber = 0;
61
62static void rtSizeDelta(FILE *file, u_int mask, routine_t *rt);
63
64routine_t *
65rtAlloc(void)
66{
routine_t *new;
68
new = (routine_t *) calloc(1, sizeof *new);
if (new == rtNULL)
  fatal("rtAlloc(): %s", strerror(errno));
new->rtNumber = rtNumber++;
new->rtName = strNULL;
new->rtErrorName = strNULL;
new->rtUserName = strNULL;
new->rtServerName = strNULL;
77
return new;
79}
80
81void
82rtSkip(void)
83{
rtNumber++;
85}
86
87argument_t *
88argAlloc(void)
89{
extern void KPD_error(FILE *file, argument_t *arg);
91
static argument_t prototype =
{
  .argName = strNULL,
  .argNext = argNULL,
  .argKind = akNone,
  .argType = itNULL,
  .argKPD_Type = argKPD_NULL,
  .argKPD_Template = (void(*)(FILE *, argument_t *, boolean_t))KPD_error,
  .argKPD_Init = KPD_error,
  .argKPD_Pack = KPD_error,
  .argKPD_Extract = KPD_error,
  .argKPD_TypeCheck = KPD_error,
  .argVarName = strNULL,
  .argMsgField = strNULL,
  .argTTName = strNULL,
  .argPadName = strNULL,
  .argSuffix = strNULL,
  .argFlags = flNone,
  .argDeallocate = d_NO,
  .argCountInOut = FALSE,
  .argRoutine = rtNULL,
  .argCount = argNULL,
  .argSubCount = argNULL,
  .argCInOut = argNULL,
  .argPoly = argNULL,
  .argDealloc = argNULL,
  .argSameCount = argNULL,
  .argParent = argNULL,
  .argMultiplier = 1,
  .argRequestPos = 0,
  .argReplyPos = 0,
  .argByReferenceUser = FALSE,
  .argByReferenceServer = FALSE,
  .argTempOnStack = FALSE,
  .argInSegment = NULL,
  .argOutSegment = NULL,
};
argument_t *new;
130
new = (argument_t *) malloc(sizeof *new);
if (new == argNULL)
  fatal("argAlloc(): %s", strerror(errno));
*new = prototype;
return new;
136}
137
138routine_t *
139rtMakeRoutine(identifier_t name, argument_t *args)
140{
routine_t *rt = rtAlloc();
142
rt->rtName = name;
rt->rtKind = rkRoutine;
rt->rtArgs = args;
146
return rt;
148}
149
150routine_t *
151rtMakeSimpleRoutine(identifier_t name, argument_t *args)
152{
routine_t *rt = rtAlloc();
154
rt->rtName = name;
rt->rtKind = rkSimpleRoutine;
rt->rtArgs = args;
158
return rt;
160}
161
162char *
163rtRoutineKindToStr(routine_kind_t rk)
164{
switch (rk) {
166
  case rkRoutine:
    return "Routine";
169
  case rkSimpleRoutine:
    return "SimpleRoutine";
172
  default:
    fatal("rtRoutineKindToStr(%d): not a routine_kind_t", rk);
    /*NOTREACHED*/
    return strNULL;
}
178}
179
180static void
181rtPrintArg(argument_t *arg)
182{
ipc_type_t *it = arg->argType;
184
if (!akCheck(arg->argKind, akbUserArg|akbServerArg) ||
    (akIdent(arg->argKind) == akeCount) ||
    (akIdent(arg->argKind) == akeDealloc) ||
    (akIdent(arg->argKind) == akeNdrCode) ||
    (akIdent(arg->argKind) == akePoly))
  return;
191
printf("\n\t");
193
switch (akIdent(arg->argKind)) {
195
  case akeRequestPort:
    printf("RequestPort");
    break;
199
  case akeReplyPort:
    printf("ReplyPort");
    break;
203
  case akeWaitTime:
    printf("WaitTime");
    break;
207
  case akeSendTime:
    printf("SendTime");
    break;
211
  case akeMsgOption:
    printf("MsgOption");
    break;
215
  case akeMsgSeqno:
    printf("MsgSeqno\t");
    break;
219
  case akeSecToken:
    printf("SecToken\t");
    break;
223
  case akeAuditToken:
    printf("AuditToken\t");
    break;
227
  case akeContextToken:
    printf("ContextToken\t");
    break;
231
  case akeImplicit:
    printf("Implicit\t");
    break;
235
  default:
    if (akCheck(arg->argKind, akbRequest)) {
      if (akCheck(arg->argKind, akbSend))
        printf("In");
      else
        printf("(In)");
    }
    if (akCheck(arg->argKind, akbReply)) {
      if (akCheck(arg->argKind, akbReturn))
        printf("Out");
      else
        printf("(Out)");
    }
    printf("\t");
}
251
printf("\t%s: %s", arg->argName, it->itName);
253
if (arg->argDeallocate == d_YES)
  printf(", Dealloc");
else if (arg->argDeallocate == d_MAYBE)
  printf(", Dealloc[]");
258
if (arg->argCountInOut)
  printf(", CountInOut");
261
if (arg->argFlags & flSameCount)
  printf(", SameCount");
264
if (arg->argFlags & flPhysicalCopy)
  printf(", PhysicalCopy");
267
if (arg->argFlags & flRetCode)
  printf(", PhysicalCopy");
270
if (arg->argFlags & flOverwrite)
  printf(", Overwrite");
273
if (arg->argFlags & flAuto)
  printf(", Auto");
276
if (arg->argFlags & flConst)
  printf(", Const");
279}
280
281void
282rtPrintRoutine(routine_t *rt)
283{
argument_t *arg;
285
printf("%s (%d) %s(", rtRoutineKindToStr(rt->rtKind), rt->rtNumber, rt->rtName);
287
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
  rtPrintArg(arg);
290
printf(")\n");
printf("\n");
293}
294
295/*
* Determines appropriate value of msg-simple for the message.
* One version for both In & Out.
*/
299
300static void
301rtCheckSimple(argument_t *args, u_int mask, boolean_t *simple)
302{
argument_t *arg;
boolean_t MustBeComplex = FALSE;
305
for (arg = args; arg != argNULL; arg = arg->argNext)
  if (akCheck(arg->argKind, mask)) {
    ipc_type_t *it = arg->argType;
309
    if (IS_KERN_PROC_DATA(it))
      MustBeComplex = TRUE;
  }
313
*simple = !MustBeComplex;
315}
316
317static void
318rtCheckFit(routine_t *rt, u_int mask, boolean_t *fitp, boolean_t *uselimp, u_int *knownp)
319{
boolean_t uselim = FALSE;
argument_t *arg;
u_int size = sizeof(mach_msg_header_t);
323
if (!rt->rtSimpleRequest)
  machine_alignment(size,sizeof(mach_msg_body_t));
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
  if (akCheck(arg->argKind, mask)) {
    ipc_type_t *it = arg->argType;
329
    machine_alignment(size, it->itMinTypeSize);
    if (it->itNative)
      uselim = TRUE;
    else if (IS_VARIABLE_SIZED_UNTYPED(it)) {
      machine_alignment(size, it->itTypeSize);
      size += it->itPadSize;
    }
  }
*knownp = size;
if (MaxMessSizeOnStack == -1) {
  *fitp = TRUE;
  *uselimp = FALSE;
}
else if (size > MaxMessSizeOnStack) {
  *fitp = FALSE;
  *uselimp = FALSE;
}
else if (!uselim) {
  *fitp = TRUE;
  *uselimp = FALSE;
}
else if (UserTypeLimit == -1) {
  *fitp = FALSE;
  *uselimp = FALSE;
}
else if (size + UserTypeLimit > MaxMessSizeOnStack) {
  *fitp = FALSE;
  *uselimp = TRUE;
}
else {
  *fitp = TRUE;
  *uselimp = TRUE;
}
363}
364
365static void
366rtFindHowMany(routine_t *rt)
367{
argument_t *arg;
int multiplier = 1;
boolean_t test;
371
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  ipc_type_t *it = arg->argType;
374
  if (IS_MULTIPLE_KPD(it)) {
    if (!it->itVarArray)
      multiplier = it->itKPD_Number;
    test = !it->itVarArray && !it->itElement->itVarArray;
    it = it->itElement;
  }
  else
    test = !it->itVarArray;
383
  if (akCheck(arg->argKind, akbSendKPD)) {
385
    if (it->itInLine)
      rt->rtCountPortsIn += it->itNumber * multiplier;
    else if (it->itPortType) {
      if (test)
        rt->rtCountOolPortsIn += it->itNumber * multiplier;
    }
    else {
      if (test)
        rt->rtCountOolIn += (it->itNumber * it->itSize + 7)/8 * multiplier;
    }
  }
  if (akCheckAll(arg->argKind, akbReturnKPD)) {
    if (it->itInLine)
      rt->rtCountPortsOut += it->itNumber * multiplier;
    else if (it->itPortType) {
      if (test)
        rt->rtCountOolPortsOut += it->itNumber * multiplier;
    }
    else {
      if (test)
        rt->rtCountOolOut += ((it->itNumber * it->itSize + 7)/8) * multiplier;
    }
  }
}
410}
411
412boolean_t
413rtCheckMask(argument_t *args, u_int mask)
414{
argument_t *arg;
416
for (arg = args; arg != argNULL; arg = arg->argNext)
  if (akCheckAll(arg->argKind, mask))
    return TRUE;
return FALSE;
421}
422
423boolean_t
424rtCheckMaskFunction(argument_t *args, u_int mask, boolean_t (*func)(argument_t *arg))
425{
argument_t *arg;
427
for (arg = args; arg != argNULL; arg = arg->argNext)
  if (akCheckAll(arg->argKind, mask))
    if ((*func)(arg))
      return TRUE;
return FALSE;
433}
434
435
436int
437rtCountKPDs(argument_t *args, u_int mask)
438{
argument_t *arg;
int count = 0;
441
for (arg = args; arg != argNULL; arg = arg->argNext)
  if (akCheckAll(arg->argKind, mask))
    count += arg->argType->itKPD_Number;
return count;
446}
447
448int
449rtCountFlags(argument_t *args, u_int flag)
450{
argument_t *arg;
int count = 0;
453
for (arg = args; arg != argNULL; arg = arg->argNext)
  if (arg->argFlags & flag)
    count++;
return count;
458}
459
460int
461rtCountArgDescriptors(argument_t *args, int *argcount)
462{
argument_t *arg;
int count = 0;
465
if (argcount)
  *argcount = 0;
for (arg = args; arg != argNULL; arg = arg->argNext)
  if (akCheck(arg->argKind, akbServerArg)) {
    if (RPCFixedArray(arg) ||
        RPCPort(arg) ||
        RPCVariableArray(arg) ||
        RPCPortArray(arg)) {
      count++;
      if (argcount)
        (*argcount)++;
    }
    else {
      if (argcount) {
        if (arg->argType->itStruct && arg->argType->itNumber &&
            (arg->argType->itSize >= 32))
          *argcount += arg->argType->itNumber * (arg->argType->itSize / 32);
        else
          (*argcount)++;
      }
    }
  }
return count;
489}
490
491int
492rtCountMask(argument_t *args, u_int mask)
493{
argument_t *arg;
int count = 0;
496
for (arg = args; arg != argNULL; arg = arg->argNext)
  if (akCheckAll(arg->argKind, mask))
    count++;
return count;
501}
502
503/* arg->argType may be NULL in this function */
504
505static void
506rtDefaultArgKind(routine_t *rt, argument_t *arg)
507{
if ((arg->argKind == akNone) && (rt->rtRequestPort == argNULL))
  arg->argKind = akRequestPort;
510
if (arg->argKind == akNone)
  arg->argKind = akIn;
513}
514
515/*
* Initializes arg->argDeallocate,
* arg->argCountInOut from arg->argFlags
* and perform consistency check over the
* flags.
*/
521
522static ipc_flags_t
523rtProcessDeallocFlag(ipc_type_t *it, ipc_flags_t flags, arg_kind_t kind, dealloc_t *what, string_t name)
524{
525
/* only one of flDealloc, flNotDealloc, flMaybeDealloc */
527
if (flags & flMaybeDealloc) {
  if (flags & (flDealloc|flNotDealloc)) {
    warn("%s: Dealloc and NotDealloc ignored with Dealloc[]", name);
    flags &= ~(flDealloc|flNotDealloc);
  }
}
534
if ((flags&(flDealloc|flNotDealloc)) == (flDealloc|flNotDealloc)) {
  warn("%s: Dealloc and NotDealloc cancel out", name);
  flags &= ~(flDealloc|flNotDealloc);
}
539
if (((IsKernelServer && akCheck(kind, akbReturn)) ||
     (IsKernelUser && akCheck(kind, akbSend))) &&
    (flags & flDealloc)) {
  /*
   *  For a KernelServer interface and an Out argument,
   *  or a KernelUser interface and an In argument,
   *  we avoid a possible spurious warning about the deallocate bit.
   *  For compatibility with Mach 2.5, the deallocate bit
   *  may need to be enabled on some inline arguments.
   */
550
  *what= d_YES;
}
else if (flags & (flMaybeDealloc|flDealloc)) {
  /* only give semantic warnings if the user specified something */
  if (it->itInLine && !it->itPortType) {
    warn("%s: Dealloc is ignored: it is meaningless  for that type of argument", name);
    flags &= ~(flMaybeDealloc|flDealloc);
  }
  else
    *what = (flags & flMaybeDealloc) ? d_MAYBE : d_YES;
}
return flags;
563}
564
565static void
566rtProcessSameCountFlag(argument_t *arg)
567{
ipc_type_t *it = arg->argType;
ipc_flags_t flags = arg->argFlags;
string_t name = arg->argVarName;
static argument_t *old_arg;
572
if (flags & flSameCount)  {
  if (!it->itVarArray) {
    warn("%s: SameCount is ignored - the argument is not variable", name);
    flags &= ~flSameCount;
  }
  if (old_arg) {
    if (old_arg->argParent)
      old_arg = old_arg->argParent;
    if (old_arg->argSameCount)
      old_arg = old_arg->argSameCount;
583
    if (!old_arg->argType->itVarArray) {
      warn("%s: SameCount is ignored - adjacent argument is not variable", name);
      flags &= ~flSameCount;
    }
588
589#define SAMECOUNT_MASK akeBITS|akbSend|akbReturn|akbRequest|akbReply|akbUserArg|akbServerArg
    if (akCheck(old_arg->argKind, SAMECOUNT_MASK) !=
        akCheck(arg->argKind, SAMECOUNT_MASK) ||
        old_arg->argCountInOut != arg->argCountInOut) {
      warn("%s: SameCount is ignored - inconsistencies with the adjacent argument\n", name);
      flags &= ~flSameCount;
    }
    arg->argSameCount = old_arg;
  }
  arg->argFlags = flags;
}
old_arg = arg;
601}
602
603static ipc_flags_t
604rtProcessCountInOutFlag(ipc_type_t *it, ipc_flags_t flags, arg_kind_t kind, boolean_t *what, string_t name)
605{
if (flags & flCountInOut) {
  if (!akCheck(kind, akbReply)) {
    warn("%s: CountInOut is ignored: argument must be Out\n", name);
    flags &= ~flCountInOut;
  }
  else if (!it->itVarArray || !it->itInLine) {
    warn("%s: CountInOut is ignored: argument isn't variable or in-line\n", name);
    flags &= ~flCountInOut;
  }
  else
    *what = TRUE;
}
return flags;
619}
620
621static ipc_flags_t
622rtProcessPhysicalCopyFlag(ipc_type_t *it, ipc_flags_t flags, arg_kind_t kind, string_t name)
623{
if (flags & flPhysicalCopy) {
  if (it->itInLine) {
    warn("%s: PhysicalCopy is ignored, argument copied inline anyway", name);
    flags &= ~flPhysicalCopy;
  }
  if (it->itPortType) {
    warn("%s: PhysicalCopy is ignored, it does not apply to ports and array of ports", name);
    flags &= ~flPhysicalCopy;
  }
}
return flags;
635}
636
637static void
638rtProcessRetCodeFlag(argument_t *thisarg)
639{
ipc_type_t *it = thisarg->argType;
ipc_flags_t flags = thisarg->argFlags;
string_t name = thisarg->argVarName;
routine_t *thisrout = thisarg->argRoutine;
644
if (flags & flRetCode) {
  if (!it->itInLine || !it->itStruct ||
      it->itSize != 32 || it->itNumber != 1) {
    warn("%s: RetCode is ignored - the type doesn't match a MIG RetCode", name);
    flags &= ~flRetCode;
  }
  else if (thisrout->rtKind != rkSimpleRoutine) {
    fatal("%s: RetCode is allowed only for SimpleRoutines", name);
  }
  else if (thisrout->rtRetCArg != argNULL) {
    warn("%s: RetCode is ignored - only one argument can be flagged as RetCode", name);
    flags &= ~flRetCode;
  }
  else {
    thisrout->rtRetCArg = thisarg;
  }
  thisarg->argFlags = flags;
}
663}
664
665static ipc_flags_t
666rtProcessOverwriteFlag(ipc_type_t *it, ipc_flags_t flags, arg_kind_t kind, string_t name)
667{
if (flags & flOverwrite)
  if (it->itInLine || it->itMigInLine ||
      /* among In, Out, InOut, we want only the Out! */
      !akCheck(kind, akbReturn) || akCheck(kind, akbSend)) {
    warn("%s: Overwrite is ignored - it must be Out AND Ool!", name);
    flags &= ~flOverwrite;
  }
return flags;
676}
677
678static void
679rtDetectKPDArg(argument_t *arg)
680{
ipc_type_t *it = arg->argType;
char *string;
683
if  (IS_KERN_PROC_DATA(it)) {
  if (akCheck(arg->argKind, akbSendBody)) {
    arg->argKind = akRemFeature(arg->argKind, akbSendBody);
    arg->argKind = akAddFeature(arg->argKind, akbSendKPD);
  }
  if (akCheck(arg->argKind, akbReturnBody)) {
    arg->argKind = akRemFeature(arg->argKind, akbReturnBody);
    arg->argKind = akAddFeature(arg->argKind, akbReturnKPD);
  }
  if (it->itInLine) {
    string = "mach_msg_port_descriptor_t";
    arg->argKPD_Type = MACH_MSG_PORT_DESCRIPTOR;
  }
  else if (it->itPortType) {
    string = "mach_msg_ool_ports_descriptor_t";
    arg->argKPD_Type = MACH_MSG_OOL_PORTS_DESCRIPTOR;
  }
  else {
    string = "mach_msg_ool_descriptor_t";
    arg->argKPD_Type = MACH_MSG_OOL_DESCRIPTOR;
  }
  it->itKPDType = string;
}
707}
708
709static void
710rtAugmentArgKind(argument_t *arg)
711{
ipc_type_t *it = arg->argType;
713
/* akbVariable means variable-sized inline */
715
if (IS_VARIABLE_SIZED_UNTYPED(it)) {
  if (akCheckAll(arg->argKind, akbRequest|akbReply))
    error("%s: Inline variable-sized arguments can't be InOut", arg->argName);
  arg->argKind = akAddFeature(arg->argKind, akbVariable);
}
if (IS_OPTIONAL_NATIVE(it))
  arg->argKind = akAddFeature(arg->argKind, akbVariable);
723
/*
 * Need to use a local variable in the following cases:
 *  1) There is a translate-out function & the argument is being
 *     returned.  We need to translate it before it hits the message.
 *  2) There is a translate-in function & the argument is
 *     sent and returned.  We need a local variable for its address.
 *  3) There is a destructor function, which will be used
 *     (SendRcv and not ReturnSnd), and there is a translate-in
 *     function whose value must be saved for the destructor.
 *  4) This is Complex KPD (array of KPD), and as such it has to
 *     be copied to a local array in input and output
 *  5) Both poly and dealloc generate warnings compile time, because
 *     we attempt to take address of bit-field structure member
 */
738
if (
    ((it->itOutTrans != strNULL) && akCheck(arg->argKind, akbReturnSnd)) ||
    ((it->itInTrans != strNULL) && akCheckAll(arg->argKind, akbSendRcv|akbReturnSnd)) ||
    ((it->itDestructor != strNULL) && akCheck(arg->argKind, akbSendRcv) && !akCheck(arg->argKind, akbReturnSnd) && (it->itInTrans != strNULL)) ||
    (IS_MULTIPLE_KPD(it)) ||
    ((akIdent(arg->argKind) == akePoly) && akCheck(arg->argKind, akbReturnSnd))  ||
    ((akIdent(arg->argKind) == akeDealloc) && akCheck(arg->argKind, akbReturnSnd))
   ) {
  arg->argKind = akRemFeature(arg->argKind, akbReplyCopy);
  arg->argKind = akAddFeature(arg->argKind, akbVarNeeded);
}
750}
751
752/*
* The Suffix allows to handle KPDs as normal data.
* it is used in InArgMsgField.
*/
756static void
757rtSuffixExtArg(argument_t *args)
758{
argument_t *arg;
char *subindex;
char string[MAX_STR_LEN];
762
for (arg = args; arg != argNULL; arg = arg->argNext)  {
  if (akCheck(arg->argKind, akbSendKPD | akbReturnKPD)) {
    if (IS_MULTIPLE_KPD(arg->argType))
      subindex = "[0]";
    else
      subindex = "";
    switch (arg->argKPD_Type) {
770
      case MACH_MSG_PORT_DESCRIPTOR:
        (void)sprintf(string, "%s.name", subindex);
        break;
774
      case MACH_MSG_OOL_DESCRIPTOR:
      case MACH_MSG_OOL_PORTS_DESCRIPTOR:
        (void)sprintf(string, "%s.address", subindex);
        break;
779
      default:
        error("Type of kernel processed data unknown\n");
    }
    arg->argSuffix = strconcat(arg->argMsgField, string);
    /* see above the list of VarNeeded cases */
    /*
     * argCount has been removed from the VarNeeded list,
     * because VarSize arrays have their Count in the untyped
     * section of the message, and because it is not possible
     * to move anything in-line/out-of-line
     */
  }
  else if (akIdent(arg->argKind) == akePoly &&
             akCheck(arg->argParent->argKind, akbSendKPD | akbReturnKPD)) {
    argument_t *par_arg = arg->argParent;
795
    if (IS_MULTIPLE_KPD(par_arg->argType))
      subindex = "[0]";
    else
      subindex = "";
    switch (par_arg->argKPD_Type) {
801
      case MACH_MSG_PORT_DESCRIPTOR:
      case MACH_MSG_OOL_PORTS_DESCRIPTOR:
        (void)sprintf(string, "%s.disposition", subindex);
        arg->argSuffix = strconcat(par_arg->argMsgField, string);
        break;
807
      default:
        error("Type of kernel processed data inconsistent\n");
    }
  }
  else if (akIdent(arg->argKind) == akeDealloc &&
             akCheck(arg->argParent->argKind, akbSendKPD | akbReturnKPD)) {
    argument_t *par_arg = arg->argParent;
815
    if (IS_MULTIPLE_KPD(par_arg->argType))
      subindex = "[0]";
    else
      subindex = "";
    switch (par_arg->argKPD_Type) {
821
      case MACH_MSG_OOL_DESCRIPTOR:
      case MACH_MSG_OOL_PORTS_DESCRIPTOR:
        (void)sprintf(string, "%s.deallocate", subindex);
        arg->argSuffix = strconcat(par_arg->argMsgField, string);
        break;
827
      default:
        error("Type of kernel processed data inconsistent\n");
    }
  }
}
833}
834
835/* arg->argType may be NULL in this function */
836
837static void
838rtCheckRoutineArg(routine_t *rt, argument_t *arg)
839{
switch (akIdent(arg->argKind)) {
841
  case akeRequestPort:
    if (rt->rtRequestPort != argNULL)
      warn("multiple RequestPort args in %s; %s won't be used", rt->rtName, rt->rtRequestPort->argName);
    rt->rtRequestPort = arg;
    break;
847
  case akeReplyPort:
    if (rt->rtReplyPort != argNULL)
      warn("multiple ReplyPort args in %s; %s won't be used", rt->rtName, rt->rtReplyPort->argName);
    rt->rtReplyPort = arg;
    break;
853
  case akeWaitTime:
    if (rt->rtWaitTime != argNULL)
      warn("multiple WaitTime/SendTime type args in %s; %s won't be used", rt->rtName, rt->rtWaitTime->argName);
    rt->rtWaitTime = arg;
    break;
859
  case akeSendTime:
    if (rt->rtWaitTime != argNULL) {
      if (akIdent(rt->rtWaitTime->argKind) == akeWaitTime) {
        warn("SendTime type argument after a WaitTime in %s; SendTime %s won't be used", rt->rtName, arg->argName);
        break;
      } else  {
        warn("multiple SendTime type args in %s; %s won't be used", rt->rtName, rt->rtWaitTime->argName);
      }
    }
    rt->rtWaitTime = arg;
    break;
871
  case akeMsgOption:
    if (rt->rtMsgOption != argNULL)
      warn("multiple MsgOption args in %s; %s won't be used", rt->rtName, rt->rtMsgOption->argName);
    rt->rtMsgOption = arg;
    break;
877
  default:
    break;
}
881}
882
883/* arg->argType may be NULL in this function */
884
885static void
886rtSetArgDefaults(routine_t *rt, argument_t *arg)
887{
arg->argRoutine = rt;
if (arg->argVarName == strNULL)
  arg->argVarName = arg->argName;
if (arg->argMsgField == strNULL)
  switch(akIdent(arg->argKind)) {
893
    case akeRequestPort:
      arg->argMsgField = "Head.msgh_request_port";
      break;
897
    case akeReplyPort:
      arg->argMsgField = "Head.msgh_reply_port";
      break;
901
    case akeNdrCode:
      arg->argMsgField = "NDR";
      break;
905
    case akeSecToken:
      arg->argMsgField = "msgh_sender";
      break;
909
    case akeAuditToken:
      arg->argMsgField = "msgh_audit";
      break;
913
    case akeContextToken:
      arg->argMsgField = "msgh_context";
      break;
917
    case akeMsgSeqno:
      arg->argMsgField = "msgh_seqno";
      break;
921
    case akeImplicit:
      /* the field is set directly by Yacc */
      break;
925
    default:
      arg->argMsgField = arg->argName;
      break;
}
930
if (arg->argTTName == strNULL)
  arg->argTTName = strconcat(arg->argName, "Template");
if (arg->argPadName == strNULL)
  arg->argPadName = strconcat(arg->argName, "Pad");
935
/*
 *  The poly args for the request and reply ports have special defaults,
 *  because their msg-type-name values aren't stored in normal fields.
 */
940
if ((rt->rtRequestPort != argNULL) &&
    (rt->rtRequestPort->argPoly == arg) &&
    (arg->argType != itNULL)) {
  arg->argMsgField = "Head.msgh_bits";
  arg->argType->itInTrans = "MACH_MSGH_BITS_REQUEST";
}
947
if ((rt->rtReplyPort != argNULL) &&
    (rt->rtReplyPort->argPoly == arg) &&
    (arg->argType != itNULL)) {
  arg->argMsgField = "Head.msgh_bits";
  arg->argType->itInTrans = "MACH_MSGH_BITS_REPLY";
}
954}
955
956static void
957rtAddCountArg(argument_t *arg)
958{
argument_t *count, *master;
ipc_type_t *it = arg->argType;
961
count = argAlloc();
963
if (IS_MULTIPLE_KPD(it) && it->itElement->itVarArray) {
  count->argName = strconcat(arg->argName, "Subs");
  count->argType = itMakeSubCountType(it->itKPD_Number, it->itVarArray, arg->argVarName);
  count->argKind = akeSubCount;
  arg->argSubCount = count;
}
else {
  count->argName = strconcat(arg->argName, "Cnt");
  count->argType = itMakeCountType();
  count->argKind = akeCount;
  arg->argCount = count;
  if (arg->argParent != argNULL)  {
    /* this is the case where we are at the second level of recursion:
     we want the Parent to access it through argCount */
    arg->argParent->argCount = count;
  }
}
master = (arg->argParent != argNULL) ? arg->argParent : arg;
if (IS_MULTIPLE_KPD(master->argType))
  count->argMultiplier = 1;
else
  count->argMultiplier = it->itElement->itNumber;
count->argParent = arg;
count->argNext = arg->argNext;
arg->argNext = count;
989
if (arg->argType->itString) {
  /* C String gets no Count argument on either side, but are still in the msg */
  count->argKind = akAddFeature(count->argKind, akCheck(arg->argKind, akbSend) ? akbSendRcv : akbReturnRcv);
  count->argVarName = (char *)0;
}
else {
  /*
   * Count arguments have to be present on the message body (NDR encoded)
   * akbVariable has to be turned down, has it foul the algorithm
   * for detecting the in-line variable sized arrays
   */
  count->argKind |= akAddFeature(akbUserArg|akbServerArg, (arg->argKind) & ~akeBITS);
  count->argKind = akRemFeature(count->argKind, akbVariable|akbVarNeeded);
  if (IS_VARIABLE_SIZED_UNTYPED(arg->argType))
  /*
   * Count arguments for the above types are explicitly declared
   * BEFORE the variable (with those bits, they would come afterwards)
   */
  count->argKind = akRemFeature(count->argKind, akbRequest|akbReply);
}
1010}
1011
1012static void
1013rtAddCountInOutArg(argument_t *arg)
1014{
argument_t *count;
1016
/*
 *  The user sees a single count variable.  However, to get the
 *  count passed from user to server for variable-sized inline OUT
 *  arrays, we need two count arguments internally.  This is
 *  because the count value lives in different message fields (and
 *  is scaled differently) in the request and reply messages.
 *
 *  The two variables have the same name to simplify code generation.
 *
 *  This variable has a null argParent field because it has akbRequest.
 *  For example, see rtCheckVariable.
 */
1029
count = argAlloc();
count->argName = strconcat(arg->argName, "Cnt");
count->argType = itMakeCountType();
count->argParent = argNULL;
count->argNext = arg->argNext;
arg->argNext = count;
(count->argCInOut = arg->argCount)->argCInOut = count;
count->argKind = akCountInOut;
1038}
1039
1040static void
1041rtAddPolyArg(argument_t *arg)
1042{
ipc_type_t *it = arg->argType;
argument_t *poly;
arg_kind_t akbsend, akbreturn;
1046
poly = argAlloc();
poly->argName = strconcat(arg->argName, "Poly");
poly->argType = itMakePolyType();
poly->argParent = arg;
poly->argNext = arg->argNext;
arg->argNext = poly;
arg->argPoly = poly;
1054
/*
 * akbsend is bits added if the arg is In;
 * akbreturn is bits added if the arg is Out.
 * The mysterious business with KernelServer subsystems:
 * when packing Out arguments, they use OutNames instead
 * of InNames, and the OutName determines if they are poly-in
 * as well as poly-out.
 */
1063
akbsend = akbSend;
akbreturn = akbReturn;
1066
if (it->itInName == MACH_MSG_TYPE_POLYMORPHIC) {
  akbsend |= akbUserArg|akbSendSnd;
  if (!IsKernelServer)
    akbreturn |= akbServerArg|akbReturnSnd;
}
if (it->itOutName == MACH_MSG_TYPE_POLYMORPHIC) {
  akbsend |= akbServerArg|akbSendRcv;
  akbreturn |= akbUserArg|akbReturnRcv;
  if (IsKernelServer)
    akbreturn |= akbServerArg|akbReturnSnd;
}
1078
poly->argKind = akPoly;
if (akCheck(arg->argKind, akbSend))
  poly->argKind = akAddFeature(poly->argKind, akCheck(arg->argKind, akbsend));
if (akCheck(arg->argKind, akbReturn))
  poly->argKind = akAddFeature(poly->argKind, akCheck(arg->argKind, akbreturn));
1084}
1085
1086static void
1087rtAddDeallocArg(argument_t *arg)
1088{
argument_t *dealloc;
1090
dealloc = argAlloc();
dealloc->argName = strconcat(arg->argName, "Dealloc");
dealloc->argType = itMakeDeallocType();
dealloc->argParent = arg;
dealloc->argNext = arg->argNext;
arg->argNext = dealloc;
arg->argDealloc = dealloc;
1098
/*
 * Dealloc flag can only be associated to KPDs.
 */
1102
dealloc->argKind = akeDealloc;
if (akCheck(arg->argKind, akbSend))
  dealloc->argKind = akAddFeature(dealloc->argKind, akCheck(arg->argKind, akbUserArg|akbSend|akbSendSnd));
if (akCheck(arg->argKind, akbReturn)) {
  dealloc->argKind = akAddFeature(dealloc->argKind, akCheck(arg->argKind, akbServerArg|akbReturn|akbReturnSnd));
  dealloc->argByReferenceServer = TRUE;
}
1110}
1111
1112static void
1113rtCheckRoutineArgs(routine_t *rt)
1114{
argument_t *arg;
1116
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  ipc_type_t *it = arg->argType;
1119
  rtDefaultArgKind(rt, arg);
  rtCheckRoutineArg(rt, arg);
1122
  /* need to set argTTName before adding implicit args */
  rtSetArgDefaults(rt, arg);
1125
  /* the arg may not have a type (if there was some error in parsing it),
     in which case we don't want to do these steps. */
1128
  if (it != itNULL) {
    arg->argFlags = rtProcessDeallocFlag(it, arg->argFlags, arg->argKind, &arg->argDeallocate, arg->argVarName);
    arg->argFlags = rtProcessCountInOutFlag(it, arg->argFlags, arg->argKind, &arg->argCountInOut, arg->argVarName);
    rtProcessSameCountFlag(arg);
    arg->argFlags = rtProcessPhysicalCopyFlag(it, arg->argFlags, arg->argKind, arg->argVarName);
    rtProcessRetCodeFlag(arg);
    arg->argFlags = rtProcessOverwriteFlag(it, arg->argFlags, arg->argKind, arg->argVarName);
    rtAugmentArgKind(arg);
1137
    /* args added here will get processed in later iterations */
    /* order of args is 'arg poly countinout count dealloc' */
1140
    if (arg->argDeallocate == d_MAYBE)
      rtAddDeallocArg(arg);
    if (it->itVarArray || (IS_MULTIPLE_KPD(it) && it->itElement->itVarArray))
      rtAddCountArg(arg);
    if (arg->argCountInOut)
      rtAddCountInOutArg(arg);
    if ((it->itInName == MACH_MSG_TYPE_POLYMORPHIC) || (it->itOutName == MACH_MSG_TYPE_POLYMORPHIC))
      rtAddPolyArg(arg);
    /*
     * Detects whether the arg has to become part of the
     * Kernel Processed Data section; if yes, define the proper
     * itUserKPDType, itServerKPDType
     */
    rtDetectKPDArg(arg);
  }
}
1157}
1158
1159boolean_t
1160rtCheckTrailerType(argument_t *arg)
1161{
if (akIdent(arg->argKind) == akeSecToken ||
    akIdent(arg->argKind) == akeAuditToken ||
    akIdent(arg->argKind) == akeContextToken )
  itCheckTokenType(arg->argVarName, arg->argType);
1166
if (akIdent(arg->argKind) == akeMsgSeqno)
  itCheckIntType(arg->argVarName, arg->argType);
/*
 * if the built-in are not used, we cannot match
 * the type/size of the desciption provided by the user
 * with the one defined in message.h.
 */
1174
return TRUE;
1176}
1177
1178static void
1179rtCheckArgTypes(routine_t *rt)
1180{
if (rt->rtRequestPort == argNULL)
  error("%s %s doesn't have a server port argument", rtRoutineKindToStr(rt->rtKind), rt->rtName);
1183
if ((rt->rtRequestPort != argNULL) &&
    (rt->rtRequestPort->argType != itNULL))
  itCheckRequestPortType(rt->rtRequestPort->argName, rt->rtRequestPort->argType);
1187
if ((rt->rtReplyPort != argNULL) &&
    (rt->rtReplyPort->argType != itNULL))
  itCheckReplyPortType(rt->rtReplyPort->argName, rt->rtReplyPort->argType);
1191
if ((rt->rtWaitTime != argNULL) &&
    (rt->rtWaitTime->argType != itNULL))
  itCheckIntType(rt->rtWaitTime->argName, rt->rtWaitTime->argType);
1195
if ((rt->rtMsgOption != argNULL) &&
    (rt->rtMsgOption->argType != itNULL))
  itCheckIntType(rt->rtMsgOption->argName, rt->rtMsgOption->argType);
1199
if ((IsKernelServer && rt->rtServerImpl) ||
    (IsKernelUser   && rt->rtUserImpl))
  fatal("Implicit data is not supported in the KernelUser and KernelServer modes");
/* rtCheckTrailerType will hit a fatal() if something goes wrong */
if (rt->rtServerImpl)
  rtCheckMaskFunction(rt->rtArgs, akbServerImplicit, rtCheckTrailerType);
if (rt->rtUserImpl)
  rtCheckMaskFunction(rt->rtArgs, akbUserImplicit, rtCheckTrailerType);
1208}
1209
1210/*
* Check for arguments which are missing seemingly needed functions.
* We make this check here instead of in itCheckDecl, because here
* we can take into account what kind of argument the type is
* being used with.
*
* These are warnings, not hard errors, because mig will generate
* reasonable code in any case.  The generated code will work fine
* if the ServerType and TransType are really the same, even though
* they have different names.
*/
1221
1222static void
1223rtCheckArgTrans(routine_t *rt)
1224{
argument_t *arg;
1226
/* the arg may not have a type (if there was some error in parsing it) */
1228
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  ipc_type_t *it = arg->argType;
1231
  if ((it != itNULL) && !streql(it->itServerType, it->itTransType)) {
    if (akCheck(arg->argKind, akbSendRcv) && (it->itInTrans == strNULL))
      warn("%s: argument has no in-translation function", arg->argName);
1235
    if (akCheck(arg->argKind, akbReturnSnd) && (it->itOutTrans == strNULL))
      warn("%s: argument has no out-translation function", arg->argName);
  }
}
1240}
1241
1242/*
* Adds an implicit return-code argument.  It exists in the reply message,
* where it is the first piece of data (After the NDR format label)..
*/
1246
1247static void
1248rtAddRetCode(routine_t *rt)
1249{
argument_t *arg = argAlloc();
1251
arg->argName = "RetCode";
arg->argType = itRetCodeType;
arg->argKind = akRetCode;
rt->rtRetCode = arg;
1256
arg->argNext = rt->rtArgs;
rt->rtArgs = arg;
1259}
1260
1261/*
* Process the Return Code.
* The MIG protocol says that RetCode != 0 are only sent through
* mig_reply_error_t structures. Therefore, there is no need
* for reserving a RetCode in a complex Reply message.
*/
1267static void
1268rtProcessRetCode(routine_t *rt)
1269{
if (!rt->rtOneWay && !rt->rtSimpleReply) {
  argument_t *arg = rt->rtRetCode;
1272
  arg->argKind = akRemFeature(arg->argKind, akbReply);
  /* we want the RetCode to be a local variable instead */
  arg->argKind = akAddFeature(arg->argKind, akbVarNeeded);
}
if (rt->rtRetCArg != argNULL && !rt->rtSimpleRequest) {
  argument_t *arg = rt->rtRetCArg;
1279
  arg->argKind = akeRetCode|akbUserArg|akbServerArg|akbSendRcv;
}
1282}
1283
1284/*
* Adds an implicit NDR argument.  It exists in the reply message,
* where it is the first piece of data.
*/
1288
1289static void
1290rtAddNdrCode(routine_t *rt)
1291{
argument_t *arg = argAlloc();
1293
arg->argName = "NDR_record";
arg->argType = itNdrCodeType;
arg->argKind = akeNdrCode;
rt->rtNdrCode = arg;
1298
/* add at beginning, so ndr-code is first in the reply message  */
arg->argNext = rt->rtArgs;
rt->rtArgs = arg;
1302}
1303
1304/*
* Process the NDR Code.
* We stick a NDR format label iff there is untyped data
*/
1308static void
1309rtProcessNdrCode(routine_t *rt)
1310{
argument_t *ndr = rt->rtNdrCode;
argument_t *arg;
boolean_t found;
1314
/* akbSendSnd|akbSendBody initialize the NDR format label */
1316#define ndr_send akbRequest|akbSend|akbSendSnd|akbSendBody
/* akbReplyInit initializes the NDR format label */
1318#define ndr_rcv  akbReply|akbReplyInit|akbReturn|akbReturnBody
1319
ndr->argKind = akAddFeature(ndr->argKind, ndr_send|ndr_rcv);
1321
for (found = FALSE, arg = ndr->argNext; arg != argNULL; arg = arg->argNext)
  if (akCheck(arg->argKind, akbSendRcv|akbSendBody) &&
     !akCheck(arg->argKind, akbServerImplicit) && !arg->argType->itPortType &&
     (!arg->argParent || akIdent(arg->argKind) == akeCount ||
     akIdent(arg->argKind) == akeCountInOut)) {
    arg->argKind = akAddFeature(arg->argKind, akbSendNdr);
    found = TRUE;
  }
if (!found)
  ndr->argKind = akRemFeature(ndr->argKind, ndr_send);
1332
found = FALSE;
if (!rt->rtOneWay)
  for (arg = ndr->argNext; arg != argNULL; arg = arg->argNext)
    if ((arg == rt->rtRetCode && akCheck(arg->argKind, akbReply)) ||
        (arg != rt->rtRetCode &&
        akCheck(arg->argKind, akbReturnRcv|akbReturnBody) &&
        !akCheck(arg->argKind, akbUserImplicit) && !arg->argType->itPortType &&
        (!arg->argParent || akIdent(arg->argKind) == akeCount ||
        akIdent(arg->argKind) == akeCountInOut))) {
      arg->argKind = akAddFeature(arg->argKind, akbReturnNdr);
      found = TRUE;
    }
if (!found && !akCheck(rt->rtRetCode->argKind, akbReply))
  ndr->argKind = akRemFeature(ndr->argKind, ndr_rcv);
1347}
1348
1349/*
*  Adds a dummy WaitTime argument to the function.
*  This argument doesn't show up in any C argument lists;
*  it implements the global WaitTime statement.
*/
1354
1355static void
1356rtAddWaitTime(routine_t *rt, identifier_t name, arg_kind_t kind)
1357{
argument_t *arg = argAlloc();
argument_t **loc;
1360
arg->argName = "dummy WaitTime arg";
arg->argVarName = name;
arg->argType = itWaitTimeType;
arg->argKind = kind;
rt->rtWaitTime = arg;
1366
/* add wait-time after msg-option, if possible */
1368
if (rt->rtMsgOption != argNULL)
  loc = &rt->rtMsgOption->argNext;
else
  loc = &rt->rtArgs;
1373
arg->argNext = *loc;
*loc = arg;
1376
rtSetArgDefaults(rt, arg);
1378}
1379
1380/*
*  Adds a dummy MsgOption argument to the function.
*  This argument doesn't show up in any C argument lists;
*  it implements the global MsgOption statement.
*/
1385
1386static void
1387rtAddMsgOption(routine_t *rt, identifier_t name)
1388{
argument_t *arg = argAlloc();
argument_t **loc;
1391
arg->argName = "dummy MsgOption arg";
arg->argVarName = name;
arg->argType = itMsgOptionType;
arg->argKind = akeMsgOption;
rt->rtMsgOption = arg;
1397
/* add msg-option after msg-seqno */
1399
loc = &rt->rtArgs;
1401
arg->argNext = *loc;
*loc = arg;
1404
rtSetArgDefaults(rt, arg);
1406}
1407
1408/*
* Process the MsgOption Code.
* We must add the information to post a receive with the right
* Trailer options.
*/
1413static void
1414rtProcessMsgOption(routine_t *rt)
1415{
argument_t *msgop = rt->rtMsgOption;
argument_t *arg;
boolean_t sectoken = FALSE;
boolean_t audittoken = FALSE;
boolean_t contexttoken = FALSE;
1421
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
  if (akCheckAll(arg->argKind, akbReturn|akbUserImplicit)) {
    if (akIdent(arg->argKind) == akeSecToken)
      sectoken = TRUE;
    else if (akIdent(arg->argKind) == akeAuditToken)
      audittoken = TRUE;
    else if (akIdent(arg->argKind) == akeContextToken)
      contexttoken = TRUE;
  }
1431
if (contexttoken == TRUE)
  msgop->argVarName = strconcat(msgop->argVarName, "|MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_CTX)");
else if (audittoken == TRUE)
  msgop->argVarName = strconcat(msgop->argVarName, "|MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_AUDIT)");
else if (sectoken == TRUE)
  msgop->argVarName = strconcat(msgop->argVarName, "|MACH_RCV_TRAILER_ELEMENTS(MACH_RCV_TRAILER_SENDER)");
/* other implicit data received by the user will be handled here */
1439}
1440
1441static void
1442rtProcessUseSpecialReplyPort(routine_t *rt)
1443{
if (IsKernelUser || IsKernelServer) {
  fatal("UseSpecialReplyPort option cannot be used with KernelUser / KernelServer\n");
}
rt->rtMsgOption->argVarName = strconcat(rt->rtMsgOption->argVarName, "|__MigSpecialReplyPortMsgOption");
1448}
1449
1450/*
*  Adds a dummy reply port argument to the function.
*/
1453
1454static void
1455rtAddDummyReplyPort(routine_t *rt, ipc_type_t *type)
1456{
argument_t *arg = argAlloc();
argument_t **loc;
1459
arg->argName = "dummy ReplyPort arg";
arg->argVarName = "dummy ReplyPort arg";
arg->argType = type;
arg->argKind = akeReplyPort;
rt->rtReplyPort = arg;
1465
/* add the reply port after the request port */
1467
if (rt->rtRequestPort != argNULL)
  loc = &rt->rtRequestPort->argNext;
else
  loc = &rt->rtArgs;
1472
arg->argNext = *loc;
*loc = arg;
1475
rtSetArgDefaults(rt, arg);
1477}
1478
1479
1480/*
* At least one overwrite keyword has been detected:
* we tag all the OOL entries (ports + data) with
* akbOverwrite which will tell us that we have to
* fill a KPD entry in the message-template
*/
1486static void
1487rtCheckOverwrite(routine_t *rt)
1488{
argument_t *arg;
int howmany = rt->rtOverwrite;
1491
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  ipc_type_t *it = arg->argType;
1494
  if (akCheck(arg->argKind, akbReturnKPD) && !it->itInLine) {
    /* among OUT args, we want OOL, OOL ports and MigInLine */
    arg->argKind = akAddFeature(arg->argKind, akbOverwrite);
    if (arg->argFlags & flOverwrite)
      howmany--;
    if (!howmany)
      return;
  }
}
1504}
1505
1506/*
* Initializes argRequestPos, argReplyPos, rtMaxRequestPos, rtMaxReplyPos,
* rtNumRequestVar, rtNumReplyVar, and adds akbVarNeeded to those arguments
* that need it because of variable-sized inline considerations.
*
* argRequestPos and argReplyPos get -1 if the value shouldn't be used.
*/
1513static void
1514rtCheckVariable(routine_t *rt)
1515{
argument_t *arg;
int NumRequestVar = 0;
int NumReplyVar = 0;
int MaxRequestPos = 0;
int MaxReplyPos = 0;
1521
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  argument_t *parent = arg->argParent;
1524
  /*
   * We skip KPDs. We have to make sure that the KPDs count
   * present in the message body follow the RequestPos/ReplyPos logic
   * The rest of the parameters are defaulted to have
   * Arg{Request, Reply}Pos = 0
   */
  if (parent == argNULL || akCheck(parent->argKind, akbSendKPD|akbReturnKPD)) {
    if (akCheckAll(arg->argKind, akbSend|akbSendBody)) {
      arg->argRequestPos = NumRequestVar;
      MaxRequestPos = NumRequestVar;
      if (akCheck(arg->argKind, akbVariable))
        NumRequestVar++;
    }
    if (akCheckAll(arg->argKind, akbReturn|akbReturnBody)) {
      arg->argReplyPos = NumReplyVar;
      MaxReplyPos = NumReplyVar;
      if (akCheck(arg->argKind, akbVariable))
        NumReplyVar++;
    }
  }
  else {
    arg->argRequestPos = parent->argRequestPos;
    arg->argReplyPos = parent->argReplyPos;
  }
  
  if (UseMachMsg2) {
    /* Kernel processed data must have Request/Reply pos of 0 */
    if (akCheck(arg->argKind, akbSendKPD)) {
      assert(arg->argRequestPos == 0);
    }
    if (akCheck(arg->argKind, akbReturnKPD)) {
      assert(arg->argReplyPos == 0);
    }
  }
  /*
   printf("Var %s Kind %x RequestPos %d\n", arg->argVarName, arg->argKind, arg->argRequestPos);
   printf("* Var %s Kind %x ReplyPos %d\n", arg->argVarName, arg->argKind, arg->argReplyPos);
   */
1563
  /* Out variables that follow a variable-sized field
     need VarNeeded or ReplyCopy; they can't be stored
     directly into the reply message. */
1567
  if (akCheckAll(arg->argKind, akbReturnSnd|akbReturnBody) &&
      !akCheck(arg->argKind, akbReplyCopy|akbVarNeeded) &&
      (arg->argReplyPos > 0))
    arg->argKind = akAddFeature(arg->argKind, akbVarNeeded);
}
1573
rt->rtNumRequestVar = NumRequestVar;
rt->rtNumReplyVar = NumReplyVar;
rt->rtMaxRequestPos = MaxRequestPos;
rt->rtMaxReplyPos = MaxReplyPos;
1578}
1579
1580/*
* Adds akbDestroy where needed.
*/
1583
1584static void
1585rtCheckDestroy(routine_t *rt)
1586{
argument_t *arg;
1588
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  ipc_type_t *it = arg->argType;
1591
  if(akCheck(arg->argKind, akbSendRcv) &&
     !akCheck(arg->argKind, akbReturnSnd) &&
     (it->itDestructor != strNULL || IS_MIG_INLINE_EMUL(it))) {
    arg->argKind = akAddFeature(arg->argKind, akbDestroy);
  }
  if (argIsIn(arg) && akCheck(arg->argKind, akbSendKPD|akbReturnKPD) &&
      arg->argKPD_Type == MACH_MSG_OOL_DESCRIPTOR &&
      (arg->argFlags & flAuto))
    arg->argKind = akAddFeature(arg->argKind, akbDestroy);
}
1602}
1603
1604/*
* Sets ByReferenceUser and ByReferenceServer.
*/
1607
1608static void
1609rtAddByReference(routine_t *rt)
1610{
argument_t *arg;
1612
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  ipc_type_t *it = arg->argType;
1615
  if (akCheck(arg->argKind, akbReturnRcv) && it->itStruct) {
    arg->argByReferenceUser = TRUE;
1618
    /*
     *  A CountInOut arg itself is not akbReturnRcv,
     *  so we need to set argByReferenceUser specially.
     */
1623
    if (arg->argCInOut != argNULL)
      arg->argCInOut->argByReferenceUser = TRUE;
  }
1627
  if ((akCheck(arg->argKind, akbReturnSnd) ||
       (akCheck(arg->argKind, akbServerImplicit) &&
        akCheck(arg->argKind, akbReturnRcv) &&
        akCheck(arg->argKind, akbSendRcv)))
      && it->itStruct) {
    arg->argByReferenceServer = TRUE;
    if (IsKernelServer && IS_KERN_PROC_DATA(it)) {
      /* because of PAC we can't take the address of a signed pointer */
      arg->argKind = akAddFeature(arg->argKind, akbVarNeeded);
    }
  }
}
1640}
1641
1642/*
* This procedure can be executed only when all the akb* and ake* have
* been set properly (when rtAddCountArg is executed, akbVarNeeded
* might not be set yet - see rtCheckVariable)
*/
1647void
1648rtAddSameCount(routine_t *rt)
1649{
argument_t *arg;
1651
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
  if (arg->argFlags & flSameCount) {
    ipc_type_t *it = arg->argType;
    argument_t *tmp_count;
    argument_t *my_count = arg->argCount;
    argument_t *ref_count = arg->argSameCount->argCount;
1658
    tmp_count = argAlloc();
    *tmp_count = *ref_count;
    /*
     * if our count is a akbVarNeeded, we need to copy this
     * attribute to the master count!
     */
    tmp_count->argKind = akeSameCount;
    ref_count->argKind = akAddFeature(ref_count->argKind, akCheck(my_count->argKind, akbVarNeeded));
    tmp_count->argKind = akAddFeature(tmp_count->argKind, akCheck(my_count->argKind, akbVarNeeded));
    tmp_count->argNext = my_count->argNext;
    tmp_count->argMultiplier = my_count->argMultiplier;
    tmp_count->argType = my_count->argType;
    tmp_count->argParent = arg;
    /* we don't need more */
    arg->argCount = tmp_count;
    arg->argNext = tmp_count;
    /* for these args, Cnt is not akbRequest, and therefore size is embedded */
    if (IS_VARIABLE_SIZED_UNTYPED(it))
      it->itMinTypeSize = 0;
    tmp_count->argType->itMinTypeSize = 0;
    tmp_count->argType->itTypeSize = 0;
  }
1681}
1682
1683static void
1684rtAddArgSegment(routine_t *rt)
1685{
argument_t *arg;
1687
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext) {
  ipc_type_t *it = arg->argType;
  if (!UseMachMsg2) {
    char *segIn = malloc(16);
    if (!segIn)
      fatal("Unable to allocate argInSegment");
    sprintf(segIn, "In%dP", arg->argRequestPos);
    arg->argInSegment = segIn;
    arg->argOutSegment = "OutP";
  } else if (IS_KERN_PROC_DATA(it) || 
    (akIdent(arg->argKind) == akePoly &&
    IS_KERN_PROC_DATA(arg->argParent->argType))) {
    arg->argInSegment = "InKP";
    arg->argOutSegment = "OutKP";
  } else {
    char *segIn = malloc(16);
    if (!segIn)
      fatal("Unable to allocate argInSegment");
    sprintf(segIn, "In%dUP", arg->argRequestPos);
    arg->argInSegment = segIn;
    arg->argOutSegment = "OutUP";
  }
}
1711}
1712
1713void
1714rtCheckRoutine(routine_t *rt)
1715{
/* Initialize random fields. */
1717
rt->rtErrorName = ErrorProc;
rt->rtOneWay = (rt->rtKind == rkSimpleRoutine);
rt->rtServerName = strconcat(ServerPrefix, rt->rtName);
rt->rtUserName = strconcat(UserPrefix, rt->rtName);
rt->rtUseSpecialReplyPort = UseSpecialReplyPort && !rt->rtOneWay;
rt->rtConsumeOnSendError = ConsumeOnSendError;
1724
/* Add implicit arguments. */
1726
rtAddRetCode(rt);
rtAddNdrCode(rt);
1729
/* Check out the arguments and their types.  Add count, poly
 implicit args.  Any arguments added after rtCheckRoutineArgs
 should have rtSetArgDefaults called on them. */
1733
rtCheckRoutineArgs(rt);
1735
/* Add dummy WaitTime and MsgOption arguments, if the routine
 doesn't have its own args and the user specified global values. */
1738
if (rt->rtReplyPort == argNULL) {
  if (rt->rtOneWay)
    rtAddDummyReplyPort(rt, itZeroReplyPortType);
  else
    rtAddDummyReplyPort(rt, itRealReplyPortType);
} else if (akCheck(rt->rtReplyPort->argKind, akbUserArg)) {
    /* If an explicit ReplyPort is used, we can't assume it will be the SRP */
    rt->rtUseSpecialReplyPort = FALSE;
}
if (rt->rtMsgOption == argNULL) {
  if (MsgOption == strNULL)
    rtAddMsgOption(rt, "MACH_MSG_OPTION_NONE");
  else
    rtAddMsgOption(rt, MsgOption);
}
if (rt->rtWaitTime == argNULL) {
  if (WaitTime != strNULL)
    rtAddWaitTime(rt, WaitTime, akeWaitTime);
  else if (SendTime != strNULL)
    rtAddWaitTime(rt, SendTime, akeSendTime);
}
if (rt->rtWaitTime && rt->rtConsumeOnSendError == ConsumeOnSendErrorNone) {
  warn("%s %s specifies a SendTime/WaitTime which may leak resources, "
    "adopt \"ConsumeOnSendError Timeout\"",
    rtRoutineKindToStr(rt->rtKind), rt->rtName);
}
1765
1766
/* Now that all the arguments are in place, do more checking. */
1768
rtCheckArgTypes(rt);
rtCheckArgTrans(rt);
1771
if (rt->rtOneWay) {
  if (rtCheckMask(rt->rtArgs, akbReturn) || rt->rtUserImpl)
    error("%s %s has OUT argument", rtRoutineKindToStr(rt->rtKind), rt->rtName);
}
1776
/* If there were any errors, don't bother calculating more info
 that is only used in code generation anyway.  Therefore,
 the following functions don't have to worry about null types. */
1780
if (mig_errors > 0)
  fatal("%d errors found. Abort.\n", mig_errors);
1783
rt->rtServerImpl  = rtCountMask(rt->rtArgs, akbServerImplicit);
rt->rtUserImpl = rtCountMask(rt->rtArgs, akbUserImplicit);
/*
 * ASSUMPTION:
 * kernel cannot change a message from simple to complex,
 * therefore SimpleSendReply and SimpleRcvReply become SimpleReply
 */
rtCheckSimple(rt->rtArgs, akbRequest, &rt->rtSimpleRequest);
rtCheckSimple(rt->rtArgs, akbReply, &rt->rtSimpleReply);
1793
rt->rtRequestKPDs = rtCountKPDs(rt->rtArgs, akbSendKPD);
rt->rtReplyKPDs = rtCountKPDs(rt->rtArgs, akbReturnKPD);
/*
 * Determine how many overwrite parameters we have:
 *  # of Overwrite args -> rt->rtOverwrite
 *  flOverwrite -> the arg has to be overwritten
 *  akbOverwrite -> the arg has to be declared in the message-template
 *  (only as a placeholder if !flOverwrite).
 */
if ((rt->rtOverwrite = rtCountFlags(rt->rtArgs, flOverwrite))) {
  rtCheckOverwrite(rt);
  rt->rtOverwriteKPDs = rtCountKPDs(rt->rtArgs, akbReturnKPD|akbOverwrite);
  if (IsKernelUser)
    fatal("Overwrite option(s) do not match with the KernelUser personality\n");
}
1809
rtCheckFit(rt, akbRequest, &rt->rtRequestFits, &rt->rtRequestUsedLimit, &rt->rtRequestSizeKnown);
rtCheckFit(rt, akbReply, &rt->rtReplyFits, &rt->rtReplyUsedLimit, &rt->rtReplySizeKnown);
1812
rtCheckVariable(rt);
rtCheckDestroy(rt);
rtAddByReference(rt);
rtSuffixExtArg(rt->rtArgs);
rtAddSameCount(rt);
rtProcessRetCode(rt);
rtProcessNdrCode(rt);
if (rt->rtUserImpl)
  rtProcessMsgOption(rt);
if (rt->rtUseSpecialReplyPort)
  rtProcessUseSpecialReplyPort(rt);
1824
rt->rtNoReplyArgs = !rtCheckMask(rt->rtArgs, akbReturnSnd);
1826
rtAddArgSegment(rt);
1828
if (UseEventLogger)
/* some more info's are needed for Event logging/Stats */
  rtFindHowMany(rt);
1832}
1833
1834void
1835rtMinRequestSize(FILE *file, routine_t *rt, char *str)
1836{
fprintf(file, "(mach_msg_size_t)(sizeof(%s)", str);
rtSizeDelta(file, akbRequest, rt);
fprintf(file, ")");
1840}
1841
1842void
1843rtMinReplySize(FILE *file, routine_t *rt, char *str)
1844{
fprintf(file, "(mach_msg_size_t)(sizeof(%s)", str);
rtSizeDelta(file, akbReply, rt);
fprintf(file, ")");
1848}
1849
1850static void
1851rtSizeDelta(FILE *file, u_int mask, routine_t *rt)
1852{
argument_t *arg;
u_int min_size = sizeof(mach_msg_header_t);
u_int max_size;
boolean_t output = FALSE;
1857
if (!rt->rtSimpleRequest)
  machine_alignment(min_size, sizeof(mach_msg_body_t));
max_size = min_size;
for (arg = rt->rtArgs; arg != argNULL; arg = arg->argNext)
  if (akCheck(arg->argKind, mask)) {
    ipc_type_t *it = arg->argType;
1864
    machine_alignment(min_size, it->itMinTypeSize);
    machine_alignment(max_size, it->itMinTypeSize);
1867
    if (IS_VARIABLE_SIZED_UNTYPED(it)) {
      machine_alignment(max_size, it->itTypeSize);
      max_size += it->itPadSize;
    }
    if (IS_OPTIONAL_NATIVE(it)) {
      if (output)
        fprintf(file, " + ");
      else {
        output = TRUE;
        fprintf(file, " - (");
      }
      fprintf(file, "_WALIGNSZ_(%s)", it->itUserType);
    }
  }
if (min_size != max_size) {
  if (output)
    fprintf(file, " + ");
  else
    fprintf(file, " - ");
  fprintf(file, "%d", max_size - min_size);
}
if (output)
  fprintf(file, ")");
1891}
1892