Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 429479f031322a0cc5c921ffb2321a51718dc875

Authored by Jan Kara 2009-04-27 22:43:50 +0800

Committed by Al Viro 2009-06-12 09:36:03 +0800

Exists in master and in 7 other branches

vfs: Make __fsync_super() a static function (version 4)

__fsync_super() does the same thing as fsync_super(). So change the only
caller to use fsync_super() and make __fsync_super() static. This removes
unnecessarily duplicated call to sync_blockdev() and prepares ground
for the changes to __fsync_super() in the following patches.

Signed-off-by: Jan Kara <jack@suse.cz>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

Showing 3 changed files with 4 additions and 6 deletions Inline Diff

fs/block_dev.c
fs/super.c
include/linux/fs.h

fs/block_dev.c

Diff comments View file @ 429479f

1	/*	1	/*
2	* linux/fs/block_dev.c	2	* linux/fs/block_dev.c
3	*	3	*
4	* Copyright (C) 1991, 1992 Linus Torvalds	4	* Copyright (C) 1991, 1992 Linus Torvalds
5	* Copyright (C) 2001 Andrea Arcangeli <andrea@suse.de> SuSE	5	* Copyright (C) 2001 Andrea Arcangeli <andrea@suse.de> SuSE
6	*/	6	*/
7		7
8	#include <linux/init.h>	8	#include <linux/init.h>
9	#include <linux/mm.h>	9	#include <linux/mm.h>
10	#include <linux/fcntl.h>	10	#include <linux/fcntl.h>
11	#include <linux/slab.h>	11	#include <linux/slab.h>
12	#include <linux/kmod.h>	12	#include <linux/kmod.h>
13	#include <linux/major.h>	13	#include <linux/major.h>
14	#include <linux/smp_lock.h>	14	#include <linux/smp_lock.h>
15	#include <linux/device_cgroup.h>	15	#include <linux/device_cgroup.h>
16	#include <linux/highmem.h>	16	#include <linux/highmem.h>
17	#include <linux/blkdev.h>	17	#include <linux/blkdev.h>
18	#include <linux/module.h>	18	#include <linux/module.h>
19	#include <linux/blkpg.h>	19	#include <linux/blkpg.h>
20	#include <linux/buffer_head.h>	20	#include <linux/buffer_head.h>
21	#include <linux/pagevec.h>	21	#include <linux/pagevec.h>
22	#include <linux/writeback.h>	22	#include <linux/writeback.h>
23	#include <linux/mpage.h>	23	#include <linux/mpage.h>
24	#include <linux/mount.h>	24	#include <linux/mount.h>
25	#include <linux/uio.h>	25	#include <linux/uio.h>
26	#include <linux/namei.h>	26	#include <linux/namei.h>
27	#include <linux/log2.h>	27	#include <linux/log2.h>
28	#include <linux/kmemleak.h>	28	#include <linux/kmemleak.h>
29	#include <asm/uaccess.h>	29	#include <asm/uaccess.h>
30	#include "internal.h"	30	#include "internal.h"
31		31
32	struct bdev_inode {	32	struct bdev_inode {
33	struct block_device bdev;	33	struct block_device bdev;
34	struct inode vfs_inode;	34	struct inode vfs_inode;
35	};	35	};
36		36
37	static const struct address_space_operations def_blk_aops;	37	static const struct address_space_operations def_blk_aops;
38		38
39	static inline struct bdev_inode BDEV_I(struct inode inode)	39	static inline struct bdev_inode BDEV_I(struct inode inode)
40	{	40	{
41	return container_of(inode, struct bdev_inode, vfs_inode);	41	return container_of(inode, struct bdev_inode, vfs_inode);
42	}	42	}
43		43
44	inline struct block_device I_BDEV(struct inode inode)	44	inline struct block_device I_BDEV(struct inode inode)
45	{	45	{
46	return &BDEV_I(inode)->bdev;	46	return &BDEV_I(inode)->bdev;
47	}	47	}
48		48
49	EXPORT_SYMBOL(I_BDEV);	49	EXPORT_SYMBOL(I_BDEV);
50		50
51	static sector_t max_block(struct block_device *bdev)	51	static sector_t max_block(struct block_device *bdev)
52	{	52	{
53	sector_t retval = ~((sector_t)0);	53	sector_t retval = ~((sector_t)0);
54	loff_t sz = i_size_read(bdev->bd_inode);	54	loff_t sz = i_size_read(bdev->bd_inode);
55		55
56	if (sz) {	56	if (sz) {
57	unsigned int size = block_size(bdev);	57	unsigned int size = block_size(bdev);
58	unsigned int sizebits = blksize_bits(size);	58	unsigned int sizebits = blksize_bits(size);
59	retval = (sz >> sizebits);	59	retval = (sz >> sizebits);
60	}	60	}
61	return retval;	61	return retval;
62	}	62	}
63		63
64	/* Kill _all_ buffers and pagecache , dirty or not.. */	64	/* Kill _all_ buffers and pagecache , dirty or not.. */
65	static void kill_bdev(struct block_device *bdev)	65	static void kill_bdev(struct block_device *bdev)
66	{	66	{
67	if (bdev->bd_inode->i_mapping->nrpages == 0)	67	if (bdev->bd_inode->i_mapping->nrpages == 0)
68	return;	68	return;
69	invalidate_bh_lrus();	69	invalidate_bh_lrus();
70	truncate_inode_pages(bdev->bd_inode->i_mapping, 0);	70	truncate_inode_pages(bdev->bd_inode->i_mapping, 0);
71	}	71	}
72		72
73	int set_blocksize(struct block_device *bdev, int size)	73	int set_blocksize(struct block_device *bdev, int size)
74	{	74	{
75	/* Size must be a power of two, and between 512 and PAGE_SIZE */	75	/* Size must be a power of two, and between 512 and PAGE_SIZE */
76	if (size > PAGE_SIZE \|\| size < 512 \|\| !is_power_of_2(size))	76	if (size > PAGE_SIZE \|\| size < 512 \|\| !is_power_of_2(size))
77	return -EINVAL;	77	return -EINVAL;
78		78
79	/* Size cannot be smaller than the size supported by the device */	79	/* Size cannot be smaller than the size supported by the device */
80	if (size < bdev_logical_block_size(bdev))	80	if (size < bdev_logical_block_size(bdev))
81	return -EINVAL;	81	return -EINVAL;
82		82
83	/* Don't change the size if it is same as current */	83	/* Don't change the size if it is same as current */
84	if (bdev->bd_block_size != size) {	84	if (bdev->bd_block_size != size) {
85	sync_blockdev(bdev);	85	sync_blockdev(bdev);
86	bdev->bd_block_size = size;	86	bdev->bd_block_size = size;
87	bdev->bd_inode->i_blkbits = blksize_bits(size);	87	bdev->bd_inode->i_blkbits = blksize_bits(size);
88	kill_bdev(bdev);	88	kill_bdev(bdev);
89	}	89	}
90	return 0;	90	return 0;
91	}	91	}
92		92
93	EXPORT_SYMBOL(set_blocksize);	93	EXPORT_SYMBOL(set_blocksize);
94		94
95	int sb_set_blocksize(struct super_block *sb, int size)	95	int sb_set_blocksize(struct super_block *sb, int size)
96	{	96	{
97	if (set_blocksize(sb->s_bdev, size))	97	if (set_blocksize(sb->s_bdev, size))
98	return 0;	98	return 0;
99	/* If we get here, we know size is power of two	99	/* If we get here, we know size is power of two
100	* and it's value is between 512 and PAGE_SIZE */	100	* and it's value is between 512 and PAGE_SIZE */
101	sb->s_blocksize = size;	101	sb->s_blocksize = size;
102	sb->s_blocksize_bits = blksize_bits(size);	102	sb->s_blocksize_bits = blksize_bits(size);
103	return sb->s_blocksize;	103	return sb->s_blocksize;
104	}	104	}
105		105
106	EXPORT_SYMBOL(sb_set_blocksize);	106	EXPORT_SYMBOL(sb_set_blocksize);
107		107
108	int sb_min_blocksize(struct super_block *sb, int size)	108	int sb_min_blocksize(struct super_block *sb, int size)
109	{	109	{
110	int minsize = bdev_logical_block_size(sb->s_bdev);	110	int minsize = bdev_logical_block_size(sb->s_bdev);
111	if (size < minsize)	111	if (size < minsize)
112	size = minsize;	112	size = minsize;
113	return sb_set_blocksize(sb, size);	113	return sb_set_blocksize(sb, size);
114	}	114	}
115		115
116	EXPORT_SYMBOL(sb_min_blocksize);	116	EXPORT_SYMBOL(sb_min_blocksize);
117		117
118	static int	118	static int
119	blkdev_get_block(struct inode *inode, sector_t iblock,	119	blkdev_get_block(struct inode *inode, sector_t iblock,
120	struct buffer_head *bh, int create)	120	struct buffer_head *bh, int create)
121	{	121	{
122	if (iblock >= max_block(I_BDEV(inode))) {	122	if (iblock >= max_block(I_BDEV(inode))) {
123	if (create)	123	if (create)
124	return -EIO;	124	return -EIO;
125		125
126	/*	126	/*
127	* for reads, we're just trying to fill a partial page.	127	* for reads, we're just trying to fill a partial page.
128	* return a hole, they will have to call get_block again	128	* return a hole, they will have to call get_block again
129	* before they can fill it, and they will get -EIO at that	129	* before they can fill it, and they will get -EIO at that
130	* time	130	* time
131	*/	131	*/
132	return 0;	132	return 0;
133	}	133	}
134	bh->b_bdev = I_BDEV(inode);	134	bh->b_bdev = I_BDEV(inode);
135	bh->b_blocknr = iblock;	135	bh->b_blocknr = iblock;
136	set_buffer_mapped(bh);	136	set_buffer_mapped(bh);
137	return 0;	137	return 0;
138	}	138	}
139		139
140	static int	140	static int
141	blkdev_get_blocks(struct inode *inode, sector_t iblock,	141	blkdev_get_blocks(struct inode *inode, sector_t iblock,
142	struct buffer_head *bh, int create)	142	struct buffer_head *bh, int create)
143	{	143	{
144	sector_t end_block = max_block(I_BDEV(inode));	144	sector_t end_block = max_block(I_BDEV(inode));
145	unsigned long max_blocks = bh->b_size >> inode->i_blkbits;	145	unsigned long max_blocks = bh->b_size >> inode->i_blkbits;
146		146
147	if ((iblock + max_blocks) > end_block) {	147	if ((iblock + max_blocks) > end_block) {
148	max_blocks = end_block - iblock;	148	max_blocks = end_block - iblock;
149	if ((long)max_blocks <= 0) {	149	if ((long)max_blocks <= 0) {
150	if (create)	150	if (create)
151	return -EIO; /* write fully beyond EOF */	151	return -EIO; /* write fully beyond EOF */
152	/*	152	/*
153	* It is a read which is fully beyond EOF. We return	153	* It is a read which is fully beyond EOF. We return
154	* a !buffer_mapped buffer	154	* a !buffer_mapped buffer
155	*/	155	*/
156	max_blocks = 0;	156	max_blocks = 0;
157	}	157	}
158	}	158	}
159		159
160	bh->b_bdev = I_BDEV(inode);	160	bh->b_bdev = I_BDEV(inode);
161	bh->b_blocknr = iblock;	161	bh->b_blocknr = iblock;
162	bh->b_size = max_blocks << inode->i_blkbits;	162	bh->b_size = max_blocks << inode->i_blkbits;
163	if (max_blocks)	163	if (max_blocks)
164	set_buffer_mapped(bh);	164	set_buffer_mapped(bh);
165	return 0;	165	return 0;
166	}	166	}
167		167
168	static ssize_t	168	static ssize_t
169	blkdev_direct_IO(int rw, struct kiocb iocb, const struct iovec iov,	169	blkdev_direct_IO(int rw, struct kiocb iocb, const struct iovec iov,
170	loff_t offset, unsigned long nr_segs)	170	loff_t offset, unsigned long nr_segs)
171	{	171	{
172	struct file *file = iocb->ki_filp;	172	struct file *file = iocb->ki_filp;
173	struct inode *inode = file->f_mapping->host;	173	struct inode *inode = file->f_mapping->host;
174		174
175	return blockdev_direct_IO_no_locking(rw, iocb, inode, I_BDEV(inode),	175	return blockdev_direct_IO_no_locking(rw, iocb, inode, I_BDEV(inode),
176	iov, offset, nr_segs, blkdev_get_blocks, NULL);	176	iov, offset, nr_segs, blkdev_get_blocks, NULL);
177	}	177	}
178		178
179	/*	179	/*
180	* Write out and wait upon all the dirty data associated with a block	180	* Write out and wait upon all the dirty data associated with a block
181	* device via its mapping. Does not take the superblock lock.	181	* device via its mapping. Does not take the superblock lock.
182	*/	182	*/
183	int sync_blockdev(struct block_device *bdev)	183	int sync_blockdev(struct block_device *bdev)
184	{	184	{
185	int ret = 0;	185	int ret = 0;
186		186
187	if (bdev)	187	if (bdev)
188	ret = filemap_write_and_wait(bdev->bd_inode->i_mapping);	188	ret = filemap_write_and_wait(bdev->bd_inode->i_mapping);
189	return ret;	189	return ret;
190	}	190	}
191	EXPORT_SYMBOL(sync_blockdev);	191	EXPORT_SYMBOL(sync_blockdev);
192		192
193	/*	193	/*
194	* Write out and wait upon all dirty data associated with this	194	* Write out and wait upon all dirty data associated with this
195	* device. Filesystem data as well as the underlying block	195	* device. Filesystem data as well as the underlying block
196	* device. Takes the superblock lock.	196	* device. Takes the superblock lock.
197	*/	197	*/
198	int fsync_bdev(struct block_device *bdev)	198	int fsync_bdev(struct block_device *bdev)
199	{	199	{
200	struct super_block *sb = get_super(bdev);	200	struct super_block *sb = get_super(bdev);
201	if (sb) {	201	if (sb) {
202	int res = fsync_super(sb);	202	int res = fsync_super(sb);
203	drop_super(sb);	203	drop_super(sb);
204	return res;	204	return res;
205	}	205	}
206	return sync_blockdev(bdev);	206	return sync_blockdev(bdev);
207	}	207	}
208	EXPORT_SYMBOL(fsync_bdev);	208	EXPORT_SYMBOL(fsync_bdev);
209		209
210	/**	210	/**
211	* freeze_bdev -- lock a filesystem and force it into a consistent state	211	* freeze_bdev -- lock a filesystem and force it into a consistent state
212	* @bdev: blockdevice to lock	212	* @bdev: blockdevice to lock
213	*	213	*
214	* This takes the block device bd_mount_sem to make sure no new mounts	214	* This takes the block device bd_mount_sem to make sure no new mounts
215	* happen on bdev until thaw_bdev() is called.	215	* happen on bdev until thaw_bdev() is called.
216	* If a superblock is found on this device, we take the s_umount semaphore	216	* If a superblock is found on this device, we take the s_umount semaphore
217	* on it to make sure nobody unmounts until the snapshot creation is done.	217	* on it to make sure nobody unmounts until the snapshot creation is done.
218	* The reference counter (bd_fsfreeze_count) guarantees that only the last	218	* The reference counter (bd_fsfreeze_count) guarantees that only the last
219	* unfreeze process can unfreeze the frozen filesystem actually when multiple	219	* unfreeze process can unfreeze the frozen filesystem actually when multiple
220	* freeze requests arrive simultaneously. It counts up in freeze_bdev() and	220	* freeze requests arrive simultaneously. It counts up in freeze_bdev() and
221	* count down in thaw_bdev(). When it becomes 0, thaw_bdev() will unfreeze	221	* count down in thaw_bdev(). When it becomes 0, thaw_bdev() will unfreeze
222	* actually.	222	* actually.
223	*/	223	*/
224	struct super_block freeze_bdev(struct block_device bdev)	224	struct super_block freeze_bdev(struct block_device bdev)
225	{	225	{
226	struct super_block *sb;	226	struct super_block *sb;
227	int error = 0;	227	int error = 0;
228		228
229	mutex_lock(&bdev->bd_fsfreeze_mutex);	229	mutex_lock(&bdev->bd_fsfreeze_mutex);
230	if (bdev->bd_fsfreeze_count > 0) {	230	if (bdev->bd_fsfreeze_count > 0) {
231	bdev->bd_fsfreeze_count++;	231	bdev->bd_fsfreeze_count++;
232	sb = get_super(bdev);	232	sb = get_super(bdev);
233	mutex_unlock(&bdev->bd_fsfreeze_mutex);	233	mutex_unlock(&bdev->bd_fsfreeze_mutex);
234	return sb;	234	return sb;
235	}	235	}
236	bdev->bd_fsfreeze_count++;	236	bdev->bd_fsfreeze_count++;
237		237
238	down(&bdev->bd_mount_sem);	238	down(&bdev->bd_mount_sem);
239	sb = get_super(bdev);	239	sb = get_super(bdev);
240	if (sb && !(sb->s_flags & MS_RDONLY)) {	240	if (sb && !(sb->s_flags & MS_RDONLY)) {
241	sb->s_frozen = SB_FREEZE_WRITE;	241	sb->s_frozen = SB_FREEZE_WRITE;
242	smp_wmb();	242	smp_wmb();
243		243
244	__fsync_super(sb);	244	fsync_super(sb);
245		245
246	sb->s_frozen = SB_FREEZE_TRANS;	246	sb->s_frozen = SB_FREEZE_TRANS;
247	smp_wmb();	247	smp_wmb();
248		248
249	sync_blockdev(sb->s_bdev);	249	sync_blockdev(sb->s_bdev);
250		250
251	if (sb->s_op->freeze_fs) {	251	if (sb->s_op->freeze_fs) {
252	error = sb->s_op->freeze_fs(sb);	252	error = sb->s_op->freeze_fs(sb);
253	if (error) {	253	if (error) {
254	printk(KERN_ERR	254	printk(KERN_ERR
255	"VFS:Filesystem freeze failed\n");	255	"VFS:Filesystem freeze failed\n");
256	sb->s_frozen = SB_UNFROZEN;	256	sb->s_frozen = SB_UNFROZEN;
257	drop_super(sb);	257	drop_super(sb);
258	up(&bdev->bd_mount_sem);	258	up(&bdev->bd_mount_sem);
259	bdev->bd_fsfreeze_count--;	259	bdev->bd_fsfreeze_count--;
260	mutex_unlock(&bdev->bd_fsfreeze_mutex);	260	mutex_unlock(&bdev->bd_fsfreeze_mutex);
261	return ERR_PTR(error);	261	return ERR_PTR(error);
262	}	262	}
263	}	263	}
264	}	264	}
265		265
266	sync_blockdev(bdev);	266	sync_blockdev(bdev);
267	mutex_unlock(&bdev->bd_fsfreeze_mutex);	267	mutex_unlock(&bdev->bd_fsfreeze_mutex);
268		268
269	return sb; /* thaw_bdev releases s->s_umount and bd_mount_sem */	269	return sb; /* thaw_bdev releases s->s_umount and bd_mount_sem */
270	}	270	}
271	EXPORT_SYMBOL(freeze_bdev);	271	EXPORT_SYMBOL(freeze_bdev);
272		272
273	/**	273	/**
274	* thaw_bdev -- unlock filesystem	274	* thaw_bdev -- unlock filesystem
275	* @bdev: blockdevice to unlock	275	* @bdev: blockdevice to unlock
276	* @sb: associated superblock	276	* @sb: associated superblock
277	*	277	*
278	* Unlocks the filesystem and marks it writeable again after freeze_bdev().	278	* Unlocks the filesystem and marks it writeable again after freeze_bdev().
279	*/	279	*/
280	int thaw_bdev(struct block_device bdev, struct super_block sb)	280	int thaw_bdev(struct block_device bdev, struct super_block sb)
281	{	281	{
282	int error = 0;	282	int error = 0;
283		283
284	mutex_lock(&bdev->bd_fsfreeze_mutex);	284	mutex_lock(&bdev->bd_fsfreeze_mutex);
285	if (!bdev->bd_fsfreeze_count) {	285	if (!bdev->bd_fsfreeze_count) {
286	mutex_unlock(&bdev->bd_fsfreeze_mutex);	286	mutex_unlock(&bdev->bd_fsfreeze_mutex);
287	return -EINVAL;	287	return -EINVAL;
288	}	288	}
289		289
290	bdev->bd_fsfreeze_count--;	290	bdev->bd_fsfreeze_count--;
291	if (bdev->bd_fsfreeze_count > 0) {	291	if (bdev->bd_fsfreeze_count > 0) {
292	if (sb)	292	if (sb)
293	drop_super(sb);	293	drop_super(sb);
294	mutex_unlock(&bdev->bd_fsfreeze_mutex);	294	mutex_unlock(&bdev->bd_fsfreeze_mutex);
295	return 0;	295	return 0;
296	}	296	}
297		297
298	if (sb) {	298	if (sb) {
299	BUG_ON(sb->s_bdev != bdev);	299	BUG_ON(sb->s_bdev != bdev);
300	if (!(sb->s_flags & MS_RDONLY)) {	300	if (!(sb->s_flags & MS_RDONLY)) {
301	if (sb->s_op->unfreeze_fs) {	301	if (sb->s_op->unfreeze_fs) {
302	error = sb->s_op->unfreeze_fs(sb);	302	error = sb->s_op->unfreeze_fs(sb);
303	if (error) {	303	if (error) {
304	printk(KERN_ERR	304	printk(KERN_ERR
305	"VFS:Filesystem thaw failed\n");	305	"VFS:Filesystem thaw failed\n");
306	sb->s_frozen = SB_FREEZE_TRANS;	306	sb->s_frozen = SB_FREEZE_TRANS;
307	bdev->bd_fsfreeze_count++;	307	bdev->bd_fsfreeze_count++;
308	mutex_unlock(&bdev->bd_fsfreeze_mutex);	308	mutex_unlock(&bdev->bd_fsfreeze_mutex);
309	return error;	309	return error;
310	}	310	}
311	}	311	}
312	sb->s_frozen = SB_UNFROZEN;	312	sb->s_frozen = SB_UNFROZEN;
313	smp_wmb();	313	smp_wmb();
314	wake_up(&sb->s_wait_unfrozen);	314	wake_up(&sb->s_wait_unfrozen);
315	}	315	}
316	drop_super(sb);	316	drop_super(sb);
317	}	317	}
318		318
319	up(&bdev->bd_mount_sem);	319	up(&bdev->bd_mount_sem);
320	mutex_unlock(&bdev->bd_fsfreeze_mutex);	320	mutex_unlock(&bdev->bd_fsfreeze_mutex);
321	return 0;	321	return 0;
322	}	322	}
323	EXPORT_SYMBOL(thaw_bdev);	323	EXPORT_SYMBOL(thaw_bdev);
324		324
325	static int blkdev_writepage(struct page page, struct writeback_control wbc)	325	static int blkdev_writepage(struct page page, struct writeback_control wbc)
326	{	326	{
327	return block_write_full_page(page, blkdev_get_block, wbc);	327	return block_write_full_page(page, blkdev_get_block, wbc);
328	}	328	}
329		329
330	static int blkdev_readpage(struct file * file, struct page * page)	330	static int blkdev_readpage(struct file * file, struct page * page)
331	{	331	{
332	return block_read_full_page(page, blkdev_get_block);	332	return block_read_full_page(page, blkdev_get_block);
333	}	333	}
334		334
335	static int blkdev_write_begin(struct file file, struct address_space mapping,	335	static int blkdev_write_begin(struct file file, struct address_space mapping,
336	loff_t pos, unsigned len, unsigned flags,	336	loff_t pos, unsigned len, unsigned flags,
337	struct page pagep, void fsdata)	337	struct page pagep, void fsdata)
338	{	338	{
339	*pagep = NULL;	339	*pagep = NULL;
340	return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,	340	return block_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
341	blkdev_get_block);	341	blkdev_get_block);
342	}	342	}
343		343
344	static int blkdev_write_end(struct file file, struct address_space mapping,	344	static int blkdev_write_end(struct file file, struct address_space mapping,
345	loff_t pos, unsigned len, unsigned copied,	345	loff_t pos, unsigned len, unsigned copied,
346	struct page page, void fsdata)	346	struct page page, void fsdata)
347	{	347	{
348	int ret;	348	int ret;
349	ret = block_write_end(file, mapping, pos, len, copied, page, fsdata);	349	ret = block_write_end(file, mapping, pos, len, copied, page, fsdata);
350		350
351	unlock_page(page);	351	unlock_page(page);
352	page_cache_release(page);	352	page_cache_release(page);
353		353
354	return ret;	354	return ret;
355	}	355	}
356		356
357	/*	357	/*
358	* private llseek:	358	* private llseek:
359	* for a block special file file->f_path.dentry->d_inode->i_size is zero	359	* for a block special file file->f_path.dentry->d_inode->i_size is zero
360	* so we compute the size by hand (just as in block_read/write above)	360	* so we compute the size by hand (just as in block_read/write above)
361	*/	361	*/
362	static loff_t block_llseek(struct file *file, loff_t offset, int origin)	362	static loff_t block_llseek(struct file *file, loff_t offset, int origin)
363	{	363	{
364	struct inode *bd_inode = file->f_mapping->host;	364	struct inode *bd_inode = file->f_mapping->host;
365	loff_t size;	365	loff_t size;
366	loff_t retval;	366	loff_t retval;
367		367
368	mutex_lock(&bd_inode->i_mutex);	368	mutex_lock(&bd_inode->i_mutex);
369	size = i_size_read(bd_inode);	369	size = i_size_read(bd_inode);
370		370
371	switch (origin) {	371	switch (origin) {
372	case 2:	372	case 2:
373	offset += size;	373	offset += size;
374	break;	374	break;
375	case 1:	375	case 1:
376	offset += file->f_pos;	376	offset += file->f_pos;
377	}	377	}
378	retval = -EINVAL;	378	retval = -EINVAL;
379	if (offset >= 0 && offset <= size) {	379	if (offset >= 0 && offset <= size) {
380	if (offset != file->f_pos) {	380	if (offset != file->f_pos) {
381	file->f_pos = offset;	381	file->f_pos = offset;
382	}	382	}
383	retval = offset;	383	retval = offset;
384	}	384	}
385	mutex_unlock(&bd_inode->i_mutex);	385	mutex_unlock(&bd_inode->i_mutex);
386	return retval;	386	return retval;
387	}	387	}
388		388
389	/*	389	/*
390	* Filp is never NULL; the only case when ->fsync() is called with	390	* Filp is never NULL; the only case when ->fsync() is called with
391	* NULL first argument is nfsd_sync_dir() and that's not a directory.	391	* NULL first argument is nfsd_sync_dir() and that's not a directory.
392	*/	392	*/
393		393
394	static int block_fsync(struct file filp, struct dentry dentry, int datasync)	394	static int block_fsync(struct file filp, struct dentry dentry, int datasync)
395	{	395	{
396	return sync_blockdev(I_BDEV(filp->f_mapping->host));	396	return sync_blockdev(I_BDEV(filp->f_mapping->host));
397	}	397	}
398		398
399	/*	399	/*
400	* pseudo-fs	400	* pseudo-fs
401	*/	401	*/
402		402
403	static __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);	403	static __cacheline_aligned_in_smp DEFINE_SPINLOCK(bdev_lock);
404	static struct kmem_cache * bdev_cachep __read_mostly;	404	static struct kmem_cache * bdev_cachep __read_mostly;
405		405
406	static struct inode bdev_alloc_inode(struct super_block sb)	406	static struct inode bdev_alloc_inode(struct super_block sb)
407	{	407	{
408	struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);	408	struct bdev_inode *ei = kmem_cache_alloc(bdev_cachep, GFP_KERNEL);
409	if (!ei)	409	if (!ei)
410	return NULL;	410	return NULL;
411	return &ei->vfs_inode;	411	return &ei->vfs_inode;
412	}	412	}
413		413
414	static void bdev_destroy_inode(struct inode *inode)	414	static void bdev_destroy_inode(struct inode *inode)
415	{	415	{
416	struct bdev_inode *bdi = BDEV_I(inode);	416	struct bdev_inode *bdi = BDEV_I(inode);
417		417
418	bdi->bdev.bd_inode_backing_dev_info = NULL;	418	bdi->bdev.bd_inode_backing_dev_info = NULL;
419	kmem_cache_free(bdev_cachep, bdi);	419	kmem_cache_free(bdev_cachep, bdi);
420	}	420	}
421		421
422	static void init_once(void *foo)	422	static void init_once(void *foo)
423	{	423	{
424	struct bdev_inode ei = (struct bdev_inode ) foo;	424	struct bdev_inode ei = (struct bdev_inode ) foo;
425	struct block_device *bdev = &ei->bdev;	425	struct block_device *bdev = &ei->bdev;
426		426
427	memset(bdev, 0, sizeof(*bdev));	427	memset(bdev, 0, sizeof(*bdev));
428	mutex_init(&bdev->bd_mutex);	428	mutex_init(&bdev->bd_mutex);
429	sema_init(&bdev->bd_mount_sem, 1);	429	sema_init(&bdev->bd_mount_sem, 1);
430	INIT_LIST_HEAD(&bdev->bd_inodes);	430	INIT_LIST_HEAD(&bdev->bd_inodes);
431	INIT_LIST_HEAD(&bdev->bd_list);	431	INIT_LIST_HEAD(&bdev->bd_list);
432	#ifdef CONFIG_SYSFS	432	#ifdef CONFIG_SYSFS
433	INIT_LIST_HEAD(&bdev->bd_holder_list);	433	INIT_LIST_HEAD(&bdev->bd_holder_list);
434	#endif	434	#endif
435	inode_init_once(&ei->vfs_inode);	435	inode_init_once(&ei->vfs_inode);
436	/* Initialize mutex for freeze. */	436	/* Initialize mutex for freeze. */
437	mutex_init(&bdev->bd_fsfreeze_mutex);	437	mutex_init(&bdev->bd_fsfreeze_mutex);
438	}	438	}
439		439
440	static inline void __bd_forget(struct inode *inode)	440	static inline void __bd_forget(struct inode *inode)
441	{	441	{
442	list_del_init(&inode->i_devices);	442	list_del_init(&inode->i_devices);
443	inode->i_bdev = NULL;	443	inode->i_bdev = NULL;
444	inode->i_mapping = &inode->i_data;	444	inode->i_mapping = &inode->i_data;
445	}	445	}
446		446
447	static void bdev_clear_inode(struct inode *inode)	447	static void bdev_clear_inode(struct inode *inode)
448	{	448	{
449	struct block_device *bdev = &BDEV_I(inode)->bdev;	449	struct block_device *bdev = &BDEV_I(inode)->bdev;
450	struct list_head *p;	450	struct list_head *p;
451	spin_lock(&bdev_lock);	451	spin_lock(&bdev_lock);
452	while ( (p = bdev->bd_inodes.next) != &bdev->bd_inodes ) {	452	while ( (p = bdev->bd_inodes.next) != &bdev->bd_inodes ) {
453	__bd_forget(list_entry(p, struct inode, i_devices));	453	__bd_forget(list_entry(p, struct inode, i_devices));
454	}	454	}
455	list_del_init(&bdev->bd_list);	455	list_del_init(&bdev->bd_list);
456	spin_unlock(&bdev_lock);	456	spin_unlock(&bdev_lock);
457	}	457	}
458		458
459	static const struct super_operations bdev_sops = {	459	static const struct super_operations bdev_sops = {
460	.statfs = simple_statfs,	460	.statfs = simple_statfs,
461	.alloc_inode = bdev_alloc_inode,	461	.alloc_inode = bdev_alloc_inode,
462	.destroy_inode = bdev_destroy_inode,	462	.destroy_inode = bdev_destroy_inode,
463	.drop_inode = generic_delete_inode,	463	.drop_inode = generic_delete_inode,
464	.clear_inode = bdev_clear_inode,	464	.clear_inode = bdev_clear_inode,
465	};	465	};
466		466
467	static int bd_get_sb(struct file_system_type *fs_type,	467	static int bd_get_sb(struct file_system_type *fs_type,
468	int flags, const char dev_name, void data, struct vfsmount *mnt)	468	int flags, const char dev_name, void data, struct vfsmount *mnt)
469	{	469	{
470	return get_sb_pseudo(fs_type, "bdev:", &bdev_sops, 0x62646576, mnt);	470	return get_sb_pseudo(fs_type, "bdev:", &bdev_sops, 0x62646576, mnt);
471	}	471	}
472		472
473	static struct file_system_type bd_type = {	473	static struct file_system_type bd_type = {
474	.name = "bdev",	474	.name = "bdev",
475	.get_sb = bd_get_sb,	475	.get_sb = bd_get_sb,
476	.kill_sb = kill_anon_super,	476	.kill_sb = kill_anon_super,
477	};	477	};
478		478
479	struct super_block *blockdev_superblock __read_mostly;	479	struct super_block *blockdev_superblock __read_mostly;
480		480
481	void __init bdev_cache_init(void)	481	void __init bdev_cache_init(void)
482	{	482	{
483	int err;	483	int err;
484	struct vfsmount *bd_mnt;	484	struct vfsmount *bd_mnt;
485		485
486	bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode),	486	bdev_cachep = kmem_cache_create("bdev_cache", sizeof(struct bdev_inode),
487	0, (SLAB_HWCACHE_ALIGN\|SLAB_RECLAIM_ACCOUNT\|	487	0, (SLAB_HWCACHE_ALIGN\|SLAB_RECLAIM_ACCOUNT\|
488	SLAB_MEM_SPREAD\|SLAB_PANIC),	488	SLAB_MEM_SPREAD\|SLAB_PANIC),
489	init_once);	489	init_once);
490	err = register_filesystem(&bd_type);	490	err = register_filesystem(&bd_type);
491	if (err)	491	if (err)
492	panic("Cannot register bdev pseudo-fs");	492	panic("Cannot register bdev pseudo-fs");
493	bd_mnt = kern_mount(&bd_type);	493	bd_mnt = kern_mount(&bd_type);
494	if (IS_ERR(bd_mnt))	494	if (IS_ERR(bd_mnt))
495	panic("Cannot create bdev pseudo-fs");	495	panic("Cannot create bdev pseudo-fs");
496	/*	496	/*
497	* This vfsmount structure is only used to obtain the	497	* This vfsmount structure is only used to obtain the
498	* blockdev_superblock, so tell kmemleak not to report it.	498	* blockdev_superblock, so tell kmemleak not to report it.
499	*/	499	*/
500	kmemleak_not_leak(bd_mnt);	500	kmemleak_not_leak(bd_mnt);
501	blockdev_superblock = bd_mnt->mnt_sb; /* For writeback */	501	blockdev_superblock = bd_mnt->mnt_sb; /* For writeback */
502	}	502	}
503		503
504	/*	504	/*
505	* Most likely _very_ bad one - but then it's hardly critical for small	505	* Most likely _very_ bad one - but then it's hardly critical for small
506	* /dev and can be fixed when somebody will need really large one.	506	* /dev and can be fixed when somebody will need really large one.
507	* Keep in mind that it will be fed through icache hash function too.	507	* Keep in mind that it will be fed through icache hash function too.
508	*/	508	*/
509	static inline unsigned long hash(dev_t dev)	509	static inline unsigned long hash(dev_t dev)
510	{	510	{
511	return MAJOR(dev)+MINOR(dev);	511	return MAJOR(dev)+MINOR(dev);
512	}	512	}
513		513
514	static int bdev_test(struct inode inode, void data)	514	static int bdev_test(struct inode inode, void data)
515	{	515	{
516	return BDEV_I(inode)->bdev.bd_dev == (dev_t )data;	516	return BDEV_I(inode)->bdev.bd_dev == (dev_t )data;
517	}	517	}
518		518
519	static int bdev_set(struct inode inode, void data)	519	static int bdev_set(struct inode inode, void data)
520	{	520	{
521	BDEV_I(inode)->bdev.bd_dev = (dev_t )data;	521	BDEV_I(inode)->bdev.bd_dev = (dev_t )data;
522	return 0;	522	return 0;
523	}	523	}
524		524
525	static LIST_HEAD(all_bdevs);	525	static LIST_HEAD(all_bdevs);
526		526
527	struct block_device *bdget(dev_t dev)	527	struct block_device *bdget(dev_t dev)
528	{	528	{
529	struct block_device *bdev;	529	struct block_device *bdev;
530	struct inode *inode;	530	struct inode *inode;
531		531
532	inode = iget5_locked(blockdev_superblock, hash(dev),	532	inode = iget5_locked(blockdev_superblock, hash(dev),
533	bdev_test, bdev_set, &dev);	533	bdev_test, bdev_set, &dev);
534		534
535	if (!inode)	535	if (!inode)
536	return NULL;	536	return NULL;
537		537
538	bdev = &BDEV_I(inode)->bdev;	538	bdev = &BDEV_I(inode)->bdev;
539		539
540	if (inode->i_state & I_NEW) {	540	if (inode->i_state & I_NEW) {
541	bdev->bd_contains = NULL;	541	bdev->bd_contains = NULL;
542	bdev->bd_inode = inode;	542	bdev->bd_inode = inode;
543	bdev->bd_block_size = (1 << inode->i_blkbits);	543	bdev->bd_block_size = (1 << inode->i_blkbits);
544	bdev->bd_part_count = 0;	544	bdev->bd_part_count = 0;
545	bdev->bd_invalidated = 0;	545	bdev->bd_invalidated = 0;
546	inode->i_mode = S_IFBLK;	546	inode->i_mode = S_IFBLK;
547	inode->i_rdev = dev;	547	inode->i_rdev = dev;
548	inode->i_bdev = bdev;	548	inode->i_bdev = bdev;
549	inode->i_data.a_ops = &def_blk_aops;	549	inode->i_data.a_ops = &def_blk_aops;
550	mapping_set_gfp_mask(&inode->i_data, GFP_USER);	550	mapping_set_gfp_mask(&inode->i_data, GFP_USER);
551	inode->i_data.backing_dev_info = &default_backing_dev_info;	551	inode->i_data.backing_dev_info = &default_backing_dev_info;
552	spin_lock(&bdev_lock);	552	spin_lock(&bdev_lock);
553	list_add(&bdev->bd_list, &all_bdevs);	553	list_add(&bdev->bd_list, &all_bdevs);
554	spin_unlock(&bdev_lock);	554	spin_unlock(&bdev_lock);
555	unlock_new_inode(inode);	555	unlock_new_inode(inode);
556	}	556	}
557	return bdev;	557	return bdev;
558	}	558	}
559		559
560	EXPORT_SYMBOL(bdget);	560	EXPORT_SYMBOL(bdget);
561		561
562	long nr_blockdev_pages(void)	562	long nr_blockdev_pages(void)
563	{	563	{
564	struct block_device *bdev;	564	struct block_device *bdev;
565	long ret = 0;	565	long ret = 0;
566	spin_lock(&bdev_lock);	566	spin_lock(&bdev_lock);
567	list_for_each_entry(bdev, &all_bdevs, bd_list) {	567	list_for_each_entry(bdev, &all_bdevs, bd_list) {
568	ret += bdev->bd_inode->i_mapping->nrpages;	568	ret += bdev->bd_inode->i_mapping->nrpages;
569	}	569	}
570	spin_unlock(&bdev_lock);	570	spin_unlock(&bdev_lock);
571	return ret;	571	return ret;
572	}	572	}
573		573
574	void bdput(struct block_device *bdev)	574	void bdput(struct block_device *bdev)
575	{	575	{
576	iput(bdev->bd_inode);	576	iput(bdev->bd_inode);
577	}	577	}
578		578
579	EXPORT_SYMBOL(bdput);	579	EXPORT_SYMBOL(bdput);
580		580
581	static struct block_device bd_acquire(struct inode inode)	581	static struct block_device bd_acquire(struct inode inode)
582	{	582	{
583	struct block_device *bdev;	583	struct block_device *bdev;
584		584
585	spin_lock(&bdev_lock);	585	spin_lock(&bdev_lock);
586	bdev = inode->i_bdev;	586	bdev = inode->i_bdev;
587	if (bdev) {	587	if (bdev) {
588	atomic_inc(&bdev->bd_inode->i_count);	588	atomic_inc(&bdev->bd_inode->i_count);
589	spin_unlock(&bdev_lock);	589	spin_unlock(&bdev_lock);
590	return bdev;	590	return bdev;
591	}	591	}
592	spin_unlock(&bdev_lock);	592	spin_unlock(&bdev_lock);
593		593
594	bdev = bdget(inode->i_rdev);	594	bdev = bdget(inode->i_rdev);
595	if (bdev) {	595	if (bdev) {
596	spin_lock(&bdev_lock);	596	spin_lock(&bdev_lock);
597	if (!inode->i_bdev) {	597	if (!inode->i_bdev) {
598	/*	598	/*
599	* We take an additional bd_inode->i_count for inode,	599	* We take an additional bd_inode->i_count for inode,
600	* and it's released in clear_inode() of inode.	600	* and it's released in clear_inode() of inode.
601	* So, we can access it via ->i_mapping always	601	* So, we can access it via ->i_mapping always
602	* without igrab().	602	* without igrab().
603	*/	603	*/
604	atomic_inc(&bdev->bd_inode->i_count);	604	atomic_inc(&bdev->bd_inode->i_count);
605	inode->i_bdev = bdev;	605	inode->i_bdev = bdev;
606	inode->i_mapping = bdev->bd_inode->i_mapping;	606	inode->i_mapping = bdev->bd_inode->i_mapping;
607	list_add(&inode->i_devices, &bdev->bd_inodes);	607	list_add(&inode->i_devices, &bdev->bd_inodes);
608	}	608	}
609	spin_unlock(&bdev_lock);	609	spin_unlock(&bdev_lock);
610	}	610	}
611	return bdev;	611	return bdev;
612	}	612	}
613		613
614	/* Call when you free inode */	614	/* Call when you free inode */
615		615
616	void bd_forget(struct inode *inode)	616	void bd_forget(struct inode *inode)
617	{	617	{
618	struct block_device *bdev = NULL;	618	struct block_device *bdev = NULL;
619		619
620	spin_lock(&bdev_lock);	620	spin_lock(&bdev_lock);
621	if (inode->i_bdev) {	621	if (inode->i_bdev) {
622	if (!sb_is_blkdev_sb(inode->i_sb))	622	if (!sb_is_blkdev_sb(inode->i_sb))
623	bdev = inode->i_bdev;	623	bdev = inode->i_bdev;
624	__bd_forget(inode);	624	__bd_forget(inode);
625	}	625	}
626	spin_unlock(&bdev_lock);	626	spin_unlock(&bdev_lock);
627		627
628	if (bdev)	628	if (bdev)
629	iput(bdev->bd_inode);	629	iput(bdev->bd_inode);
630	}	630	}
631		631
632	int bd_claim(struct block_device bdev, void holder)	632	int bd_claim(struct block_device bdev, void holder)
633	{	633	{
634	int res;	634	int res;
635	spin_lock(&bdev_lock);	635	spin_lock(&bdev_lock);
636		636
637	/* first decide result */	637	/* first decide result */
638	if (bdev->bd_holder == holder)	638	if (bdev->bd_holder == holder)
639	res = 0; /* already a holder */	639	res = 0; /* already a holder */
640	else if (bdev->bd_holder != NULL)	640	else if (bdev->bd_holder != NULL)
641	res = -EBUSY; /* held by someone else */	641	res = -EBUSY; /* held by someone else */
642	else if (bdev->bd_contains == bdev)	642	else if (bdev->bd_contains == bdev)
643	res = 0; /* is a whole device which isn't held */	643	res = 0; /* is a whole device which isn't held */
644		644
645	else if (bdev->bd_contains->bd_holder == bd_claim)	645	else if (bdev->bd_contains->bd_holder == bd_claim)
646	res = 0; /* is a partition of a device that is being partitioned */	646	res = 0; /* is a partition of a device that is being partitioned */
647	else if (bdev->bd_contains->bd_holder != NULL)	647	else if (bdev->bd_contains->bd_holder != NULL)
648	res = -EBUSY; /* is a partition of a held device */	648	res = -EBUSY; /* is a partition of a held device */
649	else	649	else
650	res = 0; /* is a partition of an un-held device */	650	res = 0; /* is a partition of an un-held device */
651		651
652	/* now impose change */	652	/* now impose change */
653	if (res==0) {	653	if (res==0) {
654	/* note that for a whole device bd_holders	654	/* note that for a whole device bd_holders
655	* will be incremented twice, and bd_holder will	655	* will be incremented twice, and bd_holder will
656	* be set to bd_claim before being set to holder	656	* be set to bd_claim before being set to holder
657	*/	657	*/
658	bdev->bd_contains->bd_holders ++;	658	bdev->bd_contains->bd_holders ++;
659	bdev->bd_contains->bd_holder = bd_claim;	659	bdev->bd_contains->bd_holder = bd_claim;
660	bdev->bd_holders++;	660	bdev->bd_holders++;
661	bdev->bd_holder = holder;	661	bdev->bd_holder = holder;
662	}	662	}
663	spin_unlock(&bdev_lock);	663	spin_unlock(&bdev_lock);
664	return res;	664	return res;
665	}	665	}
666		666
667	EXPORT_SYMBOL(bd_claim);	667	EXPORT_SYMBOL(bd_claim);
668		668
669	void bd_release(struct block_device *bdev)	669	void bd_release(struct block_device *bdev)
670	{	670	{
671	spin_lock(&bdev_lock);	671	spin_lock(&bdev_lock);
672	if (!--bdev->bd_contains->bd_holders)	672	if (!--bdev->bd_contains->bd_holders)
673	bdev->bd_contains->bd_holder = NULL;	673	bdev->bd_contains->bd_holder = NULL;
674	if (!--bdev->bd_holders)	674	if (!--bdev->bd_holders)
675	bdev->bd_holder = NULL;	675	bdev->bd_holder = NULL;
676	spin_unlock(&bdev_lock);	676	spin_unlock(&bdev_lock);
677	}	677	}
678		678
679	EXPORT_SYMBOL(bd_release);	679	EXPORT_SYMBOL(bd_release);
680		680
681	#ifdef CONFIG_SYSFS	681	#ifdef CONFIG_SYSFS
682	/*	682	/*
683	* Functions for bd_claim_by_kobject / bd_release_from_kobject	683	* Functions for bd_claim_by_kobject / bd_release_from_kobject
684	*	684	*
685	* If a kobject is passed to bd_claim_by_kobject()	685	* If a kobject is passed to bd_claim_by_kobject()
686	* and the kobject has a parent directory,	686	* and the kobject has a parent directory,
687	* following symlinks are created:	687	* following symlinks are created:
688	* o from the kobject to the claimed bdev	688	* o from the kobject to the claimed bdev
689	* o from "holders" directory of the bdev to the parent of the kobject	689	* o from "holders" directory of the bdev to the parent of the kobject
690	* bd_release_from_kobject() removes these symlinks.	690	* bd_release_from_kobject() removes these symlinks.
691	*	691	*
692	* Example:	692	* Example:
693	* If /dev/dm-0 maps to /dev/sda, kobject corresponding to	693	* If /dev/dm-0 maps to /dev/sda, kobject corresponding to
694	* /sys/block/dm-0/slaves is passed to bd_claim_by_kobject(), then:	694	* /sys/block/dm-0/slaves is passed to bd_claim_by_kobject(), then:
695	* /sys/block/dm-0/slaves/sda --> /sys/block/sda	695	* /sys/block/dm-0/slaves/sda --> /sys/block/sda
696	* /sys/block/sda/holders/dm-0 --> /sys/block/dm-0	696	* /sys/block/sda/holders/dm-0 --> /sys/block/dm-0
697	*/	697	*/
698		698
699	static int add_symlink(struct kobject from, struct kobject to)	699	static int add_symlink(struct kobject from, struct kobject to)
700	{	700	{
701	if (!from \|\| !to)	701	if (!from \|\| !to)
702	return 0;	702	return 0;
703	return sysfs_create_link(from, to, kobject_name(to));	703	return sysfs_create_link(from, to, kobject_name(to));
704	}	704	}
705		705
706	static void del_symlink(struct kobject from, struct kobject to)	706	static void del_symlink(struct kobject from, struct kobject to)
707	{	707	{
708	if (!from \|\| !to)	708	if (!from \|\| !to)
709	return;	709	return;
710	sysfs_remove_link(from, kobject_name(to));	710	sysfs_remove_link(from, kobject_name(to));
711	}	711	}
712		712
713	/*	713	/*
714	* 'struct bd_holder' contains pointers to kobjects symlinked by	714	* 'struct bd_holder' contains pointers to kobjects symlinked by
715	* bd_claim_by_kobject.	715	* bd_claim_by_kobject.
716	* It's connected to bd_holder_list which is protected by bdev->bd_sem.	716	* It's connected to bd_holder_list which is protected by bdev->bd_sem.
717	*/	717	*/
718	struct bd_holder {	718	struct bd_holder {
719	struct list_head list; /* chain of holders of the bdev */	719	struct list_head list; /* chain of holders of the bdev */
720	int count; /* references from the holder */	720	int count; /* references from the holder */
721	struct kobject sdir; / holder object, e.g. "/block/dm-0/slaves" */	721	struct kobject sdir; / holder object, e.g. "/block/dm-0/slaves" */
722	struct kobject hdev; / e.g. "/block/dm-0" */	722	struct kobject hdev; / e.g. "/block/dm-0" */
723	struct kobject hdir; / e.g. "/block/sda/holders" */	723	struct kobject hdir; / e.g. "/block/sda/holders" */
724	struct kobject sdev; / e.g. "/block/sda" */	724	struct kobject sdev; / e.g. "/block/sda" */
725	};	725	};
726		726
727	/*	727	/*
728	* Get references of related kobjects at once.	728	* Get references of related kobjects at once.
729	* Returns 1 on success. 0 on failure.	729	* Returns 1 on success. 0 on failure.
730	*	730	*
731	* Should call bd_holder_release_dirs() after successful use.	731	* Should call bd_holder_release_dirs() after successful use.
732	*/	732	*/
733	static int bd_holder_grab_dirs(struct block_device *bdev,	733	static int bd_holder_grab_dirs(struct block_device *bdev,
734	struct bd_holder *bo)	734	struct bd_holder *bo)
735	{	735	{
736	if (!bdev \|\| !bo)	736	if (!bdev \|\| !bo)
737	return 0;	737	return 0;
738		738
739	bo->sdir = kobject_get(bo->sdir);	739	bo->sdir = kobject_get(bo->sdir);
740	if (!bo->sdir)	740	if (!bo->sdir)
741	return 0;	741	return 0;
742		742
743	bo->hdev = kobject_get(bo->sdir->parent);	743	bo->hdev = kobject_get(bo->sdir->parent);
744	if (!bo->hdev)	744	if (!bo->hdev)
745	goto fail_put_sdir;	745	goto fail_put_sdir;
746		746
747	bo->sdev = kobject_get(&part_to_dev(bdev->bd_part)->kobj);	747	bo->sdev = kobject_get(&part_to_dev(bdev->bd_part)->kobj);
748	if (!bo->sdev)	748	if (!bo->sdev)
749	goto fail_put_hdev;	749	goto fail_put_hdev;
750		750
751	bo->hdir = kobject_get(bdev->bd_part->holder_dir);	751	bo->hdir = kobject_get(bdev->bd_part->holder_dir);
752	if (!bo->hdir)	752	if (!bo->hdir)
753	goto fail_put_sdev;	753	goto fail_put_sdev;
754		754
755	return 1;	755	return 1;
756		756
757	fail_put_sdev:	757	fail_put_sdev:
758	kobject_put(bo->sdev);	758	kobject_put(bo->sdev);
759	fail_put_hdev:	759	fail_put_hdev:
760	kobject_put(bo->hdev);	760	kobject_put(bo->hdev);
761	fail_put_sdir:	761	fail_put_sdir:
762	kobject_put(bo->sdir);	762	kobject_put(bo->sdir);
763		763
764	return 0;	764	return 0;
765	}	765	}
766		766
767	/* Put references of related kobjects at once. */	767	/* Put references of related kobjects at once. */
768	static void bd_holder_release_dirs(struct bd_holder *bo)	768	static void bd_holder_release_dirs(struct bd_holder *bo)
769	{	769	{
770	kobject_put(bo->hdir);	770	kobject_put(bo->hdir);
771	kobject_put(bo->sdev);	771	kobject_put(bo->sdev);
772	kobject_put(bo->hdev);	772	kobject_put(bo->hdev);
773	kobject_put(bo->sdir);	773	kobject_put(bo->sdir);
774	}	774	}
775		775
776	static struct bd_holder alloc_bd_holder(struct kobject kobj)	776	static struct bd_holder alloc_bd_holder(struct kobject kobj)
777	{	777	{
778	struct bd_holder *bo;	778	struct bd_holder *bo;
779		779
780	bo = kzalloc(sizeof(*bo), GFP_KERNEL);	780	bo = kzalloc(sizeof(*bo), GFP_KERNEL);
781	if (!bo)	781	if (!bo)
782	return NULL;	782	return NULL;
783		783
784	bo->count = 1;	784	bo->count = 1;
785	bo->sdir = kobj;	785	bo->sdir = kobj;
786		786
787	return bo;	787	return bo;
788	}	788	}
789		789
790	static void free_bd_holder(struct bd_holder *bo)	790	static void free_bd_holder(struct bd_holder *bo)
791	{	791	{
792	kfree(bo);	792	kfree(bo);
793	}	793	}
794		794
795	/**	795	/**
796	* find_bd_holder - find matching struct bd_holder from the block device	796	* find_bd_holder - find matching struct bd_holder from the block device
797	*	797	*
798	* @bdev: struct block device to be searched	798	* @bdev: struct block device to be searched
799	* @bo: target struct bd_holder	799	* @bo: target struct bd_holder
800	*	800	*
801	* Returns matching entry with @bo in @bdev->bd_holder_list.	801	* Returns matching entry with @bo in @bdev->bd_holder_list.
802	* If found, increment the reference count and return the pointer.	802	* If found, increment the reference count and return the pointer.
803	* If not found, returns NULL.	803	* If not found, returns NULL.
804	*/	804	*/
805	static struct bd_holder find_bd_holder(struct block_device bdev,	805	static struct bd_holder find_bd_holder(struct block_device bdev,
806	struct bd_holder *bo)	806	struct bd_holder *bo)
807	{	807	{
808	struct bd_holder *tmp;	808	struct bd_holder *tmp;
809		809
810	list_for_each_entry(tmp, &bdev->bd_holder_list, list)	810	list_for_each_entry(tmp, &bdev->bd_holder_list, list)
811	if (tmp->sdir == bo->sdir) {	811	if (tmp->sdir == bo->sdir) {
812	tmp->count++;	812	tmp->count++;
813	return tmp;	813	return tmp;
814	}	814	}
815		815
816	return NULL;	816	return NULL;
817	}	817	}
818		818
819	/**	819	/**
820	* add_bd_holder - create sysfs symlinks for bd_claim() relationship	820	* add_bd_holder - create sysfs symlinks for bd_claim() relationship
821	*	821	*
822	* @bdev: block device to be bd_claimed	822	* @bdev: block device to be bd_claimed
823	* @bo: preallocated and initialized by alloc_bd_holder()	823	* @bo: preallocated and initialized by alloc_bd_holder()
824	*	824	*
825	* Add @bo to @bdev->bd_holder_list, create symlinks.	825	* Add @bo to @bdev->bd_holder_list, create symlinks.
826	*	826	*
827	* Returns 0 if symlinks are created.	827	* Returns 0 if symlinks are created.
828	* Returns -ve if something fails.	828	* Returns -ve if something fails.
829	*/	829	*/
830	static int add_bd_holder(struct block_device bdev, struct bd_holder bo)	830	static int add_bd_holder(struct block_device bdev, struct bd_holder bo)
831	{	831	{
832	int err;	832	int err;
833		833
834	if (!bo)	834	if (!bo)
835	return -EINVAL;	835	return -EINVAL;
836		836
837	if (!bd_holder_grab_dirs(bdev, bo))	837	if (!bd_holder_grab_dirs(bdev, bo))
838	return -EBUSY;	838	return -EBUSY;
839		839
840	err = add_symlink(bo->sdir, bo->sdev);	840	err = add_symlink(bo->sdir, bo->sdev);
841	if (err)	841	if (err)
842	return err;	842	return err;
843		843
844	err = add_symlink(bo->hdir, bo->hdev);	844	err = add_symlink(bo->hdir, bo->hdev);
845	if (err) {	845	if (err) {
846	del_symlink(bo->sdir, bo->sdev);	846	del_symlink(bo->sdir, bo->sdev);
847	return err;	847	return err;
848	}	848	}
849		849
850	list_add_tail(&bo->list, &bdev->bd_holder_list);	850	list_add_tail(&bo->list, &bdev->bd_holder_list);
851	return 0;	851	return 0;
852	}	852	}
853		853
854	/**	854	/**
855	* del_bd_holder - delete sysfs symlinks for bd_claim() relationship	855	* del_bd_holder - delete sysfs symlinks for bd_claim() relationship
856	*	856	*
857	* @bdev: block device to be bd_claimed	857	* @bdev: block device to be bd_claimed
858	* @kobj: holder's kobject	858	* @kobj: holder's kobject
859	*	859	*
860	* If there is matching entry with @kobj in @bdev->bd_holder_list	860	* If there is matching entry with @kobj in @bdev->bd_holder_list
861	* and no other bd_claim() from the same kobject,	861	* and no other bd_claim() from the same kobject,
862	* remove the struct bd_holder from the list, delete symlinks for it.	862	* remove the struct bd_holder from the list, delete symlinks for it.
863	*	863	*
864	* Returns a pointer to the struct bd_holder when it's removed from the list	864	* Returns a pointer to the struct bd_holder when it's removed from the list
865	* and ready to be freed.	865	* and ready to be freed.
866	* Returns NULL if matching claim isn't found or there is other bd_claim()	866	* Returns NULL if matching claim isn't found or there is other bd_claim()
867	* by the same kobject.	867	* by the same kobject.
868	*/	868	*/
869	static struct bd_holder del_bd_holder(struct block_device bdev,	869	static struct bd_holder del_bd_holder(struct block_device bdev,
870	struct kobject *kobj)	870	struct kobject *kobj)
871	{	871	{
872	struct bd_holder *bo;	872	struct bd_holder *bo;
873		873
874	list_for_each_entry(bo, &bdev->bd_holder_list, list) {	874	list_for_each_entry(bo, &bdev->bd_holder_list, list) {
875	if (bo->sdir == kobj) {	875	if (bo->sdir == kobj) {
876	bo->count--;	876	bo->count--;
877	BUG_ON(bo->count < 0);	877	BUG_ON(bo->count < 0);
878	if (!bo->count) {	878	if (!bo->count) {
879	list_del(&bo->list);	879	list_del(&bo->list);
880	del_symlink(bo->sdir, bo->sdev);	880	del_symlink(bo->sdir, bo->sdev);
881	del_symlink(bo->hdir, bo->hdev);	881	del_symlink(bo->hdir, bo->hdev);
882	bd_holder_release_dirs(bo);	882	bd_holder_release_dirs(bo);
883	return bo;	883	return bo;
884	}	884	}
885	break;	885	break;
886	}	886	}
887	}	887	}
888		888
889	return NULL;	889	return NULL;
890	}	890	}
891		891
892	/**	892	/**
893	* bd_claim_by_kobject - bd_claim() with additional kobject signature	893	* bd_claim_by_kobject - bd_claim() with additional kobject signature
894	*	894	*
895	* @bdev: block device to be claimed	895	* @bdev: block device to be claimed
896	* @holder: holder's signature	896	* @holder: holder's signature
897	* @kobj: holder's kobject	897	* @kobj: holder's kobject
898	*	898	*
899	* Do bd_claim() and if it succeeds, create sysfs symlinks between	899	* Do bd_claim() and if it succeeds, create sysfs symlinks between
900	* the bdev and the holder's kobject.	900	* the bdev and the holder's kobject.
901	* Use bd_release_from_kobject() when relesing the claimed bdev.	901	* Use bd_release_from_kobject() when relesing the claimed bdev.
902	*	902	*
903	* Returns 0 on success. (same as bd_claim())	903	* Returns 0 on success. (same as bd_claim())
904	* Returns errno on failure.	904	* Returns errno on failure.
905	*/	905	*/
906	static int bd_claim_by_kobject(struct block_device bdev, void holder,	906	static int bd_claim_by_kobject(struct block_device bdev, void holder,
907	struct kobject *kobj)	907	struct kobject *kobj)
908	{	908	{
909	int err;	909	int err;
910	struct bd_holder bo, found;	910	struct bd_holder bo, found;
911		911
912	if (!kobj)	912	if (!kobj)
913	return -EINVAL;	913	return -EINVAL;
914		914
915	bo = alloc_bd_holder(kobj);	915	bo = alloc_bd_holder(kobj);
916	if (!bo)	916	if (!bo)
917	return -ENOMEM;	917	return -ENOMEM;
918		918
919	mutex_lock(&bdev->bd_mutex);	919	mutex_lock(&bdev->bd_mutex);
920		920
921	err = bd_claim(bdev, holder);	921	err = bd_claim(bdev, holder);
922	if (err)	922	if (err)
923	goto fail;	923	goto fail;
924		924
925	found = find_bd_holder(bdev, bo);	925	found = find_bd_holder(bdev, bo);
926	if (found)	926	if (found)
927	goto fail;	927	goto fail;
928		928
929	err = add_bd_holder(bdev, bo);	929	err = add_bd_holder(bdev, bo);
930	if (err)	930	if (err)
931	bd_release(bdev);	931	bd_release(bdev);
932	else	932	else
933	bo = NULL;	933	bo = NULL;
934	fail:	934	fail:
935	mutex_unlock(&bdev->bd_mutex);	935	mutex_unlock(&bdev->bd_mutex);
936	free_bd_holder(bo);	936	free_bd_holder(bo);
937	return err;	937	return err;
938	}	938	}
939		939
940	/**	940	/**
941	* bd_release_from_kobject - bd_release() with additional kobject signature	941	* bd_release_from_kobject - bd_release() with additional kobject signature
942	*	942	*
943	* @bdev: block device to be released	943	* @bdev: block device to be released
944	* @kobj: holder's kobject	944	* @kobj: holder's kobject
945	*	945	*
946	* Do bd_release() and remove sysfs symlinks created by bd_claim_by_kobject().	946	* Do bd_release() and remove sysfs symlinks created by bd_claim_by_kobject().
947	*/	947	*/
948	static void bd_release_from_kobject(struct block_device *bdev,	948	static void bd_release_from_kobject(struct block_device *bdev,
949	struct kobject *kobj)	949	struct kobject *kobj)
950	{	950	{
951	if (!kobj)	951	if (!kobj)
952	return;	952	return;
953		953
954	mutex_lock(&bdev->bd_mutex);	954	mutex_lock(&bdev->bd_mutex);
955	bd_release(bdev);	955	bd_release(bdev);
956	free_bd_holder(del_bd_holder(bdev, kobj));	956	free_bd_holder(del_bd_holder(bdev, kobj));
957	mutex_unlock(&bdev->bd_mutex);	957	mutex_unlock(&bdev->bd_mutex);
958	}	958	}
959		959
960	/**	960	/**
961	* bd_claim_by_disk - wrapper function for bd_claim_by_kobject()	961	* bd_claim_by_disk - wrapper function for bd_claim_by_kobject()
962	*	962	*
963	* @bdev: block device to be claimed	963	* @bdev: block device to be claimed
964	* @holder: holder's signature	964	* @holder: holder's signature
965	* @disk: holder's gendisk	965	* @disk: holder's gendisk
966	*	966	*
967	* Call bd_claim_by_kobject() with getting @disk->slave_dir.	967	* Call bd_claim_by_kobject() with getting @disk->slave_dir.
968	*/	968	*/
969	int bd_claim_by_disk(struct block_device bdev, void holder,	969	int bd_claim_by_disk(struct block_device bdev, void holder,
970	struct gendisk *disk)	970	struct gendisk *disk)
971	{	971	{
972	return bd_claim_by_kobject(bdev, holder, kobject_get(disk->slave_dir));	972	return bd_claim_by_kobject(bdev, holder, kobject_get(disk->slave_dir));
973	}	973	}
974	EXPORT_SYMBOL_GPL(bd_claim_by_disk);	974	EXPORT_SYMBOL_GPL(bd_claim_by_disk);
975		975
976	/**	976	/**
977	* bd_release_from_disk - wrapper function for bd_release_from_kobject()	977	* bd_release_from_disk - wrapper function for bd_release_from_kobject()
978	*	978	*
979	* @bdev: block device to be claimed	979	* @bdev: block device to be claimed
980	* @disk: holder's gendisk	980	* @disk: holder's gendisk
981	*	981	*
982	* Call bd_release_from_kobject() and put @disk->slave_dir.	982	* Call bd_release_from_kobject() and put @disk->slave_dir.
983	*/	983	*/
984	void bd_release_from_disk(struct block_device bdev, struct gendisk disk)	984	void bd_release_from_disk(struct block_device bdev, struct gendisk disk)
985	{	985	{
986	bd_release_from_kobject(bdev, disk->slave_dir);	986	bd_release_from_kobject(bdev, disk->slave_dir);
987	kobject_put(disk->slave_dir);	987	kobject_put(disk->slave_dir);
988	}	988	}
989	EXPORT_SYMBOL_GPL(bd_release_from_disk);	989	EXPORT_SYMBOL_GPL(bd_release_from_disk);
990	#endif	990	#endif
991		991
992	/*	992	/*
993	* Tries to open block device by device number. Use it ONLY if you	993	* Tries to open block device by device number. Use it ONLY if you
994	* really do not have anything better - i.e. when you are behind a	994	* really do not have anything better - i.e. when you are behind a
995	* truly sucky interface and all you are given is a device number. _Never_	995	* truly sucky interface and all you are given is a device number. _Never_
996	* to be used for internal purposes. If you ever need it - reconsider	996	* to be used for internal purposes. If you ever need it - reconsider
997	* your API.	997	* your API.
998	*/	998	*/
999	struct block_device *open_by_devnum(dev_t dev, fmode_t mode)	999	struct block_device *open_by_devnum(dev_t dev, fmode_t mode)
1000	{	1000	{
1001	struct block_device *bdev = bdget(dev);	1001	struct block_device *bdev = bdget(dev);
1002	int err = -ENOMEM;	1002	int err = -ENOMEM;
1003	if (bdev)	1003	if (bdev)
1004	err = blkdev_get(bdev, mode);	1004	err = blkdev_get(bdev, mode);
1005	return err ? ERR_PTR(err) : bdev;	1005	return err ? ERR_PTR(err) : bdev;
1006	}	1006	}
1007		1007
1008	EXPORT_SYMBOL(open_by_devnum);	1008	EXPORT_SYMBOL(open_by_devnum);
1009		1009
1010	/**	1010	/**
1011	* flush_disk - invalidates all buffer-cache entries on a disk	1011	* flush_disk - invalidates all buffer-cache entries on a disk
1012	*	1012	*
1013	* @bdev: struct block device to be flushed	1013	* @bdev: struct block device to be flushed
1014	*	1014	*
1015	* Invalidates all buffer-cache entries on a disk. It should be called	1015	* Invalidates all buffer-cache entries on a disk. It should be called
1016	* when a disk has been changed -- either by a media change or online	1016	* when a disk has been changed -- either by a media change or online
1017	* resize.	1017	* resize.
1018	*/	1018	*/
1019	static void flush_disk(struct block_device *bdev)	1019	static void flush_disk(struct block_device *bdev)
1020	{	1020	{
1021	if (__invalidate_device(bdev)) {	1021	if (__invalidate_device(bdev)) {
1022	char name[BDEVNAME_SIZE] = "";	1022	char name[BDEVNAME_SIZE] = "";
1023		1023
1024	if (bdev->bd_disk)	1024	if (bdev->bd_disk)
1025	disk_name(bdev->bd_disk, 0, name);	1025	disk_name(bdev->bd_disk, 0, name);
1026	printk(KERN_WARNING "VFS: busy inodes on changed media or "	1026	printk(KERN_WARNING "VFS: busy inodes on changed media or "
1027	"resized disk %s\n", name);	1027	"resized disk %s\n", name);
1028	}	1028	}
1029		1029
1030	if (!bdev->bd_disk)	1030	if (!bdev->bd_disk)
1031	return;	1031	return;
1032	if (disk_partitionable(bdev->bd_disk))	1032	if (disk_partitionable(bdev->bd_disk))
1033	bdev->bd_invalidated = 1;	1033	bdev->bd_invalidated = 1;
1034	}	1034	}
1035		1035
1036	/**	1036	/**
1037	* check_disk_size_change - checks for disk size change and adjusts bdev size.	1037	* check_disk_size_change - checks for disk size change and adjusts bdev size.
1038	* @disk: struct gendisk to check	1038	* @disk: struct gendisk to check
1039	* @bdev: struct bdev to adjust.	1039	* @bdev: struct bdev to adjust.
1040	*	1040	*
1041	* This routine checks to see if the bdev size does not match the disk size	1041	* This routine checks to see if the bdev size does not match the disk size
1042	* and adjusts it if it differs.	1042	* and adjusts it if it differs.
1043	*/	1043	*/
1044	void check_disk_size_change(struct gendisk disk, struct block_device bdev)	1044	void check_disk_size_change(struct gendisk disk, struct block_device bdev)
1045	{	1045	{
1046	loff_t disk_size, bdev_size;	1046	loff_t disk_size, bdev_size;
1047		1047
1048	disk_size = (loff_t)get_capacity(disk) << 9;	1048	disk_size = (loff_t)get_capacity(disk) << 9;
1049	bdev_size = i_size_read(bdev->bd_inode);	1049	bdev_size = i_size_read(bdev->bd_inode);
1050	if (disk_size != bdev_size) {	1050	if (disk_size != bdev_size) {
1051	char name[BDEVNAME_SIZE];	1051	char name[BDEVNAME_SIZE];
1052		1052
1053	disk_name(disk, 0, name);	1053	disk_name(disk, 0, name);
1054	printk(KERN_INFO	1054	printk(KERN_INFO
1055	"%s: detected capacity change from %lld to %lld\n",	1055	"%s: detected capacity change from %lld to %lld\n",
1056	name, bdev_size, disk_size);	1056	name, bdev_size, disk_size);
1057	i_size_write(bdev->bd_inode, disk_size);	1057	i_size_write(bdev->bd_inode, disk_size);
1058	flush_disk(bdev);	1058	flush_disk(bdev);
1059	}	1059	}
1060	}	1060	}
1061	EXPORT_SYMBOL(check_disk_size_change);	1061	EXPORT_SYMBOL(check_disk_size_change);
1062		1062
1063	/**	1063	/**
1064	* revalidate_disk - wrapper for lower-level driver's revalidate_disk call-back	1064	* revalidate_disk - wrapper for lower-level driver's revalidate_disk call-back
1065	* @disk: struct gendisk to be revalidated	1065	* @disk: struct gendisk to be revalidated
1066	*	1066	*
1067	* This routine is a wrapper for lower-level driver's revalidate_disk	1067	* This routine is a wrapper for lower-level driver's revalidate_disk
1068	* call-backs. It is used to do common pre and post operations needed	1068	* call-backs. It is used to do common pre and post operations needed
1069	* for all revalidate_disk operations.	1069	* for all revalidate_disk operations.
1070	*/	1070	*/
1071	int revalidate_disk(struct gendisk *disk)	1071	int revalidate_disk(struct gendisk *disk)
1072	{	1072	{
1073	struct block_device *bdev;	1073	struct block_device *bdev;
1074	int ret = 0;	1074	int ret = 0;
1075		1075
1076	if (disk->fops->revalidate_disk)	1076	if (disk->fops->revalidate_disk)
1077	ret = disk->fops->revalidate_disk(disk);	1077	ret = disk->fops->revalidate_disk(disk);
1078		1078
1079	bdev = bdget_disk(disk, 0);	1079	bdev = bdget_disk(disk, 0);
1080	if (!bdev)	1080	if (!bdev)
1081	return ret;	1081	return ret;
1082		1082
1083	mutex_lock(&bdev->bd_mutex);	1083	mutex_lock(&bdev->bd_mutex);
1084	check_disk_size_change(disk, bdev);	1084	check_disk_size_change(disk, bdev);
1085	mutex_unlock(&bdev->bd_mutex);	1085	mutex_unlock(&bdev->bd_mutex);
1086	bdput(bdev);	1086	bdput(bdev);
1087	return ret;	1087	return ret;
1088	}	1088	}
1089	EXPORT_SYMBOL(revalidate_disk);	1089	EXPORT_SYMBOL(revalidate_disk);
1090		1090
1091	/*	1091	/*
1092	* This routine checks whether a removable media has been changed,	1092	* This routine checks whether a removable media has been changed,
1093	* and invalidates all buffer-cache-entries in that case. This	1093	* and invalidates all buffer-cache-entries in that case. This
1094	* is a relatively slow routine, so we have to try to minimize using	1094	* is a relatively slow routine, so we have to try to minimize using
1095	* it. Thus it is called only upon a 'mount' or 'open'. This	1095	* it. Thus it is called only upon a 'mount' or 'open'. This
1096	* is the best way of combining speed and utility, I think.	1096	* is the best way of combining speed and utility, I think.
1097	* People changing diskettes in the middle of an operation deserve	1097	* People changing diskettes in the middle of an operation deserve
1098	* to lose :-)	1098	* to lose :-)
1099	*/	1099	*/
1100	int check_disk_change(struct block_device *bdev)	1100	int check_disk_change(struct block_device *bdev)
1101	{	1101	{
1102	struct gendisk *disk = bdev->bd_disk;	1102	struct gendisk *disk = bdev->bd_disk;
1103	struct block_device_operations * bdops = disk->fops;	1103	struct block_device_operations * bdops = disk->fops;
1104		1104
1105	if (!bdops->media_changed)	1105	if (!bdops->media_changed)
1106	return 0;	1106	return 0;
1107	if (!bdops->media_changed(bdev->bd_disk))	1107	if (!bdops->media_changed(bdev->bd_disk))
1108	return 0;	1108	return 0;
1109		1109
1110	flush_disk(bdev);	1110	flush_disk(bdev);
1111	if (bdops->revalidate_disk)	1111	if (bdops->revalidate_disk)
1112	bdops->revalidate_disk(bdev->bd_disk);	1112	bdops->revalidate_disk(bdev->bd_disk);
1113	return 1;	1113	return 1;
1114	}	1114	}
1115		1115
1116	EXPORT_SYMBOL(check_disk_change);	1116	EXPORT_SYMBOL(check_disk_change);
1117		1117
1118	void bd_set_size(struct block_device *bdev, loff_t size)	1118	void bd_set_size(struct block_device *bdev, loff_t size)
1119	{	1119	{
1120	unsigned bsize = bdev_logical_block_size(bdev);	1120	unsigned bsize = bdev_logical_block_size(bdev);
1121		1121
1122	bdev->bd_inode->i_size = size;	1122	bdev->bd_inode->i_size = size;
1123	while (bsize < PAGE_CACHE_SIZE) {	1123	while (bsize < PAGE_CACHE_SIZE) {
1124	if (size & bsize)	1124	if (size & bsize)
1125	break;	1125	break;
1126	bsize <<= 1;	1126	bsize <<= 1;
1127	}	1127	}
1128	bdev->bd_block_size = bsize;	1128	bdev->bd_block_size = bsize;
1129	bdev->bd_inode->i_blkbits = blksize_bits(bsize);	1129	bdev->bd_inode->i_blkbits = blksize_bits(bsize);
1130	}	1130	}
1131	EXPORT_SYMBOL(bd_set_size);	1131	EXPORT_SYMBOL(bd_set_size);
1132		1132
1133	static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part);	1133	static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part);
1134		1134
1135	/*	1135	/*
1136	* bd_mutex locking:	1136	* bd_mutex locking:
1137	*	1137	*
1138	* mutex_lock(part->bd_mutex)	1138	* mutex_lock(part->bd_mutex)
1139	* mutex_lock_nested(whole->bd_mutex, 1)	1139	* mutex_lock_nested(whole->bd_mutex, 1)
1140	*/	1140	*/
1141		1141
1142	static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)	1142	static int __blkdev_get(struct block_device *bdev, fmode_t mode, int for_part)
1143	{	1143	{
1144	struct gendisk *disk;	1144	struct gendisk *disk;
1145	int ret;	1145	int ret;
1146	int partno;	1146	int partno;
1147	int perm = 0;	1147	int perm = 0;
1148		1148
1149	if (mode & FMODE_READ)	1149	if (mode & FMODE_READ)
1150	perm \|= MAY_READ;	1150	perm \|= MAY_READ;
1151	if (mode & FMODE_WRITE)	1151	if (mode & FMODE_WRITE)
1152	perm \|= MAY_WRITE;	1152	perm \|= MAY_WRITE;
1153	/*	1153	/*
1154	* hooks: /n/, see "layering violations".	1154	* hooks: /n/, see "layering violations".
1155	*/	1155	*/
1156	ret = devcgroup_inode_permission(bdev->bd_inode, perm);	1156	ret = devcgroup_inode_permission(bdev->bd_inode, perm);
1157	if (ret != 0) {	1157	if (ret != 0) {
1158	bdput(bdev);	1158	bdput(bdev);
1159	return ret;	1159	return ret;
1160	}	1160	}
1161		1161
1162	lock_kernel();	1162	lock_kernel();
1163	restart:	1163	restart:
1164		1164
1165	ret = -ENXIO;	1165	ret = -ENXIO;
1166	disk = get_gendisk(bdev->bd_dev, &partno);	1166	disk = get_gendisk(bdev->bd_dev, &partno);
1167	if (!disk)	1167	if (!disk)
1168	goto out_unlock_kernel;	1168	goto out_unlock_kernel;
1169		1169
1170	mutex_lock_nested(&bdev->bd_mutex, for_part);	1170	mutex_lock_nested(&bdev->bd_mutex, for_part);
1171	if (!bdev->bd_openers) {	1171	if (!bdev->bd_openers) {
1172	bdev->bd_disk = disk;	1172	bdev->bd_disk = disk;
1173	bdev->bd_contains = bdev;	1173	bdev->bd_contains = bdev;
1174	if (!partno) {	1174	if (!partno) {
1175	struct backing_dev_info *bdi;	1175	struct backing_dev_info *bdi;
1176		1176
1177	ret = -ENXIO;	1177	ret = -ENXIO;
1178	bdev->bd_part = disk_get_part(disk, partno);	1178	bdev->bd_part = disk_get_part(disk, partno);
1179	if (!bdev->bd_part)	1179	if (!bdev->bd_part)
1180	goto out_clear;	1180	goto out_clear;
1181		1181
1182	if (disk->fops->open) {	1182	if (disk->fops->open) {
1183	ret = disk->fops->open(bdev, mode);	1183	ret = disk->fops->open(bdev, mode);
1184	if (ret == -ERESTARTSYS) {	1184	if (ret == -ERESTARTSYS) {
1185	/* Lost a race with 'disk' being	1185	/* Lost a race with 'disk' being
1186	* deleted, try again.	1186	* deleted, try again.
1187	* See md.c	1187	* See md.c
1188	*/	1188	*/
1189	disk_put_part(bdev->bd_part);	1189	disk_put_part(bdev->bd_part);
1190	bdev->bd_part = NULL;	1190	bdev->bd_part = NULL;
1191	module_put(disk->fops->owner);	1191	module_put(disk->fops->owner);
1192	put_disk(disk);	1192	put_disk(disk);
1193	bdev->bd_disk = NULL;	1193	bdev->bd_disk = NULL;
1194	mutex_unlock(&bdev->bd_mutex);	1194	mutex_unlock(&bdev->bd_mutex);
1195	goto restart;	1195	goto restart;
1196	}	1196	}
1197	if (ret)	1197	if (ret)
1198	goto out_clear;	1198	goto out_clear;
1199	}	1199	}
1200	if (!bdev->bd_openers) {	1200	if (!bdev->bd_openers) {
1201	bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);	1201	bd_set_size(bdev,(loff_t)get_capacity(disk)<<9);
1202	bdi = blk_get_backing_dev_info(bdev);	1202	bdi = blk_get_backing_dev_info(bdev);
1203	if (bdi == NULL)	1203	if (bdi == NULL)
1204	bdi = &default_backing_dev_info;	1204	bdi = &default_backing_dev_info;
1205	bdev->bd_inode->i_data.backing_dev_info = bdi;	1205	bdev->bd_inode->i_data.backing_dev_info = bdi;
1206	}	1206	}
1207	if (bdev->bd_invalidated)	1207	if (bdev->bd_invalidated)
1208	rescan_partitions(disk, bdev);	1208	rescan_partitions(disk, bdev);
1209	} else {	1209	} else {
1210	struct block_device *whole;	1210	struct block_device *whole;
1211	whole = bdget_disk(disk, 0);	1211	whole = bdget_disk(disk, 0);
1212	ret = -ENOMEM;	1212	ret = -ENOMEM;
1213	if (!whole)	1213	if (!whole)
1214	goto out_clear;	1214	goto out_clear;
1215	BUG_ON(for_part);	1215	BUG_ON(for_part);
1216	ret = __blkdev_get(whole, mode, 1);	1216	ret = __blkdev_get(whole, mode, 1);
1217	if (ret)	1217	if (ret)
1218	goto out_clear;	1218	goto out_clear;
1219	bdev->bd_contains = whole;	1219	bdev->bd_contains = whole;
1220	bdev->bd_inode->i_data.backing_dev_info =	1220	bdev->bd_inode->i_data.backing_dev_info =
1221	whole->bd_inode->i_data.backing_dev_info;	1221	whole->bd_inode->i_data.backing_dev_info;
1222	bdev->bd_part = disk_get_part(disk, partno);	1222	bdev->bd_part = disk_get_part(disk, partno);
1223	if (!(disk->flags & GENHD_FL_UP) \|\|	1223	if (!(disk->flags & GENHD_FL_UP) \|\|
1224	!bdev->bd_part \|\| !bdev->bd_part->nr_sects) {	1224	!bdev->bd_part \|\| !bdev->bd_part->nr_sects) {
1225	ret = -ENXIO;	1225	ret = -ENXIO;
1226	goto out_clear;	1226	goto out_clear;
1227	}	1227	}
1228	bd_set_size(bdev, (loff_t)bdev->bd_part->nr_sects << 9);	1228	bd_set_size(bdev, (loff_t)bdev->bd_part->nr_sects << 9);
1229	}	1229	}
1230	} else {	1230	} else {
1231	put_disk(disk);	1231	put_disk(disk);
1232	module_put(disk->fops->owner);	1232	module_put(disk->fops->owner);
1233	disk = NULL;	1233	disk = NULL;
1234	if (bdev->bd_contains == bdev) {	1234	if (bdev->bd_contains == bdev) {
1235	if (bdev->bd_disk->fops->open) {	1235	if (bdev->bd_disk->fops->open) {
1236	ret = bdev->bd_disk->fops->open(bdev, mode);	1236	ret = bdev->bd_disk->fops->open(bdev, mode);
1237	if (ret)	1237	if (ret)
1238	goto out_unlock_bdev;	1238	goto out_unlock_bdev;
1239	}	1239	}
1240	if (bdev->bd_invalidated)	1240	if (bdev->bd_invalidated)
1241	rescan_partitions(bdev->bd_disk, bdev);	1241	rescan_partitions(bdev->bd_disk, bdev);
1242	}	1242	}
1243	}	1243	}
1244	bdev->bd_openers++;	1244	bdev->bd_openers++;
1245	if (for_part)	1245	if (for_part)
1246	bdev->bd_part_count++;	1246	bdev->bd_part_count++;
1247	mutex_unlock(&bdev->bd_mutex);	1247	mutex_unlock(&bdev->bd_mutex);
1248	unlock_kernel();	1248	unlock_kernel();
1249	return 0;	1249	return 0;
1250		1250
1251	out_clear:	1251	out_clear:
1252	disk_put_part(bdev->bd_part);	1252	disk_put_part(bdev->bd_part);
1253	bdev->bd_disk = NULL;	1253	bdev->bd_disk = NULL;
1254	bdev->bd_part = NULL;	1254	bdev->bd_part = NULL;
1255	bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;	1255	bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
1256	if (bdev != bdev->bd_contains)	1256	if (bdev != bdev->bd_contains)
1257	__blkdev_put(bdev->bd_contains, mode, 1);	1257	__blkdev_put(bdev->bd_contains, mode, 1);
1258	bdev->bd_contains = NULL;	1258	bdev->bd_contains = NULL;
1259	out_unlock_bdev:	1259	out_unlock_bdev:
1260	mutex_unlock(&bdev->bd_mutex);	1260	mutex_unlock(&bdev->bd_mutex);
1261	out_unlock_kernel:	1261	out_unlock_kernel:
1262	unlock_kernel();	1262	unlock_kernel();
1263		1263
1264	if (disk)	1264	if (disk)
1265	module_put(disk->fops->owner);	1265	module_put(disk->fops->owner);
1266	put_disk(disk);	1266	put_disk(disk);
1267	bdput(bdev);	1267	bdput(bdev);
1268		1268
1269	return ret;	1269	return ret;
1270	}	1270	}
1271		1271
1272	int blkdev_get(struct block_device *bdev, fmode_t mode)	1272	int blkdev_get(struct block_device *bdev, fmode_t mode)
1273	{	1273	{
1274	return __blkdev_get(bdev, mode, 0);	1274	return __blkdev_get(bdev, mode, 0);
1275	}	1275	}
1276	EXPORT_SYMBOL(blkdev_get);	1276	EXPORT_SYMBOL(blkdev_get);
1277		1277
1278	static int blkdev_open(struct inode * inode, struct file * filp)	1278	static int blkdev_open(struct inode * inode, struct file * filp)
1279	{	1279	{
1280	struct block_device *bdev;	1280	struct block_device *bdev;
1281	int res;	1281	int res;
1282		1282
1283	/*	1283	/*
1284	* Preserve backwards compatibility and allow large file access	1284	* Preserve backwards compatibility and allow large file access
1285	* even if userspace doesn't ask for it explicitly. Some mkfs	1285	* even if userspace doesn't ask for it explicitly. Some mkfs
1286	* binary needs it. We might want to drop this workaround	1286	* binary needs it. We might want to drop this workaround
1287	* during an unstable branch.	1287	* during an unstable branch.
1288	*/	1288	*/
1289	filp->f_flags \|= O_LARGEFILE;	1289	filp->f_flags \|= O_LARGEFILE;
1290		1290
1291	if (filp->f_flags & O_NDELAY)	1291	if (filp->f_flags & O_NDELAY)
1292	filp->f_mode \|= FMODE_NDELAY;	1292	filp->f_mode \|= FMODE_NDELAY;
1293	if (filp->f_flags & O_EXCL)	1293	if (filp->f_flags & O_EXCL)
1294	filp->f_mode \|= FMODE_EXCL;	1294	filp->f_mode \|= FMODE_EXCL;
1295	if ((filp->f_flags & O_ACCMODE) == 3)	1295	if ((filp->f_flags & O_ACCMODE) == 3)
1296	filp->f_mode \|= FMODE_WRITE_IOCTL;	1296	filp->f_mode \|= FMODE_WRITE_IOCTL;
1297		1297
1298	bdev = bd_acquire(inode);	1298	bdev = bd_acquire(inode);
1299	if (bdev == NULL)	1299	if (bdev == NULL)
1300	return -ENOMEM;	1300	return -ENOMEM;
1301		1301
1302	filp->f_mapping = bdev->bd_inode->i_mapping;	1302	filp->f_mapping = bdev->bd_inode->i_mapping;
1303		1303
1304	res = blkdev_get(bdev, filp->f_mode);	1304	res = blkdev_get(bdev, filp->f_mode);
1305	if (res)	1305	if (res)
1306	return res;	1306	return res;
1307		1307
1308	if (filp->f_mode & FMODE_EXCL) {	1308	if (filp->f_mode & FMODE_EXCL) {
1309	res = bd_claim(bdev, filp);	1309	res = bd_claim(bdev, filp);
1310	if (res)	1310	if (res)
1311	goto out_blkdev_put;	1311	goto out_blkdev_put;
1312	}	1312	}
1313		1313
1314	return 0;	1314	return 0;
1315		1315
1316	out_blkdev_put:	1316	out_blkdev_put:
1317	blkdev_put(bdev, filp->f_mode);	1317	blkdev_put(bdev, filp->f_mode);
1318	return res;	1318	return res;
1319	}	1319	}
1320		1320
1321	static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)	1321	static int __blkdev_put(struct block_device *bdev, fmode_t mode, int for_part)
1322	{	1322	{
1323	int ret = 0;	1323	int ret = 0;
1324	struct gendisk *disk = bdev->bd_disk;	1324	struct gendisk *disk = bdev->bd_disk;
1325	struct block_device *victim = NULL;	1325	struct block_device *victim = NULL;
1326		1326
1327	mutex_lock_nested(&bdev->bd_mutex, for_part);	1327	mutex_lock_nested(&bdev->bd_mutex, for_part);
1328	lock_kernel();	1328	lock_kernel();
1329	if (for_part)	1329	if (for_part)
1330	bdev->bd_part_count--;	1330	bdev->bd_part_count--;
1331		1331
1332	if (!--bdev->bd_openers) {	1332	if (!--bdev->bd_openers) {
1333	sync_blockdev(bdev);	1333	sync_blockdev(bdev);
1334	kill_bdev(bdev);	1334	kill_bdev(bdev);
1335	}	1335	}
1336	if (bdev->bd_contains == bdev) {	1336	if (bdev->bd_contains == bdev) {
1337	if (disk->fops->release)	1337	if (disk->fops->release)
1338	ret = disk->fops->release(disk, mode);	1338	ret = disk->fops->release(disk, mode);
1339	}	1339	}
1340	if (!bdev->bd_openers) {	1340	if (!bdev->bd_openers) {
1341	struct module *owner = disk->fops->owner;	1341	struct module *owner = disk->fops->owner;
1342		1342
1343	put_disk(disk);	1343	put_disk(disk);
1344	module_put(owner);	1344	module_put(owner);
1345	disk_put_part(bdev->bd_part);	1345	disk_put_part(bdev->bd_part);
1346	bdev->bd_part = NULL;	1346	bdev->bd_part = NULL;
1347	bdev->bd_disk = NULL;	1347	bdev->bd_disk = NULL;
1348	bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;	1348	bdev->bd_inode->i_data.backing_dev_info = &default_backing_dev_info;
1349	if (bdev != bdev->bd_contains)	1349	if (bdev != bdev->bd_contains)
1350	victim = bdev->bd_contains;	1350	victim = bdev->bd_contains;
1351	bdev->bd_contains = NULL;	1351	bdev->bd_contains = NULL;
1352	}	1352	}
1353	unlock_kernel();	1353	unlock_kernel();
1354	mutex_unlock(&bdev->bd_mutex);	1354	mutex_unlock(&bdev->bd_mutex);
1355	bdput(bdev);	1355	bdput(bdev);
1356	if (victim)	1356	if (victim)
1357	__blkdev_put(victim, mode, 1);	1357	__blkdev_put(victim, mode, 1);
1358	return ret;	1358	return ret;
1359	}	1359	}
1360		1360
1361	int blkdev_put(struct block_device *bdev, fmode_t mode)	1361	int blkdev_put(struct block_device *bdev, fmode_t mode)
1362	{	1362	{
1363	return __blkdev_put(bdev, mode, 0);	1363	return __blkdev_put(bdev, mode, 0);
1364	}	1364	}
1365	EXPORT_SYMBOL(blkdev_put);	1365	EXPORT_SYMBOL(blkdev_put);
1366		1366
1367	static int blkdev_close(struct inode * inode, struct file * filp)	1367	static int blkdev_close(struct inode * inode, struct file * filp)
1368	{	1368	{
1369	struct block_device *bdev = I_BDEV(filp->f_mapping->host);	1369	struct block_device *bdev = I_BDEV(filp->f_mapping->host);
1370	if (bdev->bd_holder == filp)	1370	if (bdev->bd_holder == filp)
1371	bd_release(bdev);	1371	bd_release(bdev);
1372	return blkdev_put(bdev, filp->f_mode);	1372	return blkdev_put(bdev, filp->f_mode);
1373	}	1373	}
1374		1374
1375	static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)	1375	static long block_ioctl(struct file *file, unsigned cmd, unsigned long arg)
1376	{	1376	{
1377	struct block_device *bdev = I_BDEV(file->f_mapping->host);	1377	struct block_device *bdev = I_BDEV(file->f_mapping->host);
1378	fmode_t mode = file->f_mode;	1378	fmode_t mode = file->f_mode;
1379		1379
1380	/*	1380	/*
1381	* O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have	1381	* O_NDELAY can be altered using fcntl(.., F_SETFL, ..), so we have
1382	* to updated it before every ioctl.	1382	* to updated it before every ioctl.
1383	*/	1383	*/
1384	if (file->f_flags & O_NDELAY)	1384	if (file->f_flags & O_NDELAY)
1385	mode \|= FMODE_NDELAY;	1385	mode \|= FMODE_NDELAY;
1386	else	1386	else
1387	mode &= ~FMODE_NDELAY;	1387	mode &= ~FMODE_NDELAY;
1388		1388
1389	return blkdev_ioctl(bdev, mode, cmd, arg);	1389	return blkdev_ioctl(bdev, mode, cmd, arg);
1390	}	1390	}
1391		1391
1392	/*	1392	/*
1393	* Try to release a page associated with block device when the system	1393	* Try to release a page associated with block device when the system
1394	* is under memory pressure.	1394	* is under memory pressure.
1395	*/	1395	*/
1396	static int blkdev_releasepage(struct page *page, gfp_t wait)	1396	static int blkdev_releasepage(struct page *page, gfp_t wait)
1397	{	1397	{
1398	struct super_block *super = BDEV_I(page->mapping->host)->bdev.bd_super;	1398	struct super_block *super = BDEV_I(page->mapping->host)->bdev.bd_super;
1399		1399
1400	if (super && super->s_op->bdev_try_to_free_page)	1400	if (super && super->s_op->bdev_try_to_free_page)
1401	return super->s_op->bdev_try_to_free_page(super, page, wait);	1401	return super->s_op->bdev_try_to_free_page(super, page, wait);
1402		1402
1403	return try_to_free_buffers(page);	1403	return try_to_free_buffers(page);
1404	}	1404	}
1405		1405
1406	static const struct address_space_operations def_blk_aops = {	1406	static const struct address_space_operations def_blk_aops = {
1407	.readpage = blkdev_readpage,	1407	.readpage = blkdev_readpage,
1408	.writepage = blkdev_writepage,	1408	.writepage = blkdev_writepage,
1409	.sync_page = block_sync_page,	1409	.sync_page = block_sync_page,
1410	.write_begin = blkdev_write_begin,	1410	.write_begin = blkdev_write_begin,
1411	.write_end = blkdev_write_end,	1411	.write_end = blkdev_write_end,
1412	.writepages = generic_writepages,	1412	.writepages = generic_writepages,
1413	.releasepage = blkdev_releasepage,	1413	.releasepage = blkdev_releasepage,
1414	.direct_IO = blkdev_direct_IO,	1414	.direct_IO = blkdev_direct_IO,
1415	};	1415	};
1416		1416
1417	const struct file_operations def_blk_fops = {	1417	const struct file_operations def_blk_fops = {
1418	.open = blkdev_open,	1418	.open = blkdev_open,
1419	.release = blkdev_close,	1419	.release = blkdev_close,
1420	.llseek = block_llseek,	1420	.llseek = block_llseek,
1421	.read = do_sync_read,	1421	.read = do_sync_read,
1422	.write = do_sync_write,	1422	.write = do_sync_write,
1423	.aio_read = generic_file_aio_read,	1423	.aio_read = generic_file_aio_read,
1424	.aio_write = generic_file_aio_write_nolock,	1424	.aio_write = generic_file_aio_write_nolock,
1425	.mmap = generic_file_mmap,	1425	.mmap = generic_file_mmap,
1426	.fsync = block_fsync,	1426	.fsync = block_fsync,
1427	.unlocked_ioctl = block_ioctl,	1427	.unlocked_ioctl = block_ioctl,
1428	#ifdef CONFIG_COMPAT	1428	#ifdef CONFIG_COMPAT
1429	.compat_ioctl = compat_blkdev_ioctl,	1429	.compat_ioctl = compat_blkdev_ioctl,
1430	#endif	1430	#endif
1431	.splice_read = generic_file_splice_read,	1431	.splice_read = generic_file_splice_read,
1432	.splice_write = generic_file_splice_write,	1432	.splice_write = generic_file_splice_write,
1433	};	1433	};
1434		1434
1435	int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)	1435	int ioctl_by_bdev(struct block_device *bdev, unsigned cmd, unsigned long arg)
1436	{	1436	{
1437	int res;	1437	int res;
1438	mm_segment_t old_fs = get_fs();	1438	mm_segment_t old_fs = get_fs();
1439	set_fs(KERNEL_DS);	1439	set_fs(KERNEL_DS);
1440	res = blkdev_ioctl(bdev, 0, cmd, arg);	1440	res = blkdev_ioctl(bdev, 0, cmd, arg);
1441	set_fs(old_fs);	1441	set_fs(old_fs);
1442	return res;	1442	return res;
1443	}	1443	}
1444		1444
1445	EXPORT_SYMBOL(ioctl_by_bdev);	1445	EXPORT_SYMBOL(ioctl_by_bdev);
1446		1446
1447	/**	1447	/**
1448	* lookup_bdev - lookup a struct block_device by name	1448	* lookup_bdev - lookup a struct block_device by name
1449	* @pathname: special file representing the block device	1449	* @pathname: special file representing the block device
1450	*	1450	*
1451	* Get a reference to the blockdevice at @pathname in the current	1451	* Get a reference to the blockdevice at @pathname in the current
1452	* namespace if possible and return it. Return ERR_PTR(error)	1452	* namespace if possible and return it. Return ERR_PTR(error)
1453	* otherwise.	1453	* otherwise.
1454	*/	1454	*/
1455	struct block_device lookup_bdev(const char pathname)	1455	struct block_device lookup_bdev(const char pathname)
1456	{	1456	{
1457	struct block_device *bdev;	1457	struct block_device *bdev;
1458	struct inode *inode;	1458	struct inode *inode;
1459	struct path path;	1459	struct path path;
1460	int error;	1460	int error;
1461		1461
1462	if (!pathname \|\| !*pathname)	1462	if (!pathname \|\| !*pathname)
1463	return ERR_PTR(-EINVAL);	1463	return ERR_PTR(-EINVAL);
1464		1464
1465	error = kern_path(pathname, LOOKUP_FOLLOW, &path);	1465	error = kern_path(pathname, LOOKUP_FOLLOW, &path);
1466	if (error)	1466	if (error)
1467	return ERR_PTR(error);	1467	return ERR_PTR(error);
1468		1468
1469	inode = path.dentry->d_inode;	1469	inode = path.dentry->d_inode;
1470	error = -ENOTBLK;	1470	error = -ENOTBLK;
1471	if (!S_ISBLK(inode->i_mode))	1471	if (!S_ISBLK(inode->i_mode))
1472	goto fail;	1472	goto fail;
1473	error = -EACCES;	1473	error = -EACCES;
1474	if (path.mnt->mnt_flags & MNT_NODEV)	1474	if (path.mnt->mnt_flags & MNT_NODEV)
1475	goto fail;	1475	goto fail;
1476	error = -ENOMEM;	1476	error = -ENOMEM;
1477	bdev = bd_acquire(inode);	1477	bdev = bd_acquire(inode);
1478	if (!bdev)	1478	if (!bdev)
1479	goto fail;	1479	goto fail;
1480	out:	1480	out:
1481	path_put(&path);	1481	path_put(&path);
1482	return bdev;	1482	return bdev;
1483	fail:	1483	fail:
1484	bdev = ERR_PTR(error);	1484	bdev = ERR_PTR(error);
1485	goto out;	1485	goto out;
1486	}	1486	}
1487	EXPORT_SYMBOL(lookup_bdev);	1487	EXPORT_SYMBOL(lookup_bdev);
1488		1488
1489	/**	1489	/**
1490	* open_bdev_exclusive - open a block device by name and set it up for use	1490	* open_bdev_exclusive - open a block device by name and set it up for use
1491	*	1491	*
1492	* @path: special file representing the block device	1492	* @path: special file representing the block device
1493	* @mode: FMODE_... combination to pass be used	1493	* @mode: FMODE_... combination to pass be used
1494	* @holder: owner for exclusion	1494	* @holder: owner for exclusion
1495	*	1495	*
1496	* Open the blockdevice described by the special file at @path, claim it	1496	* Open the blockdevice described by the special file at @path, claim it
1497	* for the @holder.	1497	* for the @holder.
1498	*/	1498	*/
1499	struct block_device open_bdev_exclusive(const char path, fmode_t mode, void *holder)	1499	struct block_device open_bdev_exclusive(const char path, fmode_t mode, void *holder)
1500	{	1500	{
1501	struct block_device *bdev;	1501	struct block_device *bdev;
1502	int error = 0;	1502	int error = 0;
1503		1503
1504	bdev = lookup_bdev(path);	1504	bdev = lookup_bdev(path);
1505	if (IS_ERR(bdev))	1505	if (IS_ERR(bdev))
1506	return bdev;	1506	return bdev;
1507		1507
1508	error = blkdev_get(bdev, mode);	1508	error = blkdev_get(bdev, mode);
1509	if (error)	1509	if (error)
1510	return ERR_PTR(error);	1510	return ERR_PTR(error);
1511	error = -EACCES;	1511	error = -EACCES;
1512	if ((mode & FMODE_WRITE) && bdev_read_only(bdev))	1512	if ((mode & FMODE_WRITE) && bdev_read_only(bdev))
1513	goto blkdev_put;	1513	goto blkdev_put;
1514	error = bd_claim(bdev, holder);	1514	error = bd_claim(bdev, holder);
1515	if (error)	1515	if (error)
1516	goto blkdev_put;	1516	goto blkdev_put;
1517		1517
1518	return bdev;	1518	return bdev;
1519		1519
1520	blkdev_put:	1520	blkdev_put:
1521	blkdev_put(bdev, mode);	1521	blkdev_put(bdev, mode);
1522	return ERR_PTR(error);	1522	return ERR_PTR(error);
1523	}	1523	}
1524		1524
1525	EXPORT_SYMBOL(open_bdev_exclusive);	1525	EXPORT_SYMBOL(open_bdev_exclusive);
1526		1526
1527	/**	1527	/**
1528	* close_bdev_exclusive - close a blockdevice opened by open_bdev_exclusive()	1528	* close_bdev_exclusive - close a blockdevice opened by open_bdev_exclusive()
1529	*	1529	*
1530	* @bdev: blockdevice to close	1530	* @bdev: blockdevice to close
1531	* @mode: mode, must match that used to open.	1531	* @mode: mode, must match that used to open.
1532	*	1532	*
1533	* This is the counterpart to open_bdev_exclusive().	1533	* This is the counterpart to open_bdev_exclusive().
1534	*/	1534	*/
1535	void close_bdev_exclusive(struct block_device *bdev, fmode_t mode)	1535	void close_bdev_exclusive(struct block_device *bdev, fmode_t mode)
1536	{	1536	{
1537	bd_release(bdev);	1537	bd_release(bdev);
1538	blkdev_put(bdev, mode);	1538	blkdev_put(bdev, mode);
1539	}	1539	}
1540		1540
1541	EXPORT_SYMBOL(close_bdev_exclusive);	1541	EXPORT_SYMBOL(close_bdev_exclusive);
1542		1542
1543	int __invalidate_device(struct block_device *bdev)	1543	int __invalidate_device(struct block_device *bdev)
1544	{	1544	{
1545	struct super_block *sb = get_super(bdev);	1545	struct super_block *sb = get_super(bdev);
1546	int res = 0;	1546	int res = 0;
1547		1547
1548	if (sb) {	1548	if (sb) {
1549	/*	1549	/*
1550	* no need to lock the super, get_super holds the	1550	* no need to lock the super, get_super holds the
1551	* read mutex so the filesystem cannot go away	1551	* read mutex so the filesystem cannot go away
1552	* under us (->put_super runs with the write lock	1552	* under us (->put_super runs with the write lock
1553	* hold).	1553	* hold).
1554	*/	1554	*/
1555	shrink_dcache_sb(sb);	1555	shrink_dcache_sb(sb);
1556	res = invalidate_inodes(sb);	1556	res = invalidate_inodes(sb);
1557	drop_super(sb);	1557	drop_super(sb);
1558	}	1558	}
1559	invalidate_bdev(bdev);	1559	invalidate_bdev(bdev);
1560	return res;	1560	return res;
1561	}	1561	}
1562	EXPORT_SYMBOL(__invalidate_device);	1562	EXPORT_SYMBOL(__invalidate_device);
1563		1563

