void USB_OTG_BSP_mDelay (const uint32_t msec)
{
//USB_OTG_BSP_uDelay(msec * 1000);
_wait(msec,_proc_loop);
}
void fan_rpm_task(void)
{
fan_rpm = get_fan_int_counter() * 10 * 60 / 4;
_wait(MILLI_SEC(100));
}
// PD_TRACE_DECLARE_FUNCTION ( SDB__CLSSYNCMAG_SYNC, "_clsSyncManager::sync" )
INT32 _clsSyncManager::sync( _clsSyncSession &session,
const UINT32 &w,
INT64 timeout )
{
PD_TRACE_ENTRY ( SDB__CLSSYNCMAG_SYNC ) ;
SDB_ASSERT( w <= CLS_REPLSET_MAX_NODE_SIZE &&
CLS_REPLSE_WRITE_ONE <= w,
"1 <= sync num <= CLS_REPLSET_MAX_NODE_SIZE" ) ;
SDB_ASSERT( NULL != session.eduCB, "educb should not be NULL" ) ;
SDB_ASSERT( DPS_INVALID_LSN_OFFSET != session.endLsn,
"end lsn should not be valid" ) ;
INT32 rc = SDB_OK ;
UINT32 sub = 0;
BOOLEAN needWait = TRUE ;
if ( w <= CLS_REPLSE_WRITE_ONE )
{
goto done ;
}
_info->mtx.lock_r() ;
if ( 0 == _validSync )
{
_info->mtx.release_r() ;
goto done ;
}
else if ( _aliveCount < _validSync && w > _aliveCount + 1 )
{
rc = SDB_CLS_WAIT_SYNC_FAILED ;
_info->mtx.release_r() ;
goto error ;
}
else if ( w > _validSync + 1 )
{
sub = CLS_W_2_SUB( _validSync + 1 ) ;
}
else
{
sub = CLS_W_2_SUB( w ) ;
}
_mtxs[sub].get() ;
if ( DPS_INVALID_LSN_OFFSET != _checkList[sub] &&
session.endLsn < _checkList[sub] )
{
needWait = FALSE ;
}
else
{
rc = _syncList[sub].push( session ) ;
}
_mtxs[sub].release() ;
_info->mtx.release_r() ;
if ( SDB_OK != rc )
{
goto error ;
}
else if ( needWait )
{
rc = _wait( session.eduCB, sub, timeout ) ;
}
done:
PD_TRACE_EXITRC ( SDB__CLSSYNCMAG_SYNC, rc ) ;
return rc ;
error:
goto done ;
}
T& wait()
{
_wait();
return std::move(*_result);
}
void wait()
{
_wait();
}
void MicroDelay(unsigned int t){_wait(t);}
/* only support one operator in a command :
* cat < README
* cat README > newfile
* ls | cat
*/
static int parse_cmd(int argc, char **argv) {
int i;
int fd;
int pid, pid2;
int pfd[2];
char argcmd[LEN_CMD];
char type;
char **argv2;
type = ' ';
/* need a argument after >, < or | */
for (i = 1; i < argc - 1; i++) {
if (strcmp("<", argv[i]) == 0
|| strcmp(">", argv[i]) == 0
|| strcmp("|", argv[i]) == 0) {
argc = i;
argv2 = &argv[i+1];
type = argv[i][0];
argv[i] = 0;
break;
}
}
pid = _fork();
/********** in new process **********/
if (pid == 0) {
switch(type) {
case '<':{
if ((fd = _open(argv2[0], O_RONLY)) < 0) {
printf("sh1: can not open file `%s`\n", argv2[0]);
_exit();
}
if (_close(stdin) < 0) {
puts("sh1: can not close stdin\n");
_exit();
}
if (_dup(fd) < 0) {
puts("sh1: can not close stdin\n");
_exit();
}
break;
}
case '>':{
if ((fd = _open(argv2[0], O_RW | O_CREATE)) < 0) {
printf("sh1: can not open file `%s`\n", argv2[0]);
_exit();
}
if (_close(stdout) < 0) {
puts("sh1: can not close stdout\n");
_exit();
}
if (_dup(fd) < 0) {
puts("sh1: can not close stdin\n");
_exit();
}
break;
}
case '|':{
if (_pipe(pfd) < 0) {
puts("sh1: pipe\n");
_exit();
}
pid2 = _fork();
if (pid2 == 0) {
if (_close(stdin) < 0) {
printf("sh2: can not close stdin\n");
_exit();
}
if (_dup(pfd[0]) != stdin) {
printf("sh2: can not dup fd0\n");
_close(pfd[0]);
_exit();
}
memset(argcmd, 0, sizeof(argcmd));
strcpy(argcmd, "/bin/");
strcat(argcmd, argv2[0]);
if (_exec(argcmd, argv2) < 0) {
printf("sh2: can not exec %s\n", argcmd);
_close(pfd[0]);
_close(stdin);
_exit();
}
} else if (pid2 < 0) {
printf("sh2: fork fail\n");
_close(pfd[0]);
_close(stdin);
_exit();
}
break;
}
default:
break;
}
if (type == '|') {
if (_close(stdout) < 0) {
_close(pfd[1]);
_exit();
}
if (_dup(pfd[1]) != stdout) {
_close(pfd[1]);
_exit();
}
}
memset(argcmd, 0, sizeof(argcmd));
strcpy(argcmd, "/bin/");
strcat(argcmd, argv[0]);
if (_exec(argcmd, argv) < 0) {
/* when type == '|' when argv2 is invaild, printf maybe cause sleeping */
if (type != '|') printf("sh1: can not exec %s\n", argcmd);
_close(pfd[1]);
_close(stdin);
_exit();
}
/**********************************/
} else if (pid > 0) {
if (_wait() < 0) {
printf("sh: wait %d return -1\n", pid);
goto bad;
}
} else {
printf("sh: fork fail");
goto bad;
}
return 0;
bad:
return -1;
}
void CappedInsertNotifier::wait(Microseconds timeout) const {
stdx::unique_lock<stdx::mutex> lk(_mutex);
_wait(lk, _version, timeout);
}
void CappedInsertNotifier::wait() const {
stdx::unique_lock<stdx::mutex> lk(_mutex);
_wait(lk, _version, Microseconds::max());
}
Waitmsg*
p9waitfor(int pid)
{
return _wait(pid, 0);
}
Waitmsg*
p9waitnohang(void)
{
return _wait(-1, WNOHANG);
}
Waitmsg*
p9wait(void)
{
return _wait(-1, 0);
}
bool epoll_wait_call::wait_os(bool zero_timeout)
{
return _wait(zero_timeout ? 0 : m_timeout);
}
//Pessoa viaja
void person_travel(ElevatorMonitor* monitor, int thread, int person_current_floor, int destiny, buffer* buff){
pthread_mutex_lock(&monitor->monitorGlobalLock);
int inside = 0;
//Se a pessoa tem que ir para o mesmo andar que já está, retorna
if (person_current_floor == destiny) {
pthread_mutex_unlock(&monitor->monitorGlobalLock);
return;
}
//Descobre a direção do movimento da pessoa
int dir = UP;
if (destiny < person_current_floor) {
dir = DOWN;
}
else{
dir = UP;
}
//Se o elevador esta parado, com a porta aberta, indo para o mesmo sentido e não lotado, entra
if(monitor->currentFloor == person_current_floor
&& monitor->doorState == DOOR_OPEN
&& monitor->people_inside < monitor->capacity
&& monitor->movementState == dir){
inside = 1;
}
//Enquanto não entra, tenta entrar
while(!inside) {
//Se quer subir
if(person_current_floor < destiny){
//Aperta o botão no painel
if (!outsidePanel_is_up_button_on(monitor->outside_panels[person_current_floor])) {
buffer_write(buff, thread, monitor->start_time, 'S', person_current_floor);
outsidePanel_turn_on_up_button(monitor->outside_panels[person_current_floor]);
}
//Sinaliza para o elevador que ele tem um andar para ir.
pthread_cond_signal(&monitor->hasFloorToGo);
dir = UP;
buffer_write(buff, thread, monitor->start_time, 'B', monitor->currentFloor);
//Espera o elevador chegar e chamar as pessoas que querem subir
pthread_cond_wait(monitor->floorUpConditions+person_current_floor, &monitor->monitorGlobalLock);
buffer_write(buff, thread, monitor->start_time, 'E', monitor->currentFloor);
}
//Se quer descer
else if(person_current_floor > destiny){
//Aperta o botão
if (!outsidePanel_is_down_button_on(monitor->outside_panels[person_current_floor])) {
buffer_write(buff, thread, monitor->start_time, 'D', person_current_floor);
outsidePanel_turn_on_down_button(monitor->outside_panels[person_current_floor]);
}
pthread_cond_signal(&monitor->hasFloorToGo);
dir = DOWN;
buffer_write(buff, thread, monitor->start_time, 'B', monitor->currentFloor);
//Espera o elevador chamar e verificar se pode descer
pthread_cond_wait(monitor->floorDownConditions+person_current_floor, &monitor->monitorGlobalLock);
buffer_write(buff, thread, monitor->start_time, 'E', monitor->currentFloor);
}
//Pode entrar?
if(monitor->people_inside < monitor->capacity && monitor->currentFloor == person_current_floor && monitor->doorState == DOOR_OPEN){
inside = 1;
pthread_cond_signal(&monitor->hasFloorToGo);
//Avisa para mais pessoas entrarem
if(dir == UP){
pthread_cond_signal(monitor->floorUpConditions+person_current_floor);
}
else{
pthread_cond_signal(monitor->floorDownConditions+person_current_floor);
}
//Se não pode entrar, espera um tempo até chamar de novo
}else{
_wait(monitor, (2*TIME_FOR_PEOPLE_TO_LEAVE));
}
}
buffer_write(buff, thread, monitor->start_time, 'N', monitor->currentFloor);
//Entra
monitor->people_inside++;
monitor->destinies[destiny]++;
//Aperta o botao para o andar de destino
buffer_write(buff, thread, monitor->start_time, 'I', destiny);
insidePanel_press_button(monitor->inside_panel, destiny);
pthread_cond_signal(&monitor->hasFloorToGo);
//Espera chegar no andar
pthread_cond_wait(monitor->floorLeaveConditions+destiny, &monitor->monitorGlobalLock);
buffer_write(buff, thread, monitor->start_time, 'V', monitor->currentFloor);
monitor->people_inside--;
monitor->destinies[destiny]--;
//Sai, avisa mais alguem pra sair
pthread_cond_signal(monitor->floorLeaveConditions+destiny);
pthread_mutex_unlock(&monitor->monitorGlobalLock);
return;
}
int fdwait(int fd, int rw)
{
return _wait(NULL, fd, rw);
}
SQRESULT
Thread::wait(HSQUIRRELVM v)
{
_wait(v);
return 0;
}
int mqwait(void *socket, int rw)
{
return _wait(socket, -1, rw);
}
/**
* Interrupt 80h. Handles the system calls.
*
* @param regs Pointer to struct containing micro's registers.
*/
void int80(registers* regs) {
switch (regs->eax) {
case _SYS_READ:
regs->eax = _read((unsigned int)regs->ebx, (char*)translate(regs->ecx), (size_t)regs->edx);
break;
case _SYS_WRITE:
regs->eax = _write((unsigned int)regs->ebx, (const char*)translate(regs->ecx), (size_t)regs->edx);
break;
case _SYS_TIME:
regs->eax = _time((time_t*)translate(regs->ebx));
break;
case _SYS_IOCTL:
regs->eax = _ioctl(regs->ebx, regs->ecx, (void*)translate(regs->edx));
break;
case _SYS_TICKS:
regs->eax = _getTicksSinceStart();
break;
case _SYS_YIELD:
// This just makes sure we call the scheduler again, for now
break;
case _SYS_EXIT:
_exit();
break;
case _SYS_GETPID:
regs->eax = _getpid();
break;
case _SYS_GETPPID:
regs->eax = _getppid();
break;
case _SYS_RUN:
regs->eax = _run((EntryPoint) translate(regs->ebx), (char*) translate(regs->ecx), regs->edx);
break;
case _SYS_WAIT:
regs->eax = _wait();
break;
case _SYS_KILL:
_kill((pid_t) regs->ebx);
break;
case _SYS_PINFO:
regs->eax = _pinfo((struct ProcessInfo*)translate(regs->ebx), (size_t)regs->ecx);
break;
case _SYS_SLEEP:
_sleep(regs->ebx);
break;
case _SYS_NICE:
regs->eax = _nice(regs->ebx);
break;
case _SYS_RENICE:
regs->eax = _renice(regs->ebx, regs->ecx);
break;
case _SYS_CLOSE:
regs->eax = _close(regs->ebx);
break;
case _SYS_OPEN:
regs->eax = _open((char*)translate(regs->ebx), regs->ecx, regs->edx);
break;
case _SYS_CREAT:
regs->eax = _creat((char*)translate(regs->ebx), regs->ecx);
break;
case _SYS_MKDIR:
regs->eax = _mkdir((const char*)translate(regs->ebx), regs->ecx);
break;
case _SYS_RMDIR:
regs->eax = _rmdir((const char*)translate(regs->ebx));
break;
case _SYS_UNLINK:
regs->eax = _unlink((const char*)translate(regs->ebx));
break;
case _SYS_RENAME:
regs->eax = _rename((const char*)translate(regs->ebx), (const char*)translate(regs->ecx));
break;
case _SYS_CHDIR:
regs->eax = _chdir((const char*)translate(regs->ebx));
break;
case _SYS_GETCWD:
regs->eax = _getcwd((char*)translate(regs->ebx), (size_t)regs->ecx);
break;
case _SYS_READDIR:
regs->eax = _readdir(regs->ebx, (struct fs_DirectoryEntry*)translate(regs->ecx), regs->edx);
break;
case _SYS_SETPPERSONA:
_setProcessPersona(regs->ebx, regs->ecx, regs->edx);
break;
case _SYS_GETPPERSONA:
_getProcessPersona(regs->ebx, (int*)translate(regs->ecx), (int*) translate(regs->edx));
break;
case _SYS_SYMLINK:
regs->eax = _symlink((const char *)translate(regs->ebx), (const char *)translate(regs->ecx));
break;
case _SYS_MKFIFO:
regs->eax = _mkfifo((const char*)translate(regs->ebx));
break;
case _SYS_CHMOD:
regs->eax = _chmod(regs->ebx, (const char*)translate(regs->ecx));
break;
case _SYS_STAT:
regs->eax = _stat((const char*)translate(regs->ebx), (struct stat*)translate(regs->ecx));
break;
case _SYS_CHOWN:
regs->eax = _chown((const char*)translate(regs->ebx));
break;
case _SYS_LOG:
_loglevel(regs->ebx);
break;
case _SYS_STACKSIZE:
regs->eax = _stacksize();
}
}
