Attachment #22209 for bug #35819

Lines 20-25 Link Here

(-)linux-2.4.22-ppc-dev.orig/include/asm-arm/fcntl.h (+1 lines)
20	#define O_NOFOLLOW 0100000 /* don't follow links */	20	#define O_NOFOLLOW 0100000 /* don't follow links */
21	#define O_DIRECT 0200000 /* direct disk access hint - currently ignored */	21	#define O_DIRECT 0200000 /* direct disk access hint - currently ignored */
22	#define O_LARGEFILE 0400000	22	#define O_LARGEFILE 0400000
		23	#define O_STREAMING 04000000 /* streaming access */
23		24
24	#define F_DUPFD 0 /* dup */	25	#define F_DUPFD 0 /* dup */
25	#define F_GETFD 1 /* get close_on_exec */	26	#define F_GETFD 1 /* get close_on_exec */

Lines 20-25 Link Here

(-)linux-2.4.22-ppc-dev.orig/include/asm-i386/fcntl.h (+1 lines)
20	#define O_LARGEFILE 0100000	20	#define O_LARGEFILE 0100000
21	#define O_DIRECTORY 0200000 /* must be a directory */	21	#define O_DIRECTORY 0200000 /* must be a directory */
22	#define O_NOFOLLOW 0400000 /* don't follow links */	22	#define O_NOFOLLOW 0400000 /* don't follow links */
		23	#define O_STREAMING 04000000 /* streaming access */
23		24
24	#define F_DUPFD 0 /* dup */	25	#define F_DUPFD 0 /* dup */
25	#define F_GETFD 1 /* get close_on_exec */	26	#define F_GETFD 1 /* get close_on_exec */

Lines 26-31 Link Here

(-)linux-2.4.22-ppc-dev.orig/include/asm-mips/fcntl.h (+1 lines)
26	#define O_DIRECT 0x8000 /* direct disk access hint */	26	#define O_DIRECT 0x8000 /* direct disk access hint */
27	#define O_DIRECTORY 0x10000 /* must be a directory */	27	#define O_DIRECTORY 0x10000 /* must be a directory */
28	#define O_NOFOLLOW 0x20000 /* don't follow links */	28	#define O_NOFOLLOW 0x20000 /* don't follow links */
		29	#define O_STREAMING 0x400000 /* streaming access */
29		30
30	#define O_NDELAY O_NONBLOCK	31	#define O_NDELAY O_NONBLOCK
31		32

Lines 20-25 Link Here

(-)linux-2.4.22-ppc-dev.orig/include/asm-ppc/fcntl.h (+1 lines)
20	#define O_NOFOLLOW 0100000 /* don't follow links */	20	#define O_NOFOLLOW 0100000 /* don't follow links */
21	#define O_LARGEFILE 0200000	21	#define O_LARGEFILE 0200000
22	#define O_DIRECT 0400000 /* direct disk access hint */	22	#define O_DIRECT 0400000 /* direct disk access hint */
		23	#define O_STREAMING 04000000 /* streaming access */
23		24
24	#define F_DUPFD 0 /* dup */	25	#define F_DUPFD 0 /* dup */
25	#define F_GETFD 1 /* get close_on_exec */	26	#define F_GETFD 1 /* get close_on_exec */

Lines 20-25 Link Here

(-)linux-2.4.22-ppc-dev.orig/include/asm-sh/fcntl.h (+1 lines)
20	#define O_LARGEFILE 0100000	20	#define O_LARGEFILE 0100000
21	#define O_DIRECTORY 0200000 /* must be a directory */	21	#define O_DIRECTORY 0200000 /* must be a directory */
22	#define O_NOFOLLOW 0400000 /* don't follow links */	22	#define O_NOFOLLOW 0400000 /* don't follow links */
		23	#define O_STREAMING 04000000 /* streaming access */