fs/super.c

Diff comments View file @ 429479f

 /*
  *  linux/fs/super.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *
  *  super.c contains code to handle: - mount structures
  *                                   - super-block tables
  *                                   - filesystem drivers list
  *                                   - mount system call
  *                                   - umount system call
  *                                   - ustat system call
  *
  * GK 2/5/95  -  Changed to support mounting the root fs via NFS
  *
  *  Added kerneld support: Jacques Gelinas and Bjorn Ekwall
  *  Added change_root: Werner Almesberger & Hans Lermen, Feb '96
  *  Added options to /proc/mounts:
  *    Torbjörn Lindh (torbjorn.lindh@gopta.se), April 14, 1996.
  *  Added devfs support: Richard Gooch <rgooch@atnf.csiro.au>, 13-JAN-1998
  *  Heavily rewritten for 'one fs - one tree' dcache architecture. AV, Mar 2000
  */
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/smp_lock.h>
 #include <linux/acct.h>
 #include <linux/blkdev.h>
 #include <linux/quotaops.h>
 #include <linux/namei.h>
 #include <linux/buffer_head.h>		/* for fsync_super() */
 #include <linux/mount.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
 #include <linux/vfs.h>
 #include <linux/writeback.h>		/* for the emergency remount stuff */
 #include <linux/idr.h>
 #include <linux/kobject.h>
 #include <linux/mutex.h>
 #include <linux/file.h>
 #include <asm/uaccess.h>
 #include "internal.h"
 LIST_HEAD(super_blocks);
 DEFINE_SPINLOCK(sb_lock);
 /**
  *	alloc_super	-	create new superblock
  *	@type:	filesystem type superblock should belong to
  *
  *	Allocates and initializes a new &struct super_block.  alloc_super()
  *	returns a pointer new superblock or %NULL if allocation had failed.
  */
 static struct super_block *alloc_super(struct file_system_type *type)
 {
 	struct super_block *s = kzalloc(sizeof(struct super_block),  GFP_USER);
 	static struct super_operations default_op;
 	if (s) {
 		if (security_sb_alloc(s)) {
 			kfree(s);
 			s = NULL;
 			goto out;
 		}
 		INIT_LIST_HEAD(&s->s_dirty);
 		INIT_LIST_HEAD(&s->s_io);
 		INIT_LIST_HEAD(&s->s_more_io);
 		INIT_LIST_HEAD(&s->s_files);
 		INIT_LIST_HEAD(&s->s_instances);
 		INIT_HLIST_HEAD(&s->s_anon);
 		INIT_LIST_HEAD(&s->s_inodes);
 		INIT_LIST_HEAD(&s->s_dentry_lru);
 		init_rwsem(&s->s_umount);
 		mutex_init(&s->s_lock);
 		lockdep_set_class(&s->s_umount, &type->s_umount_key);
 		/*
 		 * The locking rules for s_lock are up to the
 		 * filesystem. For example ext3fs has different
 		 * lock ordering than usbfs:
 		 */
 		lockdep_set_class(&s->s_lock, &type->s_lock_key);
 		/*
 		 * sget() can have s_umount recursion.
 		 *
 		 * When it cannot find a suitable sb, it allocates a new
 		 * one (this one), and tries again to find a suitable old
 		 * one.
 		 *
 		 * In case that succeeds, it will acquire the s_umount
 		 * lock of the old one. Since these are clearly distrinct
 		 * locks, and this object isn't exposed yet, there's no
 		 * risk of deadlocks.
 		 *
 		 * Annotate this by putting this lock in a different
 		 * subclass.
 		 */
 		down_write_nested(&s->s_umount, SINGLE_DEPTH_NESTING);
 		s->s_count = S_BIAS;
 		atomic_set(&s->s_active, 1);
 		mutex_init(&s->s_vfs_rename_mutex);
 		mutex_init(&s->s_dquot.dqio_mutex);
 		mutex_init(&s->s_dquot.dqonoff_mutex);
 		init_rwsem(&s->s_dquot.dqptr_sem);
 		init_waitqueue_head(&s->s_wait_unfrozen);
 		s->s_maxbytes = MAX_NON_LFS;
 		s->dq_op = sb_dquot_ops;
 		s->s_qcop = sb_quotactl_ops;
 		s->s_op = &default_op;
 		s->s_time_gran = 1000000000;
 	}
 out:
 	return s;
 }
 /**
  *	destroy_super	-	frees a superblock
  *	@s: superblock to free
  *
  *	Frees a superblock.
  */
 static inline void destroy_super(struct super_block *s)
 {
 	security_sb_free(s);
 	kfree(s->s_subtype);
 	kfree(s->s_options);
 	kfree(s);
 }
 /* Superblock refcounting  */
 /*
  * Drop a superblock's refcount.  Returns non-zero if the superblock was
  * destroyed.  The caller must hold sb_lock.
  */
 static int __put_super(struct super_block *sb)
 {
 	int ret = 0;
 	if (!--sb->s_count) {
 		destroy_super(sb);
 		ret = 1;
 	}
 	return ret;
 }
 /*
  * Drop a superblock's refcount.
  * Returns non-zero if the superblock is about to be destroyed and
  * at least is already removed from super_blocks list, so if we are
  * making a loop through super blocks then we need to restart.
  * The caller must hold sb_lock.
  */
 int __put_super_and_need_restart(struct super_block *sb)
 {
 	/* check for race with generic_shutdown_super() */
 	if (list_empty(&sb->s_list)) {
 		/* super block is removed, need to restart... */
 		__put_super(sb);
 		return 1;
 	}
 	/* can't be the last, since s_list is still in use */
 	sb->s_count--;
 	BUG_ON(sb->s_count == 0);
 	return 0;
 }
 /**
  *	put_super	-	drop a temporary reference to superblock
  *	@sb: superblock in question
  *
  *	Drops a temporary reference, frees superblock if there's no
  *	references left.
  */
 static void put_super(struct super_block *sb)
 {
 	spin_lock(&sb_lock);
 	__put_super(sb);
 	spin_unlock(&sb_lock);
 }
 /**
  *	deactivate_super	-	drop an active reference to superblock
  *	@s: superblock to deactivate
  *
  *	Drops an active reference to superblock, acquiring a temprory one if
  *	there is no active references left.  In that case we lock superblock,
  *	tell fs driver to shut it down and drop the temporary reference we
  *	had just acquired.
  */
 void deactivate_super(struct super_block *s)
 {
 	struct file_system_type *fs = s->s_type;
 	if (atomic_dec_and_lock(&s->s_active, &sb_lock)) {
 		s->s_count -= S_BIAS-1;
 		spin_unlock(&sb_lock);
 		vfs_dq_off(s, 0);
 		down_write(&s->s_umount);
 		fs->kill_sb(s);
 		put_filesystem(fs);
 		put_super(s);
 	}
 }
 EXPORT_SYMBOL(deactivate_super);
 /**
  *	deactivate_locked_super	-	drop an active reference to superblock
  *	@s: superblock to deactivate
  *
  *	Equivalent of up_write(&s->s_umount); deactivate_super(s);, except that
  *	it does not unlock it until it's all over.  As the result, it's safe to
  *	use to dispose of new superblock on ->get_sb() failure exits - nobody
  *	will see the sucker until it's all over.  Equivalent using up_write +
  *	deactivate_super is safe for that purpose only if superblock is either
  *	safe to use or has NULL ->s_root when we unlock.
  */
 void deactivate_locked_super(struct super_block *s)
 {
 	struct file_system_type *fs = s->s_type;
 	if (atomic_dec_and_lock(&s->s_active, &sb_lock)) {
 		s->s_count -= S_BIAS-1;
 		spin_unlock(&sb_lock);
 		vfs_dq_off(s, 0);
 		fs->kill_sb(s);
 		put_filesystem(fs);
 		put_super(s);
 	} else {
 		up_write(&s->s_umount);
 	}
 }
 EXPORT_SYMBOL(deactivate_locked_super);
 /**
  *	grab_super - acquire an active reference
  *	@s: reference we are trying to make active
  *
  *	Tries to acquire an active reference.  grab_super() is used when we
  * 	had just found a superblock in super_blocks or fs_type->fs_supers
  *	and want to turn it into a full-blown active reference.  grab_super()
  *	is called with sb_lock held and drops it.  Returns 1 in case of
  *	success, 0 if we had failed (superblock contents was already dead or
  *	dying when grab_super() had been called).
  */
 static int grab_super(struct super_block *s) __releases(sb_lock)
 {
 	s->s_count++;
 	spin_unlock(&sb_lock);
 	down_write(&s->s_umount);
 	if (s->s_root) {
 		spin_lock(&sb_lock);
 		if (s->s_count > S_BIAS) {
 			atomic_inc(&s->s_active);
 			s->s_count--;
 			spin_unlock(&sb_lock);
 			return 1;
 		}
 		spin_unlock(&sb_lock);
 	}
 	up_write(&s->s_umount);
 	put_super(s);
 	yield();
 	return 0;
 }
 /*
  * Superblock locking.  We really ought to get rid of these two.
  */
 void lock_super(struct super_block * sb)
 {
 	get_fs_excl();
 	mutex_lock(&sb->s_lock);
 }
 void unlock_super(struct super_block * sb)
 {
 	put_fs_excl();
 	mutex_unlock(&sb->s_lock);
 }
 EXPORT_SYMBOL(lock_super);
 EXPORT_SYMBOL(unlock_super);
 /*
  * Write out and wait upon all dirty data associated with this
  * superblock.  Filesystem data as well as the underlying block
  * device.  Takes the superblock lock.  Requires a second blkdev
  * flush by the caller to complete the operation.
  */
