Attachment #266429 for bug #357657




	struct address_space *mapping = (struct address_space *)(gl + 1);

	gfs2_init_glock_once(gl);
	address_space_init_once(mapping);
	INIT_RADIX_TREE(&mapping->page_tree, GFP_ATOMIC);
	spin_lock_init(&mapping->tree_lock);
	spin_lock_init(&mapping->i_mmap_lock);
	INIT_LIST_HEAD(&mapping->private_list);
	spin_lock_init(&mapping->private_lock);
	INIT_RAW_PRIO_TREE_ROOT(&mapping->i_mmap);
	INIT_LIST_HEAD(&mapping->i_mmap_nonlinear);
}

/**




		call_rcu(&inode->i_rcu, i_callback);
}

void address_space_init_once(struct address_space *mapping)
{
	memset(mapping, 0, sizeof(*mapping));
	INIT_RADIX_TREE(&mapping->page_tree, GFP_ATOMIC);
	spin_lock_init(&mapping->tree_lock);
	spin_lock_init(&mapping->i_mmap_lock);
	INIT_LIST_HEAD(&mapping->private_list);
	spin_lock_init(&mapping->private_lock);
	INIT_RAW_PRIO_TREE_ROOT(&mapping->i_mmap);
	INIT_LIST_HEAD(&mapping->i_mmap_nonlinear);
	mutex_init(&mapping->unmap_mutex);
}
EXPORT_SYMBOL(address_space_init_once);

/*
 * These are initializations that only need to be done
 * once, because the fields are idempotent across use

	INIT_LIST_HEAD(&inode->i_devices);
	INIT_LIST_HEAD(&inode->i_wb_list);
	INIT_LIST_HEAD(&inode->i_lru);
	address_space_init_once(&inode->i_data);
	spin_lock_init(&inode->i_data.tree_lock);
	spin_lock_init(&inode->i_data.i_mmap_lock);
	INIT_LIST_HEAD(&inode->i_data.private_list);
	spin_lock_init(&inode->i_data.private_lock);
	INIT_RAW_PRIO_TREE_ROOT(&inode->i_data.i_mmap);
	INIT_LIST_HEAD(&inode->i_data.i_mmap_nonlinear);
	i_size_ordered_init(inode);
#ifdef CONFIG_FSNOTIFY
	INIT_HLIST_HEAD(&inode->i_fsnotify_marks);

Lines 35-45 Link Here

(-)a/fs/nilfs2/btnode.c (-5 lines)
35	#include "btnode.h"	35	#include "btnode.h"
36		36
37		37
38	void nilfs_btnode_cache_init_once(struct address_space *btnc)
39	{
40	nilfs_mapping_init_once(btnc);
41	}
42
43	static const struct address_space_operations def_btnode_aops = {	38	static const struct address_space_operations def_btnode_aops = {
44	.sync_page = block_sync_page,	39	.sync_page = block_sync_page,
45	};	40	};

Lines 37-43 struct nilfs_btnode_chkey_ctxt { Link Here

(-)a/fs/nilfs2/btnode.h (-1 lines)
37	struct buffer_head *newbh;	37	struct buffer_head *newbh;
38	};	38	};
39		39
40	void nilfs_btnode_cache_init_once(struct address_space *);
41	void nilfs_btnode_cache_init(struct address_space , struct backing_dev_info );	40	void nilfs_btnode_cache_init(struct address_space , struct backing_dev_info );
42	void nilfs_btnode_cache_clear(struct address_space *);	41	void nilfs_btnode_cache_clear(struct address_space *);
43	struct buffer_head nilfs_btnode_create_block(struct address_space btnc,	42	struct buffer_head nilfs_btnode_create_block(struct address_space btnc,

Lines 454-462 int nilfs_mdt_setup_shadow_map(struct inode *inode, Link Here

(-)a/fs/nilfs2/mdt.c (-2 / +2 lines)
454	struct backing_dev_info *bdi = inode->i_sb->s_bdi;	454	struct backing_dev_info *bdi = inode->i_sb->s_bdi;
455		455
456	INIT_LIST_HEAD(&shadow->frozen_buffers);	456	INIT_LIST_HEAD(&shadow->frozen_buffers);
457	nilfs_mapping_init_once(&shadow->frozen_data);	457	address_space_init_once(&shadow->frozen_data);
458	nilfs_mapping_init(&shadow->frozen_data, bdi, &shadow_map_aops);	458	nilfs_mapping_init(&shadow->frozen_data, bdi, &shadow_map_aops);
459	nilfs_mapping_init_once(&shadow->frozen_btnodes);	459	address_space_init_once(&shadow->frozen_btnodes);
460	nilfs_mapping_init(&shadow->frozen_btnodes, bdi, &shadow_map_aops);	460	nilfs_mapping_init(&shadow->frozen_btnodes, bdi, &shadow_map_aops);
461	mi->mi_shadow = shadow;	461	mi->mi_shadow = shadow;
462	return 0;	462	return 0;




	return nc;
}

void nilfs_mapping_init_once(struct address_space *mapping)
{
	memset(mapping, 0, sizeof(*mapping));
	INIT_RADIX_TREE(&mapping->page_tree, GFP_ATOMIC);
	spin_lock_init(&mapping->tree_lock);
	INIT_LIST_HEAD(&mapping->private_list);
	spin_lock_init(&mapping->private_lock);

	spin_lock_init(&mapping->i_mmap_lock);
	INIT_RAW_PRIO_TREE_ROOT(&mapping->i_mmap);
	INIT_LIST_HEAD(&mapping->i_mmap_nonlinear);
}

void nilfs_mapping_init(struct address_space *mapping,
			struct backing_dev_info *bdi,
			const struct address_space_operations *aops)

Lines 61-67 void nilfs_free_private_page(struct page *); Link Here

(-)a/fs/nilfs2/page.h (-1 lines)
61	int nilfs_copy_dirty_pages(struct address_space , struct address_space );	61	int nilfs_copy_dirty_pages(struct address_space , struct address_space );
62	void nilfs_copy_back_pages(struct address_space , struct address_space );	62	void nilfs_copy_back_pages(struct address_space , struct address_space );
63	void nilfs_clear_dirty_pages(struct address_space *);	63	void nilfs_clear_dirty_pages(struct address_space *);
64	void nilfs_mapping_init_once(struct address_space *mapping);
65	void nilfs_mapping_init(struct address_space *mapping,	64	void nilfs_mapping_init(struct address_space *mapping,
66	struct backing_dev_info *bdi,	65	struct backing_dev_info *bdi,
67	const struct address_space_operations *aops);	66	const struct address_space_operations *aops);

Lines 1279-1285 static void nilfs_inode_init_once(void *obj) Link Here

(-)a/fs/nilfs2/super.c (-1 / +1 lines)
1279	#ifdef CONFIG_NILFS_XATTR	1279	#ifdef CONFIG_NILFS_XATTR
1280	init_rwsem(&ii->xattr_sem);	1280	init_rwsem(&ii->xattr_sem);
1281	#endif	1281	#endif
1282	nilfs_btnode_cache_init_once(&ii->i_btnode_cache);	1282	address_space_init_once(&ii->i_btnode_cache);
1283	ii->i_bmap = &ii->i_bmap_data;	1283	ii->i_bmap = &ii->i_bmap_data;
1284	inode_init_once(&ii->vfs_inode);	1284	inode_init_once(&ii->vfs_inode);
1285	}	1285	}

Lines 649-654 struct address_space { Link Here

(-)a/include/linux/fs.h (+2 lines)
649	spinlock_t private_lock; /* for use by the address_space */	649	spinlock_t private_lock; /* for use by the address_space */
650	struct list_head private_list; /* ditto */	650	struct list_head private_list; /* ditto */
651	struct address_space assoc_mapping; / ditto */	651	struct address_space assoc_mapping; / ditto */
		652	struct mutex unmap_mutex; /* to protect unmapping */
