int
main(int argc, char *argv[])
{
   struct pstat st;
   int highpriority = 0;
   int pid = getpid();
   int defaultpriorityrun = 0;
   spin();
   check(getpinfo(&st) == 0, "getpinfo");

   int i;
   printf(1, "\n **** PInfo **** \n"); 
   for(i = 0; i < NPROC; i++) {
      if (st.inuse[i]) {
	 if(st.hticks[i] != 0)
		highpriority++;
	 if(st.pid[i] == pid && st.lticks[i] > 20)
		defaultpriorityrun = 1;
         printf(1, "pid: %d hticks: %d lticks: %d\n", st.pid[i], st.hticks[i], st.lticks[i]);
      }
   }

   check(highpriority == 0, "getpinfo shouldn't return any process with hticks not equal to 0, default priority should be low(1) ");
   check(defaultpriorityrun == 1, "getpinfo should return a process having run with default priority");
   printf(1, "Should print 1 then 2");
   exit();
}
Exemple #2
0
int main(int argc, char **argv)
{
  if (argc < 2)
    return usage();
  const char *cmd = argv[1];
  perish_if(libusb_init(NULL) < 0, "Couldn't init libusb");
  libusb_device_handle *h = libusb_open_device_with_vid_pid(NULL, 
                                                            VENDOR_ID, 
                                                            PRODUCT_ID);
  perish_if(h == NULL, "couldn't find or open device. check permissions?");
  perish_if(0 != libusb_claim_interface(h, 0), "couldn't claim interface");
  printf("device opened successfully.\n");
  signal(SIGINT, signal_handler);
  if (!strcmp(cmd, "stream"))
    stream(h);
  else if (!strcmp(cmd, "blink"))
    blink(h);
  else if (!strcmp(cmd, "spin"))
    spin(h);
  else if (!strcmp(cmd, "listen"))
  {
    ros::init(argc, argv, "roscar_driver");
    roscar_listen(h);
  }
  libusb_exit(NULL);
  return 0;
}
void SlotMachine::play(Player &player)
{
	int menuSelect = 0;
	bool continueLoop = true;
	int bet = 0;
	static int run = 0;

	while (continueLoop)
	{
		if (run++ == 0)
		{
			buildMachine(player); // just for show to build display
		}

		if (processInput(bet))
		{
			spin(bet, player);
		}
		else
		{
			continueLoop = false;
			run = 0;
		}
	}
}
Exemple #4
0
static void
test_cv_thread(unsigned long num)
{
	int i;
	struct timeval start, end, diff;

	for (i = 0; i < LOOPS; i++) {
		lock_acquire(testlock);
		while (testval1 != num) {
			gettimeofday(&start, NULL);
			cv_wait(testcv, testlock);
			gettimeofday(&end, NULL);
			timersub(&end, &start, &diff);

			/* cv_wait should wait at least 4-5 ms */
			if (diff.tv_sec == 0 && diff.tv_usec < 4000) {
				unintr_printf("%s took %ld us. That's too fast."
					      " You must be busy looping\n",
					      __FUNCTION__, diff.tv_usec);
				goto out;
			}
		}
		unintr_printf("%d: thread %3d passes\n", i, num);
		testval1 = (testval1 + NTHREADS - 1) % NTHREADS;

		/* spin for 5 ms */
		spin(5000);

		cv_broadcast(testcv, testlock);
		lock_release(testlock);
	}
out:
	__sync_fetch_and_add(&done, 1);
}
void redDevansh() // Places preload (1-2) + 2 buckies (2-4) + TURN LEFT Knocks buckies (1-6)
{
	deploy();
	intake(1);
	wait10Msec(10);
	moveStraight(1, 0, 455); //picks up
	wait10Msec(50);
	moveStraight(-1, 0, 475);//comes back
	intake(0);
			// end part 1: prepare dump
	waitForButton();
	lift(BUMP);
	holdArm();
	intake(-1);
	resetValues(1200);
		// end part 2: dump
	waitForButton();
	liftDown();
	wait10Msec(100);
	moveStraight(1, 0, 700);
		// end part 3: prepare hit
	spin(-1, 0, 200);
	intake(-1);
	lift(BUMP);
	holdArm();
	noRamp(1, 250);
	resetValues(0);
		// end part 4: hit
}
Exemple #6
0
int main(void) {
    /* Initialize and clear the display */
    gfxInit();
    gdispClear(White);

    /* Create the 3D window */
    {
    	GWindowInit	wi;

		gwinClearInit(&wi);
    	wi.show = TRUE; wi.x = (gdispGetWidth()-GL3D_WINDOW_SIZE)/2; wi.y = (gdispGetHeight()-GL3D_WINDOW_SIZE)/2; wi.width = GL3D_WINDOW_SIZE; wi.height = GL3D_WINDOW_SIZE;
        gh = gwinGL3DCreate(0, &wi);
    }

    /* Init the 3D stuff */
    setup();
    init();

    while(TRUE) {

    	// rate control
    	gfxSleepMilliseconds(FRAME_DELAY);

    	// move and redraw
    	spin();
    }   
}
Exemple #7
0
void arp_layer_receive( struct sk_buff *comer_skb ){
	assert(comer_skb->pkgsize = 14 + 28);

	struct arphdr *arphdr = (void *)(comer_skb->ethhdr + 1);
	comer_skb->arphdr = arphdr;
	////////////Entry here !!
	///////////network byte order to host order, only performed on arp header
	BYTE_ENDIAN_FLIP2(arphdr->hardware);
	BYTE_ENDIAN_FLIP2(arphdr->protocol);
	BYTE_ENDIAN_FLIP2(arphdr->operation);
	BYTE_ENDIAN_FLIP4(arphdr->myip);
	BYTE_ENDIAN_FLIP4(arphdr->yourip);

	//////////done
	//u8 *mac = arphdr->mymac;
	//oprintf("arp layer receive: operation=%u, from mac(%x %x %x %x %x %x)", arphdr->operation, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
	if(arphdr->operation == 1){		/* it's an inquiry */
		arp_respond(comer_skb);
	}	
	else if(arphdr->operation == 2){	/* it's a REPLY */
		arp_act(comer_skb);
	}
	else spin("unknown operation");
	
	//oprintf(" ARP layer exit\n");
}
Exemple #8
0
int
main(int argc, char *argv[])
{

   if (argc < 3) {
      printf(1, "Usage: usage ticks tickets1 [tickets2]...\n\n");
      printf(1, "Spawns subprocesses, each of which will run for \n"
            "approximately the given number of ticks. For each ticket\n"
            "ammount given, a child process will spawn and request that\n"
            "number of tickets.\n");
      exit();
   }

   int total = 0;
   int i;
   for (i = 0; i < argc - 2; i++) {
      total += atoi(argv[i+2]);
   }
   int ret = settickets(total);
   if (ret < 0) {
      printf(1, "settickets failed\n");
      exit();
   }

   // pids of children
   int pids[NPROC];

   // spawn children
   for (i = 0; i < argc - 2; i++) {
      pids[i] = fork();
      if (pids[i] == 0) {
         int ret = settickets(atoi(argv[i + 2]));
         if (ret < 0) {
            printf(1, "settickets failed\n");
            exit();
         }
         // spin so we get scheduled
         while(1) {
            spin();
         }
      }
   }

   // print usage info
   int ticks = atoi(argv[1]);
   int start = uptime();
   while(uptime() < start + ticks) {
      sleep(100);
      printf(1, "time: %d\n", uptime() - start);
      printinfo();
   }

   // kill children
   for (i = 0; i < argc - 2; i++) {
      kill(pids[i]);
      wait();
   }

   exit();
}
Exemple #9
0
void assertion_failure(char *exp, char *file, char * base_file, int line)
{	
	printl("%c  assert(%s) failed: file: %s, base_file: %s,ln%d",MAG_CH_ASSERT,exp, file, base_file, line);
	spin("assertion_failure()");
	__asm__ __volatile__("ud2");

}
Exemple #10
0
void
QueueCommands::MakeSpace(uint32 size)
{
	ASSERT((size & 1) == 0);

	size *= sizeof(uint32);
	bigtime_t start = system_time();

	while (fRingBuffer.space_left < size) {
		// wait until more space is free
		uint32 head = read32(fRingBuffer.register_base + RING_BUFFER_HEAD)
			& INTEL_RING_BUFFER_HEAD_MASK;

		if (head <= fRingBuffer.position)
			head += fRingBuffer.size;

		fRingBuffer.space_left = head - fRingBuffer.position;

		if (fRingBuffer.space_left < size) {
			if (system_time() > start + 1000000LL) {
				TRACE(("intel_extreme: engine stalled, head %lx\n", head));
				break;
			}
			spin(10);
		}
	}

	fRingBuffer.space_left -= size;
}
Exemple #11
0
/*======================================================================*
                               TestA
 *======================================================================*/