23		24
24	#define F_DUPFD 0 /* dup */	25	#define F_DUPFD 0 /* dup */
25	#define F_GETFD 1 /* get close_on_exec */	26	#define F_GETFD 1 /* get close_on_exec */




		SetPageReferenced(page);
}

/**
 * shrink_list - non-blockingly drop pages from the given cache list
 * @mapping: the mapping from which we want to drop pages
 * @list: which list (e.g. locked, dirty, clean)?
 * @max_index: greatest index from which we will drop pages
 */
static unsigned long shrink_list(struct address_space *mapping,
				 struct list_head *list,
				 unsigned long max_index)
{
	struct list_head *curr = list->prev;
	unsigned long nr_shrunk = 0;

	spin_lock(&pagemap_lru_lock);
	spin_lock(&pagecache_lock);

	while ((curr != list)) {
		struct page *page = list_entry(curr, struct page, list);

		curr = curr->prev;

		if (page->index > max_index)
			continue;

		if (PageDirty(page))
			continue;

		if (TryLockPage(page))
			break;

		if (page->buffers && !try_to_release_page(page, 0)) {
			/* probably dirty buffers */
			unlock_page(page);
			break;
		}

		if (page_count(page) != 1) {
			unlock_page(page);
			continue;
		}

		__lru_cache_del(page);
		__remove_inode_page(page);
		unlock_page(page);
		page_cache_release(page);
		nr_shrunk++;
	}

	spin_unlock(&pagecache_lock);
	spin_unlock(&pagemap_lru_lock);

	return nr_shrunk;
}

/**
 * shrink_pagecache - nonblockingly drop pages from the mapping.
 * @file: the file we are doing I/O on
 * @max_index: the maximum index from which we are willing to drop pages
 * 
 * This is for O_STREAMING, which says "I am streaming data, I know I will not
 * revisit this; do not cache anything".
 * 
 * max_index allows us to only drop pages which are behind `index', to avoid
 * trashing readahead.
 */
static unsigned long shrink_pagecache(struct file *file,
				      unsigned long max_index)
{
	struct address_space *mapping = file->f_dentry->d_inode->i_mapping;
	unsigned long nr_locked, nr_clean, nr_dirty;

	/*
	 * ensure we have a decent amount of work todo
	 */
	if (mapping->nrpages < 256)
		return 0;

	nr_locked = shrink_list(mapping, &mapping->locked_pages, max_index);
	nr_clean = shrink_list(mapping, &mapping->clean_pages, max_index);
	nr_dirty = shrink_list(mapping, &mapping->dirty_pages, max_index);

	return nr_locked + nr_clean + nr_dirty;
}

