[lc-checkins] CVS: linux26/mm filemap.c,1.7,1.8 vmscan.c,1.7,1.8

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/linuxcompressed/linux26/mm
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24062/mm

Modified Files:
	vmscan.c 
Added Files:
	filemap.c 
Log Message:
Ver-2.6.16-rc5: Replace page cache radix tree entry with chunk head and restore on lookup

Index: vmscan.c
===================================================================
RCS file: /cvsroot/linuxcompressed/linux26/mm/vmscan.c,v
retrieving revision 1.7
retrieving revision 1.8
diff -C2 -r1.7 -r1.8
*** vmscan.c	24 Feb 2006 21:58:33 -0000	1.7
--- vmscan.c	10 Mar 2006 13:46:21 -0000	1.8
***************
*** 312,316 ****
  	if (PageDirty(page)) return 0;

! 	printk("<1>Some page to be added to ccache.\n");
  	return 1;
  }
--- 312,316 ----
  	if (PageDirty(page)) return 0;

! 	//printk("<1>Some page to be added to ccache.\n");
  	return 1;
  }
***************
*** 321,326 ****
--- 321,329 ----
  	struct page *newpage;
  	struct address_space *mapping;
+ 	struct page *ch;	// dummy struct page as 'chunk head'
+ 	//struct chunk_head *ch;
  	mapping=page_mapping(page);

+ /*
  	printk ("<1> Add to CCache called.\n");
  	printk ("<1> 	orig page->count=%d\n", atomic_read(&page->_count));
***************
*** 328,334 ****
--- 331,339 ----
  	printk ("<1> 	orig page->flags=%u\n", page->flags);
  	printk ("<1> 	orig page->private=%u\n", page->private);
+ */

  	newpage=alloc_pages(GFP_KERNEL, 0);
  	if (!newpage) goto out;
+ /*
  	printk ("<1> 	NEW page->count=%d\n", atomic_read(&newpage->_count));
  	printk ("<1> 	NEW page->mapcount=%d\n", atomic_read(&newpage->_mapcount));
***************
*** 336,368 ****
  	printk ("<1> 	NEW page->private=%u\n", newpage->private);
  	// newly allocated pages give page_count(page) as 1

! 	//memcpy(page_address(page), page_address(newpage), PAGE_SIZE);
  	copy_highpage(newpage, page);

  	write_lock_irq(&mapping->tree_lock);
! 	if (page_count(page) != 2) goto out;
  	radix_tree_delete(&mapping->page_tree, page->index);
! 	radix_tree_insert(&mapping->page_tree, page->index, newpage);
! 	
! 	//newpage->mapping=mapping;
! 	//newpage->flags=page->flags;
! 	//*newpage=*page;
! 	//newpage->private=page->private;
! 	//newpage->lru=page->lru;
  	newpage->mapping=mapping;
  	newpage->index=page->index;

! 	// top-eight bits of flags are used for page->zone
! 	// so only touch lower 24 bits
! 	//newpage->flags=page->flags;
! 	// copy lower 24 bits of page->flags to newpage->flags
  	flags=(page->flags << 8) >> 8;
  	newpage->flags |= flags;
! 	printk ("<1> 	Now NEW page->flags=%u\n", newpage->flags);
! 	printk ("<1> -----=====-----====------====---\n");

  	ClearPageReclaim(newpage);
  	ClearPageWillCompress(newpage);
! 	SetPageCompressed(newpage);

  	set_page_count(newpage, 1);	// only pagecache ref
--- 341,379 ----
  	printk ("<1> 	NEW page->private=%u\n", newpage->private);
  	// newly allocated pages give page_count(page) as 1
+ */

! 	//memcpy(page_address(newpage), page_address(page), PAGE_SIZE);
  	copy_highpage(newpage, page);

+ 	ch = kmalloc(sizeof(struct page), GFP_KERNEL);
+ 	if (!ch) goto out;
+ 
  	write_lock_irq(&mapping->tree_lock);
! 	if (page_count(page) != 2) goto out_locked;
  	radix_tree_delete(&mapping->page_tree, page->index);
