Context Navigation

source: trunk/kernel/kern/process.h @ 453

Last change on this file since 453 was 450, checked in by alain, 6 years ago
Fix a bug in function sched_handle_signal(): When the deleted user thread is the last executed thread, the sched->u_last field must be updated to point on another user thread.
File size: 36.2 KB

Rev	Line
[1]	1	/*
	2	* process.h - process related management functions
[173]	3	*
[1]	4	* Authors Ghassan Almaless (2008,2009,2010,2011,2012)
	5	* Mohamed Lamine Karaoui (2015)
[433]	6	* Alain Greiner (2016,2017,2018)
[1]	7	*
	8	* Copyright (c) UPMC Sorbonne Universites
	9	*
	10	* This file is part of ALMOS-MKH.
	11	*
	12	* ALMOS-MKH is free software; you can redistribute it and/or modify it
	13	* under the terms of the GNU General Public License as published by
	14	* the Free Software Foundation; version 2.0 of the License.
	15	*
	16	* ALMOS-MKH is distributed in the hope that it will be useful, but
	17	* WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	19	* General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with ALMOS-MKH; if not, write to the Free Software Foundation,
	23	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	24	*/
	25
	26	#ifndef _PROCESS_H_
	27	#define _PROCESS_H_
	28
[14]	29	#include <kernel_config.h>
[1]	30	#include <errno.h>
	31	#include <hal_types.h>
	32	#include <list.h>
	33	#include <xlist.h>
	34	#include <bits.h>
	35	#include <spinlock.h>
	36	#include <hal_atomic.h>
	37	#include <vmm.h>
	38	#include <cluster.h>
	39	#include <vfs.h>
	40
	41	/** Forward declarations **/
	42
	43	struct thread_s;
	44
	45	/*********************************************************************************************
	46	* These macros are used to compose or decompose global process identifier (PID)
	47	* to or from cluster identifier / local process index (CXY , LPID)
	48	********************************************************************************************/
	49
	50	#define LPID_FROM_PID( pid ) (lpid_t)(pid & 0x0000FFFF)
	51	#define CXY_FROM_PID( pid ) (cxy_t)(pid >> 16)
	52	#define PID( cxy , lpid ) (pid_t)((cxy << 16) \| lpid )
	53
	54	/*********************************************************************************************
[428]	55	* This enum defines the actions that can be executed by the process_sigaction() function.
[409]	56	********************************************************************************************/
	57
	58	enum process_sigactions
	59	{
[436]	60	BLOCK_ALL_THREADS = 0x11,
	61	UNBLOCK_ALL_THREADS = 0x22,
	62	DELETE_ALL_THREADS = 0x33,
[409]	63	};
	64
	65	/*********************************************************************************************
[1]	66	* This structure defines an array of extended pointers on the open file descriptors
	67	* for a given process. We use an extended pointer because the open file descriptor
	68	* is always stored in the same cluster as the inode associated to the file.
	69	* A free entry in this array contains the XPTR_NULL value.
	70	* The array size is defined by a the CONFIG_PROCESS_FILE_MAX_NR parameter.
[23]	71	* All modifications (open/close) in this structure must be done by the reference cluster,
	72	* and reported in process copies.
[1]	73	********************************************************************************************/
	74
	75	typedef struct fd_array_s
	76	{
[101]	77	remote_spinlock_t lock; /! lock protecting fd_array /
	78	uint32_t current; /! current number of open files /
	79	xptr_t array[CONFIG_PROCESS_FILE_MAX_NR]; /! xptr on open file descriptors /
[1]	80	}
	81	fd_array_t;
	82
	83	/*********************************************************************************************
	84	* This structure defines a process descriptor.
	85	* A process is identified by a unique PID (process identifier):
	86	* - The PID 16 LSB bits contain the LPID (Local Process Index)
	87	* - The PID 16 MSB bits contain the owner cluster CXY.
[409]	88	* In each cluster, the process manager allocates the LPID values for the process that
	89	* are owned by this cluster.
	90	* The process descriptor is replicated in all clusters containing at least one thread
	91	* of the PID process, with the following rules :
[443]	92	* 1) The <pid>, <ppid>, <ref_xp>, <owner_xp>, <vfs_root_xp>, <vfs_bin_xp> fields are
	93	* defined in all process descriptor copies.
[23]	94	* 2) The <vfs_cwd_xp> and associated <cwd_lock>, that can be dynamically modified,
	95	* are only defined in the reference process descriptor.
[409]	96	* 2) The <vmm>, containing the VSL (list of registered vsegs), and the GPT (generic
	97	* page table), are only complete in the reference process cluster, other copies
	98	* are actually use as read-only caches.
[23]	99	* 3) the <fd_array>, containing extended pointers on the open file descriptors, is only
	100	* complete in the reference process cluster, other copies are read-only caches.
[173]	101	* 4) The <sem_root>, <mutex_root>, <barrier_root>, <condvar_root>, and the associated
[23]	102	* <sync_lock>, that are dynamically allocated, are only defined in the reference cluster.
[440]	103	* 5) The <children_root>, <children_nr>, <children_list>, and <txt_list> fields are only
[428]	104	* defined in the reference cluster, and are undefined in other clusters.
	105	* 6) The <local_list>, <copies_list>, <th_tbl>, <th_nr>, <th_lock> fields
[23]	106	* are defined in all process descriptors copies.
[433]	107	* 7) The termination <flags> and <exit_status> are only defined in the reference cluster.
[443]	108	* The term_state format is defined in the shared_syscalls.h file.
[1]	109	********************************************************************************************/
	110
	111	typedef struct process_s
	112	{
[23]	113	vmm_t vmm; /! embedded virtual memory manager /
[1]	114
[23]	115	fd_array_t fd_array; /! embedded open file descriptors array /
[1]	116
[173]	117	xptr_t vfs_root_xp; /! extended pointer on current VFS root inode /
[428]	118	xptr_t vfs_bin_xp; /! extended pointer on .elf file descriptor /
[23]	119	pid_t pid; /! process identifier /
	120	xptr_t ref_xp; /! extended pointer on reference process /
[443]	121	xptr_t owner_xp; /! extended pointer on owner process /
[428]	122	xptr_t parent_xp; /! extended pointer on parent process /
[1]	123
[23]	124	xptr_t vfs_cwd_xp; /! extended pointer on current working dir inode /
	125	remote_rwlock_t cwd_lock; /! lock protecting working directory changes /
[173]	126
[23]	127	xlist_entry_t children_root; /! root of the children process xlist /
[428]	128	remote_spinlock_t children_lock; /! lock protecting children process xlist /
[23]	129	uint32_t children_nr; /! number of children processes /
[1]	130
[428]	131	xlist_entry_t children_list; /! member of list of children of same parent /
[23]	132	xlist_entry_t local_list; /! member of list of process in same cluster /
	133	xlist_entry_t copies_list; /! member of list of copies of same process /
[428]	134	xlist_entry_t txt_list; /! member of list of processes sharing same TXT /
[1]	135
[23]	136	spinlock_t th_lock; /! lock protecting th_tbl[] concurrent access /
	137	uint32_t th_nr; /! number of threads in this cluster /
[428]	138
[23]	139	struct thread_s * th_tbl[CONFIG_THREAD_MAX_PER_CLUSTER]; /! pointers on local threads /
[1]	140
[23]	141	xlist_entry_t sem_root; /! root of the process semaphore list /
	142	xlist_entry_t mutex_root; /! root of the process mutex list /
	143	xlist_entry_t barrier_root; /! root of the process barrier list /
	144	xlist_entry_t condvar_root; /! root of the process condvar list /
[428]	145	remote_spinlock_t sync_lock; /! lock protecting sem,mutex,barrier,condvar lists /
[1]	146
[433]	147	uint32_t term_state; /! termination status (flags & exit status) /
[428]	148
	149	bool_t txt_owner; /! current TXT owner /
[1]	150	}
	151	process_t;
	152
	153	/*********************************************************************************************
[101]	154	* This structure defines the information required by the process_make_exec() function
[409]	155	* to create a new reference process descriptor, and the associated main thread.
[1]	156	********************************************************************************************/
	157
	158	typedef struct exec_info_s
	159	{
[23]	160	char path[CONFIG_VFS_MAX_PATH_LENGTH]; /! .elf file path /
[1]	161
	162	char ** args_pointers; /! physical base address of array of pointers /
	163	char * args_buf_base; /! physical base address of kernel args buffer /
	164	uint32_t args_nr; /! actual number of arguments /
	165
	166	char ** envs_pointers; /! physical base address of array of pointers /
	167	char * envs_buf_base; /! physical base address of kernel args buffer /
	168	char * envs_buf_free; /! physical address of first free slot in envs_buf /
	169	uint32_t envs_nr; /! actual number of environment variables /
	170	}
	171	exec_info_t;
	172
	173	/************* Process Descriptor Operations ***************************************/
	174