/*
 * This is a generic file read routine, and uses the
 * inode->i_op->readpage() function for the actual low-level

	filp->f_reada = 1;
	if (cached_page)
		page_cache_release(cached_page);
	if (filp->f_flags & O_STREAMING)
		shrink_pagecache(filp, index);
	UPDATE_ATIME(inode);
}


	inode->i_ctime = inode->i_mtime = CURRENT_TIME;
	mark_inode_dirty_sync(inode);

	if (file->f_flags & O_STREAMING)
		shrink_pagecache(file, pos >> PAGE_CACHE_SHIFT);

	do {
		unsigned long index, offset;
		long page_fault;

Return to bug 35819

Lines 1340-1345 Link Here

(-)linux-2.4.22-ppc-dev.orig/mm/filemap.c (+89 lines)
1340	SetPageReferenced(page);	1340	SetPageReferenced(page);
1341	}	1341	}
1342		1342
		1343	/**
		1344	* shrink_list - non-blockingly drop pages from the given cache list
		1345	* @mapping: the mapping from which we want to drop pages
		1346	* @list: which list (e.g. locked, dirty, clean)?
		1347	* @max_index: greatest index from which we will drop pages
		1348	*/
		1349	static unsigned long shrink_list(struct address_space *mapping,
		1350	struct list_head *list,
		1351	unsigned long max_index)
		1352	{
		1353	struct list_head *curr = list->prev;
		1354	unsigned long nr_shrunk = 0;
		1355
		1356	spin_lock(&pagemap_lru_lock);
		1357	spin_lock(&pagecache_lock);
		1358
		1359	while ((curr != list)) {
		1360	struct page *page = list_entry(curr, struct page, list);
		1361
		1362	curr = curr->prev;
		1363
		1364	if (page->index > max_index)
		1365	continue;
		1366
		1367	if (PageDirty(page))
		1368	continue;
		1369
		1370	if (TryLockPage(page))
		1371	break;
		1372
		1373	if (page->buffers && !try_to_release_page(page, 0)) {
		1374	/* probably dirty buffers */
		1375	unlock_page(page);
		1376	break;
		1377	}
		1378
		1379	if (page_count(page) != 1) {
		1380	unlock_page(page);
		1381	continue;
		1382	}
		1383
		1384	__lru_cache_del(page);
		1385	__remove_inode_page(page);
		1386	unlock_page(page);
		1387	page_cache_release(page);
		1388	nr_shrunk++;
		1389	}
		1390
		1391	spin_unlock(&pagecache_lock);
		1392	spin_unlock(&pagemap_lru_lock);
		1393
		1394	return nr_shrunk;
		1395	}
		1396
		1397	/**
		1398	* shrink_pagecache - nonblockingly drop pages from the mapping.
		1399	* @file: the file we are doing I/O on
		1400	* @max_index: the maximum index from which we are willing to drop pages
		1401	*
		1402	* This is for O_STREAMING, which says "I am streaming data, I know I will not
		1403	* revisit this; do not cache anything".
		1404	*
		1405	* max_index allows us to only drop pages which are behind `index', to avoid
		1406	* trashing readahead.
1407	*/
1408	static unsigned long shrink_pagecache(struct file *file,
1409	unsigned long max_index)
1410	{
1411	struct address_space *mapping = file->f_dentry->d_inode->i_mapping;
1412	unsigned long nr_locked, nr_clean, nr_dirty;
1413
1414	/*
1415	* ensure we have a decent amount of work todo
1416	*/
1417	if (mapping->nrpages < 256)
1418	return 0;
1419
1420	nr_locked = shrink_list(mapping, &mapping->locked_pages, max_index);
1421	nr_clean = shrink_list(mapping, &mapping->clean_pages, max_index);
1422	nr_dirty = shrink_list(mapping, &mapping->dirty_pages, max_index);
1423
1424	return nr_locked + nr_clean + nr_dirty;
1425	}
1426
1343	/*	1427	/*
1344	* This is a generic file read routine, and uses the	1428	* This is a generic file read routine, and uses the
1345	* inode->i_op->readpage() function for the actual low-level	1429	* inode->i_op->readpage() function for the actual low-level
Lines 1556-1561 Link Here
1556	filp->f_reada = 1;	1640	filp->f_reada = 1;
1557	if (cached_page)	1641	if (cached_page)
1558	page_cache_release(cached_page);	1642	page_cache_release(cached_page);
		1643	if (filp->f_flags & O_STREAMING)
		1644	shrink_pagecache(filp, index);
1559	UPDATE_ATIME(inode);	1645	UPDATE_ATIME(inode);
1560	}	1646	}
1561		1647
Lines 3125-3130 Link Here
3125	inode->i_ctime = inode->i_mtime = CURRENT_TIME;	3211	inode->i_ctime = inode->i_mtime = CURRENT_TIME;
3126	mark_inode_dirty_sync(inode);	3212	mark_inode_dirty_sync(inode);
3127		3213
		3214	if (file->f_flags & O_STREAMING)
		3215	shrink_pagecache(file, pos >> PAGE_CACHE_SHIFT);
		3216
3128	do {	3217	do {
3129	unsigned long index, offset;	3218	unsigned long index, offset;
3130	long page_fault;	3219	long page_fault;