-void __fsync_super(struct super_block *sb)
+static int __fsync_super(struct super_block *sb)
 {
 	sync_inodes_sb(sb, 0);
 	vfs_dq_sync(sb);
 	sync_inodes_sb(sb, 1);
 	lock_super(sb);
 	if (sb->s_dirt && sb->s_op->write_super)
 		sb->s_op->write_super(sb);
 	unlock_super(sb);
 	if (sb->s_op->sync_fs)
 		sb->s_op->sync_fs(sb, 1);
-	sync_blockdev(sb->s_bdev);
+	return sync_blockdev(sb->s_bdev);
 }
 /*
  * Write out and wait upon all dirty data associated with this
  * superblock.  Filesystem data as well as the underlying block
  * device.  Takes the superblock lock.
  */
 int fsync_super(struct super_block *sb)
 {
-	__fsync_super(sb);
+	return __fsync_super(sb);
-	return sync_blockdev(sb->s_bdev);
 }
 EXPORT_SYMBOL_GPL(fsync_super);
 /**
  *	generic_shutdown_super	-	common helper for ->kill_sb()
  *	@sb: superblock to kill
  *
  *	generic_shutdown_super() does all fs-independent work on superblock
  *	shutdown.  Typical ->kill_sb() should pick all fs-specific objects
  *	that need destruction out of superblock, call generic_shutdown_super()
  *	and release aforementioned objects.  Note: dentries and inodes _are_
  *	taken care of and do not need specific handling.
  *
  *	Upon calling this function, the filesystem may no longer alter or
  *	rearrange the set of dentries belonging to this super_block, nor may it
  *	change the attachments of dentries to inodes.
  */
 void generic_shutdown_super(struct super_block *sb)
 {
 	const struct super_operations *sop = sb->s_op;
 	if (sb->s_root) {
 		shrink_dcache_for_umount(sb);
 		fsync_super(sb);
 		lock_super(sb);
 		sb->s_flags &= ~MS_ACTIVE;
 		/* bad name - it should be evict_inodes() */
 		invalidate_inodes(sb);
 		lock_kernel();
 		if (sop->write_super && sb->s_dirt)
 			sop->write_super(sb);
 		if (sop->put_super)
 			sop->put_super(sb);
 		/* Forget any remaining inodes */
 		if (invalidate_inodes(sb)) {
 			printk("VFS: Busy inodes after unmount of %s. "
 			   "Self-destruct in 5 seconds.  Have a nice day...\n",
 			   sb->s_id);
 		}
 		unlock_kernel();
 		unlock_super(sb);
 	}
 	spin_lock(&sb_lock);
 	/* should be initialized for __put_super_and_need_restart() */
 	list_del_init(&sb->s_list);
 	list_del(&sb->s_instances);
 	spin_unlock(&sb_lock);
 	up_write(&sb->s_umount);
 }
 EXPORT_SYMBOL(generic_shutdown_super);
 /**
  *	sget	-	find or create a superblock
  *	@type:	filesystem type superblock should belong to
  *	@test:	comparison callback
  *	@set:	setup callback
  *	@data:	argument to each of them
  */
 struct super_block *sget(struct file_system_type *type,
 			int (*test)(struct super_block *,void *),
 			int (*set)(struct super_block *,void *),
 			void *data)
 {
 	struct super_block *s = NULL;
 	struct super_block *old;
 	int err;
 retry:
 	spin_lock(&sb_lock);
 	if (test) {
 		list_for_each_entry(old, &type->fs_supers, s_instances) {
 			if (!test(old, data))
 				continue;
 			if (!grab_super(old))
 				goto retry;
 			if (s) {
 				up_write(&s->s_umount);
 				destroy_super(s);
 			}
 			return old;
 		}
 	}
 	if (!s) {
 		spin_unlock(&sb_lock);
 		s = alloc_super(type);
 		if (!s)
 			return ERR_PTR(-ENOMEM);
 		goto retry;
 	}
 	err = set(s, data);
 	if (err) {
 		spin_unlock(&sb_lock);
 		up_write(&s->s_umount);
 		destroy_super(s);
 		return ERR_PTR(err);
 	}
 	s->s_type = type;
 	strlcpy(s->s_id, type->name, sizeof(s->s_id));
 	list_add_tail(&s->s_list, &super_blocks);
 	list_add(&s->s_instances, &type->fs_supers);
 	spin_unlock(&sb_lock);
 	get_filesystem(type);
 	return s;
 }
 EXPORT_SYMBOL(sget);
 void drop_super(struct super_block *sb)
 {
 	up_read(&sb->s_umount);
 	put_super(sb);
 }
 EXPORT_SYMBOL(drop_super);
 static inline void write_super(struct super_block *sb)
 {
 	lock_super(sb);
 	if (sb->s_root && sb->s_dirt)
 		if (sb->s_op->write_super)
 			sb->s_op->write_super(sb);
 	unlock_super(sb);
 }
 /*
  * Note: check the dirty flag before waiting, so we don't
  * hold up the sync while mounting a device. (The newly
  * mounted device won't need syncing.)
  */
 void sync_supers(void)
 {
 	struct super_block *sb;
 	spin_lock(&sb_lock);
 restart:
 	list_for_each_entry(sb, &super_blocks, s_list) {
 		if (sb->s_dirt) {
 			sb->s_count++;
 			spin_unlock(&sb_lock);
 			down_read(&sb->s_umount);
 			write_super(sb);
 			up_read(&sb->s_umount);
 			spin_lock(&sb_lock);
 			if (__put_super_and_need_restart(sb))
 				goto restart;
 		}
 	}
 	spin_unlock(&sb_lock);
 }
 /*
  * Call the ->sync_fs super_op against all filesystems which are r/w and
  * which implement it.
  *
  * This operation is careful to avoid the livelock which could easily happen
  * if two or more filesystems are being continuously dirtied.  s_need_sync_fs
  * is used only here.  We set it against all filesystems and then clear it as
  * we sync them.  So redirtied filesystems are skipped.
  *
  * But if process A is currently running sync_filesystems and then process B
  * calls sync_filesystems as well, process B will set all the s_need_sync_fs
  * flags again, which will cause process A to resync everything.  Fix that with
  * a local mutex.
  *
  * (Fabian) Avoid sync_fs with clean fs & wait mode 0
  */
 void sync_filesystems(int wait)
 {
 	struct super_block *sb;
 	static DEFINE_MUTEX(mutex);
 	mutex_lock(&mutex);		/* Could be down_interruptible */
 	spin_lock(&sb_lock);
 	list_for_each_entry(sb, &super_blocks, s_list) {
 		if (!sb->s_op->sync_fs)
 			continue;
 		if (sb->s_flags & MS_RDONLY)
 			continue;
 		sb->s_need_sync_fs = 1;
 	}
 restart:
 	list_for_each_entry(sb, &super_blocks, s_list) {
 		if (!sb->s_need_sync_fs)
 			continue;
 		sb->s_need_sync_fs = 0;
 		if (sb->s_flags & MS_RDONLY)
 			continue;	/* hm.  Was remounted r/o meanwhile */
 		sb->s_count++;
 		spin_unlock(&sb_lock);
 		down_read(&sb->s_umount);
 		if (sb->s_root)
 			sb->s_op->sync_fs(sb, wait);
 		up_read(&sb->s_umount);
 		/* restart only when sb is no longer on the list */
 		spin_lock(&sb_lock);
 		if (__put_super_and_need_restart(sb))
 			goto restart;
 	}
 	spin_unlock(&sb_lock);
 	mutex_unlock(&mutex);
 }
 #ifdef CONFIG_BLOCK
 /*
  *  Sync all block devices underlying some superblock
  */
 void sync_blockdevs(void)
 {
 	struct super_block *sb;
 	spin_lock(&sb_lock);
 restart:
 	list_for_each_entry(sb, &super_blocks, s_list) {
 		if (!sb->s_bdev)
 			continue;
 		sb->s_count++;
 		spin_unlock(&sb_lock);
 		down_read(&sb->s_umount);
 		if (sb->s_root)
 			sync_blockdev(sb->s_bdev);
 		up_read(&sb->s_umount);
 		spin_lock(&sb_lock);
 		if (__put_super_and_need_restart(sb))
 			goto restart;
 	}
 	spin_unlock(&sb_lock);
 }
 #endif
 /**
  *	get_super - get the superblock of a device
  *	@bdev: device to get the superblock for
  *
  *	Scans the superblock list and finds the superblock of the file system
  *	mounted on the device given. %NULL is returned if no match is found.
  */
 struct super_block * get_super(struct block_device *bdev)
 {
 	struct super_block *sb;
 	if (!bdev)
 		return NULL;
 	spin_lock(&sb_lock);
 rescan:
 	list_for_each_entry(sb, &super_blocks, s_list) {
 		if (sb->s_bdev == bdev) {
 			sb->s_count++;
 			spin_unlock(&sb_lock);
 			down_read(&sb->s_umount);
 			if (sb->s_root)
 				return sb;
 			up_read(&sb->s_umount);
 			/* restart only when sb is no longer on the list */
 			spin_lock(&sb_lock);
 			if (__put_super_and_need_restart(sb))
 				goto rescan;
 		}
 	}
 	spin_unlock(&sb_lock);
 	return NULL;
 }
 EXPORT_SYMBOL(get_super);
 struct super_block * user_get_super(dev_t dev)
 {
 	struct super_block *sb;
 	spin_lock(&sb_lock);
 rescan:
 	list_for_each_entry(sb, &super_blocks, s_list) {
 		if (sb->s_dev ==  dev) {
 			sb->s_count++;
 			spin_unlock(&sb_lock);
 			down_read(&sb->s_umount);
 			if (sb->s_root)
 				return sb;
 			up_read(&sb->s_umount);
 			/* restart only when sb is no longer on the list */
 			spin_lock(&sb_lock);
 			if (__put_super_and_need_restart(sb))
 				goto rescan;
 		}
 	}
 	spin_unlock(&sb_lock);
 	return NULL;
 }
 SYSCALL_DEFINE2(ustat, unsigned, dev, struct ustat __user *, ubuf)
 {
         struct super_block *s;
         struct ustat tmp;
         struct kstatfs sbuf;
 	int err = -EINVAL;
         s = user_get_super(new_decode_dev(dev));
         if (s == NULL)
                 goto out;
 	err = vfs_statfs(s->s_root, &sbuf);
 	drop_super(s);
 	if (err)
 		goto out;
         memset(&tmp,0,sizeof(struct ustat));
         tmp.f_tfree = sbuf.f_bfree;
         tmp.f_tinode = sbuf.f_ffree;
         err = copy_to_user(ubuf,&tmp,sizeof(struct ustat)) ? -EFAULT : 0;
 out:
 	return err;
 }
 /**
  *	do_remount_sb - asks filesystem to change mount options.
  *	@sb:	superblock in question
  *	@flags:	numeric part of options
  *	@data:	the rest of options
  *      @force: whether or not to force the change
  *
  *	Alters the mount options of a mounted file system.
  */
 int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
 {
 	int retval;
 	int remount_rw;
 #ifdef CONFIG_BLOCK
 	if (!(flags & MS_RDONLY) && bdev_read_only(sb->s_bdev))
 		return -EACCES;
 #endif
 	if (flags & MS_RDONLY)
 		acct_auto_close(sb);
 	shrink_dcache_sb(sb);
 	fsync_super(sb);
 	/* If we are remounting RDONLY and current sb is read/write,
 	   make sure there are no rw files opened */
 	if ((flags & MS_RDONLY) && !(sb->s_flags & MS_RDONLY)) {
 		if (force)
 			mark_files_ro(sb);
 		else if (!fs_may_remount_ro(sb))
 			return -EBUSY;
 		retval = vfs_dq_off(sb, 1);
 		if (retval < 0 && retval != -ENOSYS)
 			return -EBUSY;
 	}
 	remount_rw = !(flags & MS_RDONLY) && (sb->s_flags & MS_RDONLY);
 	if (sb->s_op->remount_fs) {
 		lock_super(sb);
 		retval = sb->s_op->remount_fs(sb, &flags, data);
 		unlock_super(sb);
 		if (retval)
 			return retval;
 	}
 	sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
 	if (remount_rw)
 		vfs_dq_quota_on_remount(sb);
 	return 0;
 }
 static void do_emergency_remount(struct work_struct *work)
 {
 	struct super_block *sb;
 	spin_lock(&sb_lock);
 	list_for_each_entry(sb, &super_blocks, s_list) {
 		sb->s_count++;
 		spin_unlock(&sb_lock);
 		down_read(&sb->s_umount);
 		if (sb->s_root && sb->s_bdev && !(sb->s_flags & MS_RDONLY)) {
 			/*
 			 * ->remount_fs needs lock_kernel().
 			 *
 			 * What lock protects sb->s_flags??
 			 */
 			lock_kernel();
 			do_remount_sb(sb, MS_RDONLY, NULL, 1);
 			unlock_kernel();
 		}
 		drop_super(sb);
 		spin_lock(&sb_lock);
 	}
 	spin_unlock(&sb_lock);
 	kfree(work);
 	printk("Emergency Remount complete\n");
 }
 void emergency_remount(void)
 {
 	struct work_struct *work;
 	work = kmalloc(sizeof(*work), GFP_ATOMIC);
 	if (work) {
 		INIT_WORK(work, do_emergency_remount);
 		schedule_work(work);
 	}
 }
 /*
  * Unnamed block devices are dummy devices used by virtual
  * filesystems which don't use real block-devices.  -- jrs
  */
 static DEFINE_IDA(unnamed_dev_ida);
 static DEFINE_SPINLOCK(unnamed_dev_lock);/* protects the above */
 int set_anon_super(struct super_block *s, void *data)
 {
 	int dev;
 	int error;
  retry:
 	if (ida_pre_get(&unnamed_dev_ida, GFP_ATOMIC) == 0)
 		return -ENOMEM;
 	spin_lock(&unnamed_dev_lock);
 	error = ida_get_new(&unnamed_dev_ida, &dev);
 	spin_unlock(&unnamed_dev_lock);
 	if (error == -EAGAIN)
 		/* We raced and lost with another CPU. */
 		goto retry;
 	else if (error)
 		return -EAGAIN;
 	if ((dev & MAX_ID_MASK) == (1 << MINORBITS)) {
 		spin_lock(&unnamed_dev_lock);
 		ida_remove(&unnamed_dev_ida, dev);
 		spin_unlock(&unnamed_dev_lock);
 		return -EMFILE;
 	}
 	s->s_dev = MKDEV(0, dev & MINORMASK);
 	return 0;
 }
 EXPORT_SYMBOL(set_anon_super);
 void kill_anon_super(struct super_block *sb)
 {
 	int slot = MINOR(sb->s_dev);
 	generic_shutdown_super(sb);
 	spin_lock(&unnamed_dev_lock);
 	ida_remove(&unnamed_dev_ida, slot);
 	spin_unlock(&unnamed_dev_lock);
 }
 EXPORT_SYMBOL(kill_anon_super);
 void kill_litter_super(struct super_block *sb)
 {
 	if (sb->s_root)
 		d_genocide(sb->s_root);
 	kill_anon_super(sb);
 }
 EXPORT_SYMBOL(kill_litter_super);
 static int ns_test_super(struct super_block *sb, void *data)
 {
 	return sb->s_fs_info == data;
 }
 static int ns_set_super(struct super_block *sb, void *data)
 {
 	sb->s_fs_info = data;
 	return set_anon_super(sb, NULL);
 }
 int get_sb_ns(struct file_system_type *fs_type, int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt)
 {
 	struct super_block *sb;
 	sb = sget(fs_type, ns_test_super, ns_set_super, data);
 	if (IS_ERR(sb))
 		return PTR_ERR(sb);
 	if (!sb->s_root) {
 		int err;
 		sb->s_flags = flags;
 		err = fill_super(sb, data, flags & MS_SILENT ? 1 : 0);
 		if (err) {
 			deactivate_locked_super(sb);
 			return err;
 		}
 		sb->s_flags |= MS_ACTIVE;
 	}
 	simple_set_mnt(mnt, sb);
 	return 0;
 }
 EXPORT_SYMBOL(get_sb_ns);
 #ifdef CONFIG_BLOCK
 static int set_bdev_super(struct super_block *s, void *data)
 {
 	s->s_bdev = data;
 	s->s_dev = s->s_bdev->bd_dev;
 	return 0;
 }
 static int test_bdev_super(struct super_block *s, void *data)
 {
 	return (void *)s->s_bdev == data;
 }
 int get_sb_bdev(struct file_system_type *fs_type,
 	int flags, const char *dev_name, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt)
 {
 	struct block_device *bdev;
 	struct super_block *s;
 	fmode_t mode = FMODE_READ;
 	int error = 0;
 	if (!(flags & MS_RDONLY))
 		mode |= FMODE_WRITE;
 	bdev = open_bdev_exclusive(dev_name, mode, fs_type);
 	if (IS_ERR(bdev))
 		return PTR_ERR(bdev);
 	/*
 	 * once the super is inserted into the list by sget, s_umount
 	 * will protect the lockfs code from trying to start a snapshot
 	 * while we are mounting
 	 */
 	down(&bdev->bd_mount_sem);
 	s = sget(fs_type, test_bdev_super, set_bdev_super, bdev);
 	up(&bdev->bd_mount_sem);
 	if (IS_ERR(s))
 		goto error_s;
 	if (s->s_root) {
 		if ((flags ^ s->s_flags) & MS_RDONLY) {
 			deactivate_locked_super(s);
 			error = -EBUSY;
 			goto error_bdev;
 		}
 		close_bdev_exclusive(bdev, mode);
 	} else {
 		char b[BDEVNAME_SIZE];
 		s->s_flags = flags;
 		s->s_mode = mode;
 		strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
 		sb_set_blocksize(s, block_size(bdev));
 		error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
 		if (error) {
 			deactivate_locked_super(s);
 			goto error;
 		}
 		s->s_flags |= MS_ACTIVE;
 		bdev->bd_super = s;
 	}
 	simple_set_mnt(mnt, s);
 	return 0;
 error_s:
 	error = PTR_ERR(s);
 error_bdev:
 	close_bdev_exclusive(bdev, mode);
 error:
 	return error;
 }
 EXPORT_SYMBOL(get_sb_bdev);
 void kill_block_super(struct super_block *sb)
 {
 	struct block_device *bdev = sb->s_bdev;
 	fmode_t mode = sb->s_mode;
 	bdev->bd_super = NULL;
 	generic_shutdown_super(sb);
 	sync_blockdev(bdev);
 	close_bdev_exclusive(bdev, mode);
 }
 EXPORT_SYMBOL(kill_block_super);
 #endif
 int get_sb_nodev(struct file_system_type *fs_type,
 	int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt)
 {
 	int error;
 	struct super_block *s = sget(fs_type, NULL, set_anon_super, NULL);
 	if (IS_ERR(s))
 		return PTR_ERR(s);
 	s->s_flags = flags;
 	error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
 	if (error) {
 		deactivate_locked_super(s);
 		return error;
 	}
 	s->s_flags |= MS_ACTIVE;
 	simple_set_mnt(mnt, s);
 	return 0;
 }
 EXPORT_SYMBOL(get_sb_nodev);
 static int compare_single(struct super_block *s, void *p)
 {
 	return 1;
 }
 int get_sb_single(struct file_system_type *fs_type,
 	int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt)
 {
 	struct super_block *s;
 	int error;
 	s = sget(fs_type, compare_single, set_anon_super, NULL);
 	if (IS_ERR(s))
 		return PTR_ERR(s);
 	if (!s->s_root) {
 		s->s_flags = flags;
 		error = fill_super(s, data, flags & MS_SILENT ? 1 : 0);
 		if (error) {
 			deactivate_locked_super(s);
 			return error;
 		}
 		s->s_flags |= MS_ACTIVE;
 	}
 	do_remount_sb(s, flags, data, 0);
 	simple_set_mnt(mnt, s);
 	return 0;
 }
 EXPORT_SYMBOL(get_sb_single);
 struct vfsmount *
 vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void *data)
 {
 	struct vfsmount *mnt;
 	char *secdata = NULL;
 	int error;
 	if (!type)
 		return ERR_PTR(-ENODEV);
 	error = -ENOMEM;
 	mnt = alloc_vfsmnt(name);
 	if (!mnt)
 		goto out;
 	if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
 		secdata = alloc_secdata();
 		if (!secdata)
 			goto out_mnt;
 		error = security_sb_copy_data(data, secdata);
 		if (error)
 			goto out_free_secdata;
 	}
 	error = type->get_sb(type, flags, name, data, mnt);
 	if (error < 0)
 		goto out_free_secdata;
 	BUG_ON(!mnt->mnt_sb);
  	error = security_sb_kern_mount(mnt->mnt_sb, flags, secdata);
  	if (error)
  		goto out_sb;
 	mnt->mnt_mountpoint = mnt->mnt_root;
 	mnt->mnt_parent = mnt;
 	up_write(&mnt->mnt_sb->s_umount);
 	free_secdata(secdata);
 	return mnt;
 out_sb:
 	dput(mnt->mnt_root);
 	deactivate_locked_super(mnt->mnt_sb);
 out_free_secdata:
 	free_secdata(secdata);
 out_mnt:
 	free_vfsmnt(mnt);
 out:
 	return ERR_PTR(error);
 }
 EXPORT_SYMBOL_GPL(vfs_kern_mount);
 static struct vfsmount *fs_set_subtype(struct vfsmount *mnt, const char *fstype)
 {
 	int err;
 	const char *subtype = strchr(fstype, '.');
 	if (subtype) {
 		subtype++;
 		err = -EINVAL;
 		if (!subtype[0])
 			goto err;
 	} else
 		subtype = "";
 	mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL);
 	err = -ENOMEM;
 	if (!mnt->mnt_sb->s_subtype)
 		goto err;
 	return mnt;
  err:
 	mntput(mnt);
 	return ERR_PTR(err);
 }
 struct vfsmount *
 do_kern_mount(const char *fstype, int flags, const char *name, void *data)
 {
 	struct file_system_type *type = get_fs_type(fstype);
 	struct vfsmount *mnt;
 	if (!type)
 		return ERR_PTR(-ENODEV);
 	mnt = vfs_kern_mount(type, flags, name, data);
 	if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
 	    !mnt->mnt_sb->s_subtype)
 		mnt = fs_set_subtype(mnt, fstype);
 	put_filesystem(type);
 	return mnt;
 }
 EXPORT_SYMBOL_GPL(do_kern_mount);
 struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
 {
 	return vfs_kern_mount(type, MS_KERNMOUNT, type->name, data);
 }
 EXPORT_SYMBOL_GPL(kern_mount_data);