[173]	175	/*********************************************************************************************
	176	* This function allocates memory in local cluster for a process descriptor.
	177	*********************************************************************************************
[1]	178	* @ returns pointer on process descriptor if success / return NULL if failure
	179	********************************************************************************************/
	180	process_t * process_alloc();
	181
[173]	182	/*********************************************************************************************
	183	* This function releases memory in local cluster for a process descriptor.
	184	*********************************************************************************************
[1]	185	* @ process : pointer on process descriptor to release.
	186	********************************************************************************************/
	187	void process_free( process_t * process );
	188
[173]	189	/*********************************************************************************************
[428]	190	* This function initialize, in each cluster, the kernel "process_zero", that is the owner
	191	* of all kernel threads in a given cluster. It is called by the kernel_init() function.
	192	* The process_zero descriptor is allocated as a global variable in file kernel_init.c
	193	* Both the PID and PPID fields are set to zero, the ref_xp is the local process_zero,
	194	* and the parent process is set to XPTR_NULL. The th_tbl[] is initialized as empty.
	195	*********************************************************************************************
	196	* @ process : [in] pointer on local process descriptor to initialize.
	197	********************************************************************************************/
	198	void process_zero_create( process_t * process );
	199
	200	/*********************************************************************************************
[173]	201	* This function allocates memory and initializes the "process_init" descriptor and the
[409]	202	* associated "thread_init" descriptor. It is called once at the end of the kernel
[428]	203	* initialisation procedure. Its local process identifier is 1, and parent process
	204	* is the kernel process in cluster 0.
[173]	205	* The "process_init" is the first user process, and all other user processes will be forked
[101]	206	* from this process. The code executed by "process_init" is stored in a .elf file, whose
[409]	207	* pathname is defined by the CONFIG_PROCESS_INIT_PATH configuration variable.
[428]	208	* The process_init does not use the [STDIN/STDOUT/STDERR] streams, but it is linked
	209	* to kernel TXT0, because these streams must be defined for all user processes.
[173]	210	********************************************************************************************/
[1]	211	void process_init_create();
	212
