Prj2 finished

Author: cxy1997

Project 2/VATranslate/jni/Android.mk

@@ -0,0 +1,10 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := VATranslate.c   # your source code
+LOCAL_MODULE := VATranslate    # output file name
+LOCAL_CFLAGS += -pie -fPIE   # These two line mustn’t be
+LOCAL_LDFLAGS += -pie -fPIE  # change.
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+
+include $(BUILD_EXECUTABLE)

Project 2/VATranslate/jni/VATranslate.c

@@ -0,0 +1,138 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#define __NR_get_pagetable_layout 233
+#define __NR_expose_page_table 378
+
+#define PGD_SIZE ((1 << 11) * sizeof(unsigned long))
+#define PTE_SIZE ((1 << 20) * sizeof(unsigned long))
+
+// The structure "pagetable_layout_info" stores the information of pagetable layout
+struct pagetable_layout_info
+{
+    uint32_t pgdir_shift;
+    uint32_t page_shift;
+};
+
+// for a hex byte c, return hex byte (c-8)
+char lower(char c)
+{
+    if (c >= 'a')
+        return c - 'a' + '2';
+    if (c >= 'A')
+        return c - 'A' + '2';
+    return c - 8;
+}
+
+// convert a hex string up to 8 bytes to unsigned long
+unsigned long strtolu(char *str)
+{
+    unsigned long res;
+
+    // check if the value of the string exceeds (2^31)-1
+    int flag = (strlen(str) == 8) && (str[0] >= '8');
+    if (flag)
+        str[0] = lower(str[0]);
+    
+    // convert hex to unsigned long
+    res = strtol(str, NULL, 16);
+    res |= (flag << 31);
+
+    return res;
+}
+
+void display_pagetable_layout(struct pagetable_layout_info* layout)
+{
+    printf("============================================================\n");
+    printf("Android pagetable layout:\n");
+    printf("  pgdir_shift = %u\n", layout->pgdir_shift);
+    printf("  page_shift = %u\n", layout->page_shift);
+    printf("============================================================\n");
+}
+
+void get_pagetable_layout()
+{
+    struct pagetable_layout_info pgtbl_info;
+
+    // invoke system call get_pagetable_layout()
+    if (syscall(__NR_get_pagetable_layout, &pgtbl_info, sizeof(struct pagetable_layout_info))) 
+    {
+        printf("Failed to get pagetable layout.\n\n");
+        return;
+    }
+
+    display_pagetable_layout(&pgtbl_info);
+}
+
+void expose_page_table(pid_t pid, unsigned long fake_pgd, unsigned long page_table_addr, unsigned long begin_vaddr, unsigned long end_vaddr)
+{
+    unsigned long physical_addr, v_pgd, v_pte, v_offset, pageFrame;
+    unsigned long *p;
+
+    // invoke system call expose_page_table()
+	if (syscall(__NR_expose_page_table, pid, fake_pgd, page_table_addr, begin_vaddr, end_vaddr))
+    {
+    	printf("Failed to expose pagetable layout.\n");
+    	return;
+    }
+
+    // segment the virtual address
+    v_pgd = (begin_vaddr >> 21) & 0x7FF;
+    v_pte = (begin_vaddr >> PAGE_SHIFT) & 0x1FF;
+    v_offset = begin_vaddr & 0xFFF;
+
+    // calculate physical address
+    p = (unsigned long*)((unsigned long*)fake_pgd)[v_pgd];
+    pageFrame = p[v_pte] & 0xFFFFF000;
+    if (!pageFrame)
+    {
+        printf("Invalid physical address!");
+    }
+    physical_addr = pageFrame + v_offset;
+    
+    // print calculation details
+    printf("Virtual Address Translation:\n");
+    printf("  virtual address = 0x%08lx\n", begin_vaddr);
+    printf("  pgd: 0x%03lx\tpte: 0x%03lx\toffset: 0x%03lx\n", v_pgd, v_pte, v_offset);
+    printf("  pgd_base[0x%lx] = 0x%08lx\tpte[0x%lx] = 0x%08lx\n", v_pgd, (unsigned long)p, v_pte, pageFrame);
+    printf("  physical address = 0x%08lx\n", physical_addr);
+}
+
+int main(int argc, char *argv[])
+{
+    pid_t pid;
+    unsigned long fake_pgd, page_table_addr, begin_vaddr, end_vaddr;
+
+    // invoke system call
+    get_pagetable_layout();
+
+    // check paramaters
+    if (argc != 3)
+    {
+        printf("Unmatched parameters for VATranslate!\n");
+        printf("The correct format should be:\n");
+        printf("./VATranslate #PID #VA\n");
+        return -EAGAIN;
+    }
+    pid = atoi(argv[1]);
+    begin_vaddr =strtolu(argv[2]);
+    end_vaddr = begin_vaddr + 1;
+
+    // allocate user-space memory
+    fake_pgd = (unsigned long)malloc(2 * PAGE_SIZE);
+    if (!fake_pgd)
+    	return -EFAULT;
+    page_table_addr = (unsigned long)mmap(NULL, 1 << 22, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
+    if (!page_table_addr)
+    	return -EFAULT;
+    // invoke system call
+    expose_page_table(pid, fake_pgd, page_table_addr, begin_vaddr, end_vaddr);
+    
+    // free user-space memory
+    free((void*)fake_pgd);
+    munmap((void*)page_table_addr, 1 << 22);
+    return 0;
+}

Project 2/kernel/goldfish/include/linux/mm_types.h

@@ -117,7 +117,6 @@ struct page {
 #endif
 		};
 	};
