[[email protected]: my paging work]

diff -u -r1.5 binfmt_elf32.c
@@ -178,7 +178,7 @@
 		mpnt->vm_ops = NULL;
 		mpnt->vm_pgoff = 0;
 		mpnt->vm_file = NULL;
-		mpnt->vm_private_data = 0;
+		mpnt->vm_anon = NULL;
 		insert_vm_struct(current->mm, mpnt);
 		current->mm->total_vm = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT;
 	} 

diff -u -r1.6 init.c
@@ -160,7 +160,7 @@
 		vma->vm_ops = NULL;
 		vma->vm_pgoff = 0;
 		vma->vm_file = NULL;
-		vma->vm_private_data = NULL;
+		vma->vm_anon = NULL;
 		insert_vm_struct(current->mm, vma);
 	}
 }

diff -u -r1.108 exec.c
@@ -240,7 +240,7 @@
  * This routine is used to map in a page into an address space: needed by
  * execve() for the initial stack and environment pages.
  */
-void put_dirty_page(struct task_struct * tsk, struct page *page, unsigned long address)
+void put_dirty_page(struct task_struct * tsk, struct vm_area_struct *vma, struct page *page, unsigned long address)
 {
 	pgd_t * pgd;
 	pmd_t * pmd;

@@ -248,6 +248,11 @@
 
 	if (page_count(page) != 1)
 		printk("mem_map disagrees with %p at %08lx\n", page, address);
+	if (anon_page_add(vma, address, page)) {
+		__free_page(page);
+		force_sig(SIGKILL, tsk);
+		return;
+	}
 	pgd = pgd_offset(tsk->mm, address);
 	pmd = pmd_alloc(pgd, address);
 	if (!pmd) {

@@ -297,7 +302,7 @@
 		mpnt->vm_ops = NULL;
 		mpnt->vm_pgoff = 0;
 		mpnt->vm_file = NULL;
-		mpnt->vm_private_data = (void *) 0;
+		mpnt->vm_anon = NULL;
 		vmlist_modify_lock(current->mm);
 		insert_vm_struct(current->mm, mpnt);
 		vmlist_modify_unlock(current->mm);

@@ -307,7 +312,7 @@
 	for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
 		if (bprm->page[i]) {
 			current->mm->rss++;
-			put_dirty_page(current,bprm->page[i],stack_base);
+			put_dirty_page(current,mpnt,bprm->page[i],stack_base);
 		}
 		stack_base += PAGE_SIZE;
 	}

diff -u -r1.11 inode.c
@@ -76,6 +76,7 @@
 	sync_page:	block_sync_page,
 	prepare_write:	adfs_prepare_write,
 	commit_write:	generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap:		_adfs_bmap
 };
 

diff -u -r1.33 file.c
@@ -361,6 +361,7 @@
 	sync_page: block_sync_page,
 	prepare_write: affs_prepare_write,
 	commit_write: generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap: _affs_bmap
 };
 

diff -u -r1.21 symlink.c
@@ -73,6 +73,7 @@
 
 struct address_space_operations affs_symlink_aops = {
 	readpage:	affs_symlink_readpage,
+	try_to_free_page: filemap_try_to_free_page
 };
 
 struct inode_operations affs_symlink_inode_operations = {

diff -u -r1.13 file.c
@@ -153,6 +153,7 @@
 	sync_page:	block_sync_page,
 	prepare_write:	bfs_prepare_write,
 	commit_write:	generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap:		bfs_bmap
 };
 

diff -u -r1.13 symlink.c
@@ -49,5 +49,6 @@
 }
 
 struct address_space_operations coda_symlink_aops = {
-	readpage:	coda_symlink_filler
+	readpage:	coda_symlink_filler,
+	try_to_free_page: filemap_try_to_free_page
 };