[173]	213	/*********************************************************************************************
[428]	214	* This function initializes a local, reference, user process descriptor from another process
	215	* descriptor, defined by the <model_xp> argument. The <process> and <pid> arguments must
	216	* be previously allocated by he caller. This function can be called by three functions:
	217	* 1) process_init_create() : process is the reference INIT process / pid = 1 /
	218	* the parent and model process descriptors are both the kernel process_zero.
	219	* 2) process_make_fork() : the model process descriptor is the (generally remote)
	220	* parent process.
	221	* 3) process_make exec() : the model process is the local old_process, the new_process
	222	* parent is the same as the old_process parent.
	223	* The following fields are initialised :
	224	* - It set the pid / ppid / ref_xp / parent_xp / state fields.
[409]	225	* - It initializes the VMM (register the kentry, args, envs vsegs in VSL)
[408]	226	* - It initializes the FDT, defining the three pseudo files STDIN / STDOUT / STDERR.
	227	* - It set the root_xp, bin_xp, cwd_xp fields.
	228	* - It reset the children list as empty, but does NOT register it in parent children list.
	229	* - It reset the TH_TBL list of threads as empty.
	230	* - It reset the semaphore / mutex / barrier / condvar lists as empty.
	231	* - It registers the process in the local_list, rooted in the local cluster manager.
	232	* - It registers the process in the copies_list, rooted in the owner cluster manager.
	233	* - It registers the process extended pointer in the local pref_tbl[] array.
	234	*********************************************************************************************
	235	* @ process : [in] pointer on local process descriptor to initialize.
	236	* @ pid : [in] process identifier.
[428]	237	* @ parent_xp : [in] extended pointer on parent process descriptor.
	238	* @ model_xp : [in] extended pointer on model process descriptor.
[408]	239	********************************************************************************************/
[1]	240	void process_reference_init( process_t * process,
	241	pid_t pid,
[428]	242	xptr_t parent_xp,
[408]	243	xptr_t model_xp );
[1]	244
[173]	245	/*********************************************************************************************
	246	* This function initializes a copy process descriptor, in the local cluster,
	247	* from information defined in the reference remote process descriptor.
	248	*********************************************************************************************
[1]	249	* @ process : [in] local pointer on process descriptor to initialize.
	250	* @ reference_process_xp : [in] extended pointer on reference process descriptor.
	251	* @ return 0 if success / return ENOMEM if failure
	252	********************************************************************************************/
	253	error_t process_copy_init( process_t * local_process,
	254	xptr_t reference_process_xp );
	255