-
 	/* Remainder is not double word aligned */
 	union {
 		unsigned long private;		/* Mapping-private opaque data:
@@ -159,6 +158,7 @@ struct page {
 	 */
 	void *shadow;
 #endif
+	unsigned long PG_referenced;
 }
 /*
  * The struct page can be forced to be double word aligned so that atomic ops

Project 2/kernel/goldfish/mm/swap.c

@@ -361,13 +361,9 @@ void activate_page(struct page *page)
  */
 void mark_page_accessed(struct page *page)
 {
-	if (!PageActive(page) && !PageUnevictable(page) &&
-			PageReferenced(page) && PageLRU(page)) {
+	if (!PageActive(page) && !PageUnevictable(page) && PageLRU(page)) 
 		activate_page(page);
-		ClearPageReferenced(page);
-	} else if (!PageReferenced(page)) {
-		SetPageReferenced(page);
-	}
+	page->PG_referenced = 0;
 }
 EXPORT_SYMBOL(mark_page_accessed);
 
@@ -465,7 +461,7 @@ static void lru_deactivate_fn(struct page *page, void *arg)
 	lru = page_lru_base_type(page);
 	del_page_from_lru_list(zone, page, lru + active);
 	ClearPageActive(page);
-	ClearPageReferenced(page);
+	//ClearPageReferenced(page);
 	add_page_to_lru_list(zone, page, lru);
 
 	if (PageWriteback(page) || PageDirty(page)) {

Project 2/kernel/goldfish/mm/vmscan.c

@@ -52,6 +52,8 @@
 
 #include "internal.h"
 
+#define PG_REFERENCED_SHRINK_THRESHOLD 2
+
 #define CREATE_TRACE_POINTS
 #include <trace/events/vmscan.h>
 
@@ -215,7 +217,7 @@ static int debug_shrinker_show(struct seq_file *s, void *unused)
 
 	down_read(&shrinker_rwsem);
 	list_for_each_entry(shrinker, &shrinker_list, list) {
-		char name[64];
+		//char name[64];
 		int num_objs;
 
 		num_objs = shrinker->shrink(shrinker, &sc);
@@ -748,11 +750,11 @@ static enum page_references page_check_references(struct page *page,
 						  struct mem_cgroup_zone *mz,
 						  struct scan_control *sc)
 {
-	int referenced_ptes, referenced_page;
-	unsigned long vm_flags;
+	int referenced_ptes;
+	unsigned long vm_flags, referenced_time;
 
 	referenced_ptes = page_referenced(page, 1, mz->mem_cgroup, &vm_flags);
-	referenced_page = TestClearPageReferenced(page);
+	referenced_time = (page->PG_referenced)++;
 
 	/* Lumpy reclaim - ignore references */
 	if (sc->reclaim_mode & RECLAIM_MODE_LUMPYRECLAIM)
@@ -782,9 +784,9 @@ static enum page_references page_check_references(struct page *page,
 		 * so that recently deactivated but used pages are
 		 * quickly recovered.
 		 */
-		SetPageReferenced(page);
+		--(page->PG_referenced);
 
-		if (referenced_page || referenced_ptes > 1)
+		if (referenced_time < 1 || referenced_ptes > 1)
 			return PAGEREF_ACTIVATE;
 
 		/*
@@ -797,7 +799,7 @@ static enum page_references page_check_references(struct page *page,
 	}
 
 	/* Reclaim if clean, defer dirty pages to writeback */
-	if (referenced_page && !PageSwapBacked(page))
+	if (referenced_time < 1 && !PageSwapBacked(page))
 		return PAGEREF_RECLAIM_CLEAN;
 
 	return PAGEREF_RECLAIM;
@@ -1030,6 +1032,7 @@ static unsigned long shrink_page_list(struct list_head *page_list,
 		 * Is there need to periodically free_page_list? It would
 		 * appear not as the counts should be low
 		 */
+		printk(KERN_INFO "Freeing a page.\n");
 		list_add(&page->lru, &free_pages);
 		continue;
 
@@ -1737,6 +1740,7 @@ static void shrink_active_list(unsigned long nr_to_scan,
 	isolate_mode_t isolate_mode = ISOLATE_ACTIVE;
 	struct zone *zone = mz->zone;
 
+    printk(KERN_INFO "Function shrink_active_list() called!\n");
 	lru_add_drain();
 
 	reset_reclaim_mode(sc);
@@ -1781,6 +1785,7 @@ static void shrink_active_list(unsigned long nr_to_scan,
 			}
 		}
 
+        // Totally nonsense, page_referenced() will always return 0.
 		if (page_referenced(page, 0, mz->mem_cgroup, &vm_flags)) {
 			nr_rotated += hpage_nr_pages(page);
 			/*
@@ -1797,7 +1802,16 @@ static void shrink_active_list(unsigned long nr_to_scan,
 				continue;
 			}
 		}
-
+        
+        ++(page->PG_referenced);
+        if (page->PG_referenced < PG_REFERENCED_SHRINK_THRESHOLD)
+        {
+        	printk(KERN_INFO "Reserve a page with PG_referenced = %lu.\n", page->PG_referenced);
+            list_add(&page->lru, &l_active);
+            continue;
+        }
+        
+        printk(KERN_INFO "De-activating a page!\n");
 		ClearPageActive(page);	/* we are de-activating */
 		list_add(&page->lru, &l_inactive);
 	}
@@ -2643,7 +2657,8 @@ static bool pgdat_balanced(pg_data_t *pgdat, unsigned long balanced_pages,
 {
 	unsigned long present_pages = 0;
 	int i;
-
+    
+    //schedule_timeout(HZ/10);
 	for (i = 0; i <= classzone_idx; i++)
 		present_pages += pgdat->node_zones[i].present_pages;
 
@@ -2747,6 +2762,8 @@ static unsigned long balance_pgdat(pg_data_t *pgdat, int order,
 	struct shrink_control shrink = {
 		.gfp_mask = sc.gfp_mask,
 	};
+	printk(KERN_INFO "Function balance_pgdat() invoked!\n");
+
 loop_again:
 	total_scanned = 0;
 	sc.nr_reclaimed = 0;

Project 2/memory_monitor/jni/Android.mk

@@ -0,0 +1,10 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := memory_monitor.c   # your source code
+LOCAL_MODULE := memory_monitor    # output file name
+LOCAL_CFLAGS += -pie -fPIE   # These two line mustn’t be
+LOCAL_LDFLAGS += -pie -fPIE  # change.
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+
+include $(BUILD_EXECUTABLE)

Project 2/memory_monitor/jni/memory_monitor.c

@@ -0,0 +1,39 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/* 
+ * This program investigates the file /proc/meminfo 
+ * and prints out the 5th and 6th line in it.
+ * The two specific lines contains the current size of 
+ * active and inactive memory. The examine() function 
+ * will be called every 1 second to continuously 
+ * monitor the memory status.
+ */
+
+void examine()
+{
+    char s[256];
+    freopen("/proc/meminfo", "r", stdin);
+    fgets(s, 256, stdin);
+    fgets(s, 256, stdin);
+    fgets(s, 256, stdin);
+    fgets(s, 256, stdin);
+    fgets(s, 256, stdin);
+    fgets(s, 256, stdin);
+    printf("%s", s);
+    fgets(s, 256, stdin);
+    printf("%s", s);
+}
+
+int main(int argc, char *argv[])
+{
+    int i;
+    for (i = 0; i <= 20; ++i)
+    {
+        printf("After %d second(s):\n", i);
+        examine();
+        sleep(1);
+    }
+    return 0;
+}

Project 2/occupy_mem/jni/Android.mk

@@ -0,0 +1,10 @@
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+LOCAL_SRC_FILES := occupy_mem.c   # your source code
+LOCAL_MODULE := occupy_mem    # output file name
+LOCAL_CFLAGS += -pie -fPIE   # These two line mustn’t be
+LOCAL_LDFLAGS += -pie -fPIE  # change.
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+
+include $(BUILD_EXECUTABLE)