diff -u -r1.9 inode.c
@@ -335,7 +335,8 @@
 }
 
 static struct address_space_operations cramfs_aops = {
-	readpage: cramfs_readpage
+	readpage: cramfs_readpage,
+	try_to_free_page: filemap_try_to_free_page
 };
 
 /*

diff -u -r1.8 inode.c
@@ -22,6 +22,7 @@
 struct address_space_operations efs_aops = {
 	readpage: efs_readpage,
 	sync_page: block_sync_page,
+ 	try_to_free_page: filemap_try_to_free_page,
 	bmap: _efs_bmap
 };
 

diff -u -r1.8 symlink.c
@@ -49,5 +49,6 @@
 }
 
 struct address_space_operations efs_symlink_aops = {
-	readpage:	efs_symlink_readpage
+	readpage:	efs_symlink_readpage,
+	try_to_free_page: filemap_try_to_free_page,
 };

diff -u -r1.46 inode.c
@@ -642,6 +642,7 @@
 	sync_page: block_sync_page,
 	prepare_write: ext2_prepare_write,
 	commit_write: generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap: ext2_bmap
 };
 

diff -u -r1.52 inode.c
@@ -752,6 +752,7 @@
 	sync_page: block_sync_page,
 	prepare_write: fat_prepare_write,
 	commit_write: generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap: _fat_bmap
 };
 

diff -u -r1.11 inode.c
@@ -240,6 +240,7 @@
 	sync_page: block_sync_page,
 	prepare_write: hfs_prepare_write,
 	commit_write: generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap: hfs_bmap
 };
 

diff -u -r1.12 file.c
@@ -109,6 +109,7 @@
 	sync_page: block_sync_page,
 	prepare_write: hpfs_prepare_write,
 	commit_write: generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap: _hpfs_bmap
 };
 

diff -u -r1.12 inode.c
@@ -48,7 +48,8 @@
 };
 
 struct address_space_operations hpfs_symlink_aops = {
-	readpage:	hpfs_symlink_readpage
+	readpage:	hpfs_symlink_readpage,
+	try_to_free_page: filemap_try_to_free_page
 };
 
 void hpfs_read_inode(struct inode *i)

diff -u -r1.62 inode.c
@@ -992,6 +992,7 @@
 static struct address_space_operations isofs_aops = {
 	readpage: isofs_readpage,
 	sync_page: block_sync_page,
+ 	try_to_free_page: filemap_try_to_free_page,
 	bmap: _isofs_bmap
 };
 

diff -u -r1.17 rock.c
@@ -542,5 +542,6 @@
 }
 
 struct address_space_operations isofs_symlink_aops = {
-	readpage:	rock_ridge_symlink_readpage
+	readpage:	rock_ridge_symlink_readpage,
+	try_to_free_page: filemap_try_to_free_page
 };

diff -u -r1.45 inode.c
@@ -1028,6 +1028,7 @@
 	sync_page: block_sync_page,
 	prepare_write: minix_prepare_write,
 	commit_write: generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap: minix_bmap
 };
 

diff -u -r1.6 symlink.c
@@ -98,6 +98,7 @@
  */
 struct address_space_operations ncp_symlink_aops = {
 	readpage:	ncp_symlink_readpage,
+	try_to_free_page: filemap_try_to_free_page,
 };
 	
 /* ----- create a new symbolic link -------------------------------------- */

diff -u -r1.52 file.c
@@ -203,7 +203,8 @@
 	sync_page: nfs_sync_page,
 	writepage: nfs_writepage,
 	prepare_write: nfs_prepare_write,