[173]	256	/*********************************************************************************************
[1]	257	* This function releases all memory allocated for a process descriptor in the local cluster,
[23]	258	* including memory allocated for embedded substructures (fd_array, vmm, etc).
[1]	259	* The local th_tbl[] array must be empty.
[173]	260	*********************************************************************************************
[1]	261	* @ process : pointer on the process descriptor.
	262	********************************************************************************************/
	263	void process_destroy( process_t * process );
	264
[173]	265	/*********************************************************************************************
[428]	266	* This debug function diplays on the kernel terminal TXT0 detailed informations on a
[443]	267	* process descriptor identified by the <process_xp> argument.
[428]	268	* It can be called by a thread running in any cluster.
[443]	269	* WARNING: this function uses the nolock_printk() function, and the TXT0 lock MUST be
	270	* taken by the caller function.
[428]	271	*********************************************************************************************
[443]	272	* @ process_xp : extended pointer on process descriptor.
[428]	273	********************************************************************************************/
	274	void process_display( xptr_t process_xp );
	275
	276	/*********************************************************************************************
	277	* This function returns a printable string defining the sigaction type.
	278	*********************************************************************************************
	279	* @ sigaction_type : BLOCK_ALL_THREADS / UNBLOCK_ALL_THREADS / DELETE_ALL_THREADS
	280	* @ return a string pointer.
	281	********************************************************************************************/
	282	char * process_action_str( uint32_t sigaction_type );
	283
	284	/*********************************************************************************************
[435]	285	* This function allows a client thread running in any cluster to block, unblock or delete
	286	* all threads of a process identified by the <pid> argument, depending on the
[436]	287	* <action_type> argument.
[440]	288	* WARNING : the DELETE and BLOCK actions are NOT executed on the target process main thread
	289	* (thread 0 in process owner cluster), and not executed on the calling thread itself.
[436]	290	* It uses the multicast, non blocking rpc_process_sigaction_client() function to send
[440]	291	* parallel requests to all remote clusters containing process copies.
[436]	292	* Then it blocks and deschedule to wait completion of these parallel requests.
	293	*
[416]	294	* It is used by the sys_kill() & sys_exit() functions to handle the "kill" & "exit" syscalls.
	295	* It is also used by the process_make_exec() function to handle the "exec" syscall.
[436]	296	* It is also called by the TXT device ISR to execute the ctrl C & ctrl Z commands.
	297	*
	298	* Implementation note:
	299	* This function allocates a - shared - RPC descriptor in client thread stack,
	300	* and initializes it. This RPC descriptor can be shared because all parallel,
	301	* non-blocking, RPC server threads use the same input arguments, including the
	302	* RPC responses counter field.
[409]	303	*********************************************************************************************
[435]	304	* @ pid : target process identifier.
[416]	305	* @ action_type : BLOCK_ALL_THREADS / UNBLOCK_ALL_THREADS / DELETE_ALL_THREADS
[1]	306	********************************************************************************************/
[435]	307	void process_sigaction( pid_t pid,
[409]	308	uint32_t action_type );
[1]	309
[173]	310	/*********************************************************************************************
[440]	311	* This function blocks all threads for a given <process> in the local cluster.
	312	* It scan the list of local thread, and sets the THREAD_BLOCKED_GLOBAL bit for all
	313	* threads, BUT the main thread (thread 0 in owner cluster), and the client thread
	314	* identified by the <client_xp> argument. It request the relevant schedulers to acknowledge
	315	* the blocking, using IPI if required, and returns only when all blockable threads
	316	* in cluster are actually blocked.
[416]	317	* The threads are not detached from the scheduler, and not detached from the local process.
[409]	318	*********************************************************************************************
	319	* @ process : pointer on the target process descriptor.
[440]	320	* @ client_xp : extended pointer on the client thread that should not be blocked.
[409]	321	********************************************************************************************/
[440]	322	void process_block_threads( process_t * process,
	323	xptr_t client_xp );