! 	//radix_tree_insert(&mapping->page_tree, page->index, newpage);
! 	radix_tree_insert(&mapping->page_tree, page->index, ch);
! 	set_page_private(ch, (unsigned long)newpage);	
! 	SetPageCompressed(ch);
! 
! 	ch->mapping=mapping;
! 	ch->index=page->index;
! 
  	newpage->mapping=mapping;
  	newpage->index=page->index;

! 	/*
! 	 * top-eight bits of flags are used for page->zone
! 	 * so only touch lower 24 bits
! 	 */
! 	/* copy lower 24 bits of page->flags to newpage->flags */
  	flags=(page->flags << 8) >> 8;
  	newpage->flags |= flags;
! 	//printk ("<1> 	Now NEW page->flags=%u\n", newpage->flags);
! 	//printk ("<1> -----=====-----====------====---\n");

  	ClearPageReclaim(newpage);
  	ClearPageWillCompress(newpage);
! 	//SetPageCompressed(newpage);

  	set_page_count(newpage, 1);	// only pagecache ref
***************
*** 370,373 ****
--- 381,385 ----
  	// as is done in remove_mapping(),
  	// before write_unlock_irq page->mapping is set to NULL
+ 	// so that it can be freed (or else it'll be bad_page())
  	page->mapping=NULL;

***************
*** 378,386 ****
  	unlock_page(page);

  	return 0;

  	//__free_page(newpage);
! out:
  	write_unlock_irq(&mapping->tree_lock);
  	printk("<1>***** PAGE COUNT NOT 2 -- IT IS %d ******\n", page_count(page));
  	if (newpage) __free_page(newpage);
--- 390,400 ----
  	unlock_page(page);

+ 	printk("<1> Page added to ccache\n");
  	return 0;

  	//__free_page(newpage);
! out_locked:
  	write_unlock_irq(&mapping->tree_lock);
+ out:
  	printk("<1>***** PAGE COUNT NOT 2 -- IT IS %d ******\n", page_count(page));
  	if (newpage) __free_page(newpage);
***************
*** 426,434 ****
  	}

- 	//if (!PageDirty(page)) return PAGE_CLEAN;
- 
  	if (!is_page_cache_freeable(page))
  		return PAGE_KEEP;
- 
  	if (!mapping) {
  		/*
--- 440,445 ----
***************
*** 539,546 ****
  		list_del(&page->lru);

- 		if (PageCompressed(page)) {
- 			printk("<1> ##### Compressed page here for page-out!!! #####\n");
- 		}
- 
  		if (TestSetPageLocked(page))
  			goto keep;
--- 550,553 ----
***************
*** 627,631 ****
  				 * ahead and try to reclaim the page.
  				 */
- 				
  				if (TestSetPageLocked(page))
  					goto keep;
--- 634,637 ----
***************
*** 2025,2029 ****

  	cond_resched();
! 	p->flags |= PF_MEMALLOC;
  	reclaim_state.reclaimed_slab = 0;
  	p->reclaim_state = &reclaim_state;
--- 2031,2040 ----

  	cond_resched();
! 	/*
! 	 * We need to be able to allocate from the reserves for RECLAIM_SWAP
! 	 * and we also need to be able to write out pages for RECLAIM_WRITE
! 	 * and RECLAIM_SWAP.
! 	 */
! 	p->flags |= PF_MEMALLOC | PF_SWAPWRITE;
  	reclaim_state.reclaimed_slab = 0;
  	p->reclaim_state = &reclaim_state;
***************
*** 2049,2057 ****
  		 */
  		shrink_slab(sc.nr_scanned, gfp_mask, order);
- 		sc.nr_reclaimed = 1;    /* Avoid getting the off node timeout */
  	}

  	p->reclaim_state = NULL;
! 	current->flags &= ~PF_MEMALLOC;

  	if (sc.nr_reclaimed == 0)
--- 2060,2067 ----
  		 */
  		shrink_slab(sc.nr_scanned, gfp_mask, order);
  	}

  	p->reclaim_state = NULL;
! 	current->flags &= ~(PF_MEMALLOC | PF_SWAPWRITE);

  	if (sc.nr_reclaimed == 0)