-	commit_write: nfs_commit_write
+	commit_write: nfs_commit_write,
+	try_to_free_page: filemap_try_to_free_page
 };
 
 /* 

diff -u -r1.30 fs.c
@@ -610,6 +610,7 @@
 	sync_page: block_sync_page,
 	prepare_write: ntfs_prepare_write,
 	commit_write: generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap: _ntfs_bmap
 };
 /* ntfs_read_inode is called by the Virtual File System (the kernel layer that

diff -u -r1.20 inode.c
@@ -433,6 +433,7 @@
 	sync_page: block_sync_page,
 	prepare_write: qnx4_prepare_write,
 	commit_write: generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap: qnx4_bmap
 };
 

diff -u -r1.2 inode.c
@@ -324,7 +324,8 @@
 	readpage:	ramfs_readpage,
 	writepage:	ramfs_writepage,
 	prepare_write:	ramfs_prepare_write,
-	commit_write:	ramfs_commit_write
+	commit_write:	ramfs_commit_write,
+	try_to_free_page: filemap_try_to_free_page
 };
 
 static struct file_operations ramfs_file_operations = {

diff -u -r1.42 inode.c
@@ -428,7 +428,8 @@
 /* Mapping from our types to the kernel */
 
 static struct address_space_operations romfs_aops = {
-	readpage: romfs_readpage
+	readpage: romfs_readpage,
+	try_to_free_page: filemap_try_to_free_page
 };
 
 static struct file_operations romfs_dir_operations = {

diff -u -r1.38 file.c
@@ -290,7 +290,8 @@
 	readpage: smb_readpage,
 	writepage: smb_writepage,
 	prepare_write: smb_prepare_write,
-	commit_write: smb_commit_write
+	commit_write: smb_commit_write,
+	try_to_free_page: filemap_try_to_free_page
 };
 
 /* 

diff -u -r1.41 inode.c
@@ -961,6 +961,7 @@
 	sync_page: block_sync_page,
 	prepare_write: sysv_prepare_write,
 	commit_write: generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap: sysv_bmap
 };
 

diff -u -r1.18 file.c
@@ -121,6 +121,7 @@
 	sync_page:		block_sync_page,
 	prepare_write:		udf_adinicb_prepare_write,
 	commit_write:		udf_adinicb_commit_write,
+	try_to_free_page: filemap_try_to_free_page
 };
 
 static ssize_t udf_file_write(struct file * file, const char * buf,

diff -u -r1.14 inode.c
@@ -151,6 +151,7 @@
 	sync_page:		block_sync_page,
 	prepare_write:		udf_prepare_write,
 	commit_write:		generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap:				udf_bmap,
 };
 

diff -u -r1.5 symlink.c
@@ -123,4 +123,5 @@
  */
 struct address_space_operations udf_symlink_aops = {
 	readpage:			udf_symlink_filler,
+	try_to_free_page: filemap_try_to_free_page
 };

diff -u -r1.15 inode.c
@@ -562,6 +562,7 @@
 	sync_page: block_sync_page,
 	prepare_write: ufs_prepare_write,
 	commit_write: generic_commit_write,
+	try_to_free_page: filemap_try_to_free_page,
 	bmap: ufs_bmap
 };
 

diff -u -r1.167 fs.h
@@ -343,9 +343,12 @@
 	int (*sync_page)(struct page *);
 	int (*prepare_write)(struct file *, struct page *, unsigned, unsigned);
 	int (*commit_write)(struct file *, struct page *, unsigned, unsigned);
+	int (*try_to_free_page)(struct page *);
 	/* Unfortunately this kludge is needed for FIBMAP. Don't use it */
 	int (*bmap)(struct address_space *, long);
 };
+
+extern int filemap_try_to_free_page(struct page *);
 
 struct address_space {
 	struct list_head	pages;		/* list of pages */

92 lines not on this page · raw message

76 lines not on this page · raw message

diff -u -r1.210 main.c
@@ -570,6 +570,7 @@
 	filescache_init();
 	dcache_init(mempages);
 	vma_init();
+	anon_init();
 	buffer_init(mempages);
 	page_cache_init(mempages);
 	kiobuf_setup();

diff -u -r1.99 shm.c
@@ -1344,6 +1344,7 @@
  */
 static int shm_swapout(struct page * page, struct file *file)
 {
+	UnlockPage(page);
 	return 0;
 }
 

diff -u -r1.116 fork.c
@@ -270,6 +270,9 @@
 			spin_unlock(&inode->i_mapping->i_shared_lock);
 		}
 
