[apple/xnu.git] / libsyscall / mach / err_server.sub

/*
 * @OSF_COPYRIGHT@
 */

/* 
 * Mach Operating System
 * Copyright (c) 1991,1990,1989,1988,1987 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 
 * 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 the
 * rights to redistribute these changes.
 */

/*
 *	File:	err_server.sub
 *	Author:	Douglas Orr, Carnegie Mellon University
 *	Date:	Mar, 1988
 *
 *	Definitions of Servers error strings
 */

static const char * const err_codes_netname[] = {			/* 0 */
		"(server/netname) name is not yours",
		"(server/netname) name not checked in",
		"(server/netname) no such host",
		"(server/netname) host not found",
};
static const char * const err_codes_env_mgr[] = {			/* 1 */
		NO_SUCH_ERROR,
		"(server/env_mgr) variable not found",
		"(server/env_mgr) wrong type of variable",
		"(server/env_mgr) unknown port",
		"(server/env_mgr) read only environment",
		"(server/env_mgr) no more connections available",
		"(server/env_mgr) port table full",
		"(server/env_mgr) attempting to enter a null port ",
};
static const char * const err_codes_execd[] = {			/* 2 */
		NO_SUCH_ERROR,
		"(server/execd) could not find file to run",
		"(server/execd) userid or password incorrect",
		"(server/execd) fork failed",
};
static const char * const err_codes_netmemory[] = {			/* 3 */
		"(server/netmemory) successful",
		"(server/netmemory) invalid argument",
		"(server/netmemory) resource shortage",
};
static const char * const err_codes_ufs[] = {				/* 4 */
		NO_SUCH_ERROR,
/* XXX		"(server/ufs) invalid port", */
};

static const char * const err_codes_task_master[] = {			/* 5 */
		"(server/task_master) GENERIC ERROR",
		"(server/task_master) invalid tm_task port",
		"(server/task_master) invalid task id",
		"(server/task_master) invalid kernel port",
		"(server/task_master) invalid job group",
		"(server/task_master) invalid action",
};

static const char * const err_codes_ns[] = {				/* 6 */
		"(server/ns) GENERIC ERROR",
		"(server/ns) invalid handle",
		"(server/ns) name not found",
		"(server/ns) name already exists",
		"(server/ns) name too long",
		"(server/ns) path too long",
		"(server/ns) invalid name",
		"(server/ns) not a directory",
		"(server/ns) is a directory",
		"(server/ns) directory not empty",
		"(server/ns) infinite retry loop in resolver",
		"(server/ns) infinite forwarding loop in resolver",
		"(server/ns) invalid prefix",
		"(server/ns) prefix table overflow",
		"(server/ns) bad format for directory",
		"(server/ns) unknown entry type",
		"(server/ns) invalid generation",
		"(server/ns) entry not reserved",
};

static const char * const err_codes_io[] = {			/* 7 */
		"(server/io) GENERIC ERROR",
		"(server/io) invalid offset",
		"(server/io) invalid size",
		"(server/io) invalid mode",
		"(server/io) invalid strategy",
		"(server/io) operation rejected under current I/O strategy",
};

static const char * const err_codes_auth[] = {			/* 8 */
		"(server/auth) GENERIC ERROR",
		"(server/auth) bad private port",
		"(server/auth) bad name",
		"(server/auth) not primary",
		"(server/auth) bad pauthsword",
		"(server/auth) bad group",
		"(server/auth) duplicate id",
		"(server/auth) duplicate name",
		"(server/auth) not secondary",
};

static const char * const err_codes_us[] = {				/* 9 */
		"(server/us) GENERIC ERROR",
		"(server/us) unknown error",
		"(server/us) object not found",
		"(server/us) object exists",
		"(server/us) object busy",
		"(server/us) object not started",
		"(server/us) object dead",
		"(server/us) invalid args",
		"(server/us) invalid access",
		"(server/us) invalid format",
		"(server/us) invalid buffer size",
		"(server/us) access denied",
		"(server/us) resource exhausted",
		"(server/us) quota exceeded",
		"(server/us) limit exceeded",
		"(server/us) not implemented",
		"(server/us) not supported",
		"(server/us) hardware error",
		"(server/us) retry required",
		"(server/us) not authenticated",
		"(server/us) exclusive access",
		"(server/us) timeout",
		"(server/us) bad reference count",
		"(server/us) internal error",
};

static const char * const err_codes_sunrpc[] = {			/* 10 */
		"(server/sunrpc) GENERIC ERROR",
		"(server/sunrpc) cannot encode arguments",
		"(server/sunrpc) cannot decode results",
		"(server/sunrpc) failure in sending call",
		"(server/sunrpc) failure in receiving result",
		"(server/sunrpc) call timed out",
		"(server/sunrpc) rpc versions not compatible",
		"(server/sunrpc) authentication error",
		"(server/sunrpc) program not available",
		"(server/sunrpc) program version mismatched",
		"(server/sunrpc) procedure unavailable",
		"(server/sunrpc) decode arguments error",
		"(server/sunrpc) generic other problem",
		"(server/sunrpc) unknown host name",
		"(server/sunrpc) portmapper failed",
		"(server/sunrpc) remote program not registered",
		"(server/sunrpc) unspecified error",
		"(server/sunrpc) unknown protocol",
};

