main.c

T-kernel 的extension源代码

/*
 *----------------------------------------------------------------------
 *    T-Kernel / Standard Extension
 *
 *    Copyright (C) 2006 by Ken Sakamura. All rights reserved.
 *    T-Kernel / Standard Extension is distributed 
 *      under the T-License for T-Kernel / Standard Extension.
 *----------------------------------------------------------------------
 *
 *    Version:   1.00.00
 *    Released by T-Engine Forum(http://www.t-engine.org) at 2006/8/11.
 *
 *----------------------------------------------------------------------
 */

/*
 *	main.c (file)
 *
 *	File management
 *	Initialize/Terminate the manager.
 */

#include "fminfo.h"


LOCAL ER initialize( void );
LOCAL ER finish( void );

#define TSD_INM_N_2	2
#define TSD_INM_I_2	2

/*
 * Information of the file management common section.
 */
EXPORT FmInfo	fmInfo;

/*
 * Static data
 */
EXPORT /*const*/ T_CPOR	fmPortAttr = FmPortAttr;  /* Rendezvous port attribute */


/*
 * Initialize the manager.
 */
LOCAL ER initialize( void )
{
	W	i;

	/* Clear the file management common information. */
	memset(&fmInfo, 0, (size_t)sizeof(fmInfo));

	/* Obtain the system configuration information. */
	{	W	w[L_SYSCONF_VAL];
		W	n;

		/* Obtain the task priority. */
		n = GetSysConf((UB*)"FmTskPri", w);
		if ( n != TSD_INM_N_2 ) {
			DEBUG_PRINT(("init: get FmTskPri error\n"));
			return E_SYS;
		}
		fmInfo.mgrTskPri = w[0];
		fmInfo.fsTskPri = w[1];

		/* Obtain the maximum number of files that can be opened at a time */
		n = GetSysConf((UB*)"MaxOpenF", w);
		if ( n != 1 ) {
			DEBUG_PRINT(("init: get MaxOpenF error\n"));
			return E_SYS;
		}
		fmInfo.maxOpenFile = w[0];

		/* Obtain the synchronization timeout time. */
		n = GetSysConf((UB*)"SyncTimeOut", w);
		fmInfo.syncTimeOut = ( n == 1 )? w[0]: TMO_FEVR;

		/* Obtain the time stamp update control. */
		n = GetSysConf((UB*)"FmTimeStamp", w);
		fmInfo.updTimeStamp = ( n == 1 )? (UH)w[0]: 0;
	}

	/* Create the lock for exclusive access. */
	{	ER	err;

		err = CreateLock(&fmInfo.lock, (UB*)"FMgr");
		if ( err != E_OK ) {
			DEBUG_PRINT(("init: create lock err = %d\n", err));
			return err;
		}
	}

	/* Create the rendezvous port for file manager call. */
	{	ER	err;

		SetOBJNAME(fmPortAttr.exinf, "FMgr");
		err = tk_cre_por(&fmPortAttr);
		if ( err < E_OK ) {
			DEBUG_PRINT(("init: tk_cre_por er = %d\n", err));
			return ERtoERR(err);
		}
		fmInfo.entryPort = (ID)err;
	}

	/* Create the semaphore for the synchronous execution control flag. */
	{	static T_CSEM	csem = SyncExecFlagAttr;
		ER		err;

		SetOBJNAME(csem.exinf, "FmSE");
		err = tk_cre_sem(&csem);
		if ( err < E_OK ) {
			DEBUG_PRINT(("init: tk_cre_sem er = %d\n", err));
			return ERtoERR(err);
		}
		fmInfo.syncExecFlag = (ID)err;
	}

#if !USE_PROCESS_MANAGER
	/* Set the default process information. */
	{	ER		err;

		err = InitDefaultPinfo();
		if ( err != E_OK ) {
			DEBUG_PRINT(("init: InitDefaultPinfo er = %d\n", err));
			return ERtoERR(err);
		}
	}
#endif

	/* Generate/Start the manager task.
	 *	Use two tasks: One for reception and the other for forwarding.
	 */
	for ( i = 0; i < TSD_INM_I_2; ++i ) {
		T_CTSK	ctsk;
		ID	tskid;
		UINT	calptn;
		ER	er;

		calptn = ( i == 0 )? (UINT)(Syscall_APL|Syscall_OS): (UINT)Syscall_OWN;

		SetMgrTaskAttr(&ctsk, fmInfo.mgrTskPri);
		er = tk_cre_tsk(&ctsk);
		if ( er < E_OK ) {
			DEBUG_PRINT(("init: tk_cre_tsk er = %d\n", er));
			return ERtoERR(er);
		}
		tskid = (ID)er;

		er = tk_sta_tsk(tskid, (INT)calptn);
		if ( er != E_OK ) {
			(void)tk_del_tsk(tskid);

			DEBUG_PRINT(("init: tk_sta_tsk er = %d\n", er));
			return ERtoERR(er);
		}
		fmInfo.mgrTaskID[i] = tskid;
	}

	/* Issue the initialization request to the task manager. */
	{	FmCmdPkt	pkt = NIL;
		ER		err;

		pkt.cmd.fno.w = FM_INIT_FN;  /* Initialization request */

		err = fmCallMgrTask(&pkt, Syscall_OWN);
		if ( err != E_OK ) {
			DEBUG_PRINT(("init: CallMgrTask err = %d\n", err));
			return err;
		}
		if ( pkt.cmd.ret != E_OK ) {
			DEBUG_PRINT(("InitMgrTask err = %d\n", pkt.cmd.ret));
			return pkt.cmd.ret;
		}
	}

	/* Register the extended SVC manager service function. */
	{	ER	err;

		err = fmDefineEntries(TRUE);
		if ( err != E_OK ) {
			DEBUG_PRINT(("init: DefineEntries err = %d\n", err));
			return err;
		}
	}

	return E_OK;
}