+		if (tmp->vm_anon)
+			anon_dup(mpnt, tmp);
+
 		/* Copy the pages, but defer checking for errors */
 		retval = copy_page_range(mm, current->mm, tmp);
 		if (!retval && tmp->vm_ops && tmp->vm_ops->open)

diff -u -r1.174 ksyms.c
@@ -253,6 +253,7 @@
 EXPORT_SYMBOL(filemap_swapout);
 EXPORT_SYMBOL(filemap_sync);
 EXPORT_SYMBOL(lock_page);
+EXPORT_SYMBOL(filemap_try_to_free_page);
 
 #if !defined(CONFIG_NFSD) && defined(CONFIG_NFSD_MODULE)
 EXPORT_SYMBOL(do_nfsservctl);

303 lines not on this page · raw message

diff -u -r1.12 highmem.c
@@ -74,6 +74,7 @@
 	kunmap(highpage);
 
 	/* Preserve the caching of the swap_entry. */
+#error This does not work with the new anon cache, FIXME -DaveM
 	highpage->index = page->index;
 	highpage->mapping = page->mapping;
 

148 lines not on this page · raw message

diff -u -r1.28 mlock.c
@@ -36,11 +36,15 @@
 		get_file(n->vm_file);
 	if (n->vm_ops && n->vm_ops->open)
 		n->vm_ops->open(n);
+	lock_vma_mappings(vma);
 	vmlist_modify_lock(vma->vm_mm);
 	vma->vm_pgoff += (end - vma->vm_start) >> PAGE_SHIFT;
 	vma->vm_start = end;
-	insert_vm_struct(current->mm, n);
+	__insert_vm_struct(current->mm, n);
+	if (vma->vm_anon)
+		__anon_dup(vma, n);
 	vmlist_modify_unlock(vma->vm_mm);
+	unlock_vma_mappings(vma);
 	return 0;
 }
 

@@ -61,10 +65,14 @@
 		get_file(n->vm_file);
 	if (n->vm_ops && n->vm_ops->open)
 		n->vm_ops->open(n);
+	lock_vma_mappings(vma);
 	vmlist_modify_lock(vma->vm_mm);
 	vma->vm_end = start;
-	insert_vm_struct(current->mm, n);
+	__insert_vm_struct(current->mm, n);
+	if (vma->vm_anon)
+		__anon_dup(vma, n);
 	vmlist_modify_unlock(vma->vm_mm);
+	unlock_vma_mappings(vma);
 	return 0;
 }
 

@@ -96,15 +104,21 @@
 		vma->vm_ops->open(left);
 		vma->vm_ops->open(right);
 	}
+	lock_vma_mappings(vma);
 	vmlist_modify_lock(vma->vm_mm);
 	vma->vm_pgoff += (start - vma->vm_start) >> PAGE_SHIFT;
 	vma->vm_start = start;
 	vma->vm_end = end;
 	vma->vm_flags = newflags;
 	vma->vm_raend = 0;
-	insert_vm_struct(current->mm, left);
-	insert_vm_struct(current->mm, right);
+	__insert_vm_struct(current->mm, left);
+	__insert_vm_struct(current->mm, right);
+	if (vma->vm_anon) {
+		__anon_dup(vma, left);
+		__anon_dup(vma, right);
+	}
 	vmlist_modify_unlock(vma->vm_mm);
+	unlock_vma_mappings(vma);
 	return 0;
 }
 

240 lines not on this page · raw message

diff -u -r1.27 mprotect.c
@@ -111,11 +111,15 @@
 		get_file(n->vm_file);
 	if (n->vm_ops && n->vm_ops->open)
 		n->vm_ops->open(n);
+	lock_vma_mappings(vma);
 	vmlist_modify_lock(vma->vm_mm);
 	vma->vm_pgoff += (end - vma->vm_start) >> PAGE_SHIFT;
 	vma->vm_start = end;
