sys/src/9/pc64/mmu.c

   1 #include        "u.h"
   2 #include        "../port/lib.h"
   3 #include        "mem.h"
   4 #include        "dat.h"
   5 #include        "fns.h"
   6 #include        "io.h"
   7
   8 /*
   9  * Simple segment descriptors with no translation.
  10  */
  11 #define EXECSEGM(p)     { 0, SEGL|SEGP|SEGPL(p)|SEGEXEC }
  12 #define DATASEGM(p)     { 0, SEGB|SEGG|SEGP|SEGPL(p)|SEGDATA|SEGW }
  13 #define EXEC32SEGM(p)   { 0xFFFF, SEGG|SEGD|(0xF<<16)|SEGP|SEGPL(p)|SEGEXEC|SEGR }
  14 #define DATA32SEGM(p)   { 0xFFFF, SEGB|SEGG|(0xF<<16)|SEGP|SEGPL(p)|SEGDATA|SEGW }
  15
  16 Segdesc gdt[NGDT] =
  17 {
  18 [NULLSEG]       { 0, 0},                /* null descriptor */
  19 [KESEG]         EXECSEGM(0),            /* kernel code */
  20 [KDSEG]         DATASEGM(0),            /* kernel data */
  21 [UE32SEG]       EXEC32SEGM(3),          /* user code 32 bit*/
  22 [UDSEG]         DATA32SEGM(3),          /* user data/stack */
  23 [UESEG]         EXECSEGM(3),            /* user code */
  24 };
  25
  26 static int didmmuinit = 0;
  27
  28 static struct {
  29         Lock;
  30         MMU     *free;
  31
  32         int     nalloc;
  33         int     nfree;
  34 } mmupool;
  35
  36 /* level */
  37 enum {
  38         PML4E   = 2,
  39         PDPE    = 1,
  40         PDE     = 0,
  41
  42         MAPBITS = 8*sizeof(m->mmumap[0]),
  43 };
  44
  45 static void
  46 loadptr(u16int lim, uintptr off, void (*load)(void*))
  47 {
  48         u64int b[2], *o;
  49         u16int *s;
  50
  51         o = &b[1];
  52         s = ((u16int*)o)-1;
  53
  54         *s = lim;
  55         *o = off;
  56
  57         (*load)(s);
  58 }
  59
  60 static void
  61 taskswitch(uintptr stack)
  62 {
  63         Tss *tss;
  64
  65         tss = m->tss;
  66         tss->rsp0[0] = (u32int)stack;
  67         tss->rsp0[1] = stack >> 32;
  68         tss->rsp1[0] = (u32int)stack;
  69         tss->rsp1[1] = stack >> 32;
  70         tss->rsp2[0] = (u32int)stack;
  71         tss->rsp2[1] = stack >> 32;
  72         mmuflushtlb();
  73 }
  74
  75 void
  76 mmuinit(void)
  77 {
  78         uintptr x;
  79         vlong v;
  80         int i;
  81
  82         didmmuinit = 1;
  83
  84         /* zap double map done by l.s */
  85         m->pml4[512] = 0;
  86         m->pml4[0] = 0;
  87
  88         m->tss = mallocz(sizeof(Tss), 1);
  89         if(m->tss == nil)
  90                 panic("mmuinit: no memory for Tss");
  91         m->tss->iomap = 0xDFFF;
  92         for(i=0; i<14; i+=2){
  93                 x = (uintptr)m + MACHSIZE;
  94                 m->tss->ist[i] = x;
  95                 m->tss->ist[i+1] = x>>32;
  96         }
  97
  98         /*
  99          * We used to keep the GDT in the Mach structure, but it
 100          * turns out that that slows down access to the rest of the
 101          * page.  Since the Mach structure is accessed quite often,
 102          * it pays off anywhere from a factor of 1.25 to 2 on real
 103          * hardware to separate them (the AMDs are more sensitive
 104          * than Intels in this regard).  Under VMware it pays off
 105          * a factor of about 10 to 100.
 106          */
 107         memmove(m->gdt, gdt, sizeof gdt);
 108
 109         x = (uintptr)m->tss;
 110         m->gdt[TSSSEG+0].d0 = (x<<16)|(sizeof(Tss)-1);
 111         m->gdt[TSSSEG+0].d1 = (x&0xFF000000)|((x>>16)&0xFF)|SEGTSS|SEGPL(0)|SEGP;
 112         m->gdt[TSSSEG+1].d0 = x>>32;
 113         m->gdt[TSSSEG+1].d1 = 0;
 114
 115         loadptr(sizeof(gdt)-1, (uintptr)m->gdt, lgdt);
 116         loadptr(sizeof(Segdesc)*512-1, (uintptr)IDTADDR, lidt);
 117         taskswitch((uintptr)m + MACHSIZE);
 118         ltr(TSSSEL);
 119
 120         wrmsr(0xc0000100, 0ull);        /* 64 bit fsbase */
 121         wrmsr(0xc0000101, (uvlong)&machp[m->machno]);   /* 64 bit gsbase */
 122         wrmsr(0xc0000102, 0ull);        /* kernel gs base */
 123
 124         /* enable syscall extension */
 125         rdmsr(0xc0000080, &v);
 126         v |= 1ull;
 127         wrmsr(0xc0000080, v);
 128
 129         /* IA32_STAR */
 130         wrmsr(0xc0000081, ((uvlong)UE32SEL << 48) | ((uvlong)KESEL << 32));
 131
 132         /* IA32_LSTAR */
 133         wrmsr(0xc0000082, (uvlong)syscallentry);
 134
 135         /* SYSCALL flags mask */
 136         wrmsr(0xc0000084, 0x200);
 137 }
 138
 139 /*
 140  * These could go back to being macros once the kernel is debugged,
 141  * but the extra checking is nice to have.
 142  */
 143 void*
 144 kaddr(uintptr pa)
 145 {
 146         if(pa > (uintptr)-KZERO)
 147                 panic("kaddr: pa=%#p pc=%#p", pa, getcallerpc(&pa));
 148         return (void*)(pa+KZERO);
 149 }
 150
 151 uintptr
 152 paddr(void *v)
 153 {
 154         uintptr va;
 155
 156         va = (uintptr)v;
 157         if(va >= KZERO)
 158                 return va-KZERO;
 159         if(va >= VMAP)
 160                 return va-VMAP;
 161         panic("paddr: va=%#p pc=%#p", va, getcallerpc(&v));
 162         return 0;
 163 }
 164
 165 static MMU*
 166 mmualloc(void)
 167 {
 168         MMU *p;
 169         int i, n;
 170
 171         p = m->mmufree;
 172         if(p != nil){
 173                 m->mmufree = p->next;
 174                 m->mmucount--;
 175         } else {
 176                 lock(&mmupool);
 177                 p = mmupool.free;
 178                 if(p != nil){
 179                         mmupool.free = p->next;
 180                         mmupool.nfree--;
 181                 } else {
 182                         unlock(&mmupool);
 183
 184                         n = 256;
 185                         p = malloc(n * sizeof(MMU));
 186                         if(p == nil)
 187                                 panic("mmualloc: out of memory for MMU");
 188                         p->page = mallocalign(n * PTSZ, BY2PG, 0, 0);
 189                         if(p->page == nil)
 190                                 panic("mmualloc: out of memory for MMU pages");
 191                         for(i=1; i<n; i++){
 192                                 p[i].page = p[i-1].page + (1<<PTSHIFT);
 193                                 p[i-1].next = &p[i];
 194                         }
 195
 196                         lock(&mmupool);
 197                         p[n-1].next = mmupool.free;
 198                         mmupool.free = p->next;
 199                         mmupool.nalloc += n;
 200                         mmupool.nfree += n-1;
 201                 }
 202                 unlock(&mmupool);
 203         }
 204         p->next = nil;
 205         return p;
 206 }
 207
 208 static uintptr*
 209 mmucreate(uintptr *table, uintptr va, int level, int index)
 210 {
 211         uintptr *page, flags;
 212         MMU *p;
 213
 214         flags = PTEWRITE|PTEVALID;
 215         if(va < VMAP){
 216                 assert(up != nil);
 217                 assert((va < TSTKTOP) || (va >= KMAP && va < KMAP+KMAPSIZE));
 218
 219                 p = mmualloc();
 220                 p->index = index;
 221                 p->level = level;
 222                 if(va < TSTKTOP){
 223                         flags |= PTEUSER;
 224                         if(level == PML4E){
 225                                 if((p->next = up->mmuhead) == nil)
 226                                         up->mmutail = p;
 227                                 up->mmuhead = p;
 228                                 m->mmumap[index/MAPBITS] |= 1ull<<(index%MAPBITS);
 229                         } else {
 230                                 up->mmutail->next = p;
 231                                 up->mmutail = p;
 232                         }
 233                         up->mmucount++;
 234                 } else {
 235                         if(level == PML4E){
 236                                 up->kmaptail = p;
 237                                 up->kmaphead = p;
 238                         } else {
 239                                 up->kmaptail->next = p;
 240                                 up->kmaptail = p;
 241                         }
 242                         up->kmapcount++;
 243                 }
 244                 page = p->page;
 245         } else if(didmmuinit) {
 246                 page = mallocalign(PTSZ, BY2PG, 0, 0);
 247         } else {
 248                 page = rampage();
 249         }
 250         memset(page, 0, PTSZ);
 251         table[index] = PADDR(page) | flags;
 252         return page;
 253 }
 254
 255 uintptr*
 256 mmuwalk(uintptr* table, uintptr va, int level, int create)
 257 {
 258         uintptr pte;
 259         int i, x;
 260
 261         x = PTLX(va, 3);
 262         for(i = 2; i >= level; i--){
 263                 pte = table[x];
 264                 if(pte & PTEVALID){
 265                         if(pte & PTESIZE)
 266                                 return 0;
 267                         table = KADDR(PPN(pte));
 268                 } else {
 269                         if(!create)
 270                                 return 0;
 271                         table = mmucreate(table, va, i, x);
 272                 }
 273                 x = PTLX(va, i);
 274         }
 275         return &table[x];
 276 }
 277
 278 static int
 279 ptecount(uintptr va, int level)
 280 {
 281         return (1<<PTSHIFT) - (va & PGLSZ(level+1)-1) / PGLSZ(level);
 282 }
 283
 284 void
 285 pmap(uintptr *pml4, uintptr pa, uintptr va, int size)
 286 {
 287         uintptr *pte, *ptee, flags;
 288         int z, l;
 289
 290         if((size <= 0) || va < VMAP)
 291                 panic("pmap: pa=%#p va=%#p size=%d", pa, va, size);
 292         flags = pa;
 293         pa = PPN(pa);
 294         flags -= pa;
 295         if(va >= KZERO)
 296                 flags |= PTEGLOBAL;
 297         while(size > 0){
 298                 if(size >= PGLSZ(1) && (va % PGLSZ(1)) == 0)
 299                         flags |= PTESIZE;
 300                 l = (flags & PTESIZE) != 0;
 301                 z = PGLSZ(l);
 302                 pte = mmuwalk(pml4, va, l, 1);
 303                 if(pte == 0){
 304                         pte = mmuwalk(pml4, va, ++l, 0);
 305                         if(pte && (*pte & PTESIZE)){
 306                                 flags |= PTESIZE;
 307                                 z = va & (PGLSZ(l)-1);
 308                                 va -= z;
 309                                 pa -= z;
 310                                 size += z;
 311                                 continue;
 312                         }
 313                         panic("pmap: pa=%#p va=%#p size=%d", pa, va, size);
 314                 }
 315                 ptee = pte + ptecount(va, l);
 316                 while(size > 0 && pte < ptee){
 317                         *pte++ = pa | flags;
 318                         pa += z;
 319                         va += z;
 320                         size -= z;
 321                 }
 322         }
 323 }
 324
 325 static void
 326 mmuzap(void)
 327 {
 328         uintptr *pte;
 329         u64int w;
 330         int i, x;
 331
 332         pte = m->pml4;
 333         pte[PTLX(KMAP, 3)] = 0;
 334
 335         /* common case */
 336         pte[PTLX(UTZERO, 3)] = 0;
 337         pte[PTLX(TSTKTOP, 3)] = 0;
 338         m->mmumap[PTLX(UTZERO, 3)/MAPBITS] &= ~(1ull<<(PTLX(UTZERO, 3)%MAPBITS));
 339         m->mmumap[PTLX(TSTKTOP, 3)/MAPBITS] &= ~(1ull<<(PTLX(TSTKTOP, 3)%MAPBITS));
 340
 341         for(i = 0; i < nelem(m->mmumap); pte += MAPBITS, i++){
 342                 w = m->mmumap[i];
 343                 if(w == 0)
 344                         continue;
 345                 x = 0;
 346                 do {
 347                         if(w & 1)
 348                                 pte[x] = 0;
 349                         x++;
 350                         x >>= 1;
 351                 } while(w);
 352                 m->mmumap[i] = 0;
 353         }
 354 }
 355
 356 static void
 357 mmufree(Proc *proc)
 358 {
 359         MMU *p;
 360
 361         p = proc->mmutail;
 362         if(p == nil)
 363                 return;
 364         if(m->mmucount+proc->mmucount < 256){
 365                 p->next = m->mmufree;
 366                 m->mmufree = proc->mmuhead;
 367                 m->mmucount += proc->mmucount;
 368         } else {
 369                 lock(&mmupool);
 370                 p->next = mmupool.free;
 371                 mmupool.free = proc->mmuhead;
 372                 mmupool.nfree += proc->mmucount;
 373                 unlock(&mmupool);
 374         }
 375         proc->mmuhead = proc->mmutail = nil;
 376         proc->mmucount = 0;
 377 }
 378
 379 void
 380 flushmmu(void)
 381 {
 382         int x;
 383
 384         x = splhi();
 385         up->newtlb = 1;
 386         mmuswitch(up);
 387         splx(x);
 388 }
 389
 390 void
 391 mmuswitch(Proc *proc)
 392 {
 393         MMU *p;
 394
 395         mmuzap();
 396         if(proc->newtlb){
 397                 mmufree(proc);
 398                 proc->newtlb = 0;
 399         }
 400         if((p = proc->kmaphead) != nil)
 401                 m->pml4[PTLX(KMAP, 3)] = PADDR(p->page) | PTEWRITE|PTEVALID;
 402         for(p = proc->mmuhead; p != nil && p->level == PML4E; p = p->next){
 403                 m->mmumap[p->index/MAPBITS] |= 1ull<<(p->index%MAPBITS);
 404                 m->pml4[p->index] = PADDR(p->page) | PTEUSER|PTEWRITE|PTEVALID;
 405         }
 406         taskswitch((uintptr)proc->kstack+KSTACK);
 407 }
 408
 409 void
 410 mmurelease(Proc *proc)
 411 {
 412         MMU *p;
 413
 414         mmuzap();
 415         if((p = proc->kmaptail) != nil){
 416                 if((p->next = proc->mmuhead) == nil)
 417                         proc->mmutail = p;
 418                 proc->mmuhead = proc->kmaphead;
 419                 proc->mmucount += proc->kmapcount;
 420
 421                 proc->kmaphead = proc->kmaptail = nil;
 422                 proc->kmapcount = proc->kmapindex = 0;
 423         }
 424         mmufree(proc);
 425         taskswitch((uintptr)m+MACHSIZE);
 426 }
 427
 428 void
 429 putmmu(uintptr va, uintptr pa, Page *)
 430 {
 431         uintptr *pte, old;
 432         int x;
 433
 434         x = splhi();
 435         pte = mmuwalk(m->pml4, va, 0, 1);
 436         if(pte == 0)
 437                 panic("putmmu: bug: va=%#p pa=%#p", va, pa);
 438         old = *pte;
 439         *pte = pa | PTEVALID|PTEUSER;
 440         splx(x);
 441         if(old & PTEVALID)
 442                 invlpg(va);
 443 }
 444
 445 void
 446 checkmmu(uintptr va, uintptr pa)
 447 {
 448         USED(va, pa);
 449 }
 450
 451 uintptr
 452 cankaddr(uintptr pa)
 453 {
 454         if(pa >= -KZERO)
 455                 return 0;
 456         return -KZERO - pa;
 457 }
 458
 459 void
 460 countpagerefs(ulong *ref, int print)
 461 {
 462         USED(ref, print);
 463 }
 464
 465 KMap*
 466 kmap(Page *page)
 467 {
 468         uintptr *pte, pa, va;
 469         int x;
 470
 471         pa = page->pa;
 472         if(cankaddr(pa) != 0)
 473                 return (KMap*)KADDR(pa);
 474
 475         x = splhi();
 476         va = KMAP + ((uintptr)up->kmapindex << PGSHIFT);
 477         pte = mmuwalk(m->pml4, va, 0, 1);
 478         if(pte == 0 || *pte & PTEVALID)
 479                 panic("kmap: pa=%#p va=%#p", pa, va);
 480         *pte = pa | PTEWRITE|PTEVALID;
 481         up->kmapindex = (up->kmapindex + 1) % (1<<PTSHIFT);
 482         if(up->kmapindex == 0)
 483                 mmuflushtlb();
 484         splx(x);
 485         return (KMap*)va;
 486 }
 487
 488 void
 489 kunmap(KMap *k)
 490 {
 491         uintptr *pte, va;
 492         int x;
 493
 494         va = (uintptr)k;
 495         if(va >= KZERO)
 496                 return;
 497
 498         x = splhi();
 499         pte = mmuwalk(m->pml4, va, 0, 0);
 500         if(pte == 0 || (*pte & PTEVALID) == 0)
 501                 panic("kunmap: va=%#p", va);
 502         *pte = 0;
 503         splx(x);
 504 }
 505
 506 /*
 507  * Add a device mapping to the vmap range.
 508  */
 509 void*
 510 vmap(uintptr pa, int size)
 511 {
 512         uintptr va;
 513         int o;
 514
 515         va = pa+VMAP;
 516         /*
 517          * might be asking for less than a page.
 518          */
 519         o = pa & (BY2PG-1);
 520         pa -= o;
 521         va -= o;
 522         size += o;
 523         pmap(m->pml4, pa | PTEUNCACHED|PTEWRITE|PTEVALID, va, size);
 524         return (void*)(va+o);
 525 }
 526
 527 void
 528 vunmap(void *v, int)
 529 {
 530         paddr(v);       /* will panic on error */
 531 }
 532
 533 /*
 534  * vmapsync() is currently unused as the VMAP and KZERO PDPs
 535  * are shared between processors. (see mpstartap)
 536  */
 537 int
 538 vmapsync(uintptr va)
 539 {
 540         uintptr *pte1, *pte2;
 541         int level;
 542
 543         if(va < VMAP || m->machno == 0)
 544                 return 0;
 545
 546         for(level=0; level<2; level++){
 547                 pte1 = mmuwalk(MACHP(0)->pml4, va, level, 0);
 548                 if(pte1 && *pte1 & PTEVALID){
 549                         pte2 = mmuwalk(m->pml4, va, level, 1);
 550                         if(pte2 == 0)
 551                                 break;
 552                         if(pte1 != pte2)
 553                                 *pte2 = *pte1;
 554                         return 1;
 555                 }
 556         }
 557         return 0;
 558 }