static const char * const err_codes_machobj[] = {		/* 11 */
		"(server/object system) GENERIC ERROR",
		"(server/object system) object not found",
		"(server/object system) no such operation",
		"(server/object system) undefined ipc method arguments",
		"(server/object system) too many arguments to method",
		"(server/object system) bad ipc message format",
};

static const char * const err_codes_loader[] = {		/* 12 */
		"(server/loader) GENERIC ERROR",
		"(server/loader) object file not relocated",
		"(server/loader) unknown file type",
		"(server/loader) symbol not found",
		"(server/loader) symbol multiply defined",
		"(server/loader) memory region overlap",
};


static const char * const err_codes_exception[] = {		/* 13 */
	"(server/exception) GENERIC ERROR",
	"(server/exception) invalid access",
	"(server/exception) invalid instruction",
	"(server/exception) arithmetic exception",
	"(server/exception) emulation exception",
	"(server/exception) software exception",
	"(server/exception) breakpoint exception",
};

static const char * const err_codes_ux_signal[] = {		/* 14 */
	"(server/unix-signal) GENERIC ERROR",
	"(server/unix-signal) hangup",
	"(server/unix-signal) interrupt",
	"(server/unix-signal) quit",
	"(server/unix-signal) undefined",
	"(server/unix-signal) undefined",
	"(server/unix-signal) undefined",
	"(server/unix-signal) undefined",
	"(server/unix-signal) kill",
	"(server/unix-signal) undefined",
	"(server/unix-signal) undefined",
	"(server/unix-signal) system error",
	"(server/unix-signal) pipe signal",
	"(server/unix-signal) alarm",
	"(server/unix-signal) terminate",
	"(server/unix-signal) urgent i/o",
	"(server/unix-signal) stop",
	"(server/unix-signal) terminal stop",
	"(server/unix-signal) continue",
	"(server/unix-signal) child death",
	"(server/unix-signal) tty input",
	"(server/unix-signal) tty output",
	"(server/unix-signal) i/o signal",
	"(server/unix-signal) cpu time limit exceeded",
	"(server/unix-signal) file size exceeded",
	"(server/unix-signal) virtual alarm",
	"(server/unix-signal) profile signal",
	"(server/unix-signal) window size change",
	"(server/unix-signal) user-defined signal 1",
	"(server/unix-signal) user-defined signal 2",
};

static const char * const err_codes_xkernel[] = {		/* 15 */
	"(server/xkernel) GENERIC ERROR",
	"(server/xkernel) map full",
	"(server/xkernel) inconsistent bind",
	"(server/xkernel) cannot resolve",
	"(server/xkernel) cannot unbind",
	"(server/xkernel) invalid type",
	"(server/xkernel) invalid opcode",
	"(server/xkernel) buffer too small",
	"(server/xkernel) invalid ev code",
	"(server/xkernel) event not registered",
	"(server/xkernel) invalid open",
	"(server/xkernel) already open",
	"(server/xkernel) bad addr",
};


/*	err_server subsystems      	*/
static const struct error_subsystem err_server_sub[] = {
	/* server/0; */
	{
		"(server/netname)",
		errlib_count(err_codes_netname),
		err_codes_netname,
	},
	/* server/1; */
	{
		"(server/env_mgr)",
		errlib_count(err_codes_env_mgr),
		err_codes_env_mgr,
	},
	/* server/2; */
	{
		"(server/execd)",
		errlib_count(err_codes_execd),
		err_codes_execd,
	},
	/* server/3; */
	{
		"(server/netmemory)",
		errlib_count(err_codes_netmemory),
		err_codes_netmemory,
	},
	/* server/4; */
	{
		"(server/ufs)",
		errlib_count(err_codes_ufs),
		err_codes_ufs,
	},
	/* server/5; */
	{
		"(server/task_master)",
		errlib_count(err_codes_task_master),
		err_codes_task_master,
	},
	/* server/6; */
	{
		"(server/ns)",
		errlib_count(err_codes_ns),
		err_codes_ns,
	},

	/* server/7; i/o subsystem */
	{
		"(server/io)",
		errlib_count(err_codes_io),
		err_codes_io,
	},

	/* server/8; authentication server */
	{
		"(server/auth)",
		errlib_count(err_codes_auth),
		err_codes_auth,
	},

	/* server/9; generic US system */
	{
		"(server/us)",
		errlib_count(err_codes_us),
		err_codes_us,
	},

	/* server/10; SUN RPC package */
	{
		"(server/sunrpc)",
		errlib_count(err_codes_sunrpc),
		err_codes_sunrpc,
	},

	/* server/11; MachObject system */
	{
		"(server/object system)",
		errlib_count(err_codes_machobj),
		err_codes_machobj,
	},

	/* server/12; loader */
	{
		"(server/loader)",
		errlib_count(err_codes_loader),
		err_codes_loader,
	},

	/* server/13; mach exception */
	{
		"(server/exception)",
		errlib_count(err_codes_exception),
		err_codes_exception,
	},

	/* server/14; unix signal */
	{
		"(server/unix-signal)",
		errlib_count(err_codes_ux_signal),
		err_codes_ux_signal,
	},

	/* server/15; xkernel */
	{
		"(server/xkernel)",
		errlib_count(err_codes_xkernel),
		err_codes_xkernel,
	},

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