void TestA()
{
	int fd;
	int i, n;

	char filename[MAX_FILENAME_LEN+1] = "blah";
	const char bufw[] = "abcde";
	const int rd_bytes = 3;
	char bufr[rd_bytes];

	assert(rd_bytes <= strlen(bufw));

	/* create */
	fd = open(filename, O_CREAT | O_RDWR);
	assert(fd != -1);
	printf("File created: %s (fd %d)\n", filename, fd);

	/* write */
	n = write(fd, bufw, strlen(bufw));
	assert(n == strlen(bufw));

	/* close */
	close(fd);

	/* open */
	fd = open(filename, O_RDWR);
	assert(fd != -1);
	printf("File opened. fd: %d\n", fd);

	/* read */
	n = read(fd, bufr, rd_bytes);
	assert(n == rd_bytes);
	bufr[n] = 0;
	printf("%d bytes read: %s\n", n, bufr);

	/* close */
	close(fd);

	char * filenames[] = {"/foo", "/bar", "/baz"};

	/* create files */
	for (i = 0; i < sizeof(filenames) / sizeof(filenames[0]); i++) {
		fd = open(filenames[i], O_CREAT | O_RDWR);
		assert(fd != -1);
		printf("File created: %s (fd %d)\n", filenames[i], fd);
		close(fd);
	}

	char * rfilenames[] = {"/bar", "/foo", "/baz", "/dev_tty0"};

	/* remove files */
	for (i = 0; i < sizeof(rfilenames) / sizeof(rfilenames[0]); i++) {
		if (unlink(rfilenames[i]) == 0)
			printf("File removed: %s\n", rfilenames[i]);
		else
			printf("Failed to remove file: %s\n", rfilenames[i]);
	}

	spin("TestA");
}
Exemple #12
0
bool
check_service_req(ide_device_info *device)
{
	ide_bus_info *bus = device->bus;
	int status;

	// fast bailout if there is no request pending
	if (device->num_running_reqs == 0)
		return false;

	if (bus->active_device != device) {
		// don't apply any precautions in terms of IRQ
		// -> the bus is in accessing state, so IRQs are ignored anyway
		if (bus->controller->write_command_block_regs(bus->channel_cookie,
				&device->tf, ide_mask_device_head) != B_OK)
			// on error, pretend that this device asks for service
			// -> the disappeared controller will be recognized soon ;)
			return true;

		bus->active_device = device;

		// give one clock (400 ns) to take notice
		spin(1);
	}

	status = bus->controller->get_altstatus(bus->channel_cookie);

	return (status & ide_status_service) != 0;
}
Exemple #13
0
void * ioremap(unsigned phys_addr, int size, unsigned flags){
	if(phys_addr >> 30) {
		oprintf(" %x ", phys_addr);
		spin("too big IO physical address");
	}
	return (void *)(phys_addr + PAGE_OFFSET);
}
Exemple #14
0
void rem_init()
{
    PMC_PCER = US0_PID;

    US0_CR = RXDIS | TXDIS | RSTRX | RSTTX | RSTSTA;

    USART0(PTCR) = RXTDIS | TXTDIS;

    nextbyte = &ubuf[0];
    nextbuf = &ubuf[0];    // Both buffers are already attached now
    USART0(RPR) = (u_long) &ubuf[0];
    USART0(RCR) = (u_long) UBUFLEN;
    USART0(RNPR) = (u_long) &ubuf[UBUFLEN];
    USART0(RNCR) = (u_long) UBUFLEN;
    USART0(PTCR) = RXTEN;

    US0_BRGR = BAUD_115200;
    US0_RTOR = 18;           // bit times of delay before timeout
    US0_MR = PAR_NONE | CHMODE_NORMAL | USCLKS_MCK | CHRL_8 | NBSTOP_1 | STTTO;
    spin(1000);
    US0_CR = RXEN | TXEN;

    // junk = (u_char)US0_RHR;  // Junk leftover from break
    // junk = (u_char)US0_RHR;
}
Exemple #15
0
/**
 * Main loop of HD driver.
 *
 *****************************************************************************/