[409]	324
	325	/*********************************************************************************************
[440]	326	* This function marks for deletion all threads for a given <process> in the local cluster.
	327	* It scan the list of local thread, and sets the THREAD_FLAG_REQ_DELETE bit for all
	328	* threads, BUT the main thread (thread 0 in owner cluster), and the client thread
	329	* identified by the <client_xp> argument.
	330	* The actual deletion will be done by the scheduler at the next scheduling point.
[409]	331	*********************************************************************************************
	332	* @ process : pointer on the process descriptor.
[440]	333	* @ client_xp : extended pointer on the client thread that should not be marked.
[409]	334	********************************************************************************************/
[440]	335	void process_delete_threads( process_t * process,
	336	xptr_t client_xp );
[409]	337
	338	/*********************************************************************************************
[440]	339	* This function unblocks all threads of a given user process in a given cluster.
[409]	340	*********************************************************************************************
	341	* @ process : pointer on the process descriptor.
	342	********************************************************************************************/
[440]	343	void process_unblock_threads( process_t * process );
[409]	344
	345	/*********************************************************************************************
[1]	346	* This function returns a pointer on the local copy of a process identified by its PID.
[173]	347	* If this local copy does not exist yet, it is dynamically created, from the reference
[1]	348	* process descriptor, registered in the global copies_list, and registered in the local_list.
[23]	349	* This function is used by the thread_user_create() function.
[173]	350	*********************************************************************************************
[1]	351	* @ pid : searched process identifier.
	352	* @ returns pointer on the local process descriptor if success / returns NULL if failure.
	353	********************************************************************************************/
	354	process_t * process_get_local_copy( pid_t pid );
	355
