开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
paging.c
资源名称：tizos.rar　[点击查看]
上传用户：qddsws
上传日期：2022-06-22
资源大小：723k
文件大小：15k
源码类别：

操作系统开发

开发平台：

C/C++

paging.c：源码内容
  1. #include <i386/paging.h>
  3. int avmem;
  7. /* -----------------------------------------------
  8.  * 
  9.  * PHYSICAL ALLOCATOR
  10.  *
  11.  * ----------------------------------------------*/
  14. /* PHYSICAL MEMORY STACK
  15.  * Gives free physical memory page address
  16.  * from a stack of free memory pages
  17.  *
  18.  */
  20. /* Free physical memory stack pointers */
  21. unsigned long* bottom_phys_stack; /* pointer to bottom */
  22. unsigned long* act_phys_stack; /* pointer to actual address */
  26. /* Initialize the stack */
  27. void init_stack_up() {
  28. /* Push all physical address after the 16Mb point */
  30.         long int address=0x1000000; /*(16Mb)*/
  31. long int end_address=avmem*1024*1024;
  32. int structure_size=((end_address-address)/PAGE_SIZE)*sizeof(long int);
  34. /* Prevent from adding reserved region
  35.  * to the stack */
  36. address=address+structure_size;
  38. /* Align start and end to page size */
  39. address=PAGE_ALIGN_UP(address);
  40. end_address=PAGE_ALIGN(end_address);
  43. char text[200];
  44. snprintf (text,"%x first usable page. Last usable address %xn",address,end_address);
  45. kprint (text);
  47. /* Set stack pointers */
  48. bottom_phys_stack= (unsigned long*)TEMP_MAP_16_20M;
  49. act_phys_stack = bottom_phys_stack;
  51. /* For the whole range of physical address 
  52.  * push them to the stack.
  53.  */
  54.         while (end_address>=address) {
  55.                push_up_phys(end_address&0xfffff000);
  56.                end_address=end_address-PAGE_SIZE;
  57.         }
  58. }
  60. /* Push a free address to the stack */
  61. void push_up_phys (unsigned long address) {
  62. act_phys_stack[0]=address;
  63. act_phys_stack=(unsigned long*)((unsigned long)act_phys_stack+(unsigned long)sizeof(unsigned long));
  64. }
  66. /* Pop an address from the stack */
  67. unsigned long pop_up_phys () {
  68. act_phys_stack=(unsigned long*)((unsigned long)act_phys_stack-(unsigned long)sizeof(unsigned long));
  69. unsigned long ret_val=act_phys_stack[0];
  70. return ret_val;
  71. }
  74. /*
  75.  * PAGING INITIALIZATION
  76.  * 
  77.  */
  79. void initialize_paging(int availmem)
  80. {
  81. unsigned long *page_directory;
  82.         unsigned long *page_table;
  84. avmem=availmem;
  85. init_stack_up();
  88. /* Get a physical page for the page directory */
  89. page_directory=(unsigned long*)PRE_PHYSTOVIRT(pop_up_phys());
  90. /* Set the page directory empty */
  91. empty_page_table (page_directory);
  92.   
  95. /* LOW MEMORY MAP */
  96. /* Fill page table with map Phys 0x00-4Mb to virtual 0x00-4Mb */
  97. page_table=(unsigned long*)PRE_PHYSTOVIRT(pop_up_phys());
  98. fill_page_table (page_table,0x00,1024,0x03);
  99. /* Do the mapping */
  100. set_page_table_entry (page_directory,VIRT_TO_PDE(0x00),PRE_VIRTTOPHYS(page_table),0x03);
  102. /* KERNEL MAP */
  103. /* Fill page table with map Phys 1Mb-5Mb to virtual 0xC000000 */
  104. page_table=(unsigned long*)PRE_PHYSTOVIRT(pop_up_phys());
  105. fill_page_table (page_table,0x100000,1024,0x03);
  106. /* Insert the table into the page directory */
  107. set_page_table_entry (page_directory,VIRT_TO_PDE(VIRT_KERNEL_BASE), PRE_VIRTTOPHYS(page_table),0x03);
  109. /* PHYSICAL STACK MAP */
  110. /* Fill page table with map Phys 16Mb-20Mb to virtual 0xFF000000 */
  111. page_table=(unsigned long*)PRE_PHYSTOVIRT(pop_up_phys());
  112. fill_page_table (page_table,0x1000000,1024,0x03);
  113. /* Insert the table into the page directory */
  114. set_page_table_entry (page_directory,VIRT_TO_PDE(VIRT_PHYS_STACK_BASE),PRE_VIRTTOPHYS(page_table),0x03);
  116. /* VIDEO TEMP MAP */
  117. /* Fill page table with map Phys 0xF0000000 to virtual 0xD0800000 */
  118. page_table=(unsigned long*)PRE_PHYSTOVIRT(pop_up_phys());
  119. fill_page_table (page_table,0xF0000000,1024,0x03);
  120. /* Insert the table into the page directory */
  121. set_page_table_entry (page_directory,VIRT_TO_PDE(VIRT_VIDEO),PRE_VIRTTOPHYS(page_table),0x03);
  123. /* TEMP MAP MAP */
  124. /* We give a physical address to PDE virtual address 
  125.  * VIRT_TEMP_MAP
  126.  */
  127. /* Insert the PDE for this mapping */
  128. page_table=(unsigned long*)PRE_PHYSTOVIRT(pop_up_phys());
  129. /* Set all PTE to unused */
  130. empty_page_table (page_table);
  131. /* Insert the table into the page directory */
  132. set_page_table_entry (page_directory,VIRT_TO_PDE(VIRT_TEMP_MAP),PRE_VIRTTOPHYS(page_table),0x03);
  134. /* PD TO PDE MAP */
  135. /* Insert the PD into the page directory */
  136. set_page_table_entry (page_directory,1023,PRE_VIRTTOPHYS(page_directory),0x03);
  138. /****************************
  139.  * Commit changes to the PD *
  140.  ****************************/
  141. /* The processor flushes page_directory variable */
  142. write_cr3(PRE_VIRTTOPHYS(page_directory)); // put that page directory address into CR3
  143. write_cr0(read_cr0() | 0x80000000); // set the paging bit in CR0 to 1
  145. }
  148. void fill_page_table (unsigned long* page_table, unsigned long base_physical_address, int number_of_pages, int attributes) {
  150. int i;
  151. number_of_pages=number_of_pages%1025;
  152. for(i=0; i<number_of_pages; i++)
  153. {
  154. page_table[i] = base_physical_address | attributes; 
  155. base_physical_address = base_physical_address + PAGE_SIZE; 
  156. }
  158. }
  160. void set_page_table_entry (unsigned long* page_table, int PTE_number,unsigned long phys_addr, int attributes) {
  161.  page_table[PTE_number] = phys_addr | attributes;
  162. }
  165. void empty_page_table (unsigned long* page_table) {
  167. int i;
  168. for(i=0; i<1024; i++)
  169. {
  170. page_table[i] = 0x02; 
  171. }
  173. }
  175. /* Returns the physical address to a physical
  176.  * page mapped at virtual address base VIRT_TEMP_MAP
  177.  * 
  178.  * */
  179. unsigned long get_temp_page_table () {
  180.   unsigned long* phys_page_table;
  181.   unsigned long* temp_pde;
  184.   phys_page_table=(unsigned long*)pop_up_phys();
  185. /* Get virtual address of the PDE for
  186.  * temporal mapping */
  187. temp_pde=(unsigned long *)VIRT_TO_PTE_VIRT(VIRT_TEMP_MAP);
  189. set_page_table_entry (temp_pde,0,(unsigned long)phys_page_table,0x03);
  191. /****************************
  192.  * Commit changes to the PD *
  193.  ****************************/
  194. /* The processor flushes page_directory variable */
  196. write_cr3((unsigned long)PHYS_PAGE_DIRECTORY); // put that page directory address into CR3
  197. write_cr0(read_cr0() | 0x80000000); // set the paging bit in CR0 to 1
  198. return (unsigned long)phys_page_table;
  200. }
  202. void allocate_page(unsigned long virtualbase) {
  203. /*Search for the entry for this address at the PD. */
  204. unsigned long *page_directory;
  206. page_directory=VIRT_PAGE_DIRECTORY;
  207. virtualbase=PAGE_ALIGN(virtualbase);
  209.   if( (page_directory[VIRT_TO_PDE(virtualbase)]&0x00000fff) != (unsigned long)0x02 ){
  210. // kprint ("USED PDEn");
  212. /* If the PDE exists, look for the PTE for the 
  213.  * corresponding virtual address
  214.  */
  215. unsigned long* pte_table=(unsigned long*)VIRT_TO_PTE_VIRT(virtualbase);
  216. if( (pte_table[VIRT_TO_PTE(virtualbase)]&0x00000fff) != (unsigned long)0x02 ){
  217. // kprint ("USED PTE, errorn");
  218. }
  219. else {
  220. // kprint ("FREE PTEn");
  221. unsigned long* phys_page;
  222. /* Allocate the desired page */
  223. phys_page=(unsigned long*)pop_up_phys();
  224. /* Map the physical page into the table */
  225. set_page_table_entry(pte_table,VIRT_TO_PTE(virtualbase),(unsigned long)phys_page,0x03);
  226. write_cr3((unsigned long)PHYS_PAGE_DIRECTORY); // put that page directory address into CR3
  227. write_cr0(read_cr0() | 0x80000000); // set the paging bit in CR0 to 1
  228. }
  229. }
  230. else {
  231. // kprint ("FREE PDEn");
  232. /* Get a table page mapped to TEMP_VIRT*/
  233. /* This page holds the PT , is the PTE*/
  234. unsigned long* phys_table=(unsigned long*)get_temp_page_table ();
  235. unsigned long* virt_table=(unsigned long*)VIRT_TEMP_MAP;
  236. unsigned long* phys_page;
  238. /* Map the allocated table page to the virtual address space */
  239. set_page_table_entry(page_directory,VIRT_TO_PDE(virtualbase),(unsigned long)phys_table,0x03);
  241. /* Allocate the desired page */
  242. phys_page=(unsigned long*)pop_up_phys();
  244. /* Map the physical page into the table */
  245. empty_page_table (virt_table);
  246. set_page_table_entry(virt_table,VIRT_TO_PTE(virtualbase),(unsigned long)phys_page,0x03);
  248. write_cr3((unsigned long)PHYS_PAGE_DIRECTORY); // put that page directory address into CR3
  249. write_cr0(read_cr0() | 0x80000000); // set the paging bit in CR0 to 1
  250. }
  251. }
  253. void allocate_pages(unsigned long virtualbase, int pages) {
  255.    int i=0;
  256.    for (i=0;i<pages;i++) {
  257.    allocate_page(virtualbase+(i*PAGE_SIZE));
  258. }
  259. }
  261. void deallocate_page(unsigned long virtualbase) {
  263. unsigned long *page_directory =VIRT_PAGE_DIRECTORY;
  264. /* Seatch for the PD entry for the virtualbase */
  266. page_directory=VIRT_PAGE_DIRECTORY;
  267. virtualbase=PAGE_ALIGN(virtualbase);
  268. if( (page_directory[VIRT_TO_PDE(virtualbase)]&0x00000fff) != (unsigned long)0x02 ){
  269. /* The PDE exist , now search the PTE */
  270. unsigned long* pte_table=(unsigned long*)VIRT_TO_PTE_VIRT(virtualbase);
  271. if( (pte_table[VIRT_TO_PTE(virtualbase)]&0x00000fff) != (unsigned long)0x02 ){
  272. push_up_phys(PAGE_ALIGN(pte_table[VIRT_TO_PTE(virtualbase)]));
  273. pte_table[VIRT_TO_PTE(virtualbase)]=0x02;
  274. write_cr3((unsigned long)PHYS_PAGE_DIRECTORY); // put that page directory address into CR3
  275. write_cr0(read_cr0() | 0x80000000); // set the paging bit in CR0 to 1
  276. }
  277. else {
  278. kprint ("The PTE does not existn");
  279. }
  280. }
  281. else {
  282. kprint ("The PDE does not existn");
  283. }
  284. }
  286. void deallocate_pages(unsigned long virtualbase, int pages) {
  287.    int i=0;
  288.    for (i=0;i<pages;i++) {
  289.    deallocate_page(virtualbase+(i*PAGE_SIZE));
  290. }
  291. }
  293. /* -----------------------------------------------
  294.  * 
  295.  * DYNAMIC ALLOCATOR
  296.  *
  297.  * ----------------------------------------------*/
  298. heap_struct heap_info;
  301. void kfree(unsigned long base) {
  302. struct list_node_head *p;
  303. struct list_node_head *mover;
  304. struct heap_member* region;
  305. struct heap_member* new_region;
  307. region = (struct heap_member*)(list_entry (&(heap_info.usedlist->list), struct heap_member, list));
  309. if ((base>=region->base)&&(base<region->base+region->size)) {
  310. new_region=(struct heap_member*)kmalloc(sizeof(struct heap_member));
  311. new_region->base=region->base;
  312. new_region->size=region->size;
  313. region->base=0;
  314. region->size=0;
  315. list_add(&(new_region->list),&(heap_info.freelist->list));
  316. }
  317. else {
  318. list_for_each (p,&(heap_info.usedlist->list)) {
  319. region = (struct heap_member*)list_entry (p, struct heap_member, list);
  320. if ((base>=region->base)&&(base<region->base+region->size)) {
  321. list_del (p);
  322. mover=p;
  323. }
  324. }
  325. }
  326. list_add(mover,&(heap_info.freelist->list));
  327. }
  330. void initialize_dynamic_allocator() {
  331. heap_info.heap_top=KERNEL_HEAP_START;
  333. /* Add a page to the heap that will be used to get memory */
  334. allocate_page(KERNEL_HEAP_START);
  335. heap_info.heap_top=heap_info.heap_top+PAGE_SIZE;
  338. /* The first 2 reserverd regions in the heap are for the
  339.  * freelist and usedlist */
  340. heap_info.freelist=(struct heap_member*)KERNEL_HEAP_START;
  341. heap_info.usedlist=heap_info.freelist+sizeof(struct heap_member);
  343. struct heap_member* first_free=heap_info.usedlist+sizeof(struct heap_member);
  346. /* Add this page to the free list */
  347. first_free->base=first_free+sizeof(struct heap_member);
  348. first_free->size=PAGE_SIZE-4*sizeof(struct heap_member);
  350. heap_info.freelist->base=0;
  351. heap_info.freelist->size=0;
  352. INIT_LIST_HEAD (&(heap_info.freelist->list));
  353. INIT_LIST_HEAD (&(heap_info.usedlist->list));
  355. list_add(&(first_free->list),&(heap_info.freelist->list));
  358. }
  360. unsigned long kmalloc (int bytes) {
  361. unsigned long base=0;
  363. /* Search the list for a big enough entry */
  365. struct heap_member* region;
  367. char text[200];
  368. /* returns a pointer to the base
  369.  * of a free region and a pointer
  370.  * to the list item that points to it
  371.  */
  373. bytes=bytes+sizeof(struct heap_member);
  375. struct list_node_head* heap_list_p=get_free_heap_base(bytes);
  378. if (heap_list_p!=0) {
  380. /* A piece at least of the requested size has
  381.  * been found, the size that we are requesting is
  382.  * bytes + sizeof (struct heap_member) which
  383.  * will hold the used heap_member structure
  384.  * for the used fraction.
  385.  * */
  387. region=(struct heap_member*)list_entry (heap_list_p,struct heap_member, list);
  388. // snprintf (text,"new heap base %x size %dn",region->base,region->size);
  389. // kprint (text);
  391. base=region->base;
  392. /* Substract the needed bytes from the piece */
  393. region->size=(region->size)-bytes;
  394. region->base=(region->base)+bytes;
  397. /* Heap member has been given the last bytes
  398.  * of the requested region.
  399.  * */
  400. struct heap_member* used_region=(struct heap_member*)(base+bytes-(sizeof(struct heap_member)));
  402. /* Set up the used region entry */
  403. used_region->base=base;
  404. used_region->size=bytes;
  405. /* Put the region into the list */
  406. list_add(&(used_region->list),&(heap_info.usedlist->list));
  407. }
  408. else {
  409. /* The heap is too small */
  410. /* More core needed */
  412. morecore (bytes);
  413. base=kmalloc (bytes);
  415. }
  416. return base;
  417. }
  418. unsigned long morecore(int bytes) {
  419. /* The beginning will be used to store
  420.  * the entry to the free list */
  421. bytes=bytes+sizeof(struct heap_member);
  422.    unsigned long base=PAGE_ALIGN(heap_info.heap_top);
  423. int pages=(bytes/PAGE_SIZE)+1;
  424. allocate_pages(base,pages);
  425. /* Increment the top address of heap */
  426.    heap_info.heap_top=heap_info.heap_top+pages*PAGE_SIZE;
  428. struct heap_member* free_entry;
  429. free_entry=(struct heap_member*)base;
  430. free_entry->base=base+sizeof(struct heap_member);
  431. free_entry->size=pages*PAGE_SIZE-sizeof(struct heap_member);
  432. list_add(&(free_entry->list),&(heap_info.freelist->list));
  434. return base;
  435. }
  436. void debug_print_used_list () {
  437. struct list_node_head *p;
  438. struct heap_member* region;
  441. char text[200];
  443. region = (struct heap_member*)list_entry (&(heap_info.usedlist->list), struct heap_member, list);
  444. snprintf (text,"1Used at base %x size %dn",region->base,region->size);
  445. kprint (text);
  446. list_for_each (p,&(heap_info.usedlist->list)) {
  447. region = (struct heap_member*)list_entry (p, struct heap_member, list);
  448. snprintf (text,"2Used at base %x size %dn",region->base,region->size);
  449. kprint (text);
  451. }
  452. }
  453. void debug_print_free_list () {
  454. struct list_node_head *p;
  455. struct heap_member* region;
  458. char text[200];
  459. region = (struct heap_member*)(list_entry (&(heap_info.freelist->list), struct heap_member, list));
  460. snprintf (text,"1Free at base %x size %dn",region->base,region->size);
  461. kprint (text);
  462. list_for_each (p,&(heap_info.freelist->list)) {
  463. region = (struct heap_member*)list_entry (p, struct heap_member, list);
  464. snprintf (text,"2Free at base %x size %dn",region->base,region->size);
  465. kprint (text);
  467. }
  468. }
  472. struct list_node_head* get_free_heap_base (int bytes) {
  473. struct list_node_head *p;
  474. struct heap_member* region;
  478. region = (struct heap_member*)list_entry (&(heap_info.freelist->list), struct heap_member, list);
  479. if ( (region!=0) && region->size > bytes ) {
  480. p=&(heap_info.freelist->list);
  481. /* There is enough space here */
  482. return p;
  483. }
  484. else {
  485. list_for_each (p,(&(heap_info.freelist->list))) {
  486. region = (struct heap_member*)list_entry (p, struct heap_member, list);
  487. if ( region->size >= bytes ) {
  489. /* There is enough space here */
  490. return p;
  491. }
  492. }
  493. }
  494. return 0;
  495. }