PUBLIC void task_hd()
{
    MESSAGE msg;
    init_hd();
    while (1) {
        send_recv(RECEIVE, ANY, &msg);
        int src = msg.source;

        switch (msg.type) {
        case DEV_OPEN:
            hd_open(msg.DEVICE);
            break;

        case DEV_CLOSE:
            hd_close(msg.DEVICE);
            break;

        case DEV_READ:
        case DEV_WRITE:
            hd_rdwt(&msg);
            break;

        case DEV_IOCTL:
            hd_ioctl(&msg);
            break;

        default:
            dump_msg("HD driver::unknown msg", &msg);
            spin("FS::main_loop (invalid msg.type)");
            break;
        }

        send_recv(SEND, src, &msg);
    }
}
Exemple #16
0
void
AHCIPort::ResetDevice()
{
	if (fRegs->cmd & PORT_CMD_ST)
		TRACE("AHCIPort::ResetDevice PORT_CMD_ST set, behaviour undefined\n");

	// perform a hard reset
	fRegs->sctl = (fRegs->sctl & ~0xf) | 1;
	FlushPostedWrites();
	spin(1100);
	fRegs->sctl &= ~0xf;
	FlushPostedWrites();

	if (wait_until_set(&fRegs->ssts, 0x1, 100000) < B_OK) {
		TRACE("AHCIPort::ResetDevice port %d no device detected\n", fIndex);
	}

	// clear error bits
	fRegs->serr = fRegs->serr;
	FlushPostedWrites();

	if (fRegs->ssts & 1) {
		if (wait_until_set(&fRegs->ssts, 0x3, 500000) < B_OK) {
			TRACE("AHCIPort::ResetDevice port %d device present but no phy "
				"communication\n", fIndex);
		}
	}

	// clear error bits
	fRegs->serr = fRegs->serr;
	FlushPostedWrites();
}
void MolecularOrbitals::on_addToQueueButton_clicked(bool) 
{
   int quality(m_configurator.quality->value());
   double isovalue(m_configurator.isovalue->value());
   Data::Spin spin(m_configurator.alphaRadio->isChecked() ? Data::Alpha : Data::Beta);
   QColor positive(Preferences::PositiveSurfaceColor());
   QColor negative(Preferences::NegativeSurfaceColor());
   bool simplifyMesh(m_configurator.simplifyMeshCheckBox->isChecked());

   int index(m_configurator.surfaceType->currentIndex());
   QVariant qvar(m_configurator.surfaceType->itemData(index));
   bool isSigned(true);

   int op(m_configurator.opacity->value());
   double opacity = op == 100 ? 0.999 : double(op)/100.0;

   Data::SurfaceInfo info(Data::SurfaceType::Custom, quality, isovalue, 
     positive, negative, isSigned, simplifyMesh, opacity);

   switch (qvar.toUInt()) {

      case Orbital: {
         if (spin == Data::Alpha) {
            info.type().setKind(Data::SurfaceType::AlphaOrbital);
         }else {
            info.type().setKind(Data::SurfaceType::BetaOrbital);
         }

         int orb1(m_configurator.orbitalRangeMin->currentIndex()+1);
         int orb2(m_configurator.orbitalRangeMax->currentIndex()+1);

         for (int i = std::min(orb1,orb2); i <= std::max(orb1, orb2); ++i) {
             info.type().setIndex(i);
             queueSurface(info);
         }
      } break;

      case Density: {
         info.setIsSigned(false);
         info.type().setKind(Data::SurfaceType::TotalDensity);
         queueSurface(info);
      } break;

      case SpinDiffDensity: {
            info.type().setKind(Data::SurfaceType::SpinDensity);
         queueSurface(info);
      } break;

      case SpinOnlyDensity: {
         info.setIsSigned(false);
         if (spin == Data::Alpha) {
            info.type().setKind(Data::SurfaceType::AlphaDensity);
         }else {
            info.type().setKind(Data::SurfaceType::BetaDensity);
         }
         queueSurface(info);
      } break;

   }
}
void ExcitedStates::moSelectionChanged(bool tf)
{
   QCPGraph* graph(qobject_cast<QCPGraph*>(sender()));

   if (!tf || !graph) {
      m_configurator.orbitalLabel->setText("");
      return;
   }
   
   bool ok(true);;
   unsigned orb(graph->name().toUInt(&ok));
   if (!ok) return;

   Data::OrbitalSymmetries const& orbitals(m_excitedStates.stateData().orbitalSymmetries());
   unsigned nOrbs(orbitals.nOrbitals());
   Data::Spin spin(Data::Alpha);

   if (orb >= nOrbs) {
      orb -= nOrbs; 
      spin = Data::Beta;
   }

   double energy(orbitals.energy(spin, orb));
   QString symmetry(orbitals.symmetry(Data::Alpha, orb));
   QString label(Data::SpinLabel(spin));

   label += " " + QString::number(orb+1);

   label += " orbital energy: ";
   label += QString::number(energy, 'f', 3);
   label += " Eh";
   if (!symmetry.isEmpty()) label += "  Irrep " + symmetry;

   m_configurator.orbitalLabel->setText(label);
}
Exemple #19
0
int main(int argc, char* argv[])
{
    signal (SIGINT, sigintHandler);
    printf("\033[?25l");  // Hide cursor
    spin();
    return 0;
}
void redUdit()
{
	deploy();
	intake(true);
	wait10Msec(10);
	moveStraight(1, 0, 475);
	wait10Msec(50);
	moveStraight(-1, 0, 475);
	//stopIntake();
	lift(BUMP);
	holdArm();
	waitForButton();
	intake(false);
	wait10Msec(100);
	waitForButton();
	resetValues(0);
	liftDown();
	// end Devansh
	waitForButton();
	intake(true);
	moveStraight(1, 0, (HALF_TILE));
	wait10Msec(50);
	pickUpBall(1);
	spin(-1, 0, 200);
	crossBump();
	lift(BARRIER);
	holdArm();
	wait10Msec(30);
	moveStraight(1, 0, 550);
	intake(false);
	// end udit
	resetValues(1000);
}
void redDevansh() // Places preload (1-2) + 2 buckies (2-4) + TURN LEFT Knocks buckies (1-6) + Places two Balls (2)
{
	deploy();
	intake(true);
	wait10Msec(10);
	moveStraight(1, 0, 475);
	wait10Msec(50);
	moveStraight(-1, 0, 475);
	//stopIntake();
	lift(BUMP);
	holdArm();
	waitForButton();
	intake(false);
	wait10Msec(100);
	waitForButton();
	resetValues(0);
	liftDown();
	// end Devansh
	waitForButton();
	intake(true);
	moveStraight(1, 0, (HALF_TILE));
	wait10Msec(50);
	pickUpBall(1);
	spin(-1, 0, 200);
	crossBump();
	lift(BARRIER);
	holdArm();
	wait10Msec(30);
	moveStraight(1, 0, 550);
	intake(false);
	// end udit
	resetValues(1000);
}
Exemple #22
0
void TransformManipulator::perform(const Ray * r)
{
	if(isDetached()) return;
	const Vector3F worldP = worldSpace().getTranslation();
	Matrix44F ps;
	parentSpace(ps);
	Plane pl(ps.transformAsNormal(hitPlaneNormal()), worldP);
	Vector3F hit, d;
    float t;
	if(pl.rayIntersect(*r, hit, t, 1)) {
		d = hit - worldP;
		if(d.length() > 10.f) return;
		
		if(m_mode == ToolContext::RotateTransform) {
			d = d.normal() * 8.f;
			hit = worldP + d;
		}
		
		d = hit - m_currentPoint;
		
		if(m_mode == ToolContext::MoveTransform)
			move(d);
		else
			spin(d);
			
		m_currentPoint = hit;
	}
}
Exemple #23
0
void BCS_wf::restoreUpdate(Sample_point * sample, int e,
                           Wavefunction_storage * wfstore)
{

    BCS_wf_storage * store;
    recast(wfstore, store);

    jast.restoreUpdate(sample,e,store->jast_store);
    detVal=store->detVal;
    inverse=store->inverse;

    //
    // unpaired electrons go into extra one-body orbitals, this
    // functionality will be resurrected later
    //
    //int nmo=moVal.GetDim(1);
    //int nd=moVal.GetDim(2);
    //for(int m=0; m< nmo; m++) {
    //  for(int d=0; d< nd; d++) {
    //    moVal(e,m,d)=store->moVal(m,d);
    //  }
    //}

    if(spin(e)==0) {
        int nj=derivatives.GetDim(1);
        assert(nj==nelectrons(0));
        int nd=derivatives.GetDim(2);
        for(int j=0; j< nj; j++) {
            for(int d=0; d< nd; d++) {
                derivatives(e,j,d)=store->derivatives(j,d);
            }
        }
        int ep=e+nelectrons(0);
        for(int j=0; j< nj; j++) {
            for(int d=0; d< nd; d++) {
                derivatives(ep,j,d)=store->derivatives(j+nelectrons(0),d);
            }
        }
    }
    else {
        int ni=derivatives.GetDim(0);
        assert(ni==2*nelectrons(0));
        int nd=derivatives.GetDim(2);
        int rede=e-nelectrons(0);
        for(int i=0; i< ni; i++) {
            for(int d=0; d< nd; d++) {
                derivatives(i,rede,d)=store->derivatives(i,d);
            }
        }
    }


    electronIsStaleLap=0;
    electronIsStaleVal=0;
    updateEverythingLap=0;
    updateEverythingVal=0;

    //calcLap(sample);
}
Exemple #24
0
/**
 * The second routine for test.
 * 
 * @test just for test
 *****************************************************************************/