[173]	356	/*********************************************************************************************
[436]	357	* This function returns the parent process identifier for a remote process descriptor
	358	* identified by an extended pointer.
	359	*********************************************************************************************
	360	* @ process_xp : extended pointer on remote process descriptor.
	361	* @ returns parent process dentifier.
	362	********************************************************************************************/
	363	pid_t process_get_ppid( xptr_t process_xp );
	364
	365	/*********************************************************************************************
[409]	366	* This function implements the "exec" system call, and is called by the sys_exec() function.
[408]	367	* The "new" process keep the "old" process PID and PPID, all open files, and env variables,
	368	* the vfs_root and vfs_cwd, but build a brand new memory image (new VMM from the new .elf).
[409]	369	* It actually creates a "new" reference process descriptor, and copies all relevant
	370	* information from the "old" process descriptor to the "new" process descriptor.
[408]	371	* It completes the "new" process descriptor, from information found in the <exec_info>
	372	* structure (defined in the process.h file), that must be built by the caller.
	373	* It creates and initializes the associated main thread. It finally destroys all copies
[409]	374	* of the "old" process in all clusters, and destroys all old associated threads.
[408]	375	* It is executed in the local cluster, that becomes both the "owner" and the "reference"
	376	* cluster for the "new" process.
[173]	377	*********************************************************************************************
[1]	378	* @ exec_info : [in] pointer on the exec_info structure.
	379	* @ return 0 if success / return non-zero if error.
	380	********************************************************************************************/
	381	error_t process_make_exec( exec_info_t * exec_info );
	382
[408]	383	/*********************************************************************************************
[443]	384	* This function implements the "fork" system call, and is called by the sys_fork() function,
	385	* likely throuch the RPC_PROCESS_MAKE_FORK.
	386	* It allocates memory and initializes a new "child" process descriptor, and the associated
	387	* "child" thread descriptor in local cluster. It involves up to three different clusters :
	388	* - the child (local) cluster can be any cluster selected by the sys_fork function.
[409]	389	* - the parent cluster must be the reference cluster for the parent process.
	390	* - the client cluster containing the thread requesting the fork can be any cluster.
[408]	391	* The new "child" process descriptor is initialised from informations found in the "parent"
	392	* reference process descriptor, containing the complete process description.
	393	* The new "child" thread descriptor is initialised from informations found in the "parent"
	394	* thread descriptor.
	395	*********************************************************************************************
	396	* @ parent_process_xp : extended pointer on the reference parent process.
	397	* @ parent_thread_xp : extended pointer on the parent thread requesting the fork.
	398	* @ child_pid : [out] child process identifier.
	399	* @ child_thread_ptr : [out] local pointer on child thread in target cluster.
	400	* @ return 0 if success / return non-zero if error.
	401	********************************************************************************************/
	402	error_t process_make_fork( xptr_t parent_process_xp,
	403	xptr_t parent_thread_xp,
	404	pid_t * child_pid,
	405	struct thread_s ** child_thread_ptr );
[1]	406
[446]	407
[173]	408	/****************** File Management Operations **************************************/
[1]	409
	410	/*********************************************************************************************
[173]	411	* This function initializes all entries of the local fd_array as empty.
	412	*********************************************************************************************
[1]	413	* @ process : pointer on the local process descriptor.
	414	********************************************************************************************/
	415	void process_fd_init( process_t * process );
	416
	417	/*********************************************************************************************
[23]	418	* This function uses as many remote accesses as required, to reset an entry in fd_array[],
[407]	419	* in all clusters containing a copy. The entry is identified by the <fdid> argument.
[173]	420	* This function must be executed by a thread running reference cluster, that contains
[23]	421	* the complete list of process descriptors copies.
[173]	422	*********************************************************************************************
[1]	423	* @ process : pointer on the local process descriptor.
[407]	424	* @ fdid : file descriptor index in the fd_array.
[1]	425	********************************************************************************************/
[23]	426	void process_fd_remove( process_t * process,
[407]	427	uint32_t fdid );
[1]	428
	429	/*********************************************************************************************
[173]	430	* This function returns an extended pointer on a file descriptor identified by its index
[23]	431	* in fd_array. It can be called by any thread running in any cluster.
[173]	432	* It accesses first the local process descriptor. In case of local miss, it uses remote
	433	* access to access the reference process descriptor.
	434	* It updates the local fd_array when the file descriptor exists in reference cluster.
[23]	435	* The file descriptor refcount is not incremented.
[173]	436	*********************************************************************************************
[1]	437	* @ process : pointer on the local process descriptor.
[407]	438	* @ fdid : file descriptor index in the fd_array.
[23]	439	* @ return extended pointer on file descriptor if success / return XPTR_NULL if not found.
[1]	440	********************************************************************************************/
[23]	441	xptr_t process_fd_get_xptr( process_t * process,
[407]	442	uint32_t fdid );
[1]	443
	444	/*********************************************************************************************
[173]	445	* This function checks the number of open files for a given process.
[23]	446	* It can be called by any thread in any cluster, because it uses portable remote access
	447	* primitives to access the reference process descriptor.
[173]	448	*********************************************************************************************
[23]	449	* @ returns true if file descriptor array full.
[1]	450	********************************************************************************************/
[23]	451	bool_t process_fd_array_full();
[1]	452
	453	/*********************************************************************************************
[23]	454	* This function allocates a free slot in the fd_array of the reference process,
	455	* register the <file_xp> argument in the allocated slot, and return the slot index.
	456	* It can be called by any thread in any cluster, because it uses portable remote access
	457	* primitives to access the reference process descriptor.
[173]	458	*********************************************************************************************
[23]	459	* @ file_xp : extended pointer on the file descriptor to be registered.
[407]	460	* @ fdid : [out] buffer for fd_array slot index.
[23]	461	* @ return 0 if success / return EMFILE if array full.
[1]	462	********************************************************************************************/
[407]	463	error_t process_fd_register( process_t * process,
	464	xptr_t file_xp,
	465	uint32_t * fdid );
