clock.c

T-kernel 的extension源代码

		}

		/* Obtain the system time. */
		*time = getSysTime();
	}

	if ( tz != NULL ) {
		err = CheckSpaceRW(tz, sizeof(*tz));
		if ( err < E_OK ) {
			goto err_ret;
		}

		/* Obtain the time correction data. */
		LOCK_CM( *tz = clkInfo.tz );
	}

	return E_OK;

err_ret:
	DEBUG_PRINT(("_tkse_get_tim2 err = %d\n", err));
	return err;
}

/*
 * Set the system time.
 */
LOCAL ER _tkse_set_tim2( STIME time, TIMEZONE *tz )
{
	ER	err;

	if ( (time == TSD_TT2_VAL_M1) && (tz == NULL) ) {
		/* Special request: Initialize the time. */
		err = InitSystemTime();
		if ( err < E_OK ) {
			goto err_ret;
		}

		return E_OK;
	}

#ifdef CHECK_USERLEVEL
	if ( GetUserLevel(TSK_SELF) != 0 ) {
		err = E_FACV;
		goto err_ret;
	}
#endif

	/* Parameter check */
	if ( tz != NULL ) {
		err = CheckSpaceR(tz, sizeof(*tz));
		if ( err < E_OK ) {
			goto err_ret;
		}
		err = checkTIMEZONE(tz);
		if ( err < E_OK ) {
			goto err_ret;
		}
	}

	if ( (time > 0) || (tz != NULL) ) {
		/* Set the system time. */
		err = SetSystemTime(time, tz);
		if ( err < E_OK ) {
			goto err_ret;
		}
	}

	return E_OK;

err_ret:
	DEBUG_PRINT(("_tkse_set_tim2 err = %d\n", err));
	return err;
}

/*
 * Obtain/Convert the date/time.
 */
LOCAL ER _tkse_get_tod( DATE_TIM *date_tim, STIME time, BOOL local )
{
	ER	err;

	/* Parameter check */
	err = CheckSpaceRW(date_tim, sizeof(*date_tim));
	if ( err < E_OK ) {
		goto err_ret;
	}

	if ( time <= 0 ) {
		/* Use the system time. */
		time = getSysTime();
	}

	if ( local != 0 ) {
		/* Local time correction */
		LOCK_CM( time = GMTtoLT(time, &clkInfo.tz) );
	}

	/* Convert into the calendar day/time. */
	TIMEtoDATE(date_tim, time);

	return E_OK;

err_ret:
	DEBUG_PRINT(("_tkse_get_tod err = %d\n", err));
	return err;
}

/*
 * Set/Convert the date/time.
 */
LOCAL ER _tkse_set_tod( DATE_TIM *date_tim, STIME *time, BOOL local )
{
	STIME	t;
	ER	err;

	/* Parameter check */
	err = CheckSpaceR(date_tim, sizeof(*date_tim));
	if ( err < E_OK ) {
		goto err_ret;
	}
	err = checkDATE_TIM(date_tim);
	if ( err < E_OK ) {
		goto err_ret;
	}

	if ( time != NULL ) {
		err = CheckSpaceRW(time, sizeof(*time));
		if ( err < E_OK ) {
			goto err_ret;
		}
	} else {
#ifdef CHECK_USERLEVEL
		if ( GetUserLevel(TSK_SELF) != 0 ){
			err = E_FACV;
			goto err_ret;
		}
#endif
	}

	/* Convert the calendar day/time into the total number of seconds. */
	DATEtoTIME(&t, date_tim);

	if ( local != 0 ) {
		/* Reverse correction of the local time  */
		LOCK_CM( t = LTtoGMT(t, &clkInfo.tz) );
		if ( t < 0 ) {
			err = E_PAR;
			goto err_ret;
		}
	}

	if ( time != NULL ) {
		*time = t;
	} else {
		/* Set the system time. */
		err = SetSystemTime(t, NULL);
		if ( err < E_OK ) {
			goto err_ret;
		}
	}

	return E_OK;

err_ret:
	DEBUG_PRINT(("_tkse_set_tod err = %d\n", err));
	return err;
}

/*
 * Set the system time.
 */
LOCAL ER _tkse_set_tim( SYSTIM *pk_tim )
{
	SYSTIM	tim;	/* Use it to set it through resident memory */
	ER	err;

	err = ChkSpaceR(pk_tim, sizeof(SYSTIM));
	if ( err < E_OK ) {
		goto err_ret;
	}

#ifdef CHECK_USERLEVEL
	err = GetUserLevel(TSK_SELF);
	if ( err != 0 ) {
		err = E_OACV;
		goto err_ret;
	}
#endif

	tim = *pk_tim;
	err = tk_set_tim(&tim);

err_ret:
	DEBUG_PRINT(("_tkse_set_tim err = %d\n", err));
	return err;
}

/*
 * Obtain the system time.
 */