void TestB()
{
	while(1){}

	assert(0);		/* never arrive here */

	spin("TestB()");
}
Exemple #25
0
void Certificate_Store_In_SQL::remove_key(const Private_Key& key)
   {
   auto fpr = key.fingerprint("SHA-256");
   auto stmt = m_database->new_statement("DELETE FROM " + m_prefix + "keys WHERE fingerprint == ?1");

   stmt->bind(1,fpr);
   stmt->spin();
   }
void Session_Manager_SQL::remove_entry(const std::vector<byte>& session_id)
   {
   auto stmt = m_db->new_statement("delete from tls_sessions where session_id = ?1");

   stmt->bind(1, hex_encode(session_id));

   stmt->spin();
   }
Exemple #27
0
/*======================================================================*
                               TestB
 *======================================================================*/
void TestC()
{
	spin("TestC");
	/* assert(0); */
	while(1){
		printf("C");
		milli_delay(200);
	}
}
	/// Go to origin, reset orientation
	Nav& home(){ 
		quat().identity();
		view(0, 0, 0);
		turn(0, 0, 0); 
		spin(0, 0, 0);
		vec().set(0);
		updateDirectionVectors();
		return *this;
	}
void
FDIReceiver::DisablePLL()
{
	CALLED();
	uint32 targetRegister = fRegisterBase + PCH_FDI_RX_CONTROL;
	write32(targetRegister, read32(targetRegister) & ~FDI_RX_PLL_ENABLED);
	read32(targetRegister);
	spin(100);
}
Exemple #30
0
void task_fs(){
#ifdef DEBUG_FS
    printl("in task_fs\n");
#endif
    init_fs();
    MESSAGE message;
    memset(&message,0,sizeof(message));
    while(TRUE){
        send_receive(RECEIVE,ANY,&message);
        
        int source_pid=message.source_pid;
        int fd;
	
        switch(message.type){
        case INFO_FS_CREATE:
            message.res_bool=do_create(&message);
            break;
        case INFO_FS_UNLINK:
            message.res_bool=do_unlink(&message);
            break;
        case INFO_FS_LS:
            message.res_int=do_ls(&message);
            break;
        case INFO_FS_OPEN:
            fd=do_open(&message);
            message.fd=fd;
            break;
        case INFO_FS_READ:
            do_read(&message);
            break;
        case INFO_FS_WRITE:
            do_write(&message);
            break;
        case INFO_FS_SEEK:
            do_seek(&message);
            break;
        case INFO_FS_CLOSE:
            message.res_int=do_close(&message);
            break;
        default:
            printl("\n\n\nunknown message type:%d\n",message.type);
            assert(FALSE,"unknown message type!");
        }
        if(message.type!=INFO_SUSPEND_PROCESS){
            send_receive(SEND,source_pid,&message);
        }else{
            printl("inof_suspend_process\n");
        }
    }
#ifndef _FS_H_
#define _FS_H_
    
#endif /* _FS_H_ */
    while(1)
        ;
    spin("never here");
}