include/linux/fs.h

Diff comments View file @ 429479f

 #ifndef _LINUX_FS_H
 #define _LINUX_FS_H
 /*
  * This file has definitions for some important file table
  * structures etc.
  */
 #include <linux/limits.h>
 #include <linux/ioctl.h>
 /*
  * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
  * the file limit at runtime and only root can increase the per-process
  * nr_file rlimit, so it's safe to set up a ridiculously high absolute
  * upper limit on files-per-process.
  *
  * Some programs (notably those using select()) may have to be
  * recompiled to take full advantage of the new limits..
  */
 /* Fixed constants first: */
 #undef NR_OPEN
 #define INR_OPEN 1024		/* Initial setting for nfile rlimits */
 #define BLOCK_SIZE_BITS 10
 #define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
 #define SEEK_SET	0	/* seek relative to beginning of file */
 #define SEEK_CUR	1	/* seek relative to current file position */
 #define SEEK_END	2	/* seek relative to end of file */
 #define SEEK_MAX	SEEK_END
 /* And dynamically-tunable limits and defaults: */
 struct files_stat_struct {
 	int nr_files;		/* read only */
 	int nr_free_files;	/* read only */
 	int max_files;		/* tunable */
 };
 struct inodes_stat_t {
 	int nr_inodes;
 	int nr_unused;
 	int dummy[5];		/* padding for sysctl ABI compatibility */
 };
 #define NR_FILE  8192	/* this can well be larger on a larger system */
 #define MAY_EXEC 1
 #define MAY_WRITE 2
 #define MAY_READ 4
 #define MAY_APPEND 8
 #define MAY_ACCESS 16
 #define MAY_OPEN 32
 /*
  * flags in file.f_mode.  Note that FMODE_READ and FMODE_WRITE must correspond
  * to O_WRONLY and O_RDWR via the strange trick in __dentry_open()
  */
 /* file is open for reading */
 #define FMODE_READ		((__force fmode_t)1)
 /* file is open for writing */
 #define FMODE_WRITE		((__force fmode_t)2)
 /* file is seekable */
 #define FMODE_LSEEK		((__force fmode_t)4)
 /* file can be accessed using pread */
 #define FMODE_PREAD		((__force fmode_t)8)
 /* file can be accessed using pwrite */
 #define FMODE_PWRITE		((__force fmode_t)16)
 /* File is opened for execution with sys_execve / sys_uselib */
 #define FMODE_EXEC		((__force fmode_t)32)
 /* File is opened with O_NDELAY (only set for block devices) */
 #define FMODE_NDELAY		((__force fmode_t)64)
 /* File is opened with O_EXCL (only set for block devices) */
 #define FMODE_EXCL		((__force fmode_t)128)
 /* File is opened using open(.., 3, ..) and is writeable only for ioctls
    (specialy hack for floppy.c) */
 #define FMODE_WRITE_IOCTL	((__force fmode_t)256)
 /*
  * Don't update ctime and mtime.
  *
  * Currently a special hack for the XFS open_by_handle ioctl, but we'll
  * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
  */
 #define FMODE_NOCMTIME		((__force fmode_t)2048)
 /*
  * The below are the various read and write types that we support. Some of
  * them include behavioral modifiers that send information down to the
  * block layer and IO scheduler. Terminology:
  *
  *	The block layer uses device plugging to defer IO a little bit, in
  *	the hope that we will see more IO very shortly. This increases
  *	coalescing of adjacent IO and thus reduces the number of IOs we
  *	have to send to the device. It also allows for better queuing,
  *	if the IO isn't mergeable. If the caller is going to be waiting
  *	for the IO, then he must ensure that the device is unplugged so
  *	that the IO is dispatched to the driver.
  *
  *	All IO is handled async in Linux. This is fine for background
  *	writes, but for reads or writes that someone waits for completion
  *	on, we want to notify the block layer and IO scheduler so that they
  *	know about it. That allows them to make better scheduling
  *	decisions. So when the below references 'sync' and 'async', it
  *	is referencing this priority hint.
  *
  * With that in mind, the available types are:
  *
  * READ			A normal read operation. Device will be plugged.
  * READ_SYNC		A synchronous read. Device is not plugged, caller can
  *			immediately wait on this read without caring about
  *			unplugging.
  * READA		Used for read-ahead operations. Lower priority, and the
  *			 block layer could (in theory) choose to ignore this
  *			request if it runs into resource problems.
  * WRITE		A normal async write. Device will be plugged.
  * SWRITE		Like WRITE, but a special case for ll_rw_block() that
  *			tells it to lock the buffer first. Normally a buffer
  *			must be locked before doing IO.
  * WRITE_SYNC_PLUG	Synchronous write. Identical to WRITE, but passes down
  *			the hint that someone will be waiting on this IO
  *			shortly. The device must still be unplugged explicitly,
  *			WRITE_SYNC_PLUG does not do this as we could be
  *			submitting more writes before we actually wait on any
  *			of them.
  * WRITE_SYNC		Like WRITE_SYNC_PLUG, but also unplugs the device
  *			immediately after submission. The write equivalent
  *			of READ_SYNC.
  * WRITE_ODIRECT	Special case write for O_DIRECT only.
  * SWRITE_SYNC
  * SWRITE_SYNC_PLUG	Like WRITE_SYNC/WRITE_SYNC_PLUG, but locks the buffer.
  *			See SWRITE.
  * WRITE_BARRIER	Like WRITE, but tells the block layer that all
  *			previously submitted writes must be safely on storage
  *			before this one is started. Also guarantees that when
  *			this write is complete, it itself is also safely on
  *			storage. Prevents reordering of writes on both sides
  *			of this IO.
  *
  */
 #define RW_MASK		1
 #define RWA_MASK	2
 #define READ 0
 #define WRITE 1
 #define READA 2		/* read-ahead  - don't block if no resources */
 #define SWRITE 3	/* for ll_rw_block() - wait for buffer lock */
 #define READ_SYNC	(READ | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))
 #define READ_META	(READ | (1 << BIO_RW_META))
 #define WRITE_SYNC_PLUG	(WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
 #define WRITE_SYNC	(WRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
 #define WRITE_ODIRECT	(WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))
 #define SWRITE_SYNC_PLUG	\
 			(SWRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
 #define SWRITE_SYNC	(SWRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
 #define WRITE_BARRIER	(WRITE | (1 << BIO_RW_BARRIER))
 /*
  * These aren't really reads or writes, they pass down information about
  * parts of device that are now unused by the file system.
  */
 #define DISCARD_NOBARRIER (1 << BIO_RW_DISCARD)
 #define DISCARD_BARRIER ((1 << BIO_RW_DISCARD) | (1 << BIO_RW_BARRIER))
 #define SEL_IN		1
 #define SEL_OUT		2
 #define SEL_EX		4
 /* public flags for file_system_type */
 #define FS_REQUIRES_DEV 1
 #define FS_BINARY_MOUNTDATA 2
 #define FS_HAS_SUBTYPE 4
 #define FS_REVAL_DOT	16384	/* Check the paths ".", ".." for staleness */
 #define FS_RENAME_DOES_D_MOVE	32768	/* FS will handle d_move()
 					 * during rename() internally.
 					 */
 /*
  * These are the fs-independent mount-flags: up to 32 flags are supported
  */
 #define MS_RDONLY	 1	/* Mount read-only */
 #define MS_NOSUID	 2	/* Ignore suid and sgid bits */
 #define MS_NODEV	 4	/* Disallow access to device special files */
 #define MS_NOEXEC	 8	/* Disallow program execution */
 #define MS_SYNCHRONOUS	16	/* Writes are synced at once */
 #define MS_REMOUNT	32	/* Alter flags of a mounted FS */
 #define MS_MANDLOCK	64	/* Allow mandatory locks on an FS */
 #define MS_DIRSYNC	128	/* Directory modifications are synchronous */
 #define MS_NOATIME	1024	/* Do not update access times. */
 #define MS_NODIRATIME	2048	/* Do not update directory access times */
 #define MS_BIND		4096
 #define MS_MOVE		8192
 #define MS_REC		16384
 #define MS_VERBOSE	32768	/* War is peace. Verbosity is silence.
 				   MS_VERBOSE is deprecated. */
 #define MS_SILENT	32768
 #define MS_POSIXACL	(1<<16)	/* VFS does not apply the umask */
 #define MS_UNBINDABLE	(1<<17)	/* change to unbindable */
 #define MS_PRIVATE	(1<<18)	/* change to private */
 #define MS_SLAVE	(1<<19)	/* change to slave */
 #define MS_SHARED	(1<<20)	/* change to shared */
 #define MS_RELATIME	(1<<21)	/* Update atime relative to mtime/ctime. */
 #define MS_KERNMOUNT	(1<<22) /* this is a kern_mount call */
 #define MS_I_VERSION	(1<<23) /* Update inode I_version field */
 #define MS_STRICTATIME	(1<<24) /* Always perform atime updates */
 #define MS_ACTIVE	(1<<30)
 #define MS_NOUSER	(1<<31)
 /*
  * Superblock flags that can be altered by MS_REMOUNT
  */
 #define MS_RMT_MASK	(MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_I_VERSION)
 /*
  * Old magic mount flag and mask
  */
 #define MS_MGC_VAL 0xC0ED0000
 #define MS_MGC_MSK 0xffff0000
 /* Inode flags - they have nothing to superblock flags now */
 #define S_SYNC		1	/* Writes are synced at once */
 #define S_NOATIME	2	/* Do not update access times */
 #define S_APPEND	4	/* Append-only file */
 #define S_IMMUTABLE	8	/* Immutable file */
 #define S_DEAD		16	/* removed, but still open directory */
 #define S_NOQUOTA	32	/* Inode is not counted to quota */
 #define S_DIRSYNC	64	/* Directory modifications are synchronous */
 #define S_NOCMTIME	128	/* Do not update file c/mtime */
 #define S_SWAPFILE	256	/* Do not truncate: swapon got its bmaps */
 #define S_PRIVATE	512	/* Inode is fs-internal */
 /*
  * Note that nosuid etc flags are inode-specific: setting some file-system
  * flags just means all the inodes inherit those flags by default. It might be
  * possible to override it selectively if you really wanted to with some
  * ioctl() that is not currently implemented.
  *
  * Exception: MS_RDONLY is always applied to the entire file system.
  *
  * Unfortunately, it is possible to change a filesystems flags with it mounted
  * with files in use.  This means that all of the inodes will not have their
  * i_flags updated.  Hence, i_flags no longer inherit the superblock mount
  * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
  */
 #define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))
 #define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
 #define IS_SYNC(inode)		(__IS_FLG(inode, MS_SYNCHRONOUS) || \
 					((inode)->i_flags & S_SYNC))
 #define IS_DIRSYNC(inode)	(__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
 					((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
 #define IS_MANDLOCK(inode)	__IS_FLG(inode, MS_MANDLOCK)
 #define IS_NOATIME(inode)   __IS_FLG(inode, MS_RDONLY|MS_NOATIME)
 #define IS_I_VERSION(inode)   __IS_FLG(inode, MS_I_VERSION)
 #define IS_NOQUOTA(inode)	((inode)->i_flags & S_NOQUOTA)
 #define IS_APPEND(inode)	((inode)->i_flags & S_APPEND)
 #define IS_IMMUTABLE(inode)	((inode)->i_flags & S_IMMUTABLE)
 #define IS_POSIXACL(inode)	__IS_FLG(inode, MS_POSIXACL)
 #define IS_DEADDIR(inode)	((inode)->i_flags & S_DEAD)
 #define IS_NOCMTIME(inode)	((inode)->i_flags & S_NOCMTIME)
 #define IS_SWAPFILE(inode)	((inode)->i_flags & S_SWAPFILE)
 #define IS_PRIVATE(inode)	((inode)->i_flags & S_PRIVATE)
 /* the read-only stuff doesn't really belong here, but any other place is
    probably as bad and I don't want to create yet another include file. */
 #define BLKROSET   _IO(0x12,93)	/* set device read-only (0 = read-write) */
 #define BLKROGET   _IO(0x12,94)	/* get read-only status (0 = read_write) */
 #define BLKRRPART  _IO(0x12,95)	/* re-read partition table */
 #define BLKGETSIZE _IO(0x12,96)	/* return device size /512 (long *arg) */
 #define BLKFLSBUF  _IO(0x12,97)	/* flush buffer cache */
 #define BLKRASET   _IO(0x12,98)	/* set read ahead for block device */
 #define BLKRAGET   _IO(0x12,99)	/* get current read ahead setting */
 #define BLKFRASET  _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
 #define BLKFRAGET  _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
 #define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
 #define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
 #define BLKSSZGET  _IO(0x12,104)/* get block device sector size */
 #if 0
 #define BLKPG      _IO(0x12,105)/* See blkpg.h */
 /* Some people are morons.  Do not use sizeof! */
 #define BLKELVGET  _IOR(0x12,106,size_t)/* elevator get */
 #define BLKELVSET  _IOW(0x12,107,size_t)/* elevator set */
 /* This was here just to show that the number is taken -
    probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */
 #endif
 /* A jump here: 108-111 have been used for various private purposes. */
 #define BLKBSZGET  _IOR(0x12,112,size_t)
 #define BLKBSZSET  _IOW(0x12,113,size_t)
 #define BLKGETSIZE64 _IOR(0x12,114,size_t)	/* return device size in bytes (u64 *arg) */
 #define BLKTRACESETUP _IOWR(0x12,115,struct blk_user_trace_setup)
 #define BLKTRACESTART _IO(0x12,116)
 #define BLKTRACESTOP _IO(0x12,117)
 #define BLKTRACETEARDOWN _IO(0x12,118)
 #define BLKDISCARD _IO(0x12,119)
 #define BMAP_IOCTL 1		/* obsolete - kept for compatibility */
 #define FIBMAP	   _IO(0x00,1)	/* bmap access */
 #define FIGETBSZ   _IO(0x00,2)	/* get the block size used for bmap */
 #define FIFREEZE	_IOWR('X', 119, int)	/* Freeze */
 #define FITHAW		_IOWR('X', 120, int)	/* Thaw */
 #define	FS_IOC_GETFLAGS			_IOR('f', 1, long)
 #define	FS_IOC_SETFLAGS			_IOW('f', 2, long)
 #define	FS_IOC_GETVERSION		_IOR('v', 1, long)
 #define	FS_IOC_SETVERSION		_IOW('v', 2, long)
 #define FS_IOC_FIEMAP			_IOWR('f', 11, struct fiemap)
 #define FS_IOC32_GETFLAGS		_IOR('f', 1, int)
 #define FS_IOC32_SETFLAGS		_IOW('f', 2, int)
 #define FS_IOC32_GETVERSION		_IOR('v', 1, int)
 #define FS_IOC32_SETVERSION		_IOW('v', 2, int)
 /*
  * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)
  */
 #define	FS_SECRM_FL			0x00000001 /* Secure deletion */
 #define	FS_UNRM_FL			0x00000002 /* Undelete */
 #define	FS_COMPR_FL			0x00000004 /* Compress file */
 #define FS_SYNC_FL			0x00000008 /* Synchronous updates */
 #define FS_IMMUTABLE_FL			0x00000010 /* Immutable file */
 #define FS_APPEND_FL			0x00000020 /* writes to file may only append */
 #define FS_NODUMP_FL			0x00000040 /* do not dump file */
 #define FS_NOATIME_FL			0x00000080 /* do not update atime */
 /* Reserved for compression usage... */
 #define FS_DIRTY_FL			0x00000100
 #define FS_COMPRBLK_FL			0x00000200 /* One or more compressed clusters */
 #define FS_NOCOMP_FL			0x00000400 /* Don't compress */
 #define FS_ECOMPR_FL			0x00000800 /* Compression error */
 /* End compression flags --- maybe not all used */
 #define FS_BTREE_FL			0x00001000 /* btree format dir */
 #define FS_INDEX_FL			0x00001000 /* hash-indexed directory */
 #define FS_IMAGIC_FL			0x00002000 /* AFS directory */
 #define FS_JOURNAL_DATA_FL		0x00004000 /* Reserved for ext3 */
 #define FS_NOTAIL_FL			0x00008000 /* file tail should not be merged */
 #define FS_DIRSYNC_FL			0x00010000 /* dirsync behaviour (directories only) */
 #define FS_TOPDIR_FL			0x00020000 /* Top of directory hierarchies*/
 #define FS_EXTENT_FL			0x00080000 /* Extents */
 #define FS_DIRECTIO_FL			0x00100000 /* Use direct i/o */
 #define FS_RESERVED_FL			0x80000000 /* reserved for ext2 lib */
 #define FS_FL_USER_VISIBLE		0x0003DFFF /* User visible flags */
 #define FS_FL_USER_MODIFIABLE		0x000380FF /* User modifiable flags */
 #define SYNC_FILE_RANGE_WAIT_BEFORE	1
 #define SYNC_FILE_RANGE_WRITE		2
 #define SYNC_FILE_RANGE_WAIT_AFTER	4
 #ifdef __KERNEL__
 #include <linux/linkage.h>
 #include <linux/wait.h>
 #include <linux/types.h>
 #include <linux/kdev_t.h>
 #include <linux/dcache.h>
 #include <linux/path.h>
 #include <linux/stat.h>
 #include <linux/cache.h>
 #include <linux/kobject.h>
 #include <linux/list.h>
 #include <linux/radix-tree.h>
 #include <linux/prio_tree.h>
 #include <linux/init.h>
 #include <linux/pid.h>
 #include <linux/mutex.h>
 #include <linux/capability.h>
 #include <linux/semaphore.h>
 #include <linux/fiemap.h>
 #include <asm/atomic.h>
 #include <asm/byteorder.h>
 struct export_operations;
 struct hd_geometry;
 struct iovec;
 struct nameidata;
 struct kiocb;
 struct pipe_inode_info;
 struct poll_table_struct;
 struct kstatfs;
 struct vm_area_struct;
 struct vfsmount;
 struct cred;
 extern void __init inode_init(void);
 extern void __init inode_init_early(void);
 extern void __init files_init(unsigned long);
 extern struct files_stat_struct files_stat;
 extern int get_max_files(void);
 extern int sysctl_nr_open;
 extern struct inodes_stat_t inodes_stat;
 extern int leases_enable, lease_break_time;
 #ifdef CONFIG_DNOTIFY
 extern int dir_notify_enable;
 #endif
 struct buffer_head;
 typedef int (get_block_t)(struct inode *inode, sector_t iblock,
 			struct buffer_head *bh_result, int create);
 typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 			ssize_t bytes, void *private);
 /*
  * Attribute flags.  These should be or-ed together to figure out what
  * has been changed!
  */
 #define ATTR_MODE	(1 << 0)
 #define ATTR_UID	(1 << 1)
 #define ATTR_GID	(1 << 2)
 #define ATTR_SIZE	(1 << 3)
 #define ATTR_ATIME	(1 << 4)
 #define ATTR_MTIME	(1 << 5)
 #define ATTR_CTIME	(1 << 6)
 #define ATTR_ATIME_SET	(1 << 7)
 #define ATTR_MTIME_SET	(1 << 8)
 #define ATTR_FORCE	(1 << 9) /* Not a change, but a change it */
 #define ATTR_ATTR_FLAG	(1 << 10)
 #define ATTR_KILL_SUID	(1 << 11)
 #define ATTR_KILL_SGID	(1 << 12)
 #define ATTR_FILE	(1 << 13)
 #define ATTR_KILL_PRIV	(1 << 14)
 #define ATTR_OPEN	(1 << 15) /* Truncating from open(O_TRUNC) */
 #define ATTR_TIMES_SET	(1 << 16)
 /*
  * This is the Inode Attributes structure, used for notify_change().  It
  * uses the above definitions as flags, to know which values have changed.
  * Also, in this manner, a Filesystem can look at only the values it cares
  * about.  Basically, these are the attributes that the VFS layer can
  * request to change from the FS layer.
  *
  * Derek Atkins <warlord@MIT.EDU> 94-10-20
  */
 struct iattr {
 	unsigned int	ia_valid;
 	umode_t		ia_mode;
 	uid_t		ia_uid;
 	gid_t		ia_gid;
 	loff_t		ia_size;
 	struct timespec	ia_atime;
 	struct timespec	ia_mtime;
 	struct timespec	ia_ctime;
 	/*
 	 * Not an attribute, but an auxilary info for filesystems wanting to
 	 * implement an ftruncate() like method.  NOTE: filesystem should
 	 * check for (ia_valid & ATTR_FILE), and not for (ia_file != NULL).
 	 */
 	struct file	*ia_file;
 };
 /*
  * Includes for diskquotas.
  */
 #include <linux/quota.h>
 /**
  * enum positive_aop_returns - aop return codes with specific semantics
  *
  * @AOP_WRITEPAGE_ACTIVATE: Informs the caller that page writeback has
  * 			    completed, that the page is still locked, and
  * 			    should be considered active.  The VM uses this hint
  * 			    to return the page to the active list -- it won't
  * 			    be a candidate for writeback again in the near
  * 			    future.  Other callers must be careful to unlock
  * 			    the page if they get this return.  Returned by
  * 			    writepage();
  *
  * @AOP_TRUNCATED_PAGE: The AOP method that was handed a locked page has
  *  			unlocked it and the page might have been truncated.
  *  			The caller should back up to acquiring a new page and
  *  			trying again.  The aop will be taking reasonable
  *  			precautions not to livelock.  If the caller held a page
  *  			reference, it should drop it before retrying.  Returned
  *  			by readpage().
  *
  * address_space_operation functions return these large constants to indicate
  * special semantics to the caller.  These are much larger than the bytes in a
  * page to allow for functions that return the number of bytes operated on in a
  * given page.
  */
 enum positive_aop_returns {
 	AOP_WRITEPAGE_ACTIVATE	= 0x80000,
 	AOP_TRUNCATED_PAGE	= 0x80001,
 };
 #define AOP_FLAG_UNINTERRUPTIBLE	0x0001 /* will not do a short write */
 #define AOP_FLAG_CONT_EXPAND		0x0002 /* called from cont_expand */
 #define AOP_FLAG_NOFS			0x0004 /* used by filesystem to direct
 						* helper code (eg buffer layer)
 						* to clear GFP_FS from alloc */
 /*
  * oh the beauties of C type declarations.
  */
 struct page;
 struct address_space;
 struct writeback_control;
 struct iov_iter {
 	const struct iovec *iov;
 	unsigned long nr_segs;
 	size_t iov_offset;
 	size_t count;
 };
 size_t iov_iter_copy_from_user_atomic(struct page *page,
 		struct iov_iter *i, unsigned long offset, size_t bytes);
 size_t iov_iter_copy_from_user(struct page *page,
 		struct iov_iter *i, unsigned long offset, size_t bytes);
 void iov_iter_advance(struct iov_iter *i, size_t bytes);
 int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes);
 size_t iov_iter_single_seg_count(struct iov_iter *i);
 static inline void iov_iter_init(struct iov_iter *i,
 			const struct iovec *iov, unsigned long nr_segs,
 			size_t count, size_t written)
 {
 	i->iov = iov;
 	i->nr_segs = nr_segs;
 	i->iov_offset = 0;
 	i->count = count + written;
 	iov_iter_advance(i, written);
 }
 static inline size_t iov_iter_count(struct iov_iter *i)
 {
 	return i->count;
 }
 /*
  * "descriptor" for what we're up to with a read.
  * This allows us to use the same read code yet
  * have multiple different users of the data that
  * we read from a file.
  *
  * The simplest case just copies the data to user
  * mode.
  */
 typedef struct {
 	size_t written;
 	size_t count;
 	union {
 		char __user *buf;
 		void *data;
 	} arg;
 	int error;
 } read_descriptor_t;
 typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
 		unsigned long, unsigned long);
 struct address_space_operations {
 	int (*writepage)(struct page *page, struct writeback_control *wbc);
 	int (*readpage)(struct file *, struct page *);
 	void (*sync_page)(struct page *);
 	/* Write back some dirty pages from this mapping. */
 	int (*writepages)(struct address_space *, struct writeback_control *);
 	/* Set a page dirty.  Return true if this dirtied it */
 	int (*set_page_dirty)(struct page *page);
 	int (*readpages)(struct file *filp, struct address_space *mapping,
 			struct list_head *pages, unsigned nr_pages);
 	int (*write_begin)(struct file *, struct address_space *mapping,
 				loff_t pos, unsigned len, unsigned flags,
 				struct page **pagep, void **fsdata);
 	int (*write_end)(struct file *, struct address_space *mapping,
 				loff_t pos, unsigned len, unsigned copied,
 				struct page *page, void *fsdata);
 	/* Unfortunately this kludge is needed for FIBMAP. Don't use it */
 	sector_t (*bmap)(struct address_space *, sector_t);
 	void (*invalidatepage) (struct page *, unsigned long);
 	int (*releasepage) (struct page *, gfp_t);
 	ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
 			loff_t offset, unsigned long nr_segs);
 	int (*get_xip_mem)(struct address_space *, pgoff_t, int,
 						void **, unsigned long *);
 	/* migrate the contents of a page to the specified target */
 	int (*migratepage) (struct address_space *,
 			struct page *, struct page *);
 	int (*launder_page) (struct page *);
 	int (*is_partially_uptodate) (struct page *, read_descriptor_t *,
 					unsigned long);
 };
 /*
  * pagecache_write_begin/pagecache_write_end must be used by general code
  * to write into the pagecache.
  */
 int pagecache_write_begin(struct file *, struct address_space *mapping,
 				loff_t pos, unsigned len, unsigned flags,
 				struct page **pagep, void **fsdata);
 int pagecache_write_end(struct file *, struct address_space *mapping,
 				loff_t pos, unsigned len, unsigned copied,
 				struct page *page, void *fsdata);
 struct backing_dev_info;
 struct address_space {
 	struct inode		*host;		/* owner: inode, block_device */
 	struct radix_tree_root	page_tree;	/* radix tree of all pages */
 	spinlock_t		tree_lock;	/* and lock protecting it */
 	unsigned int		i_mmap_writable;/* count VM_SHARED mappings */
 	struct prio_tree_root	i_mmap;		/* tree of private and shared mappings */
 	struct list_head	i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
 	spinlock_t		i_mmap_lock;	/* protect tree, count, list */
 	unsigned int		truncate_count;	/* Cover race condition with truncate */
 	unsigned long		nrpages;	/* number of total pages */
 	pgoff_t			writeback_index;/* writeback starts here */
 	const struct address_space_operations *a_ops;	/* methods */
 	unsigned long		flags;		/* error bits/gfp mask */
 	struct backing_dev_info *backing_dev_info; /* device readahead, etc */
 	spinlock_t		private_lock;	/* for use by the address_space */
 	struct list_head	private_list;	/* ditto */
 	struct address_space	*assoc_mapping;	/* ditto */
 } __attribute__((aligned(sizeof(long))));
 	/*
 	 * On most architectures that alignment is already the case; but
 	 * must be enforced here for CRIS, to let the least signficant bit
 	 * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
 	 */
 struct block_device {
 	dev_t			bd_dev;  /* not a kdev_t - it's a search key */
 	struct inode *		bd_inode;	/* will die */
 	struct super_block *	bd_super;
 	int			bd_openers;
 	struct mutex		bd_mutex;	/* open/close mutex */
 	struct semaphore	bd_mount_sem;
 	struct list_head	bd_inodes;
 	void *			bd_holder;
 	int			bd_holders;
 #ifdef CONFIG_SYSFS
 	struct list_head	bd_holder_list;
 #endif
 	struct block_device *	bd_contains;
 	unsigned		bd_block_size;
 	struct hd_struct *	bd_part;
 	/* number of times partitions within this device have been opened. */
 	unsigned		bd_part_count;
 	int			bd_invalidated;
 	struct gendisk *	bd_disk;
 	struct list_head	bd_list;
 	struct backing_dev_info *bd_inode_backing_dev_info;
 	/*
 	 * Private data.  You must have bd_claim'ed the block_device
 	 * to use this.  NOTE:  bd_claim allows an owner to claim
 	 * the same device multiple times, the owner must take special
 	 * care to not mess up bd_private for that case.
 	 */
 	unsigned long		bd_private;
 	/* The counter of freeze processes */
 	int			bd_fsfreeze_count;
 	/* Mutex for freeze */
 	struct mutex		bd_fsfreeze_mutex;
 };
 /*
  * Radix-tree tags, for tagging dirty and writeback pages within the pagecache
  * radix trees
  */
 #define PAGECACHE_TAG_DIRTY	0
 #define PAGECACHE_TAG_WRITEBACK	1
 int mapping_tagged(struct address_space *mapping, int tag);
 /*
  * Might pages of this file be mapped into userspace?
  */
 static inline int mapping_mapped(struct address_space *mapping)
 {
 	return	!prio_tree_empty(&mapping->i_mmap) ||
 		!list_empty(&mapping->i_mmap_nonlinear);
 }
 /*
  * Might pages of this file have been modified in userspace?
  * Note that i_mmap_writable counts all VM_SHARED vmas: do_mmap_pgoff
  * marks vma as VM_SHARED if it is shared, and the file was opened for
  * writing i.e. vma may be mprotected writable even if now readonly.
  */
 static inline int mapping_writably_mapped(struct address_space *mapping)
 {
 	return mapping->i_mmap_writable != 0;
 }
 /*
  * Use sequence counter to get consistent i_size on 32-bit processors.
  */
 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
 #include <linux/seqlock.h>
 #define __NEED_I_SIZE_ORDERED
 #define i_size_ordered_init(inode) seqcount_init(&inode->i_size_seqcount)
 #else
 #define i_size_ordered_init(inode) do { } while (0)
 #endif
 struct inode {
 	struct hlist_node	i_hash;
 	struct list_head	i_list;
 	struct list_head	i_sb_list;
 	struct list_head	i_dentry;
 	unsigned long		i_ino;
 	atomic_t		i_count;
 	unsigned int		i_nlink;
 	uid_t			i_uid;
 	gid_t			i_gid;
 	dev_t			i_rdev;
 	u64			i_version;
 	loff_t			i_size;
 #ifdef __NEED_I_SIZE_ORDERED
 	seqcount_t		i_size_seqcount;
 #endif
 	struct timespec		i_atime;
 	struct timespec		i_mtime;
 	struct timespec		i_ctime;
 	unsigned int		i_blkbits;
 	blkcnt_t		i_blocks;
 	unsigned short          i_bytes;
 	umode_t			i_mode;
 	spinlock_t		i_lock;	/* i_blocks, i_bytes, maybe i_size */
 	struct mutex		i_mutex;
 	struct rw_semaphore	i_alloc_sem;
 	const struct inode_operations	*i_op;
 	const struct file_operations	*i_fop;	/* former ->i_op->default_file_ops */
 	struct super_block	*i_sb;
 	struct file_lock	*i_flock;
 	struct address_space	*i_mapping;
 	struct address_space	i_data;
 #ifdef CONFIG_QUOTA
 	struct dquot		*i_dquot[MAXQUOTAS];
 #endif
 	struct list_head	i_devices;
 	union {
 		struct pipe_inode_info	*i_pipe;
 		struct block_device	*i_bdev;
 		struct cdev		*i_cdev;
 	};
 	int			i_cindex;
 	__u32			i_generation;
 #ifdef CONFIG_FSNOTIFY
 	__u32			i_fsnotify_mask; /* all events this inode cares about */
 	struct hlist_head	i_fsnotify_mark_entries; /* fsnotify mark entries */
 #endif
 #ifdef CONFIG_INOTIFY
 	struct list_head	inotify_watches; /* watches on this inode */
 	struct mutex		inotify_mutex;	/* protects the watches list */
 #endif
 	unsigned long		i_state;
 	unsigned long		dirtied_when;	/* jiffies of first dirtying */
 	unsigned int		i_flags;
 	atomic_t		i_writecount;
 #ifdef CONFIG_SECURITY
 	void			*i_security;
 #endif
 	void			*i_private; /* fs or device private pointer */
 };
 /*
  * inode->i_mutex nesting subclasses for the lock validator:
  *
  * 0: the object of the current VFS operation
  * 1: parent
  * 2: child/target
  * 3: quota file
  *
  * The locking order between these classes is
  * parent -> child -> normal -> xattr -> quota
  */
 enum inode_i_mutex_lock_class
 {
 	I_MUTEX_NORMAL,
 	I_MUTEX_PARENT,
 	I_MUTEX_CHILD,
 	I_MUTEX_XATTR,
 	I_MUTEX_QUOTA
 };
 /*
  * NOTE: in a 32bit arch with a preemptable kernel and
  * an UP compile the i_size_read/write must be atomic
  * with respect to the local cpu (unlike with preempt disabled),
  * but they don't need to be atomic with respect to other cpus like in
  * true SMP (so they need either to either locally disable irq around
  * the read or for example on x86 they can be still implemented as a
  * cmpxchg8b without the need of the lock prefix). For SMP compiles
  * and 64bit archs it makes no difference if preempt is enabled or not.
  */
 static inline loff_t i_size_read(const struct inode *inode)
 {
 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
 	loff_t i_size;
 	unsigned int seq;
 	do {
 		seq = read_seqcount_begin(&inode->i_size_seqcount);
 		i_size = inode->i_size;
 	} while (read_seqcount_retry(&inode->i_size_seqcount, seq));
 	return i_size;
 #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
 	loff_t i_size;
 	preempt_disable();
 	i_size = inode->i_size;
 	preempt_enable();
 	return i_size;
 #else
 	return inode->i_size;
 #endif
 }
 /*
  * NOTE: unlike i_size_read(), i_size_write() does need locking around it
  * (normally i_mutex), otherwise on 32bit/SMP an update of i_size_seqcount
  * can be lost, resulting in subsequent i_size_read() calls spinning forever.
  */
 static inline void i_size_write(struct inode *inode, loff_t i_size)
 {
 #if BITS_PER_LONG==32 && defined(CONFIG_SMP)
 	write_seqcount_begin(&inode->i_size_seqcount);
 	inode->i_size = i_size;
 	write_seqcount_end(&inode->i_size_seqcount);
 #elif BITS_PER_LONG==32 && defined(CONFIG_PREEMPT)
 	preempt_disable();
 	inode->i_size = i_size;
 	preempt_enable();
 #else
 	inode->i_size = i_size;
 #endif
 }
 static inline unsigned iminor(const struct inode *inode)
 {
 	return MINOR(inode->i_rdev);
 }
 static inline unsigned imajor(const struct inode *inode)
 {
 	return MAJOR(inode->i_rdev);
 }
 extern struct block_device *I_BDEV(struct inode *inode);
 struct fown_struct {
 	rwlock_t lock;          /* protects pid, uid, euid fields */
 	struct pid *pid;	/* pid or -pgrp where SIGIO should be sent */
 	enum pid_type pid_type;	/* Kind of process group SIGIO should be sent to */
 	uid_t uid, euid;	/* uid/euid of process setting the owner */
 	int signum;		/* posix.1b rt signal to be delivered on IO */
 };
 /*
  * Track a single file's readahead state
  */
 struct file_ra_state {
 	pgoff_t start;			/* where readahead started */
 	unsigned int size;		/* # of readahead pages */
 	unsigned int async_size;	/* do asynchronous readahead when
 					   there are only # of pages ahead */
 	unsigned int ra_pages;		/* Maximum readahead window */
 	int mmap_miss;			/* Cache miss stat for mmap accesses */
 	loff_t prev_pos;		/* Cache last read() position */
 };
 /*
  * Check if @index falls in the readahead windows.
  */
 static inline int ra_has_index(struct file_ra_state *ra, pgoff_t index)
 {
 	return (index >= ra->start &&
 		index <  ra->start + ra->size);
 }
 #define FILE_MNT_WRITE_TAKEN	1
 #define FILE_MNT_WRITE_RELEASED	2
 struct file {
 	/*
 	 * fu_list becomes invalid after file_free is called and queued via
 	 * fu_rcuhead for RCU freeing
 	 */
 	union {
 		struct list_head	fu_list;
 		struct rcu_head 	fu_rcuhead;
 	} f_u;
 	struct path		f_path;
 #define f_dentry	f_path.dentry
 #define f_vfsmnt	f_path.mnt
 	const struct file_operations	*f_op;
 	spinlock_t		f_lock;  /* f_ep_links, f_flags, no IRQ */
 	atomic_long_t		f_count;
 	unsigned int 		f_flags;
 	fmode_t			f_mode;
 	loff_t			f_pos;
 	struct fown_struct	f_owner;
 	const struct cred	*f_cred;
 	struct file_ra_state	f_ra;
 	u64			f_version;
 #ifdef CONFIG_SECURITY
 	void			*f_security;
 #endif
 	/* needed for tty driver, and maybe others */
 	void			*private_data;
 #ifdef CONFIG_EPOLL
 	/* Used by fs/eventpoll.c to link all the hooks to this file */
 	struct list_head	f_ep_links;
 #endif /* #ifdef CONFIG_EPOLL */
 	struct address_space	*f_mapping;
 #ifdef CONFIG_DEBUG_WRITECOUNT
 	unsigned long f_mnt_write_state;
 #endif
 };
 extern spinlock_t files_lock;
 #define file_list_lock() spin_lock(&files_lock);
 #define file_list_unlock() spin_unlock(&files_lock);
 #define get_file(x)	atomic_long_inc(&(x)->f_count)
 #define file_count(x)	atomic_long_read(&(x)->f_count)
 #ifdef CONFIG_DEBUG_WRITECOUNT
 static inline void file_take_write(struct file *f)
 {
 	WARN_ON(f->f_mnt_write_state != 0);
 	f->f_mnt_write_state = FILE_MNT_WRITE_TAKEN;
 }
 static inline void file_release_write(struct file *f)
 {
 	f->f_mnt_write_state |= FILE_MNT_WRITE_RELEASED;
 }
 static inline void file_reset_write(struct file *f)
 {
 	f->f_mnt_write_state = 0;
 }
 static inline void file_check_state(struct file *f)
 {
 	/*
 	 * At this point, either both or neither of these bits
 	 * should be set.
 	 */
 	WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN);
 	WARN_ON(f->f_mnt_write_state == FILE_MNT_WRITE_RELEASED);
 }
 static inline int file_check_writeable(struct file *f)
 {
 	if (f->f_mnt_write_state == FILE_MNT_WRITE_TAKEN)
 		return 0;
 	printk(KERN_WARNING "writeable file with no "
 			    "mnt_want_write()\n");
 	WARN_ON(1);
 	return -EINVAL;
 }
 #else /* !CONFIG_DEBUG_WRITECOUNT */
 static inline void file_take_write(struct file *filp) {}
 static inline void file_release_write(struct file *filp) {}
 static inline void file_reset_write(struct file *filp) {}
 static inline void file_check_state(struct file *filp) {}
 static inline int file_check_writeable(struct file *filp)
 {
 	return 0;
 }
 #endif /* CONFIG_DEBUG_WRITECOUNT */
 #define	MAX_NON_LFS	((1UL<<31) - 1)
 /* Page cache limit. The filesystems should put that into their s_maxbytes
    limits, otherwise bad things can happen in VM. */
 #if BITS_PER_LONG==32
 #define MAX_LFS_FILESIZE	(((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
 #elif BITS_PER_LONG==64
 #define MAX_LFS_FILESIZE 	0x7fffffffffffffffUL
 #endif
 #define FL_POSIX	1
 #define FL_FLOCK	2
 #define FL_ACCESS	8	/* not trying to lock, just looking */
 #define FL_EXISTS	16	/* when unlocking, test for existence */
 #define FL_LEASE	32	/* lease held on this file */
 #define FL_CLOSE	64	/* unlock on close */
 #define FL_SLEEP	128	/* A blocking lock */
 /*
  * Special return value from posix_lock_file() and vfs_lock_file() for
  * asynchronous locking.
  */
 #define FILE_LOCK_DEFERRED 1
 /*
  * The POSIX file lock owner is determined by
  * the "struct files_struct" in the thread group
  * (or NULL for no owner - BSD locks).
  *
  * Lockd stuffs a "host" pointer into this.
  */
 typedef struct files_struct *fl_owner_t;
 struct file_lock_operations {
 	void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
 	void (*fl_release_private)(struct file_lock *);
 };
 struct lock_manager_operations {
 	int (*fl_compare_owner)(struct file_lock *, struct file_lock *);
 	void (*fl_notify)(struct file_lock *);	/* unblock callback */
 	int (*fl_grant)(struct file_lock *, struct file_lock *, int);
 	void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
 	void (*fl_release_private)(struct file_lock *);
 	void (*fl_break)(struct file_lock *);
 	int (*fl_mylease)(struct file_lock *, struct file_lock *);
 	int (*fl_change)(struct file_lock **, int);
 };
 struct lock_manager {
 	struct list_head list;
 };
 void locks_start_grace(struct lock_manager *);
 void locks_end_grace(struct lock_manager *);
 int locks_in_grace(void);
 /* that will die - we need it for nfs_lock_info */
 #include <linux/nfs_fs_i.h>
 struct file_lock {
 	struct file_lock *fl_next;	/* singly linked list for this inode  */
 	struct list_head fl_link;	/* doubly linked list of all locks */
 	struct list_head fl_block;	/* circular list of blocked processes */
 	fl_owner_t fl_owner;
 	unsigned char fl_flags;
 	unsigned char fl_type;
 	unsigned int fl_pid;
 	struct pid *fl_nspid;
 	wait_queue_head_t fl_wait;
 	struct file *fl_file;
 	loff_t fl_start;
 	loff_t fl_end;
 	struct fasync_struct *	fl_fasync; /* for lease break notifications */
 	unsigned long fl_break_time;	/* for nonblocking lease breaks */
 	struct file_lock_operations *fl_ops;	/* Callbacks for filesystems */
 	struct lock_manager_operations *fl_lmops;	/* Callbacks for lockmanagers */
 	union {
 		struct nfs_lock_info	nfs_fl;
 		struct nfs4_lock_info	nfs4_fl;
 		struct {
 			struct list_head link;	/* link in AFS vnode's pending_locks list */
 			int state;		/* state of grant or error if -ve */
 		} afs;
 	} fl_u;
 };
 /* The following constant reflects the upper bound of the file/locking space */
 #ifndef OFFSET_MAX
 #define INT_LIMIT(x)	(~((x)1 << (sizeof(x)*8 - 1)))
 #define OFFSET_MAX	INT_LIMIT(loff_t)
 #define OFFT_OFFSET_MAX	INT_LIMIT(off_t)
 #endif
 #include <linux/fcntl.h>
 extern void send_sigio(struct fown_struct *fown, int fd, int band);
 /* fs/sync.c */
 extern int do_sync_mapping_range(struct address_space *mapping, loff_t offset,
 			loff_t endbyte, unsigned int flags);
 #ifdef CONFIG_FILE_LOCKING
 extern int fcntl_getlk(struct file *, struct flock __user *);
 extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
 			struct flock __user *);
 #if BITS_PER_LONG == 32
 extern int fcntl_getlk64(struct file *, struct flock64 __user *);
 extern int fcntl_setlk64(unsigned int, struct file *, unsigned int,
 			struct flock64 __user *);
 #endif
 extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
 extern int fcntl_getlease(struct file *filp);
 /* fs/locks.c */
 extern void locks_init_lock(struct file_lock *);
 extern void locks_copy_lock(struct file_lock *, struct file_lock *);
 extern void __locks_copy_lock(struct file_lock *, const struct file_lock *);
 extern void locks_remove_posix(struct file *, fl_owner_t);
 extern void locks_remove_flock(struct file *);
 extern void posix_test_lock(struct file *, struct file_lock *);
 extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
 extern int posix_lock_file_wait(struct file *, struct file_lock *);
 extern int posix_unblock_lock(struct file *, struct file_lock *);
 extern int vfs_test_lock(struct file *, struct file_lock *);
 extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
 extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
 extern int flock_lock_file_wait(struct file *filp, struct file_lock *fl);
 extern int __break_lease(struct inode *inode, unsigned int flags);
 extern void lease_get_mtime(struct inode *, struct timespec *time);
 extern int generic_setlease(struct file *, long, struct file_lock **);
 extern int vfs_setlease(struct file *, long, struct file_lock **);
 extern int lease_modify(struct file_lock **, int);
 extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
 extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
 #else /* !CONFIG_FILE_LOCKING */
 static inline int fcntl_getlk(struct file *file, struct flock __user *user)
 {
 	return -EINVAL;
 }
 static inline int fcntl_setlk(unsigned int fd, struct file *file,
 			      unsigned int cmd, struct flock __user *user)
 {
 	return -EACCES;
 }
 #if BITS_PER_LONG == 32
 static inline int fcntl_getlk64(struct file *file, struct flock64 __user *user)
 {
 	return -EINVAL;
 }
 static inline int fcntl_setlk64(unsigned int fd, struct file *file,
 				unsigned int cmd, struct flock64 __user *user)
 {
 	return -EACCES;
 }
 #endif
 static inline int fcntl_setlease(unsigned int fd, struct file *filp, long arg)
 {
 	return 0;
 }
 static inline int fcntl_getlease(struct file *filp)
 {
 	return 0;
 }
 static inline void locks_init_lock(struct file_lock *fl)
 {
 	return;
 }
 static inline void __locks_copy_lock(struct file_lock *new, struct file_lock *fl)
 {
 	return;
 }
 static inline void locks_copy_lock(struct file_lock *new, struct file_lock *fl)
 {
 	return;
 }
 static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)
 {
 	return;
 }
 static inline void locks_remove_flock(struct file *filp)
 {
 	return;
 }
 static inline void posix_test_lock(struct file *filp, struct file_lock *fl)
 {
 	return;
 }
 static inline int posix_lock_file(struct file *filp, struct file_lock *fl,
 				  struct file_lock *conflock)
 {
 	return -ENOLCK;
 }
 static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
 {
 	return -ENOLCK;
 }
 static inline int posix_unblock_lock(struct file *filp,
 				     struct file_lock *waiter)
 {
 	return -ENOENT;
 }
 static inline int vfs_test_lock(struct file *filp, struct file_lock *fl)
 {
 	return 0;
 }
 static inline int vfs_lock_file(struct file *filp, unsigned int cmd,
 				struct file_lock *fl, struct file_lock *conf)
 {
 	return -ENOLCK;
 }
 static inline int vfs_cancel_lock(struct file *filp, struct file_lock *fl)
 {
 	return 0;
 }
 static inline int flock_lock_file_wait(struct file *filp,
 				       struct file_lock *request)
 {
 	return -ENOLCK;
 }
 static inline int __break_lease(struct inode *inode, unsigned int mode)
 {
 	return 0;
 }
 static inline void lease_get_mtime(struct inode *inode, struct timespec *time)
 {
 	return;
 }
 static inline int generic_setlease(struct file *filp, long arg,
 				    struct file_lock **flp)
 {
 	return -EINVAL;
 }
 static inline int vfs_setlease(struct file *filp, long arg,
 			       struct file_lock **lease)
 {
 	return -EINVAL;
 }
 static inline int lease_modify(struct file_lock **before, int arg)
 {
 	return -EINVAL;
 }
 static inline int lock_may_read(struct inode *inode, loff_t start,
 				unsigned long len)
 {
 	return 1;
 }
 static inline int lock_may_write(struct inode *inode, loff_t start,
 				 unsigned long len)
 {
 	return 1;
 }
 #endif /* !CONFIG_FILE_LOCKING */
 struct fasync_struct {
 	int	magic;
 	int	fa_fd;
 	struct	fasync_struct	*fa_next; /* singly linked list */
 	struct	file 		*fa_file;
 };
 #define FASYNC_MAGIC 0x4601
 /* SMP safe fasync helpers: */
 extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
 /* can be called from interrupts */
 extern void kill_fasync(struct fasync_struct **, int, int);
 /* only for net: no internal synchronization */
 extern void __kill_fasync(struct fasync_struct *, int, int);
 extern int __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
 extern int f_setown(struct file *filp, unsigned long arg, int force);
 extern void f_delown(struct file *filp);
 extern pid_t f_getown(struct file *filp);
 extern int send_sigurg(struct fown_struct *fown);
 /*
  *	Umount options
  */
 #define MNT_FORCE	0x00000001	/* Attempt to forcibily umount */
 #define MNT_DETACH	0x00000002	/* Just detach from the tree */
 #define MNT_EXPIRE	0x00000004	/* Mark for expiry */
 extern struct list_head super_blocks;
 extern spinlock_t sb_lock;
 #define sb_entry(list)  list_entry((list), struct super_block, s_list)
 #define S_BIAS (1<<30)
 struct super_block {
 	struct list_head	s_list;		/* Keep this first */
 	dev_t			s_dev;		/* search index; _not_ kdev_t */
 	unsigned long		s_blocksize;
 	unsigned char		s_blocksize_bits;
 	unsigned char		s_dirt;
 	unsigned long long	s_maxbytes;	/* Max file size */
 	struct file_system_type	*s_type;
 	const struct super_operations	*s_op;
 	struct dquot_operations	*dq_op;
  	struct quotactl_ops	*s_qcop;
 	const struct export_operations *s_export_op;
 	unsigned long		s_flags;
 	unsigned long		s_magic;
 	struct dentry		*s_root;
 	struct rw_semaphore	s_umount;
 	struct mutex		s_lock;
 	int			s_count;
 	int			s_need_sync_fs;
 	atomic_t		s_active;
 #ifdef CONFIG_SECURITY
 	void                    *s_security;
 #endif
 	struct xattr_handler	**s_xattr;
 	struct list_head	s_inodes;	/* all inodes */
 	struct list_head	s_dirty;	/* dirty inodes */
 	struct list_head	s_io;		/* parked for writeback */
 	struct list_head	s_more_io;	/* parked for more writeback */
 	struct hlist_head	s_anon;		/* anonymous dentries for (nfs) exporting */
 	struct list_head	s_files;
 	/* s_dentry_lru and s_nr_dentry_unused are protected by dcache_lock */
 	struct list_head	s_dentry_lru;	/* unused dentry lru */
 	int			s_nr_dentry_unused;	/* # of dentry on lru */
 	struct block_device	*s_bdev;
 	struct mtd_info		*s_mtd;
 	struct list_head	s_instances;
 	struct quota_info	s_dquot;	/* Diskquota specific options */
 	int			s_frozen;
 	wait_queue_head_t	s_wait_unfrozen;
 	char s_id[32];				/* Informational name */
 	void 			*s_fs_info;	/* Filesystem private info */
 	fmode_t			s_mode;
 	/*
 	 * The next field is for VFS *only*. No filesystems have any business
 	 * even looking at it. You had been warned.
 	 */
 	struct mutex s_vfs_rename_mutex;	/* Kludge */
 	/* Granularity of c/m/atime in ns.
 	   Cannot be worse than a second */
 	u32		   s_time_gran;
 	/*
 	 * Filesystem subtype.  If non-empty the filesystem type field
 	 * in /proc/mounts will be "type.subtype"
 	 */
 	char *s_subtype;
 	/*
 	 * Saved mount options for lazy filesystems using
 	 * generic_show_options()
 	 */
 	char *s_options;
 };
 extern struct timespec current_fs_time(struct super_block *sb);
 /*
  * Snapshotting support.
  */
 enum {
 	SB_UNFROZEN = 0,
 	SB_FREEZE_WRITE	= 1,
 	SB_FREEZE_TRANS = 2,
 };
 #define vfs_check_frozen(sb, level) \
 	wait_event((sb)->s_wait_unfrozen, ((sb)->s_frozen < (level)))
 #define get_fs_excl() atomic_inc(&current->fs_excl)
 #define put_fs_excl() atomic_dec(&current->fs_excl)
 #define has_fs_excl() atomic_read(&current->fs_excl)
 #define is_owner_or_cap(inode)	\
 	((current_fsuid() == (inode)->i_uid) || capable(CAP_FOWNER))
 /* not quite ready to be deprecated, but... */
 extern void lock_super(struct super_block *);
 extern void unlock_super(struct super_block *);
 /*
  * VFS helper functions..
  */
 extern int vfs_create(struct inode *, struct dentry *, int, struct nameidata *);
 extern int vfs_mkdir(struct inode *, struct dentry *, int);
 extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
 extern int vfs_symlink(struct inode *, struct dentry *, const char *);
 extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
 extern int vfs_rmdir(struct inode *, struct dentry *);
 extern int vfs_unlink(struct inode *, struct dentry *);
 extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
 /*
  * VFS dentry helper functions.
  */
 extern void dentry_unhash(struct dentry *dentry);
 /*
  * VFS file helper functions.
  */
 extern int file_permission(struct file *, int);
 /*
  * VFS FS_IOC_FIEMAP helper definitions.
  */
 struct fiemap_extent_info {
 	unsigned int fi_flags;		/* Flags as passed from user */
 	unsigned int fi_extents_mapped;	/* Number of mapped extents */
 	unsigned int fi_extents_max;	/* Size of fiemap_extent array */
 	struct fiemap_extent *fi_extents_start; /* Start of fiemap_extent
 						 * array */
 };
 int fiemap_fill_next_extent(struct fiemap_extent_info *info, u64 logical,
 			    u64 phys, u64 len, u32 flags);
 int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
 /*
  * File types
  *
  * NOTE! These match bits 12..15 of stat.st_mode
  * (ie "(i_mode >> 12) & 15").
  */
 #define DT_UNKNOWN	0
 #define DT_FIFO		1
 #define DT_CHR		2
 #define DT_DIR		4
 #define DT_BLK		6
 #define DT_REG		8
 #define DT_LNK		10
 #define DT_SOCK		12
 #define DT_WHT		14
 #define OSYNC_METADATA	(1<<0)
 #define OSYNC_DATA	(1<<1)
 #define OSYNC_INODE	(1<<2)
 int generic_osync_inode(struct inode *, struct address_space *, int);
 /*
  * This is the "filldir" function type, used by readdir() to let
  * the kernel specify what kind of dirent layout it wants to have.
  * This allows the kernel to read directories into kernel space or
  * to have different dirent layouts depending on the binary type.
  */
 typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
 struct block_device_operations;
 /* These macros are for out of kernel modules to test that
  * the kernel supports the unlocked_ioctl and compat_ioctl
  * fields in struct file_operations. */
 #define HAVE_COMPAT_IOCTL 1
 #define HAVE_UNLOCKED_IOCTL 1
 /*
  * NOTE:
  * read, write, poll, fsync, readv, writev, unlocked_ioctl and compat_ioctl
  * can be called without the big kernel lock held in all filesystems.
  */
 struct file_operations {
 	struct module *owner;
 	loff_t (*llseek) (struct file *, loff_t, int);
 	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
 	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
 	ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
 	ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
 	int (*readdir) (struct file *, void *, filldir_t);
 	unsigned int (*poll) (struct file *, struct poll_table_struct *);
 	int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
 	long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
 	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
 	int (*mmap) (struct file *, struct vm_area_struct *);
 	int (*open) (struct inode *, struct file *);
 	int (*flush) (struct file *, fl_owner_t id);
 	int (*release) (struct inode *, struct file *);
 	int (*fsync) (struct file *, struct dentry *, int datasync);
 	int (*aio_fsync) (struct kiocb *, int datasync);
 	int (*fasync) (int, struct file *, int);
 	int (*lock) (struct file *, int, struct file_lock *);
 	ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
 	unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
 	int (*check_flags)(int);
 	int (*flock) (struct file *, int, struct file_lock *);
 	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
 	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
 	int (*setlease)(struct file *, long, struct file_lock **);
 };
 struct inode_operations {
 	int (*create) (struct inode *,struct dentry *,int, struct nameidata *);
 	struct dentry * (*lookup) (struct inode *,struct dentry *, struct nameidata *);
 	int (*link) (struct dentry *,struct inode *,struct dentry *);
 	int (*unlink) (struct inode *,struct dentry *);
 	int (*symlink) (struct inode *,struct dentry *,const char *);
 	int (*mkdir) (struct inode *,struct dentry *,int);
 	int (*rmdir) (struct inode *,struct dentry *);
 	int (*mknod) (struct inode *,struct dentry *,int,dev_t);
 	int (*rename) (struct inode *, struct dentry *,
 			struct inode *, struct dentry *);
 	int (*readlink) (struct dentry *, char __user *,int);
 	void * (*follow_link) (struct dentry *, struct nameidata *);
 	void (*put_link) (struct dentry *, struct nameidata *, void *);
 	void (*truncate) (struct inode *);
 	int (*permission) (struct inode *, int);
 	int (*setattr) (struct dentry *, struct iattr *);
 	int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
 	int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
 	ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
 	ssize_t (*listxattr) (struct dentry *, char *, size_t);
 	int (*removexattr) (struct dentry *, const char *);
 	void (*truncate_range)(struct inode *, loff_t, loff_t);
 	long (*fallocate)(struct inode *inode, int mode, loff_t offset,
 			  loff_t len);
 	int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
 		      u64 len);
 };
 struct seq_file;
 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
 				unsigned long nr_segs, unsigned long fast_segs,
 				struct iovec *fast_pointer,
 				struct iovec **ret_pointer);
 extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);
 extern ssize_t vfs_write(struct file *, const char __user *, size_t, loff_t *);
 extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
 		unsigned long, loff_t *);
 extern ssize_t vfs_writev(struct file *, const struct iovec __user *,
 		unsigned long, loff_t *);
 struct super_operations {
    	struct inode *(*alloc_inode)(struct super_block *sb);
 	void (*destroy_inode)(struct inode *);
    	void (*dirty_inode) (struct inode *);
 	int (*write_inode) (struct inode *, int);
 	void (*drop_inode) (struct inode *);
 	void (*delete_inode) (struct inode *);
 	void (*put_super) (struct super_block *);
 	void (*write_super) (struct super_block *);
 	int (*sync_fs)(struct super_block *sb, int wait);
 	int (*freeze_fs) (struct super_block *);
 	int (*unfreeze_fs) (struct super_block *);
 	int (*statfs) (struct dentry *, struct kstatfs *);
 	int (*remount_fs) (struct super_block *, int *, char *);
 	void (*clear_inode) (struct inode *);
 	void (*umount_begin) (struct super_block *);
 	int (*show_options)(struct seq_file *, struct vfsmount *);
 	int (*show_stats)(struct seq_file *, struct vfsmount *);
 #ifdef CONFIG_QUOTA
 	ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
 	ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
 #endif
 	int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
 };
 /*
  * Inode state bits.  Protected by inode_lock.
  *
  * Three bits determine the dirty state of the inode, I_DIRTY_SYNC,
  * I_DIRTY_DATASYNC and I_DIRTY_PAGES.
  *
  * Four bits define the lifetime of an inode.  Initially, inodes are I_NEW,
  * until that flag is cleared.  I_WILL_FREE, I_FREEING and I_CLEAR are set at
  * various stages of removing an inode.
  *
  * Two bits are used for locking and completion notification, I_LOCK and I_SYNC.
  *
  * I_DIRTY_SYNC		Inode is dirty, but doesn't have to be written on
  *			fdatasync().  i_atime is the usual cause.
  * I_DIRTY_DATASYNC	Data-related inode changes pending. We keep track of
  *			these changes separately from I_DIRTY_SYNC so that we
  *			don't have to write inode on fdatasync() when only
  *			mtime has changed in it.
  * I_DIRTY_PAGES	Inode has dirty pages.  Inode itself may be clean.
  * I_NEW		get_new_inode() sets i_state to I_LOCK|I_NEW.  Both
  *			are cleared by unlock_new_inode(), called from iget().
  * I_WILL_FREE		Must be set when calling write_inode_now() if i_count
  *			is zero.  I_FREEING must be set when I_WILL_FREE is
  *			cleared.
  * I_FREEING		Set when inode is about to be freed but still has dirty
  *			pages or buffers attached or the inode itself is still
  *			dirty.
  * I_CLEAR		Set by clear_inode().  In this state the inode is clean
  *			and can be destroyed.
  *
  *			Inodes that are I_WILL_FREE, I_FREEING or I_CLEAR are
  *			prohibited for many purposes.  iget() must wait for
  *			the inode to be completely released, then create it
  *			anew.  Other functions will just ignore such inodes,
  *			if appropriate.  I_LOCK is used for waiting.
  *
  * I_LOCK		Serves as both a mutex and completion notification.
  *			New inodes set I_LOCK.  If two processes both create
  *			the same inode, one of them will release its inode and
  *			wait for I_LOCK to be released before returning.
  *			Inodes in I_WILL_FREE, I_FREEING or I_CLEAR state can
  *			also cause waiting on I_LOCK, without I_LOCK actually
  *			being set.  find_inode() uses this to prevent returning
  *			nearly-dead inodes.
  * I_SYNC		Similar to I_LOCK, but limited in scope to writeback
  *			of inode dirty data.  Having a separate lock for this
  *			purpose reduces latency and prevents some filesystem-
  *			specific deadlocks.
  *
  * Q: What is the difference between I_WILL_FREE and I_FREEING?
  * Q: igrab() only checks on (I_FREEING|I_WILL_FREE).  Should it also check on
  *    I_CLEAR?  If not, why?
  */
 #define I_DIRTY_SYNC		1
 #define I_DIRTY_DATASYNC	2
 #define I_DIRTY_PAGES		4
 #define I_NEW			8
 #define I_WILL_FREE		16
 #define I_FREEING		32
 #define I_CLEAR			64
 #define __I_LOCK		7
 #define I_LOCK			(1 << __I_LOCK)
 #define __I_SYNC		8
 #define I_SYNC			(1 << __I_SYNC)
 #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
 extern void __mark_inode_dirty(struct inode *, int);
 static inline void mark_inode_dirty(struct inode *inode)
 {
 	__mark_inode_dirty(inode, I_DIRTY);
 }
 static inline void mark_inode_dirty_sync(struct inode *inode)
 {
 	__mark_inode_dirty(inode, I_DIRTY_SYNC);
 }
 /**
  * inc_nlink - directly increment an inode's link count
  * @inode: inode
  *
  * This is a low-level filesystem helper to replace any
  * direct filesystem manipulation of i_nlink.  Currently,
  * it is only here for parity with dec_nlink().
  */
 static inline void inc_nlink(struct inode *inode)
 {
 	inode->i_nlink++;
 }
 static inline void inode_inc_link_count(struct inode *inode)
 {
 	inc_nlink(inode);
 	mark_inode_dirty(inode);
 }
 /**
  * drop_nlink - directly drop an inode's link count
  * @inode: inode
  *
  * This is a low-level filesystem helper to replace any
  * direct filesystem manipulation of i_nlink.  In cases
  * where we are attempting to track writes to the
  * filesystem, a decrement to zero means an imminent
  * write when the file is truncated and actually unlinked
  * on the filesystem.
  */
 static inline void drop_nlink(struct inode *inode)
 {
 	inode->i_nlink--;
 }
 /**
  * clear_nlink - directly zero an inode's link count
  * @inode: inode
  *
  * This is a low-level filesystem helper to replace any
  * direct filesystem manipulation of i_nlink.  See
  * drop_nlink() for why we care about i_nlink hitting zero.
  */
 static inline void clear_nlink(struct inode *inode)
 {
 	inode->i_nlink = 0;
 }
 static inline void inode_dec_link_count(struct inode *inode)
 {
 	drop_nlink(inode);
 	mark_inode_dirty(inode);
 }
 /**
  * inode_inc_iversion - increments i_version
  * @inode: inode that need to be updated
  *
  * Every time the inode is modified, the i_version field will be incremented.
  * The filesystem has to be mounted with i_version flag
  */
 static inline void inode_inc_iversion(struct inode *inode)
 {
        spin_lock(&inode->i_lock);
        inode->i_version++;
        spin_unlock(&inode->i_lock);
 }
 extern void touch_atime(struct vfsmount *mnt, struct dentry *dentry);
 static inline void file_accessed(struct file *file)
 {
 	if (!(file->f_flags & O_NOATIME))
 		touch_atime(file->f_path.mnt, file->f_path.dentry);
 }
 int sync_inode(struct inode *inode, struct writeback_control *wbc);
 struct file_system_type {
 	const char *name;
 	int fs_flags;
 	int (*get_sb) (struct file_system_type *, int,
 		       const char *, void *, struct vfsmount *);
 	void (*kill_sb) (struct super_block *);
 	struct module *owner;
 	struct file_system_type * next;
 	struct list_head fs_supers;
 	struct lock_class_key s_lock_key;
 	struct lock_class_key s_umount_key;
 	struct lock_class_key i_lock_key;
 	struct lock_class_key i_mutex_key;
 	struct lock_class_key i_mutex_dir_key;
 	struct lock_class_key i_alloc_sem_key;
 };
 extern int get_sb_ns(struct file_system_type *fs_type, int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt);
 extern int get_sb_bdev(struct file_system_type *fs_type,
 	int flags, const char *dev_name, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt);
 extern int get_sb_single(struct file_system_type *fs_type,
 	int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt);
 extern int get_sb_nodev(struct file_system_type *fs_type,
 	int flags, void *data,
 	int (*fill_super)(struct super_block *, void *, int),
 	struct vfsmount *mnt);
 void generic_shutdown_super(struct super_block *sb);
 void kill_block_super(struct super_block *sb);
 void kill_anon_super(struct super_block *sb);
 void kill_litter_super(struct super_block *sb);
 void deactivate_super(struct super_block *sb);
 void deactivate_locked_super(struct super_block *sb);
 int set_anon_super(struct super_block *s, void *data);
 struct super_block *sget(struct file_system_type *type,
 			int (*test)(struct super_block *,void *),
 			int (*set)(struct super_block *,void *),
 			void *data);
 extern int get_sb_pseudo(struct file_system_type *, char *,
 	const struct super_operations *ops, unsigned long,
 	struct vfsmount *mnt);
 extern void simple_set_mnt(struct vfsmount *mnt, struct super_block *sb);
 int __put_super_and_need_restart(struct super_block *sb);
 /* Alas, no aliases. Too much hassle with bringing module.h everywhere */
 #define fops_get(fops) \
 	(((fops) && try_module_get((fops)->owner) ? (fops) : NULL))
 #define fops_put(fops) \
 	do { if (fops) module_put((fops)->owner); } while(0)
 extern int register_filesystem(struct file_system_type *);
 extern int unregister_filesystem(struct file_system_type *);
 extern struct vfsmount *kern_mount_data(struct file_system_type *, void *data);
 #define kern_mount(type) kern_mount_data(type, NULL)
 extern int may_umount_tree(struct vfsmount *);
 extern int may_umount(struct vfsmount *);
 extern long do_mount(char *, char *, char *, unsigned long, void *);
 extern struct vfsmount *collect_mounts(struct path *);
 extern void drop_collected_mounts(struct vfsmount *);
 extern int vfs_statfs(struct dentry *, struct kstatfs *);
 extern int current_umask(void);
 /* /sys/fs */
 extern struct kobject *fs_kobj;
 extern int rw_verify_area(int, struct file *, loff_t *, size_t);
 #define FLOCK_VERIFY_READ  1
 #define FLOCK_VERIFY_WRITE 2
 #ifdef CONFIG_FILE_LOCKING
 extern int locks_mandatory_locked(struct inode *);
 extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
 /*
  * Candidates for mandatory locking have the setgid bit set
  * but no group execute bit -  an otherwise meaningless combination.
  */
 static inline int __mandatory_lock(struct inode *ino)
 {
 	return (ino->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID;
 }
 /*
  * ... and these candidates should be on MS_MANDLOCK mounted fs,
  * otherwise these will be advisory locks
  */
 static inline int mandatory_lock(struct inode *ino)
 {
 	return IS_MANDLOCK(ino) && __mandatory_lock(ino);
 }
 static inline int locks_verify_locked(struct inode *inode)
 {
 	if (mandatory_lock(inode))
 		return locks_mandatory_locked(inode);
 	return 0;
 }
 static inline int locks_verify_truncate(struct inode *inode,
 				    struct file *filp,
 				    loff_t size)
 {
 	if (inode->i_flock && mandatory_lock(inode))
 		return locks_mandatory_area(
 			FLOCK_VERIFY_WRITE, inode, filp,
 			size < inode->i_size ? size : inode->i_size,
 			(size < inode->i_size ? inode->i_size - size
 			 : size - inode->i_size)
 		);
 	return 0;
 }
 static inline int break_lease(struct inode *inode, unsigned int mode)
 {
 	if (inode->i_flock)
 		return __break_lease(inode, mode);
 	return 0;
 }
 #else /* !CONFIG_FILE_LOCKING */
 static inline int locks_mandatory_locked(struct inode *inode)
 {
 	return 0;
 }
 static inline int locks_mandatory_area(int rw, struct inode *inode,
 				       struct file *filp, loff_t offset,
 				       size_t count)
 {
 	return 0;
 }
 static inline int __mandatory_lock(struct inode *inode)
 {
 	return 0;
 }
 static inline int mandatory_lock(struct inode *inode)
 {
 	return 0;
 }
 static inline int locks_verify_locked(struct inode *inode)
 {
 	return 0;
 }
 static inline int locks_verify_truncate(struct inode *inode, struct file *filp,
 					size_t size)
 {
 	return 0;
 }
 static inline int break_lease(struct inode *inode, unsigned int mode)
 {
 	return 0;
 }
 #endif /* CONFIG_FILE_LOCKING */
 /* fs/open.c */
 extern int do_truncate(struct dentry *, loff_t start, unsigned int time_attrs,
 		       struct file *filp);
 extern long do_sys_open(int dfd, const char __user *filename, int flags,
 			int mode);
 extern struct file *filp_open(const char *, int, int);
 extern struct file * dentry_open(struct dentry *, struct vfsmount *, int,
 				 const struct cred *);
 extern int filp_close(struct file *, fl_owner_t id);
 extern char * getname(const char __user *);
 /* fs/dcache.c */
 extern void __init vfs_caches_init_early(void);
 extern void __init vfs_caches_init(unsigned long);
 extern struct kmem_cache *names_cachep;
 #define __getname()	kmem_cache_alloc(names_cachep, GFP_KERNEL)
 #define __putname(name) kmem_cache_free(names_cachep, (void *)(name))
 #ifndef CONFIG_AUDITSYSCALL
 #define putname(name)   __putname(name)
 #else
 extern void putname(const char *name);
 #endif
 #ifdef CONFIG_BLOCK
 extern int register_blkdev(unsigned int, const char *);
 extern void unregister_blkdev(unsigned int, const char *);
 extern struct block_device *bdget(dev_t);
 extern void bd_set_size(struct block_device *, loff_t size);
 extern void bd_forget(struct inode *inode);
 extern void bdput(struct block_device *);
 extern struct block_device *open_by_devnum(dev_t, fmode_t);
 extern void invalidate_bdev(struct block_device *);
 extern int sync_blockdev(struct block_device *bdev);
 extern struct super_block *freeze_bdev(struct block_device *);
 extern void emergency_thaw_all(void);
 extern int thaw_bdev(struct block_device *bdev, struct super_block *sb);
 extern int fsync_bdev(struct block_device *);
 extern int fsync_super(struct super_block *);
 extern int fsync_no_super(struct block_device *);
 #else
 static inline void bd_forget(struct inode *inode) {}
 static inline int sync_blockdev(struct block_device *bdev) { return 0; }
 static inline void invalidate_bdev(struct block_device *bdev) {}
 static inline struct super_block *freeze_bdev(struct block_device *sb)
 {
 	return NULL;
 }
 static inline int thaw_bdev(struct block_device *bdev, struct super_block *sb)
 {
 	return 0;
 }
 #endif
 extern const struct file_operations def_blk_fops;
 extern const struct file_operations def_chr_fops;
 extern const struct file_operations bad_sock_fops;
 extern const struct file_operations def_fifo_fops;
 #ifdef CONFIG_BLOCK
 extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
 extern int blkdev_ioctl(struct block_device *, fmode_t, unsigned, unsigned long);
 extern long compat_blkdev_ioctl(struct file *, unsigned, unsigned long);
 extern int blkdev_get(struct block_device *, fmode_t);
 extern int blkdev_put(struct block_device *, fmode_t);
 extern int bd_claim(struct block_device *, void *);
 extern void bd_release(struct block_device *);
 #ifdef CONFIG_SYSFS
 extern int bd_claim_by_disk(struct block_device *, void *, struct gendisk *);
 extern void bd_release_from_disk(struct block_device *, struct gendisk *);
 #else
 #define bd_claim_by_disk(bdev, holder, disk)	bd_claim(bdev, holder)
 #define bd_release_from_disk(bdev, disk)	bd_release(bdev)
 #endif
 #endif
 /* fs/char_dev.c */
 #define CHRDEV_MAJOR_HASH_SIZE	255
 extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
 extern int register_chrdev_region(dev_t, unsigned, const char *);
 extern int register_chrdev(unsigned int, const char *,
 			   const struct file_operations *);
 extern void unregister_chrdev(unsigned int, const char *);
 extern void unregister_chrdev_region(dev_t, unsigned);
 extern void chrdev_show(struct seq_file *,off_t);
 /* fs/block_dev.c */
 #define BDEVNAME_SIZE	32	/* Largest string for a blockdev identifier */
 #define BDEVT_SIZE	10	/* Largest string for MAJ:MIN for blkdev */
 #ifdef CONFIG_BLOCK
 #define BLKDEV_MAJOR_HASH_SIZE	255
 extern const char *__bdevname(dev_t, char *buffer);
 extern const char *bdevname(struct block_device *bdev, char *buffer);
 extern struct block_device *lookup_bdev(const char *);
 extern struct block_device *open_bdev_exclusive(const char *, fmode_t, void *);
 extern void close_bdev_exclusive(struct block_device *, fmode_t);
 extern void blkdev_show(struct seq_file *,off_t);
 #else
 #define BLKDEV_MAJOR_HASH_SIZE	0
 #endif
 extern void init_special_inode(struct inode *, umode_t, dev_t);
 /* Invalid inode operations -- fs/bad_inode.c */
 extern void make_bad_inode(struct inode *);
 extern int is_bad_inode(struct inode *);
 extern const struct file_operations read_pipefifo_fops;
 extern const struct file_operations write_pipefifo_fops;
 extern const struct file_operations rdwr_pipefifo_fops;
 extern int fs_may_remount_ro(struct super_block *);
 #ifdef CONFIG_BLOCK
 /*
  * return READ, READA, or WRITE
  */
 #define bio_rw(bio)		((bio)->bi_rw & (RW_MASK | RWA_MASK))
 /*
  * return data direction, READ or WRITE
  */
 #define bio_data_dir(bio)	((bio)->bi_rw & 1)
 extern void check_disk_size_change(struct gendisk *disk,
 				   struct block_device *bdev);
 extern int revalidate_disk(struct gendisk *);
 extern int check_disk_change(struct block_device *);
 extern int __invalidate_device(struct block_device *);
 extern int invalidate_partition(struct gendisk *, int);
 #endif
 extern int invalidate_inodes(struct super_block *);
 unsigned long __invalidate_mapping_pages(struct address_space *mapping,
 					pgoff_t start, pgoff_t end,
 					bool be_atomic);
 unsigned long invalidate_mapping_pages(struct address_space *mapping,
 					pgoff_t start, pgoff_t end);
 static inline unsigned long __deprecated
 invalidate_inode_pages(struct address_space *mapping)
 {
 	return invalidate_mapping_pages(mapping, 0, ~0UL);
 }
 static inline void invalidate_remote_inode(struct inode *inode)
 {
 	if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
 	    S_ISLNK(inode->i_mode))
 		invalidate_mapping_pages(inode->i_mapping, 0, -1);
 }
 extern int invalidate_inode_pages2(struct address_space *mapping);
 extern int invalidate_inode_pages2_range(struct address_space *mapping,
 					 pgoff_t start, pgoff_t end);
 extern void generic_sync_sb_inodes(struct super_block *sb,
 				struct writeback_control *wbc);
 extern int write_inode_now(struct inode *, int);
 extern int filemap_fdatawrite(struct address_space *);
 extern int filemap_flush(struct address_space *);
 extern int filemap_fdatawait(struct address_space *);
 extern int filemap_write_and_wait(struct address_space *mapping);
 extern int filemap_write_and_wait_range(struct address_space *mapping,
 				        loff_t lstart, loff_t lend);
 extern int wait_on_page_writeback_range(struct address_space *mapping,
 				pgoff_t start, pgoff_t end);
 extern int __filemap_fdatawrite_range(struct address_space *mapping,
 				loff_t start, loff_t end, int sync_mode);
 extern int filemap_fdatawrite_range(struct address_space *mapping,
 				loff_t start, loff_t end);
 extern int vfs_fsync(struct file *file, struct dentry *dentry, int datasync);
 extern void sync_supers(void);
 extern void sync_filesystems(int wait);