-	insert_vm_struct(current->mm, n);
+	__insert_vm_struct(current->mm, n);
+	if (vma->vm_anon)
+		__anon_dup(vma, n);
 	vmlist_modify_unlock(vma->vm_mm);
+	unlock_vma_mappings(vma);
 	return 0;
 }
 

@@ -138,10 +142,14 @@
 		get_file(n->vm_file);
 	if (n->vm_ops && n->vm_ops->open)
 		n->vm_ops->open(n);
+	lock_vma_mappings(vma);
 	vmlist_modify_lock(vma->vm_mm);
 	vma->vm_end = start;
-	insert_vm_struct(current->mm, n);
+	__insert_vm_struct(current->mm, n);
+	if (vma->vm_anon)
+		__anon_dup(vma, n);
 	vmlist_modify_unlock(vma->vm_mm);
+	unlock_vma_mappings(vma);
 	return 0;
 }
 

@@ -172,6 +180,7 @@
 		vma->vm_ops->open(left);
 		vma->vm_ops->open(right);
 	}
+	lock_vma_mappings(vma);
 	vmlist_modify_lock(vma->vm_mm);
 	vma->vm_pgoff += (start - vma->vm_start) >> PAGE_SHIFT;
 	vma->vm_start = start;

@@ -179,9 +188,14 @@
 	vma->vm_flags = newflags;
 	vma->vm_raend = 0;
 	vma->vm_page_prot = prot;
-	insert_vm_struct(current->mm, left);
-	insert_vm_struct(current->mm, right);
+	__insert_vm_struct(current->mm, left);
+	__insert_vm_struct(current->mm, right);
+	if (vma->vm_anon) {
+		__anon_dup(vma, left);
+		__anon_dup(vma, right);
+	}
 	vmlist_modify_unlock(vma->vm_mm);
+	unlock_vma_mappings(vma);
 	return 0;
 }
 

diff -u -r1.34 mremap.c
@@ -141,10 +141,14 @@
 				get_file(new_vma->vm_file);
 			if (new_vma->vm_ops && new_vma->vm_ops->open)
 				new_vma->vm_ops->open(new_vma);
+			lock_vma_mappings(vma);
 			vmlist_modify_lock(current->mm);
-			insert_vm_struct(current->mm, new_vma);
+			__insert_vm_struct(current->mm, new_vma);
+			if (vma->vm_anon)
+				__anon_dup(vma, new_vma);
 			merge_segments(current->mm, new_vma->vm_start, new_vma->vm_end);
 			vmlist_modify_unlock(vma->vm_mm);