[1]	466
	467	/*********************************************************************************************
[409]	468	* This function copies all non-zero entries (other than the three first stdin/stdout/stderr)
	469	* from a remote <src_xp> fd_array, embedded in a process descriptor, to another remote
	470	* <dst_xp> fd_array, embedded in another process descriptor.
	471	* The calling thread can be running in any cluster.
[1]	472	* It takes the remote lock protecting the <src_xp> fd_array during the copy.
[173]	473	* For each involved file descriptor, the refcount is incremented.
	474	*********************************************************************************************
[1]	475	* @ dst_xp : extended pointer on the destination fd_array_t.
	476	* @ src_xp : extended pointer on the source fd_array_t.
	477	********************************************************************************************/
	478	void process_fd_remote_copy( xptr_t dst_xp,
	479	xptr_t src_xp );
	480
	481
[23]	482
[173]	483	/****************** Thread Related Operations ***************************************/
[1]	484
	485	/*********************************************************************************************
	486	* This function registers a new thread in the local process descriptor.
	487	* It checks that there is an available slot in the local th_tbl[] array,
	488	* allocates a new LTID, and registers the new thread in the th_tbl[].
[443]	489	* It takes the lock protecting exclusive access to the th_tbl[].
[173]	490	*********************************************************************************************
[1]	491	* @ process : pointer on the local process descriptor.
	492	* @ thread : pointer on new thread to be registered.
	493	* @ trdid : [out] address of buffer for allocated trdid.
	494	* @ returns 0 if success / returns non zero if no slot available.
	495	********************************************************************************************/
	496	error_t process_register_thread( process_t * process,
	497	struct thread_s * thread,
	498	trdid_t * trdid );
	499
	500	/*********************************************************************************************
	501	* This function removes a thread registration from the local process descriptor.
[443]	502	* It takes the lock protecting exclusive access to the th_tbl[].
[173]	503	*********************************************************************************************
[1]	504	* @ thread : local pointer on thread to be removed.
[443]	505	* @ return true if the removed thread was the last registered thread.
[1]	506	********************************************************************************************/
[443]	507	bool_t process_remove_thread( struct thread_s * thread );
[1]	508
	509
