コード例 #1
0
ファイル: e1000.c プロジェクト: blanham/ChickenOS
void e1000_rxinit(struct e1000 *e)
{
    uintptr_t ptr;
    struct e1000_rx_desc *descs;
    ptr = (uintptr_t)(kmalloc(sizeof(struct e1000_rx_desc)*NUM_RX_DESC + 16));
    e->rx_free = (uint8_t *)ptr;
    if(ptr % 16 != 0)
        ptr = (ptr + 16) - (ptr % 16);
    descs = (struct e1000_rx_desc *)ptr;
    for(int i = 0; i < NUM_RX_DESC; i++)
    {
        e->rx_descs[i] = (struct e1000_rx_desc *)((uintptr_t)descs + i*16);
        e->rx_descs[i]->addr = (uint64_t)(uintptr_t)V2P(kmalloc(8192 + 16));
        e->rx_descs[i]->status = 0;
    }

    //give the card the pointer to the descriptors
    e1000_outl(e, REG_RXDESCLO, V2P(ptr));
    e1000_outl(e, REG_RXDESCHI, 0);

    //now setup total length of descriptors
    e1000_outl(e, REG_RXDESCLEN, NUM_RX_DESC * 16);

    //setup numbers
    e1000_outl(e, REG_RXDESCHEAD, 0);
    e1000_outl(e, REG_RXDESCTAIL, NUM_RX_DESC);
    e->rx_cur = 0;

    //enable receiving
    //uint32_t flags = (2 << 16) | (1 << 25) | (1 << 26) | (1 << 15) | (1 << 5) | (0 << 8) | (1 << 4) | (1 << 3) | ( 1 << 2);
    uint32_t flags = (2 << 16) | (1 << 25) | (1 << 26) | (1 << 15) | (1 << 5) | (0 << 8) | (0 << 4) | (0 << 3) | ( 1 << 2);
//	uint32_t flags = (2 << 16) | (1 << 25) | (1 << 26) | (1 << 15) | (1 << 5) | (0 << 8) | (1 << 4) | ( 1 << 2);
//	e1000_outl(e, REG_RCTRL, RCTRL_8192 | RCTRL_MPE);
    e1000_outl(e, REG_RCTRL, flags);//RCTRL_8192 | RCTRL_MPE | RCTRL_UPE |RCTRL_EN);
}
コード例 #2
0
ファイル: main.c プロジェクト: MarcoCBA/Proyectos
// Start the non-boot (AP) processors.
static void
startothers(void)
{
  extern uchar _binary_entryother_start[], _binary_entryother_size[];
  uchar *code;
  struct cpu *c;
  char *stack;

  // Write entry code to unused memory at 0x7000.
  // The linker has placed the image of entryother.S in
  // _binary_entryother_start.
  code = P2V(0x7000);
  memmove(code, _binary_entryother_start, (uint)_binary_entryother_size);

  for(c = cpus; c < cpus+ncpu; c++){
    if(c == cpus+cpunum())  // We've started already.
      continue;

    // Tell entryother.S what stack to use, where to enter, and what
    // pgdir to use. We cannot use kpgdir yet, because the AP processor
    // is running in low  memory, so we use entrypgdir for the APs too.
    stack = kalloc();
    *(void**)(code-4) = stack + KSTACKSIZE;
    *(void**)(code-8) = mpenter;
    *(int**)(code-12) = (void *) V2P(entrypgdir);

    lapicstartap(c->apicid, V2P(code));

    // wait for cpu to finish mpmain()
    while(c->started == 0)
      ;
  }
}
コード例 #3
0
ファイル: proc.c プロジェクト: Machiry/arunos
/* proc_creates allocates a new process and returns it. */
struct Process *proc_create(void)
{
	struct Process *proc = NULL;
	int i;
	int pid = -1;
	struct SectionTableEntry *vm = NULL;
	char *kernel_stack = NULL;
	char *user_stack = NULL;

	for (i = 0; i < PROCESS_COUNT_MAX; i++)
		if (process_table[i].state == UNUSED) {
			pid = i + 1;
			break;
		}

	if (pid == -1)
		return NULL;

	kernel_stack = kalloc();
	user_stack = kalloc();

	vm = process_vm[pid - 1];
	memset(vm, 0, SECTION_TABLE_SIZE);