LOCAL ER _tkse_get_tim( SYSTIM *pk_tim )
{
	SYSTIM	tim;	/* Use it for resident memory once to take it out */
	ER	err;

	err = ChkSpaceRW(pk_tim, sizeof(SYSTIM));
	if ( err < E_OK ) {
		goto err_ret;
	}

	err = tk_get_tim(&tim);
	*pk_tim = tim;

err_ret:
	DEBUG_PRINT(("_tkse_get_tim err = %d\n", err));
	return err;
}

/*
 * Obtain the system operating time.
 */
LOCAL ER _tkse_get_otm( SYSTIM *pk_tim )
{
	SYSTIM	tim;	/* Use it for resident memory once to take it out */
	ER	err;

	err = ChkSpaceRW(pk_tim, sizeof(SYSTIM));
	if ( err < E_OK ) {
		goto err_ret;
	}

	err = tk_get_otm(&tim);
	*pk_tim = tim;

err_ret:
	DEBUG_PRINT(("_tkse_get_otm err = %d\n", err));
	return err;
}
/* ------------------------------------------------------------------------ */

/*
 * System call entry
 */
LOCAL WER SyscallEntry( VP para, W fn )
{
	switch ( fn ) {
	  case CM_GET_TIM2_FN: {
		CM_GET_TIM2_PARA *p = para;
		return _tkse_get_tim2(p->time, p->tz);
	  }
	  case CM_SET_TIM2_FN: {
		CM_SET_TIM2_PARA *p = para;
		return _tkse_set_tim2(p->time, p->tz);
	  }
	  case CM_GET_TOD_FN: {
		CM_GET_TOD_PARA *p = para;
		return _tkse_get_tod(p->date_tim, p->time, p->local);
	  }
	  case CM_SET_TOD_FN: {
		CM_SET_TOD_PARA *p = para;
		return _tkse_set_tod(p->date_tim, p->time, p->local);
	  }
	  case CM_SET_TIM_FN: {
		CM_SET_TIM_PARA *p = para;
		return _tkse_set_tim(p->pk_tim);
	  }
	  case CM_GET_TIM_FN: {
		CM_GET_TIM_PARA *p = para;
		return _tkse_get_tim(p->pk_tim);
	  }
	  case CM_GET_OTM_FN: {
		CM_GET_OTM_PARA *p = para;
		return _tkse_get_otm(p->pk_tim);
	  }
	  default: {
		/* nothing to do */
		break;
	  }
	}
	return E_RSFN;
}

/*
 * Initialization
 */
LOCAL ER initialize( void )
{
	T_DSSY	dssy;
	W	n, w[L_SYSCONF_VAL];
	ER	err;

	/* ON/OFF of the time update notification */
	n = GetSysConf((UB*)"CmClkUpd", w);
	if ( n > 1 ) {
		err = E_SYS;
		goto err_ret;
	}
	clkInfo.clkupd = ( n == 1 )? w[0]: 1;
	clkInfo.cycid  = 0;

	/* Default of the local time is Japan Standard Time (JST). */
	clkInfo.tz.adjust  = -(TSD_CLO_HUR_9 * TSD_CLO_HUR_60 * TSD_CLO_SEC_60);
	clkInfo.tz.dst_flg = 0;
	clkInfo.tz.dst_adj = 0;

	/* Generate a lock. */
	err = CreateLock(&clkInfo.lk, (UB*)"Clk");
	if ( err < E_OK ) {
		goto err_ret;
	}

	/* Registr the manager. */
	dssy.ssyatr    = TA_NULL;
	dssy.ssypri    = CM_PRI;
	dssy.svchdr    = (FP)SyscallEntry;
	dssy.breakfn   = NULL;
	dssy.startupfn = NULL;
	dssy.cleanupfn = NULL;
	dssy.eventfn   = NULL;
	dssy.resblksz  = 0;
	err = tk_def_ssy(CM_SVC, &dssy);
	if ( err < E_OK ) {
		goto err_ret;
	}

	return E_OK;

err_ret:
	DEBUG_PRINT(("initialize err = %d\n", err));
	return err;
}

/*
 * End processing
 */
LOCAL ER finish( void )
{
	ER	err, error = E_OK;

	/* Deregister the manager. */
	err = tk_def_ssy(CM_SVC, NULL);
	if ( err < E_OK ) {
		error = err;
	}

	/* Stop the cyclic start handler. */
	if ( clkInfo.cycid > 0 ) {
		err = tk_del_cyc(clkInfo.cycid);
		if ( err < E_OK ) {
			error = err;
		}
		clkInfo.cycid = 0;
	}

	/* Delete the lock. */
	DeleteLock(&clkInfo.lk);

#ifdef DEBUG
	if ( error < E_OK ) {
		DEBUG_PRINT(("finish err = %d\n", error));
	}
#endif
	return error;
}

/*
 * Time management entry (Initialization/End)
 */
EXPORT ER ClockMgr( INT ac, UB *av[] )
{
	ER	err;

	if ( ac >= 0 ) {
		/* Initialization */
		err = initialize();
		if ( err < E_OK ) {
			finish();
		}
	} else {
		/* End processing */
		err = finish();
	}
	return err;
}