[428]	510	/************* Terminals related operations ******************************************/
[1]	511
[428]	512	/*********************************************************************************************
	513	* This function scan the set of user TXT terminals to find a free terminal
	514	* (the list of attached processes is empty for a free TXT terminal).
	515	* It is called only by the process_reference_init() function when creating a KSH process.
	516	* It makes a kernel panic if no free TXT terminal is found.
[441]	517	* The allocated TXT terminal is only released if the KSH process is deleted,
	518	* which is a rare and abnormal event.
[428]	519	*********************************************************************************************
	520	* @ return TXT terminal index if succes / kernel panic if no terminal found.
	521	********************************************************************************************/
	522	uint32_t process_txt_alloc();
	523
	524	/*********************************************************************************************
[450]	525	* This function attach a process, identified by the <process> argument to a TXT terminal,
	526	* identified by the <txt_id> channel index argument.
	527	* The process descriptor identified by the <process> argument must be in the owner cluster.
[428]	528	* It insert the process descriptor in the xlist rooted in the TXT_RX device.
	529	* It is called by the process_reference_init() function.
	530	*********************************************************************************************
	531	* @ process : local pointer on process descriptor.
	532	* @ txt_id : TXT channel index.
	533	********************************************************************************************/
	534	void process_txt_attach( process_t * process,
	535	uint32_t txt_id );
	536
	537	/*********************************************************************************************
[436]	538	* This function detach a process, identified by the <process_xp> argument,
[446]	539	* from the list of process attached to a given TXT terminal. It transfer the TXT ownership
	540	* to another process, if the detached process is the TXT owner.
	541	* The process descriptor identified by the <process_xp> argument must be in the owner
	542	* cluster, but the calling thread can be running in any cluster.
[428]	543	*********************************************************************************************
[436]	544	* @ process_xp : extended pointer on process descriptor.
[428]	545	********************************************************************************************/
[436]	546	void process_txt_detach( xptr_t process_xp );
[428]	547
	548	/*********************************************************************************************
[436]	549	* This function gives to a process identified by the <owner_xp> argument, and attached
[428]	550	* to terminal TXT[i] the exclusive ownership of the TXT_RX[i] terminal.
[436]	551	* The process descriptor must be in the process owner cluster.
[428]	552	*********************************************************************************************
[436]	553	* @ owner_xp : extended pointer on process descriptor in owner cluster.
[428]	554	********************************************************************************************/
[436]	555	void process_txt_set_ownership( xptr_t owner_xp );
[428]	556
	557	/*********************************************************************************************
[436]	558	* When the process dentified by the <owner_xp> argument has the exclusive ownership of
	559	* the TXT_RX terminal, this function transfer this ownership to another attached process.
[443]	560	* The process descriptor must be the process owner.
	561	* This function does nothing if the process identified by the <process_xp> is not
	562	* the TXT owner.
[436]	563	* - If the current owner is not the KSH process, the new owner is the KSH process.
[443]	564	* - If the current owner is the KSH process, the new owner is another attached process.
[436]	565	* - If there is no other attached process, the TXT has no more defined owner.
[428]	566	*********************************************************************************************
[436]	567	* @ owner_xp : extended pointer on process descriptor in owner cluster.
[428]	568	********************************************************************************************/
[436]	569	void process_txt_transfer_ownership( xptr_t owner_xp );
[428]	570
[435]	571	/*********************************************************************************************
[436]	572	* This function returns the TXT owner process (foreground process)
[435]	573	* for a given TXT terminal identified by its <channel> index.
	574	*********************************************************************************************
	575	* @ channel : TXT terminal channel.
[436]	576	* @ return extentded pointer on TXT owner process in owner cluster.
[435]	577	********************************************************************************************/
[436]	578	xptr_t process_txt_get_owner( uint32_t channel );
[435]	579
	580	/*********************************************************************************************
	581	* This debug function diplays on the kernel terminal the list of processes attached
	582	* to a given terminal identified by the <txt_id> argument.
	583	*********************************************************************************************
	584	* @ txt_id : TXT terminal channel.
	585	********************************************************************************************/
	586	void process_txt_display( uint32_t txt_id );
	587
	588
[1]	589	#endif /* _PROCESS_H_ */

Note: See TracBrowser for help on using the repository browser.

Download in other formats: