2 * linux/fs/9p/vfs_super.c
4 * This file contians superblock ops for 9P2000. It is intended that
5 * you mount this file system on directories.
7 * Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
8 * Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2
12 * as published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to:
21 * Free Software Foundation
22 * 51 Franklin Street, Fifth Floor
23 * Boston, MA 02111-1301 USA
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/errno.h>
31 #include <linux/file.h>
32 #include <linux/stat.h>
33 #include <linux/string.h>
34 #include <linux/inet.h>
35 #include <linux/pagemap.h>
36 #include <linux/seq_file.h>
37 #include <linux/mount.h>
38 #include <linux/idr.h>
39 #include <linux/sched.h>
40 #include <linux/slab.h>
41 #include <linux/statfs.h>
42 #include <linux/magic.h>
43 #include <net/9p/9p.h>
44 #include <net/9p/client.h>
52 static const struct super_operations v9fs_super_ops
, v9fs_super_ops_dotl
;
55 * v9fs_set_super - set the superblock
57 * @data: file system specific data
61 static int v9fs_set_super(struct super_block
*s
, void *data
)
64 return set_anon_super(s
, data
);
68 * v9fs_fill_super - populate superblock with info
70 * @v9ses: session information
71 * @flags: flags propagated from v9fs_mount()
76 v9fs_fill_super(struct super_block
*sb
, struct v9fs_session_info
*v9ses
,
77 int flags
, void *data
)
81 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
82 sb
->s_blocksize_bits
= fls(v9ses
->maxdata
- 1);
83 sb
->s_blocksize
= 1 << sb
->s_blocksize_bits
;
84 sb
->s_magic
= V9FS_MAGIC
;
85 if (v9fs_proto_dotl(v9ses
)) {
86 sb
->s_op
= &v9fs_super_ops_dotl
;
87 sb
->s_xattr
= v9fs_xattr_handlers
;
89 sb
->s_op
= &v9fs_super_ops
;
91 ret
= super_setup_bdi(sb
);
96 sb
->s_bdi
->ra_pages
= (VM_MAX_READAHEAD
* 1024)/PAGE_SIZE
;
98 sb
->s_flags
|= MS_ACTIVE
| MS_DIRSYNC
| MS_NOATIME
;
100 sb
->s_flags
|= MS_SYNCHRONOUS
;
102 #ifdef CONFIG_9P_FS_POSIX_ACL
103 if ((v9ses
->flags
& V9FS_ACL_MASK
) == V9FS_POSIX_ACL
)
104 sb
->s_flags
|= MS_POSIXACL
;
107 save_mount_options(sb
, data
);
112 * v9fs_mount - mount a superblock
113 * @fs_type: file system type
114 * @flags: mount flags
115 * @dev_name: device name that was mounted
116 * @data: mount options
120 static struct dentry
*v9fs_mount(struct file_system_type
*fs_type
, int flags
,
121 const char *dev_name
, void *data
)
123 struct super_block
*sb
= NULL
;
124 struct inode
*inode
= NULL
;
125 struct dentry
*root
= NULL
;
126 struct v9fs_session_info
*v9ses
= NULL
;
127 umode_t mode
= S_IRWXUGO
| S_ISVTX
;
131 p9_debug(P9_DEBUG_VFS
, "\n");
133 v9ses
= kzalloc(sizeof(struct v9fs_session_info
), GFP_KERNEL
);
135 return ERR_PTR(-ENOMEM
);
137 fid
= v9fs_session_init(v9ses
, dev_name
, data
);
139 retval
= PTR_ERR(fid
);
143 sb
= sget(fs_type
, NULL
, v9fs_set_super
, flags
, v9ses
);
145 retval
= PTR_ERR(sb
);
148 retval
= v9fs_fill_super(sb
, v9ses
, flags
, data
);
152 if (v9ses
->cache
== CACHE_LOOSE
|| v9ses
->cache
== CACHE_FSCACHE
)
153 sb
->s_d_op
= &v9fs_cached_dentry_operations
;
155 sb
->s_d_op
= &v9fs_dentry_operations
;
157 inode
= v9fs_get_inode(sb
, S_IFDIR
| mode
, 0);
159 retval
= PTR_ERR(inode
);
163 root
= d_make_root(inode
);
169 if (v9fs_proto_dotl(v9ses
)) {
170 struct p9_stat_dotl
*st
= NULL
;
171 st
= p9_client_getattr_dotl(fid
, P9_STATS_BASIC
);
173 retval
= PTR_ERR(st
);
176 d_inode(root
)->i_ino
= v9fs_qid2ino(&st
->qid
);
177 v9fs_stat2inode_dotl(st
, d_inode(root
));
180 struct p9_wstat
*st
= NULL
;
181 st
= p9_client_stat(fid
);
183 retval
= PTR_ERR(st
);
187 d_inode(root
)->i_ino
= v9fs_qid2ino(&st
->qid
);
188 v9fs_stat2inode(st
, d_inode(root
), sb
);
193 retval
= v9fs_get_acl(inode
, fid
);
196 v9fs_fid_add(root
, fid
);
198 p9_debug(P9_DEBUG_VFS
, " simple set mount, return 0\n");
199 return dget(sb
->s_root
);
202 p9_client_clunk(fid
);
203 v9fs_session_close(v9ses
);
206 return ERR_PTR(retval
);
210 * we will do the session_close and root dentry release
211 * in the below call. But we need to clunk fid, because we haven't
212 * attached the fid to dentry so it won't get clunked
215 p9_client_clunk(fid
);
216 deactivate_locked_super(sb
);
217 return ERR_PTR(retval
);
221 * v9fs_kill_super - Kill Superblock
226 static void v9fs_kill_super(struct super_block
*s
)
228 struct v9fs_session_info
*v9ses
= s
->s_fs_info
;
230 p9_debug(P9_DEBUG_VFS
, " %p\n", s
);
234 v9fs_session_cancel(v9ses
);
235 v9fs_session_close(v9ses
);
238 p9_debug(P9_DEBUG_VFS
, "exiting kill_super\n");
242 v9fs_umount_begin(struct super_block
*sb
)
244 struct v9fs_session_info
*v9ses
;
246 v9ses
= sb
->s_fs_info
;
247 v9fs_session_begin_cancel(v9ses
);
250 static int v9fs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
252 struct v9fs_session_info
*v9ses
;
254 struct p9_rstatfs rs
;
257 fid
= v9fs_fid_lookup(dentry
);
263 v9ses
= v9fs_dentry2v9ses(dentry
);
264 if (v9fs_proto_dotl(v9ses
)) {
265 res
= p9_client_statfs(fid
, &rs
);
267 buf
->f_type
= rs
.type
;
268 buf
->f_bsize
= rs
.bsize
;
269 buf
->f_blocks
= rs
.blocks
;
270 buf
->f_bfree
= rs
.bfree
;
271 buf
->f_bavail
= rs
.bavail
;
272 buf
->f_files
= rs
.files
;
273 buf
->f_ffree
= rs
.ffree
;
274 buf
->f_fsid
.val
[0] = rs
.fsid
& 0xFFFFFFFFUL
;
275 buf
->f_fsid
.val
[1] = (rs
.fsid
>> 32) & 0xFFFFFFFFUL
;
276 buf
->f_namelen
= rs
.namelen
;
281 res
= simple_statfs(dentry
, buf
);
286 static int v9fs_drop_inode(struct inode
*inode
)
288 struct v9fs_session_info
*v9ses
;
289 v9ses
= v9fs_inode2v9ses(inode
);
290 if (v9ses
->cache
== CACHE_LOOSE
|| v9ses
->cache
== CACHE_FSCACHE
)
291 return generic_drop_inode(inode
);
293 * in case of non cached mode always drop the
294 * the inode because we want the inode attribute
295 * to always match that on the server.
300 static int v9fs_write_inode(struct inode
*inode
,
301 struct writeback_control
*wbc
)
304 struct p9_wstat wstat
;
305 struct v9fs_inode
*v9inode
;
307 * send an fsync request to server irrespective of
310 p9_debug(P9_DEBUG_VFS
, "%s: inode %p\n", __func__
, inode
);
311 v9inode
= V9FS_I(inode
);
312 if (!v9inode
->writeback_fid
)
314 v9fs_blank_wstat(&wstat
);
316 ret
= p9_client_wstat(v9inode
->writeback_fid
, &wstat
);
318 __mark_inode_dirty(inode
, I_DIRTY_DATASYNC
);
324 static int v9fs_write_inode_dotl(struct inode
*inode
,
325 struct writeback_control
*wbc
)
328 struct v9fs_inode
*v9inode
;
330 * send an fsync request to server irrespective of
333 v9inode
= V9FS_I(inode
);
334 p9_debug(P9_DEBUG_VFS
, "%s: inode %p, writeback_fid %p\n",
335 __func__
, inode
, v9inode
->writeback_fid
);
336 if (!v9inode
->writeback_fid
)
339 ret
= p9_client_fsync(v9inode
->writeback_fid
, 0);
341 __mark_inode_dirty(inode
, I_DIRTY_DATASYNC
);
347 static const struct super_operations v9fs_super_ops
= {
348 .alloc_inode
= v9fs_alloc_inode
,
349 .destroy_inode
= v9fs_destroy_inode
,
350 .statfs
= simple_statfs
,
351 .evict_inode
= v9fs_evict_inode
,
352 .show_options
= generic_show_options
,
353 .umount_begin
= v9fs_umount_begin
,
354 .write_inode
= v9fs_write_inode
,
357 static const struct super_operations v9fs_super_ops_dotl
= {
358 .alloc_inode
= v9fs_alloc_inode
,
359 .destroy_inode
= v9fs_destroy_inode
,
360 .statfs
= v9fs_statfs
,
361 .drop_inode
= v9fs_drop_inode
,
362 .evict_inode
= v9fs_evict_inode
,
363 .show_options
= generic_show_options
,
364 .umount_begin
= v9fs_umount_begin
,
365 .write_inode
= v9fs_write_inode_dotl
,
368 struct file_system_type v9fs_fs_type
= {
371 .kill_sb
= v9fs_kill_super
,
372 .owner
= THIS_MODULE
,
373 .fs_flags
= FS_RENAME_DOES_D_MOVE
,
375 MODULE_ALIAS_FS("9p");