Welcome to BiscuitOS

shang2010

是不是又来造轮子了，，，才4个人就可以了

Buddy_Zhang1

回复 11# shang2010

人不在数量，在于质量

Buddy_Zhang1

BiscuitOS 内核（linux0.11） 关于逻辑地址，虚拟地址，线性地址和物理地址的转换过程：

1. /*
   
2. * Logical Address Mechanism on MMU
   
3. *
   
4. * (C) 2018.01 BiscuitOS <buddy.zhang@aliyun.com>
   
5. *
   
6. * This program is free software; you can redistribute it and/or modify
   
7. * it under the terms of the GNU General Public License version 2 as
   
8. * published by the Free Software Foundation.
   
9. */
   
10. #include <linux/kernel.h>
    
11. #include <linux/head.h>
    
12. #include <linux/sched.h>
    
13. 
    
14. #include <test/debug.h>
    
15. 
    
16. static char var[50] = "BiscuitOS";
    
17. 
    
18. /*
    
19. * Logical address convent to physical address
    
20. */
    
21. static void logic_to_physic(void)
    
22. {
    
23.     struct logic_addr la;
    
24.     unsigned long virtual, linear, physic;
    
25.     unsigned long base, limit;
    
26.     unsigned long cs, ds, cr3, cr4;
    
27.     unsigned char cpl, dpl;
    
28.     struct desc_struct *desc;
    
29.     unsigned long PDE, PTE;
    
30. 
    
31.     /* Obtain specific segment selector */
    
32.     __asm__ ("movl %%cs, %0\n\r"
    
33.              "movl %%ds, %1"
    
34.              : "=r" (cs), "=r" (ds));
    
35. 
    
36.     /* Establish a logical address */
    
37.     la.offset = (unsigned long)&var;
    
38.     la.sel    = ds;
    
39. 
    
40.     /* Obtain virtual address */
    
41.     virtual = la.offset;
    
42. 
    
43.     /* violation COW */
    
44.     var[48] = 'A';
    
45. 
    
46.     /* Uses the offset in the segment selector to locate the segment
    
47.      * descriptor for the segment in the GDT or LDT and reads it into
    
48.      * the processor. (This step is needed only when a new segment selector
    
49.      * is loaded into a segment register.) */
    
50.     if ((la.sel >> 2) & 0x1)
    
51.         desc = &current->ldt[la.sel >> 3];
    
52.     else
    
53.         desc = &gdt[la.sel >> 3];
    
54.     /* Examines the segment descriptor to check the access rights and range
    
55.      * of the segment to insure that the segment is accessible and that
    
56.      * offset is within the limit of the segment */
    
57.     base  = get_base(*desc);
    
58.     limit = get_limit(*desc) * 4096;
    
59.     if (la.offset > limit)
    
60.         panic("Out of segment\n");
    
61.     cpl = cs & 0x3;
    
62.     dpl = desc->b >> 13 & 0x3;
    
63.     if (cpl > dpl)
    
64.         panic("Trigger #GP");
    
65. 
    
66.     /* Obtain linear address on flat-protect model */
    
67.     linear = base + la.offset;
    
68.    
    
69.     /* Obtain physical address of pgdir from CR3 register, the contents of
    
70.      * 'cr3' is point to the physical of pg_dir, so refers it as a pointer. */
    
71.     __asm__ ("movl %%cr3, %0" : "=r" (cr3));
    
72. 
    
73.     /* A 4-KByte naturally aligned page directory is located at the
    
74.      * physical address specified in bits 31:12 of CR3. A page directory
    
75.      * comprises 1024 32-bit entries (PDEs). A PDE is selected using
    
76.      * the physical address defined as follow:
    
77.      *
    
78.      * -- Bits 39:32 are all 0
    
79.      * -- Bits 31:12 are from CR3.
    
80.      * -- Bits 11:2  are bits 31:22 of the linear address
    
81.      * -- Bits  1:0  are 0.
    
82.      *
    
83.      * Becasue a PDE is identified using bits 31:22 of the linear address,
    
84.      * it control access to a 4-Mbytes region of the linear-address space.
    
85.      * Use of the PDE depends on CR4.PSE and PDE's PS flag (bit 7)*/
    
86.     PDE =  ((unsigned char)(((cr3 >> 12) & 0xFFFFF) << 12) +
    
87.            (((linear >> 22) & 0x3FF) << 2)) & 0xFFFFFFFC;
    
88.     /* Another way to compute PDE:
    
89.      * PDE = (unsigned long *)cr3[linear >> 22] */
    
90. 
    
91.     __asm__ ("movl %%cr4, %0" : "=r" (cr4));
    
92.     if (((cr4 >> 4) & 0x1) && ((PDE >> 4) & 0x1)) {
    
93.         /* If CR4.PSE = 1 and the PDE's PS flag is 1, the PDE maps a 4-MByte
    
94.          * page. The final physical address is computed as follows:
    
95.          *
    
96.          * -- Bits 39:32 are bits 20:13 of the PDE.
    
97.          * -- Bits 31:22 are bits 31:22 of the PDE.
    
98.          * -- Bits 21:0  are from the original linear address.
    
99.          */
    
100.         PTE = 0x0; /* No complete on BiscuitOS */
     
101.     } else if (!((cr4 >> 4) & 0x1) && !((PDE >> 4) & 0x1)) {
     
102.         /* If CR4.PSE = 0 or the PDE's PS flag is 0, a 4-KByte naturally
     
103.          * aligned page table is located at the physical address specified
     
104.          * in bits 31:12 of the PDE. A page table comprises 1024 32-bit
     
105.          * entries (PTEs). A PTE is selected using the physical address
     
106.          * defined as follows:
     
107.          *
     
108.          * -- Bits 39:32 are all 0
     
109.          * -- Bits 31:12 are from the PDE.
     
110.          * -- Bits 11:2  are bits 21:12 of the linear address.
     
111.          * -- Bits  1:0  are 0.
     
112.          */
     
113.         PTE = (unsigned long)((unsigned char *)(
     
114.               ((*(unsigned long *)PDE >> 12) & 0xFFFFF) << 12) +
     
115.               (((linear >> 12) & 0x3FF) << 2)) & 0xFFFFFFFC;
     
116.         /* Anther way to compute PTE:
     
117.          * PTE = (unsigned long *)PDE[(linear >> 12) & 0x3FF] */
     
118.     }
     
119.     /* Because a PTE is identified using bits 31:12 of the linear address,
     
120.      * every PTE maps a 4-KByte page. The final physical address is
     
121.      * computed as follows:
     
122.      *
     
123.      * -- Bits 39:32 are all 0
     
124.      * -- Bits 31:12 are from the PTE.
     
125.      * -- Bits 11:0  are from the original linear address.
     
126.      */
     
127.     physic = (unsigned long)(unsigned char *)(
     
128.              ((*(unsigned long *)PTE >> 12) & 0xFFFFF) << 12) +
     
129.              (linear & 0xFFF);
     
130. 
     
131.     printk("Logical Address: %#x:%#x\n", la.sel, la.offset);
     
132.     printk("Virtual Address: %#x\n", virtual);
     
133.     printk("Linear  Address: %#x\n", linear);
     
134.     printk("Physic  Address: %#x\n", physic);
     
135.     printk("Original:  %s\n", la.offset);
     
136.     printk("Translate: %s\n", physic);
     
137. }

复制代码