mach/err_server.sub

   1 /*
   2  * Mach Operating System
   3  * Copyright (c) 1991,1990,1989,1988,1987 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  Software.Distribution@CS.CMU.EDU
  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  * HISTORY
  28  * $Log$
  29  * Revision 1.1  1992/10/06 18:29:53  roland
  30  * entered into RCS
  31  *
  32  * Revision 2.2  92/01/16  00:10:29  rpd
  33  *      Moved from user collection to mk collection.
  34  *
  35  * Revision 2.3  91/08/29  15:51:39  rpd
  36  *      Fixed err_codes_netname.
  37  *      [91/08/22            rpd]
  38  *
  39  * Revision 2.2  91/03/27  16:05:51  mrt
  40  *      First checkin
  41  *
  42  * Revision 2.3  90/10/29  17:27:20  dpj
  43  *      Merged-up to U25
  44  *      [90/09/02  20:00:25  dpj]
  45  *
  46  */
  47 /*
  48  *      File:   err_server.sub
  49  *      Author: Douglas Orr, Carnegie Mellon University
  50  *      Date:   Mar, 1988
  51  *
  52  *      Definitions of Servers error strings
  53  */
  54
  55 static char * err_codes_netname[] = {                   /* 0 */
  56                 "(server/netname) name is not yours",
  57                 "(server/netname) name not checked in",
  58                 "(server/netname) no such host",
  59                 "(server/netname) host not found",
  60 };
  61 static char * err_codes_env_mgr[] = {                   /* 1 */
  62                 NO_SUCH_ERROR,
  63                 "(server/env_mgr) variable not found",
  64                 "(server/env_mgr) wrong type of variable",
  65                 "(server/env_mgr) unknown port",
  66                 "(server/env_mgr) read only environment",
  67                 "(server/env_mgr) no more connections available",
  68                 "(server/env_mgr) port table full",
  69                 "(server/env_mgr) attempting to enter a null port ",
  70 };
  71 static char * err_codes_execd[] = {                     /* 2 */
  72                 NO_SUCH_ERROR,
  73                 "(server/execd) could not find file to run",
  74                 "(server/execd) userid or password incorrect",
  75                 "(server/execd) fork failed",
  76 };
  77 static char * err_codes_netmemory[] = {                 /* 3 */
  78                 "(server/netmemory) successful",
  79                 "(server/netmemory) invalid argument",
  80                 "(server/netmemory) resource shortage",
  81 };
  82 static char * err_codes_ufs[] = {                       /* 4 */
  83                 NO_SUCH_ERROR,
  84 /* XXX          "(server/ufs) invalid port", */
  85 };
  86
  87 static char * err_codes_task_master[] = {               /* 5 */
  88                 "(server/task_master) GENERIC ERROR",
  89                 "(server/task_master) invalid tm_task port",
  90                 "(server/task_master) invalid task id",
  91                 "(server/task_master) invalid kernel port",
  92                 "(server/task_master) invalid job group",
  93                 "(server/task_master) invalid action",
  94 };
  95
  96 static char * err_codes_ns[] = {                        /* 6 */
  97                 "(server/ns) GENERIC ERROR",
  98                 "(server/ns) invalid handle",
  99                 "(server/ns) name not found",
 100                 "(server/ns) name already exists",
 101                 "(server/ns) name too long",
 102                 "(server/ns) path too long",
 103                 "(server/ns) invalid name",
 104                 "(server/ns) not a directory",
 105                 "(server/ns) is a directory",
 106                 "(server/ns) directory not empty",
 107                 "(server/ns) infinite retry loop in resolver",
 108                 "(server/ns) infinite forwarding loop in resolver",
 109                 "(server/ns) invalid prefix",
 110                 "(server/ns) prefix table overflow",
 111                 "(server/ns) bad format for directory",
 112                 "(server/ns) unknown entry type",
 113                 "(server/ns) invalid generation",
 114                 "(server/ns) entry not reserved",
 115 };
 116
 117 static char     * err_codes_io[] = {                    /* 7 */
 118                 "(server/io) GENERIC ERROR",
 119                 "(server/io) invalid offset",
 120                 "(server/io) invalid size",
 121                 "(server/io) invalid mode",
 122                 "(server/io) invalid strategy",
 123                 "(server/io) operation rejected under current I/O strategy",
 124 };
 125
 126 static char * err_codes_auth[] = {                      /* 8 */
 127                 "(server/auth) GENERIC ERROR",
 128                 "(server/auth) bad private port",
 129                 "(server/auth) bad name",
 130                 "(server/auth) not primary",
 131                 "(server/auth) bad pauthsword",
 132                 "(server/auth) bad group",
 133                 "(server/auth) duplicate id",
 134                 "(server/auth) duplicate name",
 135                 "(server/auth) not secondary",
 136 };
 137
 138 static char * err_codes_us[] = {                        /* 9 */
 139                 "(server/us) GENERIC ERROR",
 140                 "(server/us) unknown error",
 141                 "(server/us) object not found",
 142                 "(server/us) object exists",
 143                 "(server/us) object busy",
 144                 "(server/us) object not started",
 145                 "(server/us) object dead",
 146                 "(server/us) invalid args",
 147                 "(server/us) invalid access",
 148                 "(server/us) invalid format",
 149                 "(server/us) invalid buffer size",
 150                 "(server/us) access denied",
 151                 "(server/us) resource exhausted",
 152                 "(server/us) quota exceeded",
 153                 "(server/us) limit exceeded",
 154                 "(server/us) not implemented",
 155                 "(server/us) not supported",
 156                 "(server/us) hardware error",
 157                 "(server/us) retry required",
 158                 "(server/us) not authenticated",
 159                 "(server/us) exclusive access",
 160                 "(server/us) timeout",
 161                 "(server/us) bad reference count",
 162                 "(server/us) internal error",
 163 };
 164
 165 static char * err_codes_sunrpc[] = {                    /* 10 */
 166                 "(server/sunrpc) GENERIC ERROR",
 167                 "(server/sunrpc) cannot encode arguments",
 168                 "(server/sunrpc) cannot decode results",
 169                 "(server/sunrpc) failure in sending call",
 170                 "(server/sunrpc) failure in receiving result",
 171                 "(server/sunrpc) call timed out",
 172                 "(server/sunrpc) rpc versions not compatible",
 173                 "(server/sunrpc) authentication error",
 174                 "(server/sunrpc) program not available",
 175                 "(server/sunrpc) program version mismatched",
 176                 "(server/sunrpc) procedure unavailable",
 177                 "(server/sunrpc) decode arguments error",
 178                 "(server/sunrpc) generic other problem",
 179                 "(server/sunrpc) unknown host name",
 180                 "(server/sunrpc) portmapper failed",
 181                 "(server/sunrpc) remote program not registered",
 182                 "(server/sunrpc) unspecified error",
 183                 "(server/sunrpc) unknown protocol",
 184 };
 185
 186 static char     * err_codes_machobj[] = {               /* 11 */
 187                 "(server/object system) GENERIC ERROR",
 188                 "(server/object system) object not found",
 189                 "(server/object system) no such operation",
 190                 "(server/object system) undefined ipc method arguments",
 191                 "(server/object system) too many arguments to method",
 192                 "(server/object system) bad ipc message format",
 193 };
 194
 195 static char     * err_codes_loader[] = {                /* 12 */
 196                 "(server/loader) GENERIC ERROR",
 197                 "(server/loader) object file not relocated",
 198                 "(server/loader) unknown file type",
 199                 "(server/loader) symbol not found",
 200                 "(server/loader) symbol multiply defined",
 201                 "(server/loader) memory region overlap",
 202 };
 203
 204
 205 static char     * err_codes_exception[] = {             /* 13 */
 206         "(server/exception) GENERIC ERROR",
 207         "(server/exception) invalid access",
 208         "(server/exception) invalid instruction",
 209         "(server/exception) arithmetic exception",
 210         "(server/exception) emulation exception",
 211         "(server/exception) software exception",
 212         "(server/exception) breakpoint exception",
 213 };
 214
 215 static char     * err_codes_ux_signal[] = {             /* 14 */
 216         "(server/unix-signal) GENERIC ERROR",
 217         "(server/unix-signal) hangup",
 218         "(server/unix-signal) interrupt",
 219         "(server/unix-signal) quit",
 220         "(server/unix-signal) undefined",
 221         "(server/unix-signal) undefined",
 222         "(server/unix-signal) undefined",
 223         "(server/unix-signal) undefined",
 224         "(server/unix-signal) kill",
 225         "(server/unix-signal) undefined",
 226         "(server/unix-signal) undefined",
 227         "(server/unix-signal) system error",
 228         "(server/unix-signal) pipe signal",
 229         "(server/unix-signal) alarm",
 230         "(server/unix-signal) terminate",
 231         "(server/unix-signal) urgent i/o",
 232         "(server/unix-signal) stop",
 233         "(server/unix-signal) terminal stop",
 234         "(server/unix-signal) continue",
 235         "(server/unix-signal) child death",
 236         "(server/unix-signal) tty input",
 237         "(server/unix-signal) tty output",
 238         "(server/unix-signal) i/o signal",
 239         "(server/unix-signal) cpu time limit exceeded",
 240         "(server/unix-signal) file size exceeded",
 241         "(server/unix-signal) virtual alarm",
 242         "(server/unix-signal) profile signal",
 243         "(server/unix-signal) window size change",
 244         "(server/unix-signal) user-defined signal 1",
 245         "(server/unix-signal) user-defined signal 2",
 246 };
 247
 248 static char     * err_codes_xkernel[] = {               /* 15 */
 249         "(server/xkernel) GENERIC ERROR",
 250         "(server/xkernel) map full",
 251         "(server/xkernel) inconsistent bind",
 252         "(server/xkernel) cannot resolve",
 253         "(server/xkernel) cannot unbind",
 254         "(server/xkernel) invalid type",
 255         "(server/xkernel) invalid opcode",
 256         "(server/xkernel) buffer too small",
 257         "(server/xkernel) invalid ev code",
 258         "(server/xkernel) event not registered",
 259         "(server/xkernel) invalid open",
 260         "(server/xkernel) already open",
 261         "(server/xkernel) bad addr",
 262 };
 263
 264
 265 /*      err_server subsystems           */
 266 static struct error_subsystem err_server_sub[] = {
 267         /* server/0; */
 268         {
 269                 "(server/netname)",
 270                 errlib_count(err_codes_netname),
 271                 err_codes_netname,
 272         },
 273         /* server/1; */
 274         {
 275                 "(server/env_mgr)",
 276                 errlib_count(err_codes_env_mgr),
 277                 err_codes_env_mgr,
 278         },
 279         /* server/2; */
 280         {
 281                 "(server/execd)",
 282                 errlib_count(err_codes_execd),
 283                 err_codes_execd,
 284         },
 285         /* server/3; */
 286         {
 287                 "(server/netmemory)",
 288                 errlib_count(err_codes_netmemory),
 289                 err_codes_netmemory,
 290         },
 291         /* server/4; */
 292         {
 293                 "(server/ufs)",
 294                 errlib_count(err_codes_ufs),
 295                 err_codes_ufs,
 296         },
 297         /* server/5; */
 298         {
 299                 "(server/task_master)",
 300                 errlib_count(err_codes_task_master),
 301                 err_codes_task_master,
 302         },
 303         /* server/6; */
 304         {
 305                 "(server/ns)",
 306                 errlib_count(err_codes_ns),
 307                 err_codes_ns,
 308         },
 309
 310         /* server/7; i/o subsystem */
 311         {
 312                 "(server/io)",
 313                 errlib_count(err_codes_io),
 314                 err_codes_io,
 315         },
 316
 317         /* server/8; authentication server */
 318         {
 319                 "(server/auth)",
 320                 errlib_count(err_codes_auth),
 321                 err_codes_auth,
 322         },
 323
 324         /* server/9; generic US system */
 325         {
 326                 "(server/us)",
 327                 errlib_count(err_codes_us),
 328                 err_codes_us,
 329         },
 330
 331         /* server/10; SUN RPC package */
 332         {
 333                 "(server/sunrpc)",
 334                 errlib_count(err_codes_sunrpc),
 335                 err_codes_sunrpc,
 336         },
 337
 338         /* server/11; MachObject system */
 339         {
 340                 "(server/object system)",
 341                 errlib_count(err_codes_machobj),
 342                 err_codes_machobj,
 343         },
 344
 345         /* server/12; loader */
 346         {
 347                 "(server/loader)",
 348                 errlib_count(err_codes_loader),
 349                 err_codes_loader,
 350         },
 351
 352         /* server/13; mach exception */
 353         {
 354                 "(server/exception)",
 355                 errlib_count(err_codes_exception),
 356                 err_codes_exception,
 357         },
 358
 359         /* server/14; unix signal */
 360         {
 361                 "(server/unix-signal)",
 362                 errlib_count(err_codes_ux_signal),
 363                 err_codes_ux_signal,
 364         },
 365
 366         /* server/15; xkernel */
 367         {
 368                 "(server/xkernel)",
 369                 errlib_count(err_codes_xkernel),
 370                 err_codes_xkernel,
 371         },
 372
 373 };
 374