source: trunk/libc/include/InnoTekLIBC/sharedpm.h@ 2937

Last change on this file since 2937 was 2937, checked in by bird, 19 years ago

Made libc07.dll link and load. still some init and term work left.
  • Property cvs2svn:cvs-rev set to 1.25
  • Property svn:eol-style set to native
  • Property svn:executable set to *
  • Property svn:keywords set to Author Date Id Revision
File size: 36.8 KB
Line 
1/** $Id: sharedpm.h 2937 2007-01-03 02:03:12Z bird $ */
2/** @file
3 *
4 * LIBC Shared Process Management.
5 *
6 * Copyright (c) 2004-2005 knut st. osmundsen <bird@anduin.net>
7 * Copyright (c) 2004 nickk
8 *
9 * This file is part of InnoTek LIBC.
10 *
11 * InnoTek LIBC is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * InnoTek LIBC is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with InnoTek LIBC; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 */
26
27#ifndef __InnoTekLIBC_sharedpm_h__
28#define __InnoTekLIBC_sharedpm_h__
29
30#include <sys/cdefs.h>
31#include <sys/types.h>
32#include <sys/signal.h>
33#include <sys/ipc.h>
34
35
36__BEGIN_DECLS
37
38/** The name of the shared semaphore protecting the memory. */
39#define SPM_MUTEX_NAME "\\SEM32\\INNOTEKLIBC-V1.3"
40
41/** The name of the shared memory. */
42#define SPM_MEMORY_NAME "\\SHAREMEM\\INNOTEKLIBC-V1.3"
43
44/** The timeout for accessing the shared mem semaphore. */
45#define SPM_MUTEX_TIMEOUT (30*1000)
46
47/** Allocate 512KB if OBJ_ANY isn't supported.
48 * If it is supported we allocated the double amount. */
49#define SPM_MEMORY_SIZE (512*1024)
50
51/** The defined max size of a process.
52 * A good bit is reserved for the future here.
53 *
54 * Theoretically speaking, OS/2 cannot entertain more than a 1000 processes.
55 * So, even if we reserve a good bit here it's not gonna cause any trouble.
56 */
57#define SPM_PROCESS_SIZE (256)
58
59/**
60 * The SPM version.
61 */
62#define SPM_VERSION 0x00010003
63
64
65/**
66 * Process termination reason.
67 */
68typedef enum __LIBC_EXIT_REASON
69{
70 /** No reason. */
71 __LIBC_EXIT_REASON_NONE = 0,
72 /** Normal exit. */
73 __LIBC_EXIT_REASON_EXIT = 1,
74 /** OS/2 hard error. */
75 __LIBC_EXIT_REASON_HARDERROR = 2,
76 /** Trap (i.e. 16-bit?). */
77 __LIBC_EXIT_REASON_TRAP = 3,
78 /** Kill process. */
79 __LIBC_EXIT_REASON_KILL = 4,
80 /** Exception. */
81 __LIBC_EXIT_REASON_XCPT = 5,
82 /** Signal base. */
83 __LIBC_EXIT_REASON_SIGNAL_BASE = 32,
84 /** Signal max. */
85 __LIBC_EXIT_REASON_SIGNAL_MAX = 256,
86 /** Hack to ensure that this will be a 32-bit int. */
87 __LIBC_EXIT_REASON_MAKE_INT32 = 0x7fffffff
88} __LIBC_EXIT_REASON;
89
90
91/** Pointer to child termination data. */
92typedef struct __LIBC_SPMCHILDNOTIFY *__LIBC_PSPMCHILDNOTIFY;
93
94/**
95 * Child termination notification data.
96 */
97typedef struct __LIBC_SPMCHILDNOTIFY
98{
99 /** Pointer to the next node in the list. */
100 __LIBC_PSPMCHILDNOTIFY volatile pNext;
101 /** Structure size. */
102 unsigned cb;
103 /** Process Id. */
104 pid_t pid;
105 /** Process Group Id. */
106 pid_t pgrp;
107 /** Exit code. */
108 int iExitCode;
109 /** Reason code. */
110 __LIBC_EXIT_REASON enmDeathReason;
111} __LIBC_SPMCHILDNOTIFY;
112
113
114/**
115 * Process state.
116 */
117typedef enum __LIBC_SPMPROCSTAT
118{
119 /** The process is free. */
120 __LIBC_PROCSTATE_FREE = 0,
121 /** The process is waiting for a chile to be created and snatch all the
122 * inherited goodies from it.
123 * If not caught before DosExecPgm/DosStartSession returns
124 * it will be freed by the disappointed parent.
125 */
126 __LIBC_PROCSTATE_EMBRYO = 1,
127 /** The process is running. */
128 __LIBC_PROCSTATE_ALIVE = 2,
129 /** The process is dead but other guys are still using it's data. */
130 __LIBC_PROCSTATE_ZOMBIE = 3,
131 /** Reserved process state. */
132 __LIBC_PROCSTATE_RESERVED = 4,
133 /** The maximum state number (exclusive). */
134 __LIBC_PROCSTATE_MAX = 5,
135 /** Hack to ensure that this will be a 32-bit int. */
136 __LIBC_PROCSTATE_MAKE_INT32 = 0x7fffffff
137} __LIBC_SPMPROCSTAT;
138
139
140/** Pointer to (queued) signal. */
141typedef struct __libc_SPMSignal *__LIBC_PSPMSIGNAL;
142
143/**
144 * Signal (queued).
145 */
146typedef struct __libc_SPMSignal
147{
148 /** Structure size. */
149 unsigned cb;
150 /** Pointer to the next signal. */
151 __LIBC_PSPMSIGNAL volatile pNext;
152 /** Sender process.
153 * This is used to decrement the cSigsSent count of the sender. */
154 pid_t pidSender;
155 /** Signal info. */
156 siginfo_t Info;
157} __LIBC_SPMSIGNAL;
158
159
160/** Inheritance FH Bundle Type.
161 * @{ */
162/** Termination bundle. */
163#define __LIBC_SPM_INH_FHB_TYPE_END (0)
164/** Standard bundle. */
165#define __LIBC_SPM_INH_FHB_TYPE_STANDARD (0xe0 | (sizeof(unsigned) + sizeof(ino_t) + sizeof(dev_t) + sizeof(unsigned)))
166/** Directory bundle. */
167#define __LIBC_SPM_INH_FHB_TYPE_DIRECTORY (0xc0 | (sizeof(unsigned) + sizeof(ino_t) + sizeof(dev_t) + sizeof(unsigned) + sizeof(unsigned)))
168/** Socket bundle, using the BSD 4.4 backend. */
169#define __LIBC_SPM_INH_FHB_TYPE_SOCKET_44 (0xa0 | (sizeof(unsigned) + sizeof(unsigned short)))
170/** Socket bundle, using the BSD 4.3 backend. */
171#define __LIBC_SPM_INH_FHB_TYPE_SOCKET_43 (0x80 | (sizeof(unsigned) + sizeof(unsigned short)))
172/*#define __LIBC_SPM_INH_FHB_TYPE_ (0x60 | (sizeof(unsigned) + ))*/
173/*#define __LIBC_SPM_INH_FHB_TYPE_ (0x40 | (sizeof(unsigned) + ))*/
174/*#define __LIBC_SPM_INH_FHB_TYPE_ (0x20 | (sizeof(unsigned) + ))*/
175/*#define __LIBC_SPM_INH_FHB_TYPE_ (0x00 | (sizeof(unsigned) + ))*/
176/** Get the per file handle size from the bundle type. */
177#define __LIBC_SPM_INH_FHB_SIZE(type) ((type) & 0x1f)
178/** @} */
179
180/**
181 * SPM Inheritance File Handle Bundle Header.
182 */
183#pragma pack(1)
184typedef struct __libc_SPMInhFHBHdr
185{
186 /** Bundle type. */
187 unsigned char uchType;
188 /** Count of handles in this bundle. */
189 unsigned char cHandles;
190 /** Start handle number. */
191 unsigned short StartFH;
192} __LIBC_SPMINHFHBHDR;
193#pragma pack()
194/** Pointer to SPM filehandle bundle header. */
195typedef __LIBC_SPMINHFHBHDR *__LIBC_PSPMINHFHBHDR;
196
197/**
198 * SPM standard filehandle inherit bundle
199 * This is used for OS/2 filehandles which only needs flags
200 * transfered.
201 */
202#pragma pack(1)
203typedef struct __libc_SPMInhFH
204{
205 /** The common bundle header. */
206 __LIBC_SPMINHFHBHDR Hdr;
207 /** Array Hdr.cHandles entries. */
208 struct
209 {
210 /** The flags. */
211 unsigned fFlags;
212 /** The inode number. */
213 ino_t Inode;
214 /** The device number. */
215 dev_t Dev;
216 /** String table offset of the native path. */
217 unsigned offNativePath : 24;
218 unsigned u8Reserved : 8;
219 } aHandles[1];
220} __LIBC_SPMINHFHBSTD;
221#pragma pack()
222/** Pointer to SPM standard filehandle inherit bundle. */
223typedef __LIBC_SPMINHFHBSTD *__LIBC_PSPMINHFHBSTD;
224
225/**
226 * SPM directory filehandle inherit bundle.
227 */
228#pragma pack(1)
229typedef struct __libc_SPMInhFHDir
230{
231 /** The common bundle header. */
232 __LIBC_SPMINHFHBHDR Hdr;
233 /** Array of flags of Hdr.cHandles entries. */
234 struct
235 {
236 /** The flags. */
237 unsigned fFlags;
238 /** The inode number. */
239 ino_t Inode;
240 /** The device number. */
241 dev_t Dev;
242 /** String table offset of the native path. */
243 unsigned offNativePath : 24;
244 /** Set if this path is in the unix tree. */
245 unsigned fInUnixTree : 1;
246 unsigned u7Reserved : 7;
247 /** The current position. */
248 unsigned uCurEntry;
249 } aHandles[1];
250} __LIBC_SPMINHFHBDIR;
251#pragma pack()
252/** Pointer to SPM directory filehandle inherit bundle. */
253typedef __LIBC_SPMINHFHBDIR *__LIBC_PSPMINHFHBDIR;
254
255/**
256 * SPM socket filehandle inherit bundle.
257 *
258 * This is used for both BSD 4.3 and 4.4 sockets. The data needed
259 * here is the flags and the socket number.
260 */
261#pragma pack(1)
262typedef struct __libc_SPMInhFHSocket
263{
264 /** The common bundle header. */
265 __LIBC_SPMINHFHBHDR Hdr;
266 /** Array of flags of Hdr.cHandles entries. */
267 struct
268 {
269 /** The file handle flags. */
270 unsigned fFlags;
271 /** The socket number. */
272 unsigned short usSocket;
273 } aHandles[1];
274} __LIBC_SPMINHFHBSOCK;
275#pragma pack()
276/** Pointer to SPM socket filehandle inherit bundle. */
277typedef __LIBC_SPMINHFHBSOCK *__LIBC_PSPMINHFHBSOCK;
278
279/**
280 * The SPM fs inherit data, part 1.
281 * The FS data is stored in two sections for legacy reasons.
282 */
283typedef struct __libc_SPMInhFS
284{
285 /** In Unix Tree global. */
286 int fInUnixTree;
287 /** Size of the unix root. Only set if there's an official root. */
288 size_t cchUnixRoot;
289 /** The current unix root if cchUnixRoot is non-zero. */
290 char szUnixRoot[1];
291} __LIBC_SPMINHFS;
292/** Pointer to FS inherit data. */
293typedef __LIBC_SPMINHFS *__LIBC_PSPMINHFS;
294
295/**
296 * SPM fs inherit data, part two.
297 */
298typedef struct __libc_SPMInhFS2
299{
300 /** The size of this structure. */
301 unsigned cb;
302 /** The umask value. */
303 unsigned fUMask;
304} __LIBC_SPMINHFS2;
305/** Pointer to FS inherit data, part two. */
306typedef __LIBC_SPMINHFS2 *__LIBC_PSPMINHFS2;
307
308/**
309 * SPM signal inherit data.
310 */
311typedef struct __libc_SPMInhSig
312{
313 /** The size of this structure. */
314 unsigned cb;
315 /** Mask of signals which should be ignored. */
316 sigset_t SigSetIGN;
317} __LIBC_SPMINHSIG;
318/** Pointer to Signal inherit data. */
319typedef __LIBC_SPMINHSIG *__LIBC_PSPMINHSIG;
320
321
322
323/**
324 * Inherit structure.
325 *
326 * All the data it contains is allocated in one block heap block!
327 */
328typedef struct __libc_SPMInherit
329{
330 /** Size of the inherit structure. */
331 size_t cb;
332 /** Pointer to the filehandle part.
333 * This is a succession of bundles terminating with a _END one. */
334 __LIBC_PSPMINHFHBHDR pFHBundles;
335 /** Pointer to the file system part. If NULL default values are assumed. */
336 __LIBC_PSPMINHFS pFS;
337 /** Pointer to the signal part. If NULL default values are assumed. */
338 __LIBC_PSPMINHSIG pSig;
339 /** Pointer to strings (filenames++).
340 * All the strings are NULL terminated and referenced by offset. */
341 char *pszStrings;
342 /** More file system stuff. */
343 __LIBC_PSPMINHFS2 pFS2;
344} __LIBC_SPMINHERIT;
345/** Pointer to inherit data. */
346typedef __LIBC_SPMINHERIT *__LIBC_PSPMINHERIT;
347
348
349/** Pointer to per process data structure. */
350typedef struct __libc_SPMProcess *__LIBC_PSPMPROCESS;
351
352/**
353 * Per Process Data.
354 */
355typedef struct __libc_SPMProcess
356{
357 /** 0 - Pointer to the next process in the list.
358 * Every process is in one or another list depending on their state. */
359 volatile __LIBC_PSPMPROCESS pNext;
360 /** 4 - Pointer to the previous process in the list. */
361 volatile __LIBC_PSPMPROCESS pPrev;
362
363
364 /** Core
365 * @{ */
366 /** 8 - Version of the SPM which created this process. */
367 unsigned uVersion;
368 /** 12 - Number of references to this process.
369 * A process is not actually free till the reference count
370 * reaches 0. */
371 volatile unsigned cReferences;
372 /** 16 - State of this process. */
373 volatile __LIBC_SPMPROCSTAT enmState;
374 /** 20 - Process id. */
375 pid_t pid;
376 /** 24 - Process id of parent.
377 * This might not match the OS/2 one since there are no notification
378 * when a parent dies. */
379 pid_t pidParent;
380 /** @} */
381
382
383 /** User & Group
384 * @{ */
385 /** 28 - User id (also called Real User id). */
386 uid_t uid;
387 /** 32 - Effective user id. */
388 uid_t euid;
389 /** 36 - Saved user id. */
390 uid_t svuid;
391 /** 40 - Group id (also called Real Group id). */
392 gid_t gid;
393 /** 44 - Effecive group id. */
394 gid_t egid;
395 /** 48 - Saved group id. */
396 gid_t svgid;
397 /** 52 - Supplementary group ids. */
398 gid_t agidGroups[16 /*NGROUPS_MAX*/];
399 /** @} */
400
401
402 /** Misc
403 * @{ */
404 /** 116 - Creation timestamp. */
405 unsigned uTimestamp;
406 /** 120 - The SPM open count of this process. */
407 unsigned cSPMOpens;
408 /** 124 - Indicates that the process is a full featured LIBC process.
409 * Until this flag is set (atomically) it's not a good idea to
410 * queue signals on the process since it won't have a signal handler
411 * installed, and thus won't get to know about them.
412 */
413 volatile unsigned fExeInited;
414 /** 128 - Reserved for future use. Must be 0. */
415 unsigned uMiscReserved;
416 /** @} */
417
418
419 /** Fork
420 * @{ */
421 /** 132 - Pointer to fork module list head. */
422 void * volatile pvModuleHead;
423 /** 136 - Pointer to fork module list tail pointer. */
424 void * volatile * volatile ppvModuleTail;
425 /** 140 - Pointer to fork handle which a child should use when spawned by fork(). */
426 void *pvForkHandle;
427 /** @} */
428
429
430 /** Signals & Job Control
431 * @{ */
432 /** 144 - Incoming signal queue (FIFO).
433 * For signals which aren't queable only one signal can be queued.
434 */
435 volatile __LIBC_PSPMSIGNAL pSigHead;
436 /** 148 - Number of signals send.
437 * After _POSIX_SIGQUEUE_MAX signals only SIGCHLD will be allowed sent.
438 */
439 volatile unsigned cSigsSent;
440 /** 152 - Session Id. */
441 pid_t sid;
442 /** 156 - Process group. */
443 pid_t pgrp;
444 /** 160 - Reserved for future use. Must be 0. */
445 unsigned uSigReserved1;
446 /** 164 - Reserved for future use. Must be 0. */
447 unsigned uSigReserved2;
448 /** @} */
449
450
451 /** Termination
452 * @{ */
453 /** 168 - Termination information which will be sent to the parent process. */
454 __LIBC_PSPMCHILDNOTIFY pTerm;
455 /** 172 - List of child termination notifications. */
456 __LIBC_PSPMCHILDNOTIFY volatile pChildNotifyHead;
457 /** 176 - Pointer to the pointer where to insert the next child notification. */
458 __LIBC_PSPMCHILDNOTIFY volatile * volatile ppChildNotifyTail;
459 /** @} */
460
461 /** 180 - Per Process Sockets Reference Counters. (Data is process local.) */
462 uint16_t *pacTcpipRefs;
463 /** 184 - The Process priority (unix). */
464 int iNice;
465 /** 188 - Reserved fields with default value 0. */
466 unsigned auReserved[56 - 47];
467
468
469 /** 224 - Number of possible pointers to shared memory starting at pInherit.
470 * This means we can extend the structure with pointers for as long as we
471 * want and still have older LIBC versions cleanup the mess. */
472 unsigned cPoolPointers;
473 /** 228 - Pointer to data inherited from the parent process. */
474 __LIBC_PSPMINHERIT volatile pInherit;
475 /** 232 - Pointer to data inherited from the parent process when it's locked.
476 * When locked pInherit is NULL and this member points to the data instead.
477 * This prevents spmAlloc() from reclaiming it while it's in use. */
478 __LIBC_PSPMINHERIT volatile pInheritLocked;
479
480} __LIBC_SPMPROCESS;
481
482/** The current value for __LIBC_SPMPROCESS::cPoolPointers. */
483#define __LIBC_SPMPROCESS_POOLPOINTERS 2
484
485/**
486 * Pool chunk.
487 */
488typedef struct __libc_SPMPoolChunk
489{
490 /** Next block in the list of all blocks.. */
491 struct __libc_SPMPoolChunk *pPrev;
492 /** Previous block in the list of all blocks.. */
493 struct __libc_SPMPoolChunk *pNext;
494} __LIBC_SPMPOOLCHUNK, *__LIBC_PSPMPOOLCHUNK;
495
496/**
497 * Free pool chunk.
498 */
499typedef struct __libc_SPMPoolChunkFree
500{
501 /** Main list. */
502 __LIBC_SPMPOOLCHUNK core;
503 /** Next block in list of free nodes. */
504 struct __libc_SPMPoolChunkFree *pPrev;
505 /** Previous block in list of free nodes. */
506 struct __libc_SPMPoolChunkFree *pNext;
507 /** Size of this block. */
508 size_t cb;
509} __LIBC_SPMPOOLCHUNKFREE, *__LIBC_PSPMPOOLCHUNKFREE;
510
511/**
512 * Pool chunk alignment.
513 */
514#define SPM_POOL_ALIGN(size) (((size) + 7) & ~7)
515
516/**
517 * This structure contains the global TCP/IP socket data.
518 */
519typedef struct __libc_SPMTcpIp
520{
521 /** Size of the structure. */
522 size_t cb;
523 /** The number of elements in the acRefs array. */
524 unsigned cSockets;
525 /** Array containing the references counters for the sockets in the system. */
526 uint16_t acRefs[32768];
527} __LIBC_SPMTCPIP, *__LIBC_PSPMTCPIP;
528
529
530/**
531 * The structure contains the system load averages.
532 */
533typedef struct __libc_SPMLoadAvg
534{
535 /** Array of the three stamples.
536 * The entries are for 1, 5 and 15 min averages respectively.
537 *
538 * The samples them selfs are stored as integers and not as a
539 * double as the interface returns. The reason is that this is smaller
540 * and it's what both BSD and Linux is doing. The fraction part is
541 * the lower 11 bits (this is also identical to BSD and Linux).
542 */
543 uint32_t u32Samples[3];
544 /** Timestamp of the last update. */
545 unsigned uTimestamp;
546} __LIBC_SPMLOADAVG;
547/** Pointer to load averages. */
548typedef __LIBC_SPMLOADAVG *__LIBC_PSPMLOADAVG;
549
550
551/**
552 * This is the header of the LIBC shared memory.
553 */
554typedef struct __libc_SPMHeader
555{
556 /** 0 - SPM version. (the one which initialized the memory) */
557 unsigned uVersion;
558
559 /** 4 - Size of the shared memory. */
560 size_t cb;
561 /** 8 - Free memory. */
562 volatile size_t cbFree;
563 /** 12 - Start chunk of shared memory pool. */
564 volatile __LIBC_PSPMPOOLCHUNK pPoolHead;
565 /** 16 - End chunk of shared memory pool. */
566 volatile __LIBC_PSPMPOOLCHUNK pPoolTail;
567 /** 20 - Start free chunk in the shared memory pool. */
568 volatile __LIBC_PSPMPOOLCHUNKFREE pPoolFreeHead;
569 /** 24 - End free chunk in the shared memory pool. */
570 volatile __LIBC_PSPMPOOLCHUNKFREE pPoolFreeTail;
571
572 /** 28 - The size of one process block in this version of the shared memory. */
573 size_t cbProcess;
574 /** 32 - Array index by process state giving the head pointers
575 * to the processes in that state. */
576 volatile __LIBC_PSPMPROCESS apHeads[__LIBC_PROCSTATE_MAX];
577 /** 52 -List of free child (termination) notification structures. */
578 volatile __LIBC_PSPMCHILDNOTIFY pChildNotifyFreeHead;
579
580 /** 56 - Pointer to the tcpip globals. */
581 __LIBC_PSPMTCPIP pTcpip;
582 /** 60 - Creator pid. */
583 pid_t pidCreate;
584 /** 64 - Creation timestamp. */
585 __extension__ union
586 {
587#ifdef INCL_DOSDATETIME
588 DATETIME dtCreate;
589#endif
590 char ach[16];
591 };
592
593 /** 80 - System Load Averages. */
594 volatile __LIBC_SPMLOADAVG LoadAvg;
595
596 /** 96 - List of free signal structures. This will reduce
597 * the time spent allocating a signal structure in most cases.
598 * During SPM init 8 signal structures will be allocated and queued. */
599 volatile __LIBC_PSPMSIGNAL pSigFreeHead;
600 /** 100 - Number of free signal structures in the list.
601 * This is used to prevent the list from growing infinitly under stress.
602 * When cSigFree reaches 32 unused signal structures will be freed instead
603 * of put in the list. */
604 volatile unsigned cSigFree;
605 /** 104 - Number of active signals.
606 * This is used to keep a reasonable limit of the number of active signal
607 * structures so a process cannot exhaust the shared memory pool.
608 * The maximum is defined by cSigMaxActive.
609 */
610 volatile unsigned cSigActive;
611 /** 108 - The maximum number of active signals.
612 * This is initialized by the SPM creator but can be adjusted later.
613 */
614 unsigned cSigMaxActive;
615 /** 112 - Notification event semaphore.
616 * This semaphore is signaled when an event occurs. An event is either a signal
617 * or a child notification.
618 * At the moment this isn't used by anyone, but it's being signaled just in case.
619 */
620 unsigned long hevNotify;
621
622 /** 116 - Pointer to SysV Sempahore globals. */
623 struct __libc_SysV_Sem *pSysVSem;
624 /** 120 - Pointer to SysV Shared Memory globals. */
625 struct __libc_SysV_Shm *pSysVShm;
626 /** 124 - Pointer to SysV Message Queue globals. */
627 struct __libc_SysV_Msg *pSysVMsg;
628
629 /* 128 - The rest of the block, up to cbProcess, is undefined in this version.
630 * Future versions of LIBC may use this area assuming it's initalized with zeros.
631 */
632} __LIBC_SPMHEADER, *__LIBC_PSPMHEADER;
633
634
635/**
636 * SPM Exception handler registration record.
637 */
638typedef struct __LIBC_SPMXCPTREGREC
639{
640 __extension__ union
641 {
642#ifdef INCL_DOSEXCEPTIONS
643 EXCEPTIONREGISTRATIONRECORD Core;
644#endif
645 void *apv[2];
646 };
647 unsigned uFutureStuff0;
648 unsigned uFutureStuff1;
649} __LIBC_SPMXCPTREGREC;
650/** Pointer to SPM exception handler registration record. */
651typedef __LIBC_SPMXCPTREGREC *__LIBC_PSPMXCPTREGREC;
652
653
654/**
655 * Gets the current process.
656 *
657 * @returns Pointer to the current process.
658 * @returns NULL and errno on failure.
659 * @remark For this too __libc_spmRelease() must be called when done.
660 * @param fAutoInit Set if it's ok to automatically initialize SPM.
661 */
662__LIBC_PSPMPROCESS __libc_spmSelf(int fAutoInit);
663
664/**
665 * Gets the inherit data associated with the current process.
666 * This call prevents it from being release by underrun handling.
667 *
668 * @returns Pointer to inherit data.
669 * The caller must call __libc_spmInheritRelease() when done.
670 * @returns NULL and errno if no inherit data.
671 */
672__LIBC_PSPMINHERIT __libc_spmInheritRequest(void);
673
674/**
675 * Releases the inherit data locked by the __libc_spmInheritRequest() call.
676 *
677 * @returns 0 on success.
678 * @returns -1 and errno on failure.
679 */
680int __libc_spmInheritRelease(void);
681
682/**
683 * Frees the inherit data of this process.
684 * This is called when the executable is initialized.
685 */
686void __libc_spmInheritFree(void);
687
688/**
689 * Create an embryo related to the current process.
690 *
691 * @returns pointer to the embryo process.
692 * The allocated process must be released by the caller.
693 * @returns NULL and errno on failure.
694 * @param pidParent The parent pid (i.e. this process).
695 */
696__LIBC_PSPMPROCESS __libc_spmCreateEmbryo(pid_t pidParent);
697
698/**
699 * Searches for a process given by pid.
700 *
701 * @returns Pointer to the desired process on success.
702 * @returns NULL and errno on failure.
703 * @param pid Process id to search for.
704 * @param enmState The state of the process.
705 * @remark Call __libc_spmRelease() to release the result.
706 */
707__LIBC_PSPMPROCESS __libc_spmQueryProcess(pid_t pid);
708
709/**
710 * Searches for a process with a given pid and state.
711 *
712 * @returns Pointer to the desired process on success.
713 * @returns NULL and errno on failure.
714 * @param pid Process id to search for.
715 * @param enmState The state of the process.
716 * @remark Call __libc_spmRelease() to release the result.
717 */
718__LIBC_PSPMPROCESS __libc_spmQueryProcessInState(pid_t pid, __LIBC_SPMPROCSTAT enmState);
719
720/**
721 * Process enumeration callback function.
722 *
723 * @returns 0 to continue the enumeration.
724 * @returns Non-zero to stop the enumeration. The enumeration
725 * api will return this same value.
726 *
727 * @param pProcess The current process.
728 * @param pvUser The user argument.
729 * @remark It is *not* allowed to terminate the thread or process, do long jumps
730 * or anything else which causes the enumeration function not to release
731 * the lock.
732 * It is not allowed to do expensive stuff either as it will harm other
733 * processes in the system which want to access the shared process facility!
734 */
735typedef int __LIBC_FNSPNENUM(__LIBC_PSPMPROCESS pProcess, void *pvUser);
736/** Pointer to an process enumeration callback function. */
737typedef __LIBC_FNSPNENUM *__LIBC_PFNSPNENUM;
738
739/**
740 * Enumerates all alive processes in a group.
741 *
742 * @returns 0 on success.
743 * @returns -ESRCH if the process group wasn't found.
744 * @returns -EINVAL if pgrp is negative.
745 * @returns Whatever non-zero value the pfnCallback function returns to stop the enumeration.
746 *
747 * @param pgrp The process group id. 0 is an alias for the process group the caller belongs to.
748 * @param pfnCallback Callback function.
749 * @param pvUser User argument to the callback.
750 */
751int __libc_spmEnumProcessesByPGrp(pid_t pgrp, __LIBC_PFNSPNENUM pfnCallback, void *pvUser);
752
753/**
754 * Enumerates all alive processes owned by a user.
755 *
756 * @returns 0 on success.
757 * @returns -ESRCH if the process group wasn't found.
758 * @returns -EINVAL if uid is negative.
759 * @returns Whatever non-zero value the pfnCallback function returns to stop the enumeration.
760 *
761 * @param uid The process user id.
762 * @param pfnCallback Callback function.
763 * @param pvUser User argument to the callback.
764 */
765int __libc_spmEnumProcessesByUser(uid_t uid, __LIBC_PFNSPNENUM pfnCallback, void *pvUser);
766
767/**
768 * Release reference to the given process.
769 *
770 * @returns 0 on success.
771 * @returns -1 on failure.
772 * @param pProcess Pointer to process to release.
773 */
774int __libc_spmRelease(__LIBC_PSPMPROCESS pProcess);
775
776/**
777 * Checks if the calling process can see the specfied one.
778 *
779 * @returns 0 if it can see it.
780 * @returns -ESRCH (or other approriate error code) if it cannot.
781 *
782 * @param pProcess The process in question.
783 */
784int __libc_spmCanSee(__LIBC_PSPMPROCESS pProcess);
785
786/**
787 * Checks if we are a system-wide super user.
788 *
789 * @returns 0 if we are.
790 * @returns -EPERM if we aren't.
791 */
792int __libc_spmIsSuperUser(void);
793
794/**
795 * Checks if the caller can modify the specified process.
796 *
797 * @returns 0 if we can modify it.
798 * @returns -EPERM if we cannot modify it.
799 * @param pProcess The process in question.
800 */
801int __libc_spmCanModify(__LIBC_PSPMPROCESS pProcess);
802
803/**
804 * Checks if the calling process is a member of the specified group.
805 *
806 * @returns 0 if member.
807 * @returns -EPERM if not member.
808 * @param gid The group id in question.
809 */
810int __libc_spmIsGroupMember(gid_t gid);
811
812/**
813 * Check if the caller can access the SysV IPC object as requested.
814 *
815 * @returns 0 if we can.
816 * @returns -EPERM if we cannot.
817 * @param pPerm The IPC permission structure.
818 * @param Mode The access request. IPC_M, IPC_W or IPC_R.
819 */
820int __libc_spmCanIPC(struct ipc_perm *pPerm, mode_t Mode);
821
822/**
823 * Marks the current process (if we have it around) as zombie
824 * or dead freeing all resources associated with it.
825 *
826 * @param uReason The OS/2 exit list type reason code.
827 * This is only used if the current code is NONE.
828 * @param iExitCode The unix exit code for this process.
829 * This is only if the current code is 0.
830 * @remark this might not be a sufficient interface for process termination but we'll see.
831 */
832void __libc_spmTerm(__LIBC_EXIT_REASON enmDeathReason, int iExitCode);
833
834/**
835 * Query about notifications from a specific child process.
836 * The notifications are related to death, the cause and such.
837 *
838 * @returns 0 on success.
839 * @returns Negative error code (errno.h) on failure.
840 * @param pid Process id.
841 * @param pNotify Where to store the notification from the child.
842 */
843int __libc_spmQueryChildNotification(pid_t pid, __LIBC_PSPMCHILDNOTIFY pNotifyOut);
844
845/**
846 * Validates a process group id.
847 *
848 * @returns 0 if valid.
849 * @returns -ESRCH if not valid.
850 * @param pgrp Process group id to validate. 0 if the same as
851 * the same as the current process.
852 * @param fOnlyChildren Restrict the search to immediate children.
853 */
854int __libc_spmValidPGrp(pid_t pgrp, int fOnlyChildren);
855
856
857/**
858 * Identificators which can be obtained using __libc_spmGetId().
859 */
860typedef enum __LIBC_SPMID
861{
862 __LIBC_SPMID_PID = 0,
863 __LIBC_SPMID_PPID,
864 __LIBC_SPMID_SID,
865 __LIBC_SPMID_PGRP,
866 __LIBC_SPMID_UID,
867 __LIBC_SPMID_EUID,
868 __LIBC_SPMID_SVUID,
869 __LIBC_SPMID_GID,
870 __LIBC_SPMID_EGID,
871 __LIBC_SPMID_SVGID
872} __LIBC_SPMID;
873
874
875/**
876 * Gets the specified Id.
877 *
878 * @returns Requested Id.
879 * @param enmId Identification to get.
880 */
881unsigned __libc_spmGetId(__LIBC_SPMID enmId);
882
883/**
884 * Sets the effective user id of the current process.
885 * If the caller is superuser real and saved user id are also set.
886 *
887 * @returns 0 on success.
888 * @returns Negative error code (errno) on failure.
889 * @param uid New effective user id.
890 * For superusers this is also the new real and saved user id.
891 */
892int __libc_spmSetUid(uid_t uid);
893
894/**
895 * Sets the real, effective and saved user ids of the current process.
896 * Unprivilegde users can only set them to the real user id, the
897 * effective user id or the saved user id.
898 *
899 * @returns 0 on success.
900 * @returns Negative error code (errno) on failure.
901 * @param ruid New real user id. Ignore if -1.
902 * @param euid New effective user id. Ignore if -1.
903 * @param svuid New Saved user id. Ignore if -1.
904 */
905int __libc_spmSetUidAll(uid_t ruid, uid_t euid, uid_t svuid);
906
907/**
908 * Sets the effective group id of the current process.
909 * If the caller is superuser real and saved group id are also set.
910 *
911 * @returns 0 on success.
912 * @returns Negative error code (errno) on failure.
913 */
914int __libc_spmSetGid(gid_t gid);
915
916/**
917 * Sets the real, effective and saved group ids of the current process.
918 * Unprivilegde users can only set them to the real group id, the
919 * effective group id or the saved group id.
920 *
921 * @returns 0 on success.
922 * @returns Negative error code (errno) on failure.
923 * @param rgid New real group id. Ignore if -1.
924 * @param egid New effective group id. Ignore if -1.
925 * @param svgid New Saved group id. Ignore if -1.
926 */
927int __libc_spmSetGidAll(gid_t rgid, gid_t egid, gid_t svgid);
928
929/**
930 * Locks the LIBC shared memory for short exclusive access.
931 * The call must call __libc_spmUnlock() as fast as possible and make
932 * no api calls until that is done.
933 *
934 * @returns 0 on success.
935 * @returns Negative error code (errno.h) on failure.
936 *
937 * @param pRegRec Pointer to the exception handler registration record.
938 * @param ppSPMHdr Where to store the pointer to the SPM header. Can be NULL.
939 *
940 * @remark Don't even think of calling this if you're not LIBC!
941 */
942int __libc_spmLock(__LIBC_PSPMXCPTREGREC pRegRec, __LIBC_PSPMHEADER *ppSPMHdr);
943
944/**
945 * Unlock the LIBC shared memory after call to __libc_spmLock().
946 *
947 * @returns 0 on success.
948 * @returns Negative error code (errno.h) on failure.
949 *
950 * @param pRegRec Pointer to the exception handler registration record.
951 *
952 * @remark Don't even think of calling this if you're not LIBC!
953 */
954int __libc_spmUnlock(__LIBC_PSPMXCPTREGREC pRegRec);
955
956/**
957 * Allocate memory from the LIBC shared memory.
958 *
959 * The SPM must be locked using __libc_spmLock() prior to calling this function!
960 *
961 * @returns Pointer to allocated memory on success.
962 * @returns NULL on failure.
963 *
964 * @param cbSize Size of memory to allocate.
965 *
966 * @remark Don't think of calling this if you're not LIBC!
967 */
968void * __libc_spmAllocLocked(size_t cbSize);
969
970/**
971 * Free memory allocated by __libc_spmAllocLocked() or __libc_spmAlloc().
972 *
973 * The SPM must be locked using __libc_spmLock() prior to calling this function!
974 *
975 * @returns 0 on success.
976 * @returns -1 and errno on failure.
977 *
978 * @param pv Pointer to memory block returned by __libc_SpmAlloc().
979 * NULL is allowed.
980 * @remark Don't think of calling this if you're not LIBC!
981 */
982int __libc_spmFreeLocked(void *pv);
983
984/**
985 * Allocate memory from the LIBC shared memory.
986 *
987 * @returns Pointer to allocated memory on success.
988 * @returns NULL on failure.
989 *
990 * @param cbSize Size of memory to allocate.
991 *
992 * @remark Don't think of calling this if you're not LIBC!
993 */
994void * __libc_spmAlloc(size_t cbSize);
995
996/**
997 * Free memory allocated by __libc_SpmAlloc().
998 *
999 * @returns 0 on success.
1000 * @returns -1 and errno on failure.
1001 *
1002 * @param pv Pointer to memory block returned by __libc_SpmAlloc().
1003 * NULL is allowed.
1004 *
1005 * @remark Don't think of calling this if you're not LIBC!
1006 */
1007int __libc_spmFree(void *pv);
1008
1009/**
1010 * Register termination handler.
1011 *
1012 * This is a manual way of by passing a.out's broken weak symbols.
1013 */
1014void __libc_spmRegTerm(void (*pfnTerm)(void));
1015
1016
1017/**
1018 * Adds the first reference to a new socket.
1019 *
1020 * @returns 0 on success.
1021 * @returns Negative error code (errno.h) on failure.
1022 * @param iSocket The new socket.
1023 */
1024int __libc_spmSocketNew(int iSocket);
1025
1026/**
1027 * References a socket.
1028 *
1029 * @returns The new reference count.
1030 * The low 16-bits are are the global count.
1031 * The high 15-bits are are the process count.
1032 * @returns Negative error code (errno.h) on failure.
1033 * @param iSocket socket to reference.
1034 */
1035int __libc_spmSocketRef(int iSocket);
1036
1037/**
1038 * Dereferences a socket.
1039 *
1040 * @returns The new reference count.
1041 * The low 16-bits are are the global count.
1042 * The high 15-bits are are the process count.
1043 * @returns Negative error code (errno.h) on failure.
1044 * @param iSocket Socket to dereference.
1045 */
1046int __libc_spmSocketDeref(int iSocket);
1047
1048/**
1049 * Get the stored load average samples.
1050 *
1051 * @returns 0 on success.
1052 * @returns Negative error code (errno.h) on failure.
1053 * @param pLoadAvg Where to store the load average samples.
1054 * @param puTimestamp Where to store the current timestamp.
1055 */
1056int __libc_spmGetLoadAvg(__LIBC_PSPMLOADAVG pLoadAvg, unsigned *puTimestamp);
1057
1058/**
1059 * Get the stored load average samples.
1060 *
1061 * @returns 0 on success.
1062 * @returns Negative error code (errno.h) on failure.
1063 * @param pLoadAvg Where to store the load average samples.
1064 */
1065int __libc_spmSetLoadAvg(const __LIBC_SPMLOADAVG *pLoadAvg);
1066
1067/**
1068 * Marks the process as a full LIBC process.
1069 *
1070 * Up to this point it was just a process which LIBC happend to be loaded into.
1071 *
1072 * @returns 0 on success.
1073 * @returns Negative error code (errno.h) on failure.
1074 */
1075void __libc_spmExeInited(void);
1076
1077/**
1078 * Queues a signal on another process.
1079 *
1080 * @returns 0 on success.
1081 * @returns Negative error code (errno.h) on failure.
1082 * @param pSigInfo Signal to queue.
1083 * @param pid Pid to queue it on.
1084 * @param fQueued Set if the signal type is queued.
1085 */
1086int __libc_spmSigQueue(int iSignalNo, siginfo_t *pSigInfo, pid_t pid, int fQueued);
1087
1088/**
1089 * Callback which is called when a signal have been queued on a process.
1090 *
1091 * @returns 0 on success.
1092 * @returns Negative error code (errno.h) on failure.
1093 * @param iSignalNo The signal which have been queued.
1094 * @param pProcess Process which the signal was queued on.
1095 * @param pvUser User argument.
1096 */
1097typedef int (*__LIBC_PFNSPMSIGNALED)(int iSignalNo, const __LIBC_SPMPROCESS * pProcess, void *pvUser);
1098
1099/**
1100 * Queues a signal on another process.
1101 *
1102 * @returns 0 on success.
1103 * @returns Negative error code (errno.h) on failure.
1104 * @param iSignalNo The signal to send. If 0 only permissions are checked.
1105 * @param pSigInfo Signal to queue. If NULL only permissions are checked.
1106 * @param pgrp Process group to queue a signal on.
1107 * @param fQueued Set if the signal type is queued.
1108 * @param pfnCallback Pointer to callback function to post process signaled processes.
1109 * The callback must be _very_ careful. No crashing or blocking!
1110 * @param pvUser User argument specified to pfnCallback.
1111 */
1112int __libc_spmSigQueuePGrp(int iSignalNo, siginfo_t *pSigInfo, pid_t pgrp, int fQueued, __LIBC_PFNSPMSIGNALED pfnCallback, void *pvUser);
1113
1114/**
1115 * Get the signal set of pending signals.
1116 *
1117 * @returns Number of pending signals on success.
1118 * @returns 0 if no signals are pending.
1119 * @returns Negative error code (errno.h) on failure.
1120 * @param pSigSet Where to create the set of pending signals.
1121 */
1122int __libc_spmSigPending(sigset_t *pSigSet);
1123
1124/**
1125 * De-queues one or more pending signals of a specific type.
1126 *
1127 * @returns Number of de-queued signals on success.
1128 * @returns Negative error code (errno.h) on failure.
1129 * @param iSignalNo Signal type to dequeue.
1130 * @param paSignals Where to store the signals.
1131 * @param cSignals Size of the signal array.
1132 * @param cbSignal Size of one signal entry.
1133 */
1134int __libc_spmSigDequeue(int iSignalNo, siginfo_t *paSignals, unsigned cSignals, size_t cbSignal);
1135
1136
1137/**
1138 * Checks the SPM memory for trouble.
1139 *
1140 * @returns 0 on perfect state.
1141 * @returns -1 and errno on mutex failure.
1142 * @returns Number of failures if SPM is broken.
1143 * @param fBreakpoint Raise breakpoint exception if a problem is encountered.
1144 * @param fVerbose Log everything.
1145 */
1146int __libc_SpmCheck(int fBreakpoint, int fVerbose);
1147
1148__END_DECLS
1149
1150#endif /* __InnoTekLIBC_sharedpm_h__ */
Note: See TracBrowser for help on using the repository browser.