-extern void __fsync_super(struct super_block *sb);
 extern void emergency_sync(void);
 extern void emergency_remount(void);
 extern int do_remount_sb(struct super_block *sb, int flags,
 			 void *data, int force);
 #ifdef CONFIG_BLOCK
 extern sector_t bmap(struct inode *, sector_t);
 #endif
 extern int notify_change(struct dentry *, struct iattr *);
 extern int inode_permission(struct inode *, int);
 extern int generic_permission(struct inode *, int,
 		int (*check_acl)(struct inode *, int));
 static inline bool execute_ok(struct inode *inode)
 {
 	return (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode);
 }
 extern int get_write_access(struct inode *);
 extern int deny_write_access(struct file *);
 static inline void put_write_access(struct inode * inode)
 {
 	atomic_dec(&inode->i_writecount);
 }
 static inline void allow_write_access(struct file *file)
 {
 	if (file)
 		atomic_inc(&file->f_path.dentry->d_inode->i_writecount);
 }
 extern int do_pipe_flags(int *, int);
 extern struct file *create_read_pipe(struct file *f, int flags);
 extern struct file *create_write_pipe(int flags);
 extern void free_write_pipe(struct file *);
 extern struct file *do_filp_open(int dfd, const char *pathname,
 		int open_flag, int mode, int acc_mode);
 extern int may_open(struct path *, int, int);
 extern int kernel_read(struct file *, unsigned long, char *, unsigned long);
 extern struct file * open_exec(const char *);
 /* fs/dcache.c -- generic fs support functions */
 extern int is_subdir(struct dentry *, struct dentry *);
 extern ino_t find_inode_number(struct dentry *, struct qstr *);
 #include <linux/err.h>
 /* needed for stackable file system support */
 extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t vfs_llseek(struct file *file, loff_t offset, int origin);
 extern struct inode * inode_init_always(struct super_block *, struct inode *);
 extern void inode_init_once(struct inode *);
 extern void inode_add_to_lists(struct super_block *, struct inode *);
 extern void iput(struct inode *);
 extern struct inode * igrab(struct inode *);
 extern ino_t iunique(struct super_block *, ino_t);
 extern int inode_needs_sync(struct inode *inode);
 extern void generic_delete_inode(struct inode *inode);
 extern void generic_drop_inode(struct inode *inode);
 extern struct inode *ilookup5_nowait(struct super_block *sb,
 		unsigned long hashval, int (*test)(struct inode *, void *),
 		void *data);
 extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
 		int (*test)(struct inode *, void *), void *data);
 extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
 extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
 extern struct inode * iget_locked(struct super_block *, unsigned long);
 extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
 extern int insert_inode_locked(struct inode *);
 extern void unlock_new_inode(struct inode *);
 extern void __iget(struct inode * inode);
 extern void iget_failed(struct inode *);
 extern void clear_inode(struct inode *);
 extern void destroy_inode(struct inode *);
 extern struct inode *new_inode(struct super_block *);
 extern int should_remove_suid(struct dentry *);
 extern int file_remove_suid(struct file *);
 extern void __insert_inode_hash(struct inode *, unsigned long hashval);
 extern void remove_inode_hash(struct inode *);
 static inline void insert_inode_hash(struct inode *inode) {
 	__insert_inode_hash(inode, inode->i_ino);
 }
 extern struct file * get_empty_filp(void);
 extern void file_move(struct file *f, struct list_head *list);
 extern void file_kill(struct file *f);
 #ifdef CONFIG_BLOCK
 struct bio;
 extern void submit_bio(int, struct bio *);
 extern int bdev_read_only(struct block_device *);
 #endif
 extern int set_blocksize(struct block_device *, int);
 extern int sb_set_blocksize(struct super_block *, int);
 extern int sb_min_blocksize(struct super_block *, int);
 extern int sb_has_dirty_inodes(struct super_block *);
 extern int generic_file_mmap(struct file *, struct vm_area_struct *);
 extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
 extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
 int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
 extern ssize_t generic_file_aio_read(struct kiocb *, const struct iovec *, unsigned long, loff_t);
 extern ssize_t generic_file_aio_write(struct kiocb *, const struct iovec *, unsigned long, loff_t);
 extern ssize_t generic_file_aio_write_nolock(struct kiocb *, const struct iovec *,
 		unsigned long, loff_t);
 extern ssize_t generic_file_direct_write(struct kiocb *, const struct iovec *,
 		unsigned long *, loff_t, loff_t *, size_t, size_t);
 extern ssize_t generic_file_buffered_write(struct kiocb *, const struct iovec *,
 		unsigned long, loff_t, loff_t *, size_t, ssize_t);
 extern ssize_t do_sync_read(struct file *filp, char __user *buf, size_t len, loff_t *ppos);
 extern ssize_t do_sync_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos);
 extern int generic_segment_checks(const struct iovec *iov,
 		unsigned long *nr_segs, size_t *count, int access_flags);
 /* fs/splice.c */
 extern ssize_t generic_file_splice_read(struct file *, loff_t *,
 		struct pipe_inode_info *, size_t, unsigned int);
 extern ssize_t default_file_splice_read(struct file *, loff_t *,
 		struct pipe_inode_info *, size_t, unsigned int);
 extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
 		struct file *, loff_t *, size_t, unsigned int);
 extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
 		struct file *out, loff_t *, size_t len, unsigned int flags);
 extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
 		size_t len, unsigned int flags);
 extern void
 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
 extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
 extern loff_t generic_file_llseek_unlocked(struct file *file, loff_t offset,
 			int origin);
 extern int generic_file_open(struct inode * inode, struct file * filp);
 extern int nonseekable_open(struct inode * inode, struct file * filp);
 #ifdef CONFIG_FS_XIP
 extern ssize_t xip_file_read(struct file *filp, char __user *buf, size_t len,
 			     loff_t *ppos);
 extern int xip_file_mmap(struct file * file, struct vm_area_struct * vma);
 extern ssize_t xip_file_write(struct file *filp, const char __user *buf,
 			      size_t len, loff_t *ppos);
 extern int xip_truncate_page(struct address_space *mapping, loff_t from);
 #else
 static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
 {
 	return 0;
 }
 #endif
 #ifdef CONFIG_BLOCK
 ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,
 	struct block_device *bdev, const struct iovec *iov, loff_t offset,
 	unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io,
 	int lock_type);
 enum {
 	DIO_LOCKING = 1, /* need locking between buffered and direct access */
 	DIO_NO_LOCKING,  /* bdev; no locking at all between buffered/direct */
 	DIO_OWN_LOCKING, /* filesystem locks buffered and direct internally */
 };
 static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb,
 	struct inode *inode, struct block_device *bdev, const struct iovec *iov,
 	loff_t offset, unsigned long nr_segs, get_block_t get_block,
 	dio_iodone_t end_io)
 {
 	return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
 				nr_segs, get_block, end_io, DIO_LOCKING);
 }
 static inline ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb,
 	struct inode *inode, struct block_device *bdev, const struct iovec *iov,
 	loff_t offset, unsigned long nr_segs, get_block_t get_block,
 	dio_iodone_t end_io)
 {
 	return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
 				nr_segs, get_block, end_io, DIO_NO_LOCKING);
 }
 static inline ssize_t blockdev_direct_IO_own_locking(int rw, struct kiocb *iocb,
 	struct inode *inode, struct block_device *bdev, const struct iovec *iov,
 	loff_t offset, unsigned long nr_segs, get_block_t get_block,
 	dio_iodone_t end_io)
 {
 	return __blockdev_direct_IO(rw, iocb, inode, bdev, iov, offset,
 				nr_segs, get_block, end_io, DIO_OWN_LOCKING);
 }
 #endif
 extern const struct file_operations generic_ro_fops;
 #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
 extern int vfs_readlink(struct dentry *, char __user *, int, const char *);
 extern int vfs_follow_link(struct nameidata *, const char *);
 extern int page_readlink(struct dentry *, char __user *, int);
 extern void *page_follow_link_light(struct dentry *, struct nameidata *);
 extern void page_put_link(struct dentry *, struct nameidata *, void *);
 extern int __page_symlink(struct inode *inode, const char *symname, int len,
 		int nofs);
 extern int page_symlink(struct inode *inode, const char *symname, int len);
 extern const struct inode_operations page_symlink_inode_operations;
 extern int generic_readlink(struct dentry *, char __user *, int);
 extern void generic_fillattr(struct inode *, struct kstat *);
 extern int vfs_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 void inode_add_bytes(struct inode *inode, loff_t bytes);
 void inode_sub_bytes(struct inode *inode, loff_t bytes);
 loff_t inode_get_bytes(struct inode *inode);
 void inode_set_bytes(struct inode *inode, loff_t bytes);
 extern int vfs_readdir(struct file *, filldir_t, void *);
 extern int vfs_stat(char __user *, struct kstat *);
 extern int vfs_lstat(char __user *, struct kstat *);
 extern int vfs_fstat(unsigned int, struct kstat *);
 extern int vfs_fstatat(int , char __user *, struct kstat *, int);
 extern int do_vfs_ioctl(struct file *filp, unsigned int fd, unsigned int cmd,
 		    unsigned long arg);
 extern int __generic_block_fiemap(struct inode *inode,
 				  struct fiemap_extent_info *fieinfo, u64 start,
 				  u64 len, get_block_t *get_block);
 extern int generic_block_fiemap(struct inode *inode,
 				struct fiemap_extent_info *fieinfo, u64 start,
 				u64 len, get_block_t *get_block);
 extern void get_filesystem(struct file_system_type *fs);
 extern void put_filesystem(struct file_system_type *fs);
 extern struct file_system_type *get_fs_type(const char *name);
 extern struct super_block *get_super(struct block_device *);
 extern struct super_block *user_get_super(dev_t);
 extern void drop_super(struct super_block *sb);
 extern int dcache_dir_open(struct inode *, struct file *);
 extern int dcache_dir_close(struct inode *, struct file *);
 extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
 extern int dcache_readdir(struct file *, void *, filldir_t);
 extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 extern int simple_statfs(struct dentry *, struct kstatfs *);
 extern int simple_link(struct dentry *, struct inode *, struct dentry *);
 extern int simple_unlink(struct inode *, struct dentry *);
 extern int simple_rmdir(struct inode *, struct dentry *);
 extern int simple_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
 extern int simple_sync_file(struct file *, struct dentry *, int);
 extern int simple_empty(struct dentry *);
 extern int simple_readpage(struct file *file, struct page *page);
 extern int simple_prepare_write(struct file *file, struct page *page,
 			unsigned offset, unsigned to);
 extern int simple_write_begin(struct file *file, struct address_space *mapping,
 			loff_t pos, unsigned len, unsigned flags,
 			struct page **pagep, void **fsdata);
 extern int simple_write_end(struct file *file, struct address_space *mapping,
 			loff_t pos, unsigned len, unsigned copied,
 			struct page *page, void *fsdata);
 extern struct dentry *simple_lookup(struct inode *, struct dentry *, struct nameidata *);
 extern ssize_t generic_read_dir(struct file *, char __user *, size_t, loff_t *);
 extern const struct file_operations simple_dir_operations;
 extern const struct inode_operations simple_dir_inode_operations;
 struct tree_descr { char *name; const struct file_operations *ops; int mode; };
 struct dentry *d_alloc_name(struct dentry *, const char *);
 extern int simple_fill_super(struct super_block *, int, struct tree_descr *);
 extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
 extern void simple_release_fs(struct vfsmount **mount, int *count);
 extern ssize_t simple_read_from_buffer(void __user *to, size_t count,
 			loff_t *ppos, const void *from, size_t available);
 #ifdef CONFIG_MIGRATION
 extern int buffer_migrate_page(struct address_space *,
 				struct page *, struct page *);
 #else
 #define buffer_migrate_page NULL
 #endif
 extern int inode_change_ok(struct inode *, struct iattr *);
 extern int __must_check inode_setattr(struct inode *, struct iattr *);
 extern void file_update_time(struct file *file);
 extern int generic_show_options(struct seq_file *m, struct vfsmount *mnt);
 extern void save_mount_options(struct super_block *sb, char *options);
 extern void replace_mount_options(struct super_block *sb, char *options);
 static inline ino_t parent_ino(struct dentry *dentry)
 {
 	ino_t res;
 	spin_lock(&dentry->d_lock);
 	res = dentry->d_parent->d_inode->i_ino;
 	spin_unlock(&dentry->d_lock);
 	return res;
 }
 /* Transaction based IO helpers */
 /*
  * An argresp is stored in an allocated page and holds the
  * size of the argument or response, along with its content
  */
 struct simple_transaction_argresp {
 	ssize_t size;
 	char data[0];
 };
 #define SIMPLE_TRANSACTION_LIMIT (PAGE_SIZE - sizeof(struct simple_transaction_argresp))
 char *simple_transaction_get(struct file *file, const char __user *buf,
 				size_t size);
 ssize_t simple_transaction_read(struct file *file, char __user *buf,
 				size_t size, loff_t *pos);
 int simple_transaction_release(struct inode *inode, struct file *file);
 void simple_transaction_set(struct file *file, size_t n);
 /*
  * simple attribute files
  *
  * These attributes behave similar to those in sysfs:
  *
  * Writing to an attribute immediately sets a value, an open file can be
  * written to multiple times.
  *
  * Reading from an attribute creates a buffer from the value that might get
  * read with multiple read calls. When the attribute has been read
  * completely, no further read calls are possible until the file is opened
  * again.
  *
  * All attributes contain a text representation of a numeric value
  * that are accessed with the get() and set() functions.
  */
 #define DEFINE_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt)		\
 static int __fops ## _open(struct inode *inode, struct file *file)	\
 {									\
 	__simple_attr_check_format(__fmt, 0ull);			\
 	return simple_attr_open(inode, file, __get, __set, __fmt);	\
 }									\
 static struct file_operations __fops = {				\
 	.owner	 = THIS_MODULE,						\
 	.open	 = __fops ## _open,					\
 	.release = simple_attr_release,					\
 	.read	 = simple_attr_read,					\
 	.write	 = simple_attr_write,					\
 };
 static inline void __attribute__((format(printf, 1, 2)))
 __simple_attr_check_format(const char *fmt, ...)
 {
 	/* don't do anything, just let the compiler check the arguments; */
 }
 int simple_attr_open(struct inode *inode, struct file *file,
 		     int (*get)(void *, u64 *), int (*set)(void *, u64),
 		     const char *fmt);
 int simple_attr_release(struct inode *inode, struct file *file);
 ssize_t simple_attr_read(struct file *file, char __user *buf,
 			 size_t len, loff_t *ppos);
 ssize_t simple_attr_write(struct file *file, const char __user *buf,
 			  size_t len, loff_t *ppos);
 struct ctl_table;
 int proc_nr_files(struct ctl_table *table, int write, struct file *filp,
 		  void __user *buffer, size_t *lenp, loff_t *ppos);
 int __init get_filesystem_list(char *buf);
 #endif /* __KERNEL__ */
 #endif /* _LINUX_FS_H */