652	} __attribute__((aligned(sizeof(long))));	653	} __attribute__((aligned(sizeof(long))));
653	/*	654	/*
654	* On most architectures that alignment is already the case; but	655	* On most architectures that alignment is already the case; but
Lines 2225-2230 extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin); Link Here
2225		2226
2226	extern int inode_init_always(struct super_block , struct inode );	2227	extern int inode_init_always(struct super_block , struct inode );
2227	extern void inode_init_once(struct inode *);	2228	extern void inode_init_once(struct inode *);
		2229	extern void address_space_init_once(struct address_space *mapping);
2228	extern void ihold(struct inode * inode);	2230	extern void ihold(struct inode * inode);
2229	extern void iput(struct inode *);	2231	extern void iput(struct inode *);
2230	extern struct inode * igrab(struct inode *);	2232	extern struct inode * igrab(struct inode *);

Lines 2648-2653 void unmap_mapping_range(struct address_space *mapping, Link Here

(-)a/mm/memory.c (+2 lines)
2648	details.last_index = ULONG_MAX;	2648	details.last_index = ULONG_MAX;
2649	details.i_mmap_lock = &mapping->i_mmap_lock;	2649	details.i_mmap_lock = &mapping->i_mmap_lock;
2650		2650
		2651	mutex_lock(&mapping->unmap_mutex);
2651	spin_lock(&mapping->i_mmap_lock);	2652	spin_lock(&mapping->i_mmap_lock);
2652		2653
2653	/* Protect against endless unmapping loops */	2654	/* Protect against endless unmapping loops */
Lines 2664-2669 void unmap_mapping_range(struct address_space *mapping, Link Here
2664	if (unlikely(!list_empty(&mapping->i_mmap_nonlinear)))	2665	if (unlikely(!list_empty(&mapping->i_mmap_nonlinear)))
2665	unmap_mapping_range_list(&mapping->i_mmap_nonlinear, &details);	2666	unmap_mapping_range_list(&mapping->i_mmap_nonlinear, &details);
2666	spin_unlock(&mapping->i_mmap_lock);	2667	spin_unlock(&mapping->i_mmap_lock);
		2668	mutex_unlock(&mapping->unmap_mutex);
2667	}	2669	}
2668	EXPORT_SYMBOL(unmap_mapping_range);	2670	EXPORT_SYMBOL(unmap_mapping_range);
2669		2671