+			unlock_vma_mappings(vma);
 			do_munmap(current->mm, addr, old_len);
 			current->mm->total_vm += new_len >> PAGE_SHIFT;
 			if (new_vma->vm_flags & VM_LOCKED) {

diff -u -r1.85 page_alloc.c
@@ -24,6 +24,8 @@
 #define NUMNODES numnodes
 #endif
 
+extern int nr_anon_pages;
+
 int nr_swap_pages = 0;
 int nr_lru_pages = 0;
 pg_data_t *pgdat_list = (pg_data_t *)0;

@@ -273,8 +275,6 @@
 struct page * __alloc_pages(zonelist_t *zonelist, unsigned long order)
 {
 	zone_t **zone = zonelist->zones;
-	int gfp_mask = zonelist->gfp_mask;
-	static int low_on_memory;
 
 	/*
 	 * If this is a recursive call, we'd better

@@ -284,11 +284,6 @@
 	if (current->flags & PF_MEMALLOC)
 		goto allocate_ok;
 
-	/* If we're a memory hog, unmap some pages */
-	if (current->hog && low_on_memory &&
-			(gfp_mask & __GFP_WAIT))
-		swap_out(4, gfp_mask);
-
 	/*
 	 * (If anyone calls gfp from interrupts nonatomically then it
 	 * will sooner or later tripped up by a schedule().)

@@ -306,13 +301,11 @@
 		/* Are we supposed to free memory? Don't make it worse.. */
 		if (!z->zone_wake_kswapd && z->free_pages > z->pages_low) {
 			struct page *page = rmqueue(z, order);
-			low_on_memory = 0;
 			if (page)
 				return page;
 		}
 	}
 
-	low_on_memory = 1;
 	/*
 	 * Ok, no obvious zones were available, start
 	 * balancing things a bit..

@@ -396,8 +389,9 @@
 		nr_free_pages() << (PAGE_SHIFT-10),
 		nr_free_highpages() << (PAGE_SHIFT-10));
 
-	printk("( Free: %d, lru_cache: %d (%d %d %d) )\n",
+	printk("( Free: %d, anon: %d lru_cache: %d (%d %d %d) )\n",
 		nr_free_pages(),
+	        nr_anon_pages,
 		nr_lru_pages,
 		freepages.min,
 		freepages.low,

@@ -539,7 +533,11 @@
 	freepages.min += i;
 	freepages.low += i * 2;
 	freepages.high += i * 3;
-	memlist_init(&lru_cache);
+	memlist_init(&lru_active);
+	memlist_init(&lru_inactive);
+	memlist_init(&lru_dirty);
+	inactive_pages = 0;
+	inactive_goal = realtotalpages / 3;
 
 	/*
 	 * Some architectures (with lots of mem and discontinous memory

diff -u -r1.35 page_io.c
@@ -89,8 +89,9 @@
  		return 1;
 
  	wait_on_page(page);
+
 	/* This shouldn't happen, but check to be sure. */
-	if (page_count(page) == 0)
+	if (page_count(page) <= 1)
 		printk(KERN_ERR "rw_swap_page: page unused while waiting!\n");
 
 	return 1;

@@ -101,21 +102,21 @@
  * that all swap pages go through the swap cache! We verify that:
  *  - the page is locked
  *  - it's marked as being swap-cache
- *  - it's associated with the swap inode
+ *  - if we're writing, it is in the anon cache
+ *  - it has a valid swap handle
  */
 void rw_swap_page(int rw, struct page *page, int wait)
 {
-	swp_entry_t entry;
-
-	entry.val = page->index;
-
 	if (!PageLocked(page))
 		PAGE_BUG(page);
 	if (!PageSwapCache(page))
 		PAGE_BUG(page);
-	if (page->mapping != &swapper_space)
+	if (rw == WRITE && !PageAnon(page))
 		PAGE_BUG(page);
-	if (!rw_swap_page_base(rw, entry, page, wait))
+	if (!page->swapid.val)
+		PAGE_BUG(page);
+
+	if (!rw_swap_page_base(rw, page->swapid, page, wait))
 		UnlockPage(page);
 }
 

244 lines not on this page · raw message

diff -u -r1.72 swapfile.c
@@ -211,9 +211,9 @@
 		goto new_swap_entry;
 
 	/* We have the old entry in the page offset still */
-	if (!page->index)
+	if (!page->swapid.val)
 		goto new_swap_entry;
-	entry.val = page->index;
+	entry = page->swapid;
 	type = SWP_TYPE(entry);
 	if (type >= nr_swapfiles)
 		goto new_swap_entry;

@@ -271,6 +271,8 @@
 	}
 	if (pte_val(pte) != entry.val)
 		return;
+	if (anon_page_add(vma, address, page))
+		return;
 	set_pte(dir, pte_mkdirty(mk_pte(page, vma->vm_page_prot)));
 	swap_free(entry);
 	get_page(page);

@@ -934,7 +936,7 @@
 	swp_entry_t entry;
 	int retval = 0;
 
-	entry.val = page->index;
+	entry = page->swapid;
 	if (!entry.val)
 		goto bad_entry;
 	type = SWP_TYPE(entry);

1,123 lines not on this page · raw message

202 lines not on this page · raw message