/*
 * Terminate the manager.
 */
LOCAL ER finish( void )
{
	W	i;
	ER	error = E_OK;

	/* Deregister the extended SVC manager service function. */
	{	ER	err;

		err = fmDefineEntries(FALSE);
		if ( err != E_OK ) {
			DEBUG_PRINT(("finish: DefineEntries err = %d\n", err));
			error = err;
		}
	}

	/* Issue the termination request to the task manager. */
	if ( fmInfo.mgrTaskID[1] != InvalidID ) {

		FmCmdPkt	pkt = NIL;
		ER		err;

		pkt.cmd.fno.w = FM_FINISH_FN;  /* Termination request */

		err = fmCallMgrTask(&pkt, Syscall_OWN);
		if ( err != E_OK ) {
			DEBUG_PRINT(("finish: CallMgrTask err = %d\n", err));
			error = err;
		}
		if ( pkt.cmd.ret != E_OK ) {
			DEBUG_PRINT(("FinishMgrTask err = %d\n", pkt.cmd.ret));
			error = pkt.cmd.ret;
		}
	}

	/* Delete the manager task. */
	for ( i = 0; i < TSD_INM_I_2; ++i ) {
		ID	tskid;
		ER	er;

		tskid = fmInfo.mgrTaskID[i];
		if ( tskid == InvalidID ) {
			continue;
		}

		er = tk_ter_tsk(tskid);
		if ( er < E_OK ) {
			DEBUG_PRINT(("finish: tk_ter_tsk er = %d\n", er));
			error = ERtoERR(er);
		}
		er = tk_del_tsk(tskid);
		if ( er != E_OK ) {
			DEBUG_PRINT(("finish: tk_del_tsk er = %d\n", er));
			error = ERtoERR(er);
		}
	}

	/* Delete the semaphore for the synchronous execution control flag. */
	if ( fmInfo.syncExecFlag != InvalidID ) {
		ER	er;

		er = tk_del_sem(fmInfo.syncExecFlag);
		if ( er < E_OK ) {
			DEBUG_PRINT(("finish: tk_del_sem er = %d\n", er));
			error = ERtoERR(er);
		}
	}

	/* Delete the rendezvous port for file manager call. */
	if ( fmInfo.entryPort != InvalidID ) {
		ER	er;

		er = tk_del_por(fmInfo.entryPort);
		if ( er < E_OK ) {
			DEBUG_PRINT(("finish: tk_del_por er = %d\n", er));
			error = ERtoERR(er);
		}
	}

	/* Delete the lock for exclusive access. */
	DeleteLock(&fmInfo.lock);

	return error;
}

/*
 * Manager entry
 *	(Initialization/Termination)
 */
EXPORT ER FileMgr( INT ac, UB *av[] )
{
	ER	err;

	if ( ac >= 0 ) {
		/* Initialization */
		err = initialize();
		if ( err != E_OK ) {
			/* Initialization failed. */
			(void)finish();
		}
	} else {
		/* Termination */
		err = finish();
	}

	return err;
}