	setup_kernel_vm(vm);
	map_pages(vm, (struct MemoryMapping){
		KERNEL_STACK_BOTTOM,
		V2P(kernel_stack),
		V2P(kernel_stack) + PAGE_SIZE,
		AP_RW_R
	});
コード例 #4
0
ファイル: frame.c プロジェクト: eXeC64/piker
void frame_init()
{
    /* All frames are free to begin with */
    for(uint32_t i = 0; i < 4096; ++i) {
        frames_bitmap[i] = 0x00000000;
    }

    /* Now lets mark the kernel's frames as taken */
    uintptr_t kstart = V2P((uintptr_t)&_start);
    uintptr_t kend   = V2P((uintptr_t)&_end);

    for(uintptr_t i = kstart; i < kend; i += 0x1000) {
        frame_set(i, 1);
    }

    /* We also need to mark the GPU's frames as taken */
    /* For now we're assuming we have 512MB of memory
     * and 64 MB of it is allocated to the GPU */

    /* 64 MB */
    uintptr_t gpu_size = 0x04000000;
    uintptr_t gpu_end =  0x20000000;
    uintptr_t gpu_start =  gpu_end - gpu_size;

    for(uintptr_t i = gpu_start; i < gpu_end; i += 0x1000) {
        frame_set(i, 1);
    }

    /* Mark frame 0 as taken, so null pointers *NEVER* point to anything */
    frame_set(0, 1);
}
コード例 #5
0
ファイル: vm.c プロジェクト: baileyparker/xv6-public
// Allocate page tables and physical memory to grow process from oldsz to
// newsz, which need not be page aligned.  Returns new size or 0 on error.
int
allocuvm(pde_t *pgdir, uint oldsz, uint newsz)
{
  char *mem;
  uint a;

  if(newsz >= KERNBASE)
    return 0;
  if(newsz < oldsz)
    return oldsz;

  a = PGROUNDUP(oldsz);
  for(; a < newsz; a += PGSIZE){
    mem = kalloc();
    if(mem == 0){
      cprintf("allocuvm out of memory\n");
      deallocuvm(pgdir, newsz, oldsz);
      return 0;
    }
    memset(mem, 0, PGSIZE);
    if (mappages(pgdir, (char*)a, PGSIZE, V2P(mem), PTE_W|PTE_U) < 0)
      panic("allocuvm: cannot create pagetable");
  }
  return newsz;
}
コード例 #6
0
ファイル: vm.c プロジェクト: baileyparker/xv6-public
// Given a parent process's page table, create a copy
// of it for a child.
pde_t*
copyuvm(pde_t *pgdir, uint sz)
{
  pde_t *d;
  pte_t *pte;
  uint pa, i, flags;
  char *mem;

  if((d = setupkvm()) == 0)
    return 0;
  for(i = 0; i < sz; i += PGSIZE){
    if((pte = walkpgdir(pgdir, (void *) i, 0)) == 0)
      panic("copyuvm: pte should exist");
    if(!(*pte & PTE_P))
      panic("copyuvm: page not present");
    pa = PTE_ADDR(*pte);
    flags = PTE_FLAGS(*pte);
    if((mem = kalloc()) == 0)
      goto bad;
    memmove(mem, (char*)P2V(pa), PGSIZE);
    if(mappages(d, (void*)i, PGSIZE, V2P(mem), flags) < 0)
      goto bad;
  }
  return d;

bad:
  freevm(d);
  return 0;
}
コード例 #7
0
ファイル: address-space.cpp プロジェクト: matthoosier/os
bool BackedMapping::Map (RefPtr<TranslationTable> aPageTable)
{
    assert(!mMapped);

    VmAddr_t virt = mBaseAddress;
    size_t numPagesLeft = mRegion->GetPageCount();
    List<Page, &Page::list_link>::Iterator pageIter = mRegion->GetPages();

    while (numPagesLeft > 0) {
        Page * p = *pageIter;
        bool mapped = aPageTable->MapPage(virt, V2P(p->base_address), mProtection);
        if (!mapped) {
            assert(false);
            Mapping::Unmap(aPageTable, mRegion->GetPageCount() - numPagesLeft);
            return false;
        }

        virt += PAGE_SIZE;
        numPagesLeft--;
        ++pageIter;
    }

    mMapped = true;
    return true;
}
コード例 #8
0
ファイル: syscall_exit.c プロジェクト: Machiry/arunos
int syscall_exit(int arg1)
{
	int pid;

	(void) arg1;
	if (current_process == NULL)
		return -1;

	set_translation_table_base((uint32_t) V2P(kernel_vm));
	__asm__ volatile("ldr sp, =kernel_stack_start");

	for (pid = 0; pid < PROCESS_COUNT_MAX; pid++) {
		struct Process *proc = &process_table[pid];

		if (proc->state == SLEEPING &&
		    proc->wait_pid == current_process->pid) {
		    	
			proc->wait_pid = -1;
			proc->state = READY;
		}
	}

	proc_free(current_process);
	current_process = NULL;

	schedule();

	return 0;
}
コード例 #9
0
ファイル: pcnet.c プロジェクト: blanham/ChickenOS
void pcnet_receive(struct pcnet *l)
{
	size_t len;
	uint8_t *buf;
	struct sockbuf *sb;
	while((l->rx_descs[l->cur_rx].status & 0x8000) == 0)
	{
		if(!(l->rx_descs[l->cur_rx].status & 0x4000) &&
			(l->rx_descs[l->cur_rx].status & 0x0300) == 0x0300)
		{
			len = l->rx_descs[l->cur_rx].flags2 & 0xFFFF;
			buf = l->rx_buffers[l->cur_rx];
			sb = sockbuf_alloc(l->dev, len);
			kmemcpy(sb->data, buf, len);
			network_received(sb);


		}	
		l->rx_descs[l->cur_rx].addr = V2P(l->rx_buffers[l->cur_rx]);
		l->rx_descs[l->cur_rx].status = 0x8000;
		l->rx_descs[l->cur_rx].len = -2048;
		l->rx_descs[l->cur_rx].flags2 = 0;

		l->cur_rx++;
		if(l->cur_rx == 8)
			l->cur_rx = 0;
	}
}
コード例 #10
0
ファイル: e1000.c プロジェクト: blanham/ChickenOS
void e1000_txinit(struct e1000 *e)
{
    uintptr_t ptr;
    struct e1000_tx_desc *descs;
    ptr = (uintptr_t)(kmalloc(sizeof(struct e1000_tx_desc)*NUM_TX_DESC + 16));
    e->tx_free = (uint8_t *)ptr;
    if(ptr % 16 != 0)
        ptr = (ptr + 16) - (ptr % 16);
    descs = (struct e1000_tx_desc *)ptr;
    for(int i = 0; i < NUM_TX_DESC; i++)
    {
        e->tx_descs[i] = (struct e1000_tx_desc *)((uintptr_t)descs + i*16);
        e->tx_descs[i]->addr = 0;
        e->tx_descs[i]->cmd = 0;
    }

    //give the card the pointer to the descriptors
    e1000_outl(e, REG_TXDESCLO, V2P(ptr));
    e1000_outl(e, REG_TXDESCHI, 0);

    //now setup total length of descriptors
    e1000_outl(e, REG_TXDESCLEN, NUM_TX_DESC * 16);

    //setup numbers
    e1000_outl(e, REG_TXDESCHEAD, 0);
    e1000_outl(e, REG_TXDESCTAIL, NUM_TX_DESC);
    e->tx_cur = 0;

    e1000_outl(e, REG_TCTRL, (1 << 1) | (1 << 3));
}
コード例 #11
0
void JniWebView::SetRect(int id, const Rect& controlRect)
{
	Rect rect = V2P(controlRect);
	jmethodID mid = GetMethodID("SetRect", "(IFFFF)V");
	if (mid)
	{
		GetEnvironment()->CallStaticVoidMethod(GetJavaClass(), mid, id, rect.x, rect.y, rect.dx, rect.dy);
	}
}
コード例 #12
0
void JniWebView::Initialize(WebViewControl* control, int id, const Rect& controlRect)
{
	controls[id] = control;
	Rect rect = V2P(controlRect);

	jmethodID mid = GetMethodID("Initialize", "(IFFFF)V");
	if (mid)
		GetEnvironment()->CallStaticVoidMethod(GetJavaClass(), mid, id, rect.x, rect.y, rect.dx, rect.dy);
}
コード例 #13
0
ファイル: acpi.c プロジェクト: tim48134/xylos
// check if the given address has a valid header
unsigned int *acpiCheckRSDPtr(unsigned int *ptr)
{
	char sig[8];
	sig[0] = 'R';
	sig[1] = 'S';
	sig[2] = 'D';
	sig[3] = ' ';
	sig[4] = 'P';
	sig[5] = 'T';
	sig[6] = 'R' ;
	sig[7] = ' ';
	struct RSDPtr *rsdp = (struct RSDPtr *) ptr;
	u8int *bptr;
	u8int check = 0;
	int i;

	cprintf("\nrsdp addr 0x%x...", rsdp);

	//char temp[8];
	//for(i = 0; i < 8; i++){
	//if(rsdp->Signature != 0){
	//temp[i] = (char) *(rsdp+i);
	//} else {
	//   temp[i] = 0;
	// }
	//}

	//cprintf("\ninside Check, about to try memcmp....\n");
	//if (strncmp(sig, temp, 8) == 0)
	if(memcmp( (void*) V2P(&sig), (void*) rsdp, 8) == 0) {
		//cprintf("inside memcmp..");
		// check checksum rsdpd
		bptr = (u8int *) ptr;
		for (i = 0; i < sizeof(struct RSDPtr); i++) {
			check += *bptr;
			bptr++;
		}

		// found valid rsdpd
		if (check == 0) {
			cprintf("found valid ");

			if (rsdp->Revision == 0) {
				cprintf("acpi 1");
			} else {
				cprintf("acpi 2");
			}


			return (unsigned int *) rsdp->RsdtAddress;
		}
	}
	//cprintf("leaving Check\n");
	return 0;
}
コード例 #14
0
ファイル: e1000.c プロジェクト: blanham/ChickenOS
size_t e1000_send(struct network_dev *dev, uint8_t *_buf, size_t length)
{
    struct e1000 *e = dev->device;
    e->tx_descs[e->tx_cur]->addr = (uint64_t)(uintptr_t)V2P(_buf);
    e->tx_descs[e->tx_cur]->length = length;
    e->tx_descs[e->tx_cur]->cmd = ((1 << 3) | 3);
    uint8_t old_cur = e->tx_cur;
    e->tx_cur = (e->tx_cur + 1) % NUM_TX_DESC;
    e1000_outl(e, REG_TXDESCTAIL, e->tx_cur);
    while(!(e->tx_descs[old_cur]->status & 0xff));
    return 0;
}
コード例 #15
0
ファイル: rtl8139.c プロジェクト: blanham/ChickenOS
void rtl8139_start(struct rtl8139 *rtl)
{
	rtl->tx_cur = 0;
	rtl_outb(rtl, 0x37, 0x10);
	while((rtl_inb(rtl, 0x37) & 0x10) != 0);
	
	kmemset(rtl->rx_buffer, 0, (8192*8)+16+1500);
	rtl_outl(rtl, 0x30,(uintptr_t)V2P(rtl->rx_buffer));
	rtl_outb(rtl, 0x37, 0xc);
	
	for(int i=0; i < 4; i++)
	{
		rtl_outl(rtl, 0x20 + i*4, (uintptr_t)V2P(rtl->tx_buffers) + i*(8192 +16+1500));
	}
	//TODO: need to register pci IRQs instead of doing it directly
	//interrupt_register(32 + rtl->pci_hdr->int_line, &rtl_handler);

	pci_register_irq(rtl->pci, &rtl_handler, rtl);
	rtl_outl(rtl, 0x44, (1 << 7) | 8|  (1 << 1));
	rtl_outw(rtl, 0x3c, 0x5 );
	for(int i = 0; i < 6; i ++)
		rtl->mac[i] = rtl_inb(rtl, i);
	for(int i = 0; i < 100; i++)
	{
	/*	uint16_t isr = rtl_inw(rtl, ISR);
		if(isr & 0x20)
		{
			rtl_outw(rtl, ISR, 0x20);
			printf("isr %x\n",isr);
			break;
		}*/
	}
	
	



}
コード例 #16
0
ファイル: vm.c プロジェクト: baileyparker/xv6-public
// Load the initcode into address 0 of pgdir.
// sz must be less than a page.
void
inituvm(pde_t *pgdir, char *init, uint sz)
{
  char *mem;

  if(sz >= PGSIZE)
    panic("inituvm: more than a page");
  if ((mem = kalloc()) == 0)
    panic("inituvm: cannot allocate memory");
  memset(mem, 0, PGSIZE);
  if (mappages(pgdir, 0, PGSIZE, V2P(mem), PTE_W|PTE_U) < 0)
    panic("inituvm: cannot create pagetable");
  memmove(mem, init, sz);
}
コード例 #17
0
ファイル: vm.c プロジェクト: baileyparker/xv6-public
// Switch TSS and h/w page table to correspond to process p.
void
switchuvm(struct proc *p)
{
  pushcli();
  cpu->gdt[SEG_TSS] = SEG16(STS_T32A, &cpu->ts, sizeof(cpu->ts)-1, 0);
  cpu->gdt[SEG_TSS].s = 0;
  cpu->ts.ss0 = SEG_KDATA << 3;
  cpu->ts.esp0 = (uint)proc->kstack + KSTACKSIZE;
  ltr(SEG_TSS << 3);
  if(p->pgdir == 0)
    panic("switchuvm: no pgdir");
  lcr3(V2P(p->pgdir));  // switch to new address space
  popcli();
}
コード例 #18
0
ファイル: vm.c プロジェクト: finallyjustice/xv6-OS-for-arm-v8
// Switch to the user page table (TTBR0)
void switchuvm (struct proc *p)
{
    uint64 val64;

    pushcli();

    if (p->pgdir == 0) {
        panic("switchuvm: no pgdir");
    }

    val64 = (uint64) V2P(p->pgdir) | 0x00;

    asm("MSR TTBR0_EL1, %[v]": :[v]"r" (val64):);
    flush_tlb();

    popcli();
}
コード例 #19
0
ファイル: rtl8139.c プロジェクト: blanham/ChickenOS
size_t rtl8139_send(struct network_dev *dev, uint8_t *_buf, size_t length)
{
	struct rtl8139 *rtl = dev->device;
	
	void* tx_buffer = (void *)(rtl->tx_buffers + 8192*rtl->tx_cur);
	kmemset(tx_buffer, 0, (length <60) ? 60 : length);
	kmemcpy(tx_buffer, _buf, length);
		
	if(length < 60)
		length = 60;
	
	rtl_outl(rtl, 0x20 + rtl->tx_cur*4, V2P(tx_buffer));
	rtl_outl(rtl, 0x10 + rtl->tx_cur*4, length | (48 << 16)); 
	rtl->tx_cur++;
	rtl->tx_cur %= 4;

	return length;
}
コード例 #20
0
ファイル: pcnet.c プロジェクト: blanham/ChickenOS
size_t pcnet_send(struct network_dev *dev, uint8_t *_buf, size_t length)
{
	struct pcnet *l = dev->device;
//	interrupt_disable();	
	kmemcpy(l->tx_buffers[l->cur_tx], _buf, length);
	l->tx_descs[l->cur_tx].addr = (uintptr_t)V2P(l->tx_buffers[l->cur_tx]);
	l->tx_descs[l->cur_tx].flags2 = 0;
	l->tx_descs[l->cur_tx].status |= 0x8300;
	l->tx_descs[l->cur_tx].len =  -length;
//	printf("%p, io %x %x\n",l, &l->io_base, l->tx_descs[l->cur_tx].addr);
	uint16_t csr = pcnet_csr_inl(l, 0);
	pcnet_csr_outl(l, 0, csr | 8);
	l->cur_tx++;
	if(l->cur_tx == 8)
		l->cur_tx = 0;

//	interrupt_enable();	
	return length;
}
コード例 #21
0
ファイル: kalloc.c プロジェクト: zeqli/xv6
//PAGEBREAK: 21
// Free the page of physical memory pointed at by v,
// which normally should have been returned by a
// call to kalloc().  (The exception is when
// initializing the allocator; see kinit above.)
void
kfree(char *v)
{
  struct run *r;

  if((uint)v % PGSIZE || v < end || v2p(v) >= PHYSTOP)
    panic("kfree");

  // Fill with junk to catch dangling refs.
  memset(v, 1, PGSIZE);

  if(kmem.use_lock)
    acquire(&kmem.lock);
  r = &kmem.runs[(V2P(v) / PGSIZE)];
  r->next = kmem.freelist;
  kmem.freelist = r;
  if(kmem.use_lock)
    release(&kmem.lock);
}
コード例 #22
0
ファイル: vm.c プロジェクト: baileyparker/xv6-public
// Return the address of the PTE in page table pgdir
// that corresponds to virtual address va.  If alloc!=0,
// create any required page table pages.
static pte_t *
walkpgdir(pde_t *pgdir, const void *va, int alloc)
{
  pde_t *pde;
  pte_t *pgtab;

  pde = &pgdir[PDX(va)];
  if(*pde & PTE_P){
    pgtab = (pte_t*)P2V(PTE_ADDR(*pde));
  } else {
    if(!alloc || (pgtab = (pte_t*)kalloc()) == 0)
      return 0;
    // Make sure all those PTE_P bits are zero.
    memset(pgtab, 0, PGSIZE);
    // The permissions here are overly generous, but they can
    // be further restricted by the permissions in the page table
    // entries, if necessary.
    *pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U;
  }
  return &pgtab[PTX(va)];
}
コード例 #23
0
ファイル: proc.c プロジェクト: leadingtheway/Jix
void
userinit(void)
{
    struct proc *p;
    extern char _binary_kernel_initcode_start[],
            _binary_kernel_initcode_size[];
    char *mem;

    p = allocproc();
    assert(p);

    initproc = p;
    if((p->pgdir = setupkvm(kalloc)) == NULL)
        panic("userinit: out of memory?");

    if ((int)_binary_kernel_initcode_size > PGSIZE)
        panic("inituvm: initcode more than a page");

    mem = kalloc();
    memset(mem, 0, PGSIZE);
    mappages(p->pgdir, 0, PGSIZE, V2P(mem), PTE_W|PTE_U, kalloc);
    memcpy(mem, (char *)_binary_kernel_initcode_start,
           (int)_binary_kernel_initcode_size);

    safestrcpy(p->name, "initcode", sizeof(p->name));
    p->brk = PGSIZE;
    memset(p->tf, 1, sizeof(*p->tf));
    p->tf->cs = (SEG_UCODE << 3) | DPL_USER;
    p->tf->ss = (SEG_UDATA << 3) | DPL_USER;
    p->tf->ds = p->tf->es =
            p->tf->fs = p->tf->gs = p->tf->ss;
    p->tf->eflags = FL_IF;
    p->tf->esp = PGSIZE;
    p->tf->eip = 0;  // beginning of initcode

    p->counter = p->priority = 10;
    p->state = RUNNABLE;
}
コード例 #24
0
ファイル: proc.c プロジェクト: leadingtheway/Jix
void
schedule()
{
    struct proc *p;
    int c, idle;

    while (1) {
        c = 0;
        idle = 1;

        while (1) {
            for (p = ptable; p < ptable + NPROC; p++)
                if (p->state == RUNNABLE) {
                    if (p != ptable + TASK_IDLE)
                        idle = 0;
                    if (p->counter > c) {
                        c = p->counter;
                        current = p;
                    }
                }

            if ((current == ptable + TASK_IDLE && idle) ||
                    current != ptable + TASK_IDLE)
                break;
                // task_idle && !idle
            for (p = ptable; p < ptable + NPROC; p++)
                    p->counter = p->priority;
        }
        // break to here
        // current has been set
        // char *a[] = {"0", "1", "2", "3", "4", "5", "6", "7","8"};
        // kputs(a[current - ptable]);
        tss.esp0 = (u32)current->kstack + KSTACKSZ;
        lcr3(V2P(current->pgdir));
        swtch(&scheduler, current->context);
    }
}
コード例 #25
0
ファイル: frame.c プロジェクト: eXeC64/piker
void frame_free(uintptr_t frame)
{
    frame_set(V2P(frame), 0); /* convert from virt address */
}
コード例 #26
0
ファイル: vm.c プロジェクト: arielqw/ariel-ami
//   0xfe000000..0: mapped direct (devices such as ioapic)
//
// The kernel allocates physical memory for its heap and for user memory
// between V2P(end) and the end of physical memory (PHYSTOP)
// (directly addressable from end..P2V(PHYSTOP)).

// This table defines the kernel's mappings, which are present in
// every process's page table.
static struct kmap {
  void *virt;
  uint phys_start;
  uint phys_end;
  int perm;
} kmap[] = {
 { (void*)KERNBASE, 0,             EXTMEM,    PTE_W}, // I/O space
 { (void*)KERNLINK, V2P(KERNLINK), V2P(data), 0},     // kern text+rodata
 { (void*)data,     V2P(data),     PHYSTOP,   PTE_W}, // kern data+memory
 { (void*)DEVSPACE, DEVSPACE,      0,         PTE_W}, // more devices
};

// Set up kernel part of a page table.
pde_t*
setupkvm(void)
{
  pde_t *pgdir;
  struct kmap *k;

  if((pgdir = (pde_t*)kalloc()) == 0)
    return 0;
  memset(pgdir, 0, PGSIZE);
  if (p2v(PHYSTOP) > (void*)DEVSPACE)
コード例 #27
0
ファイル: vm.c プロジェクト: davidbalbert/thimble
//      0..USERTOP: user memory (canonical lower half; not included in kmap below)
//
//      KERNBASE..KERNBASE+EXTMEM -> 0..EXTMEM: I/O space (e.g. VGA), bootloader stack, etc.
//      KERNBASE+EXTMEM..data -> EXTMEM..v2p(data): kernel text and rodata. Read-only.
//      data..KERNBASE+PHYSTOP -> v2p(data)..PHYSTOP: kernel data and 1-1 mapping with free physical memory
//      KERNBASE+DEVSPACE..KERNBASE+DEVTOP -> DEVSPACE..DEVTOP: memory mapped devices

typedef struct Kmap Kmap;
static struct Kmap {
    void *addr;
    uintptr phys_start;
    uintptr phys_end;
    int perm;
} kmap[] = {
    {(void *)KERNBASE,           0,         EXTMEM,    PTE_W}, // memory mapped devices
    {(void *)KERNBASE+EXTMEM,    EXTMEM,    V2P(data), 0},     // Kernel read only data
    {(void *)data,               V2P(data), PHYSTOP,   PTE_W}, // kernel data + physical pages
    {(void*)(KERNBASE+DEVSPACE), DEVSPACE,  DEVTOP,    PTE_W}, // more devices
};


Pml4e *
setupkvm(void)
{
    Pml4e *pgmap = kalloc();
    Kmap *k;

    if (pgmap == nil)
        return nil;

    memzero(pgmap, PGSIZE);
コード例 #28
0
ファイル: main.c プロジェクト: WareX97/aPlus
int init(void) {
    
    void find_pci(uint32_t device, uint16_t venid, uint16_t devid, void* data) {
        if((venid == 0x1022) && (devid == 0x2000))
            *((uint32_t*) data) = device;
    }

    int pci = 0;
    pci_scan(&find_pci, -1, &pci);
    if(!pci) {
        kprintf(ERROR "pcnet: pci device not found!\n");
        return -1;
    }

    struct pcnet* dev = (struct pcnet*) kmalloc(sizeof(struct pcnet), GFP_KERNEL);
    struct ethif* eth = (struct ethif*) kmalloc(sizeof(struct ethif), GFP_KERNEL);

    memset(dev, 0, sizeof(struct pcnet));
    memset(eth, 0, sizeof(struct ethif));


    eth->internals = (void*) dev;
    dev->pci = pci;



    spinlock_init(&dev->lock);

    dev->buf = (uintptr_t) kvalloc(0x10000, GFP_KERNEL);
    dev->bufp = (uintptr_t) V2P((void*) dev->buf);

    uint16_t cmd = pci_read_field(dev->pci, PCI_COMMAND, 4);
    if(!(cmd & (1 << 2))) 
        pci_write_field(dev->pci, PCI_COMMAND, 4, cmd | (1 << 2));


    dev->irq = pci_read_field(dev->pci, PCI_INTERRUPT_LINE, 1);
    dev->io = pci_read_field(dev->pci, PCI_BAR0, 4) & 0xFFFFFFF0;
    dev->mem = pci_read_field(dev->pci, PCI_BAR1, 4) & 0xFFFFFFF0;

    
    kprintf(LOG "pcnet: irq: %d, io: %p, mem: %p\n", dev->irq, dev->io, dev->mem);

    int i;
    for(i = 0; i < 6; i++)
        eth->address[i] = inb(dev->io + i);

    

    pcnet_irqno = dev->irq;   /* FIXME: fix current_irq */

    irq_enable(dev->irq, pcnet_irq);
    irq_set_data(dev->irq, dev);


    eth->low_level_init = pcnet_init;
    eth->low_level_startoutput = pcnet_startoutput;
    eth->low_level_output = pcnet_output;
    eth->low_level_endoutput = pcnet_endoutput;
    eth->low_level_startinput = pcnet_startinput;
    eth->low_level_input = pcnet_input;
    eth->low_level_endinput = pcnet_endinput;
    eth->low_level_input_nomem = pcnet_input_nomem;


    IP4_ADDR(&eth->ip, 10, 0, 2, 15);
    IP4_ADDR(&eth->nm, 255, 255, 255, 0);
    IP4_ADDR(&eth->gw, 10, 0, 2, 2);

    struct netif* netif = (struct netif*) kmalloc(sizeof(struct netif), GFP_KERNEL);
    dev->netif = netif;

    if(!netif_add(netif, &eth->ip, &eth->nm, &eth->gw, eth, ethif_init, ethernet_input)) {
        kprintf(ERROR "pcnet: netif_add() failed\n");

        kfree(dev);
        kfree(eth);
        kfree(netif);
        return -1;
    }

    netif_set_default(netif);
    netif_set_up(netif);

    return 0;
}
コード例 #29
0
ファイル: gmm.c プロジェクト: czxxjtu/videosearch
void gmm_fisher_save_soft_assgn(int n, const float *v, const gmm_t * g, int flags,
                                float *dp_dlambda,
                                float *word_total_soft_assignment) {
    long d=g->d, k=g->k;
    float *p = fvec_new(n * k);
    long i,j,l;
    long ii=0;

    float * vp = NULL; /* v*p */
    float * sum_pj = NULL; /* sum of p's for a given j */

    gmm_compute_p(n,v,g,p,flags | GMM_FLAGS_W);

#define P(j,i) p[(i)*k+(j)]
#define V(l,i) v[(i)*d+(l)]
#define MU(l,j) g->mu[(j)*d+(l)]
#define SIGMA(l,j) g->sigma[(j)*d+(l)]
#define VP(l,j) vp[(j)*d+(l)]

    // Save total soft assignment per centroid
    if (word_total_soft_assignment != NULL) {
        for (j=0; j<k; j++) {
            double sum=0;
            for (i=0; i<n; i++) {
                sum += P(j,i);
            }
            if (n != 0) {
                word_total_soft_assignment[j] = (float)(sum/n);
            } else {
                word_total_soft_assignment[j] = 0.0;
            }
        }
    }

    if(flags & GMM_FLAGS_W) {

        for(j=1; j<k; j++) {
            double accu=0;

            for(i=0; i<n; i++)
                accu+= P(j,i)/g->w[j] - P(0,i)/g->w[0];

            /* normalization */
            double f=n*(1/g->w[j]+1/g->w[0]);

            dp_dlambda[ii++]=accu/sqrt(f);
        }
    }

    if(flags & GMM_FLAGS_MU) {
        float *dp_dmu=dp_dlambda+ii;

#define DP_DMU(l,j) dp_dmu[(j)*d+(l)]

        if(0) { /* simple and slow */

            for(j=0; j<k; j++) {
                for(l=0; l<d; l++) {
                    double accu=0;

                    for(i=0; i<n; i++)
                        accu += P(j,i) * (V(l,i)-MU(l,j)) / SIGMA(l,j);

                    DP_DMU(l,j)=accu;
                }
            }

        } else { /* complicated and fast */

            /* precompute  tables that may be useful for sigma too */
            vp = fvec_new(k * d);
            fmat_mul_tr(v,p,d,k,n,vp);

            sum_pj = fvec_new(k);
            for(j=0; j<k; j++) {
                double sum=0;
                for(i=0; i<n; i++) sum += P(j,i);
                sum_pj[j] = sum;
            }

            for(j=0; j<k; j++) {
                for(l=0; l<d; l++)
                    DP_DMU(l,j) = (VP(l,j) - MU(l,j) * sum_pj[j]) / SIGMA(l,j);
            }

        }
        /* normalization */
        if(!(flags & GMM_FLAGS_NO_NORM)) {
            for(j=0; j<k; j++)
                for(l=0; l<d; l++) {
                    float nf = sqrt(n*g->w[j]/SIGMA(l,j));
                    if(nf > 0) DP_DMU(l,j) /= nf;
                }
        }
#undef DP_DMU
        ii+=d*k;
    }

    if(flags & (GMM_FLAGS_SIGMA | GMM_FLAGS_1SIGMA)) {


        if(flags & GMM_FLAGS_1SIGMA) { /* fast not implemented for 1 sigma */

            for(j=0; j<k; j++) {
                double accu2=0;
                for(l=0; l<d; l++) {
                    double accu=0;

                    for(i=0; i<n; i++)
                        accu += P(j,i) * (sqr(V(l,i)-MU(l,j)) / SIGMA(l,j) - 1) / sqrt(SIGMA(l,j));

                    if(flags & GMM_FLAGS_SIGMA) {

                        double f=flags & GMM_FLAGS_NO_NORM ? 1.0 : 2*n*g->w[j]/SIGMA(l,j);

                        dp_dlambda[ii++]=accu/sqrt(f);
                    }
                    accu2+=accu;
                }

                if(flags & GMM_FLAGS_1SIGMA) {
                    double f=flags & GMM_FLAGS_NO_NORM ? 1.0 : 2*d*n*g->w[j]/SIGMA(0,j);
                    dp_dlambda[ii++]=accu2/sqrt(f);
                }

            }

        } else { /* fast and complicated */
            assert(flags & GMM_FLAGS_SIGMA);
            float *dp_dsigma = dp_dlambda + ii;

            if(!vp) {
                vp = fvec_new(k * d);
                fmat_mul_tr(v,p,d,k,n,vp);
            }

            if(!sum_pj) {
                sum_pj = fvec_new(k);
                for(j=0; j<k; j++) {
                    double sum=0;
                    for(i=0; i<n; i++) sum += P(j,i);
                    sum_pj[j] = sum;
                }
            }
            float *v2 = fvec_new(n * d);
            for(i = n*d-1 ; i >= 0; i--) v2[i] = v[i] * v[i];
            float *v2p = fvec_new(k * d);
            fmat_mul_tr(v2,p,d,k,n,v2p);
            free(v2);

#define V2P(l,j) v2p[(j)*d+(l)]
#define DP_DSIGMA(i,j) dp_dsigma[(i)+(j)*d]
            for(j=0; j<k; j++) {

                for(l=0; l<d; l++) {
                    double accu;

                    accu = V2P(l, j);

                    accu += VP(l, j) * (- 2 * MU(l,j));

                    accu += sum_pj[j] * (sqr(MU(l,j))  - SIGMA(l,j));

                    /* normalization */

                    double f;

                    if(flags & GMM_FLAGS_NO_NORM) {
                        f = pow(SIGMA(l,j), -1.5);
                    } else {
                        f = 1 / (SIGMA(l,j) * sqrt(2*n*g->w[j]));
                    }

                    DP_DSIGMA(l,j) = accu * f;

                }

            }

            free(v2p);

#undef DP_DSIGMA
#undef V2P
            ii += d * k;
        }

    }

    assert(ii==gmm_fisher_sizeof(g,flags));
#undef P
#undef V
#undef MU
#undef SIGMA
    free(p);
    free(sum_pj);
    free(vp);
}
コード例 #30
0
ファイル: vm.c プロジェクト: baileyparker/xv6-public
// Switch h/w page table register to the kernel-only page table,
// for when no process is running.
void
switchkvm(void)
{
  lcr3(V2P(kpgdir));   // switch to the kernel page table
}