Return to bug 357657

Lines 295-300 static void destroy_inode(struct inode *inode) Link Here

(-)a/fs/inode.c (-7 / +15 lines)
295	call_rcu(&inode->i_rcu, i_callback);	295	call_rcu(&inode->i_rcu, i_callback);
296	}	296	}
297		297
		298	void address_space_init_once(struct address_space *mapping)
		299	{
		300	memset(mapping, 0, sizeof(*mapping));
		301	INIT_RADIX_TREE(&mapping->page_tree, GFP_ATOMIC);
		302	spin_lock_init(&mapping->tree_lock);
		303	spin_lock_init(&mapping->i_mmap_lock);
		304	INIT_LIST_HEAD(&mapping->private_list);
		305	spin_lock_init(&mapping->private_lock);
		306	INIT_RAW_PRIO_TREE_ROOT(&mapping->i_mmap);
		307	INIT_LIST_HEAD(&mapping->i_mmap_nonlinear);
		308	mutex_init(&mapping->unmap_mutex);
		309	}
		310	EXPORT_SYMBOL(address_space_init_once);
		311
298	/*	312	/*
299	* These are initializations that only need to be done	313	* These are initializations that only need to be done
300	* once, because the fields are idempotent across use	314	* once, because the fields are idempotent across use
Lines 308-320 void inode_init_once(struct inode *inode) Link Here
308	INIT_LIST_HEAD(&inode->i_devices);	322	INIT_LIST_HEAD(&inode->i_devices);
309	INIT_LIST_HEAD(&inode->i_wb_list);	323	INIT_LIST_HEAD(&inode->i_wb_list);
310	INIT_LIST_HEAD(&inode->i_lru);	324	INIT_LIST_HEAD(&inode->i_lru);
311	INIT_RADIX_TREE(&inode->i_data.page_tree, GFP_ATOMIC);	325	address_space_init_once(&inode->i_data);
312	spin_lock_init(&inode->i_data.tree_lock);
313	spin_lock_init(&inode->i_data.i_mmap_lock);
314	INIT_LIST_HEAD(&inode->i_data.private_list);
315	spin_lock_init(&inode->i_data.private_lock);
316	INIT_RAW_PRIO_TREE_ROOT(&inode->i_data.i_mmap);
317	INIT_LIST_HEAD(&inode->i_data.i_mmap_nonlinear);
318	i_size_ordered_init(inode);	326	i_size_ordered_init(inode);
319	#ifdef CONFIG_FSNOTIFY	327	#ifdef CONFIG_FSNOTIFY
320	INIT_HLIST_HEAD(&inode->i_fsnotify_marks);	328	INIT_HLIST_HEAD(&inode->i_fsnotify_marks);

Lines 492-510 unsigned nilfs_page_count_clean_buffers(struct page *page, Link Here

(-)a/fs/nilfs2/page.c (-13 lines)
492	return nc;	492	return nc;
493	}	493	}
494		494
495	void nilfs_mapping_init_once(struct address_space *mapping)
496	{
497	memset(mapping, 0, sizeof(*mapping));
498	INIT_RADIX_TREE(&mapping->page_tree, GFP_ATOMIC);
499	spin_lock_init(&mapping->tree_lock);
500	INIT_LIST_HEAD(&mapping->private_list);
501	spin_lock_init(&mapping->private_lock);
502
503	spin_lock_init(&mapping->i_mmap_lock);
504	INIT_RAW_PRIO_TREE_ROOT(&mapping->i_mmap);
505	INIT_LIST_HEAD(&mapping->i_mmap_nonlinear);
506	}
507
508	void nilfs_mapping_init(struct address_space *mapping,	495	void nilfs_mapping_init(struct address_space *mapping,
509	struct backing_dev_info *bdi,	496	struct backing_dev_info *bdi,
510	const struct address_space_operations *aops)	497	const struct address_space_operations *aops)

Lines 59-72 static void gfs2_init_gl_aspace_once(void *foo) Link Here

(-)a/fs/gfs2/main.c (-8 / +1 lines)
59	struct address_space mapping = (struct address_space )(gl + 1);	59	struct address_space mapping = (struct address_space )(gl + 1);
60		60
61	gfs2_init_glock_once(gl);	61	gfs2_init_glock_once(gl);
62	memset(mapping, 0, sizeof(*mapping));	62	address_space_init_once(mapping);
63	INIT_RADIX_TREE(&mapping->page_tree, GFP_ATOMIC);
64	spin_lock_init(&mapping->tree_lock);
65	spin_lock_init(&mapping->i_mmap_lock);
66	INIT_LIST_HEAD(&mapping->private_list);
67	spin_lock_init(&mapping->private_lock);
68	INIT_RAW_PRIO_TREE_ROOT(&mapping->i_mmap);
69	INIT_LIST_HEAD(&mapping->i_mmap_nonlinear);
70	}	63	}
71		64
72	/**	65	/**