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/mount.h>
37 #include <linux/idr.h>
38 #include <linux/sched.h>
39 #include <linux/slab.h>
40 #include <linux/statfs.h>
41 #include <linux/magic.h>
42 #include <net/9p/9p.h>
43 #include <net/9p/client.h>
51 static const struct super_operations v9fs_super_ops
, v9fs_super_ops_dotl
;
54 * v9fs_set_super - set the superblock
56 * @data: file system specific data
60 static int v9fs_set_super(struct super_block
*s
, void *data
)
63 return set_anon_super(s
, data
);
67 * v9fs_fill_super - populate superblock with info
69 * @v9ses: session information
70 * @flags: flags propagated from v9fs_mount()
75 v9fs_fill_super(struct super_block
*sb
, struct v9fs_session_info
*v9ses
,
76 int flags
, void *data
)
80 sb
->s_maxbytes
= MAX_LFS_FILESIZE
;
81 sb
->s_blocksize_bits
= fls(v9ses
->maxdata
- 1);
82 sb
->s_blocksize
= 1 << sb
->s_blocksize_bits
;
83 sb
->s_magic
= V9FS_MAGIC
;
84 if (v9fs_proto_dotl(v9ses
)) {
85 sb
->s_op
= &v9fs_super_ops_dotl
;
86 sb
->s_xattr
= v9fs_xattr_handlers
;
88 sb
->s_op
= &v9fs_super_ops
;
90 ret
= super_setup_bdi(sb
);
95 sb
->s_bdi
->ra_pages
= (VM_MAX_READAHEAD
* 1024)/PAGE_SIZE
;
97 sb
->s_flags
|= MS_ACTIVE
| MS_DIRSYNC
| MS_NOATIME
;
99 sb
->s_flags
|= MS_SYNCHRONOUS
;
101 #ifdef CONFIG_9P_FS_POSIX_ACL
102 if ((v9ses
->flags
& V9FS_ACL_MASK
) == V9FS_POSIX_ACL
)
103 sb
->s_flags
|= MS_POSIXACL
;
110 * v9fs_mount - mount a superblock
111 * @fs_type: file system type
112 * @flags: mount flags
113 * @dev_name: device name that was mounted
114 * @data: mount options
118 static struct dentry
*v9fs_mount(struct file_system_type
*fs_type
, int flags
,
119 const char *dev_name
, void *data
)
121 struct super_block
*sb
= NULL
;
122 struct inode
*inode
= NULL
;
123 struct dentry
*root
= NULL
;
124 struct v9fs_session_info
*v9ses
= NULL
;
125 umode_t mode
= S_IRWXUGO
| S_ISVTX
;
129 p9_debug(P9_DEBUG_VFS
, "\n");
131 v9ses
= kzalloc(sizeof(struct v9fs_session_info
), GFP_KERNEL
);
133 return ERR_PTR(-ENOMEM
);
135 fid
= v9fs_session_init(v9ses
, dev_name
, data
);
137 retval
= PTR_ERR(fid
);
141 sb
= sget(fs_type
, NULL
, v9fs_set_super
, flags
, v9ses
);
143 retval
= PTR_ERR(sb
);
146 retval
= v9fs_fill_super(sb
, v9ses
, flags
, data
);
150 if (v9ses
->cache
== CACHE_LOOSE
|| v9ses
->cache
== CACHE_FSCACHE
)
151 sb
->s_d_op
= &v9fs_cached_dentry_operations
;
153 sb
->s_d_op
= &v9fs_dentry_operations
;
155 inode
= v9fs_get_inode(sb
, S_IFDIR
| mode
, 0);
157 retval
= PTR_ERR(inode
);
161 root
= d_make_root(inode
);
167 if (v9fs_proto_dotl(v9ses
)) {
168 struct p9_stat_dotl
*st
= NULL
;
169 st
= p9_client_getattr_dotl(fid
, P9_STATS_BASIC
);
171 retval
= PTR_ERR(st
);
174 d_inode(root
)->i_ino
= v9fs_qid2ino(&st
->qid
);
175 v9fs_stat2inode_dotl(st
, d_inode(root
), 0);
178 struct p9_wstat
*st
= NULL
;
179 st
= p9_client_stat(fid
);
181 retval
= PTR_ERR(st
);
185 d_inode(root
)->i_ino
= v9fs_qid2ino(&st
->qid
);
186 v9fs_stat2inode(st
, d_inode(root
), sb
, 0);
191 retval
= v9fs_get_acl(inode
, fid
);
194 v9fs_fid_add(root
, fid
);
196 p9_debug(P9_DEBUG_VFS
, " simple set mount, return 0\n");
197 return dget(sb
->s_root
);
200 p9_client_clunk(fid
);
201 v9fs_session_close(v9ses
);
204 return ERR_PTR(retval
);
208 * we will do the session_close and root dentry release
209 * in the below call. But we need to clunk fid, because we haven't
210 * attached the fid to dentry so it won't get clunked
213 p9_client_clunk(fid
);
214 deactivate_locked_super(sb
);
215 return ERR_PTR(retval
);
219 * v9fs_kill_super - Kill Superblock
224 static void v9fs_kill_super(struct super_block
*s
)
226 struct v9fs_session_info
*v9ses
= s
->s_fs_info
;
228 p9_debug(P9_DEBUG_VFS
, " %p\n", s
);
232 v9fs_session_cancel(v9ses
);
233 v9fs_session_close(v9ses
);
236 p9_debug(P9_DEBUG_VFS
, "exiting kill_super\n");
240 v9fs_umount_begin(struct super_block
*sb
)
242 struct v9fs_session_info
*v9ses
;
244 v9ses
= sb
->s_fs_info
;
245 v9fs_session_begin_cancel(v9ses
);
248 static int v9fs_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
250 struct v9fs_session_info
*v9ses
;
252 struct p9_rstatfs rs
;
255 fid
= v9fs_fid_lookup(dentry
);
261 v9ses
= v9fs_dentry2v9ses(dentry
);
262 if (v9fs_proto_dotl(v9ses
)) {
263 res
= p9_client_statfs(fid
, &rs
);
265 buf
->f_type
= rs
.type
;
266 buf
->f_bsize
= rs
.bsize
;
267 buf
->f_blocks
= rs
.blocks
;
268 buf
->f_bfree
= rs
.bfree
;
269 buf
->f_bavail
= rs
.bavail
;
270 buf
->f_files
= rs
.files
;
271 buf
->f_ffree
= rs
.ffree
;
272 buf
->f_fsid
.val
[0] = rs
.fsid
& 0xFFFFFFFFUL
;
273 buf
->f_fsid
.val
[1] = (rs
.fsid
>> 32) & 0xFFFFFFFFUL
;
274 buf
->f_namelen
= rs
.namelen
;
279 res
= simple_statfs(dentry
, buf
);
284 static int v9fs_drop_inode(struct inode
*inode
)
286 struct v9fs_session_info
*v9ses
;
287 v9ses
= v9fs_inode2v9ses(inode
);
288 if (v9ses
->cache
== CACHE_LOOSE
|| v9ses
->cache
== CACHE_FSCACHE
)
289 return generic_drop_inode(inode
);
291 * in case of non cached mode always drop the
292 * the inode because we want the inode attribute
293 * to always match that on the server.
298 static int v9fs_write_inode(struct inode
*inode
,
299 struct writeback_control
*wbc
)
302 struct p9_wstat wstat
;
303 struct v9fs_inode
*v9inode
;
305 * send an fsync request to server irrespective of
308 p9_debug(P9_DEBUG_VFS
, "%s: inode %p\n", __func__
, inode
);
309 v9inode
= V9FS_I(inode
);
310 if (!v9inode
->writeback_fid
)
312 v9fs_blank_wstat(&wstat
);
314 ret
= p9_client_wstat(v9inode
->writeback_fid
, &wstat
);
316 __mark_inode_dirty(inode
, I_DIRTY_DATASYNC
);
322 static int v9fs_write_inode_dotl(struct inode
*inode
,
323 struct writeback_control
*wbc
)
326 struct v9fs_inode
*v9inode
;
328 * send an fsync request to server irrespective of
331 v9inode
= V9FS_I(inode
);
332 p9_debug(P9_DEBUG_VFS
, "%s: inode %p, writeback_fid %p\n",
333 __func__
, inode
, v9inode
->writeback_fid
);
334 if (!v9inode
->writeback_fid
)
337 ret
= p9_client_fsync(v9inode
->writeback_fid
, 0);
339 __mark_inode_dirty(inode
, I_DIRTY_DATASYNC
);
345 static const struct super_operations v9fs_super_ops
= {
346 .alloc_inode
= v9fs_alloc_inode
,
347 .destroy_inode
= v9fs_destroy_inode
,
348 .statfs
= simple_statfs
,
349 .evict_inode
= v9fs_evict_inode
,
350 .show_options
= v9fs_show_options
,
351 .umount_begin
= v9fs_umount_begin
,
352 .write_inode
= v9fs_write_inode
,
355 static const struct super_operations v9fs_super_ops_dotl
= {
356 .alloc_inode
= v9fs_alloc_inode
,
357 .destroy_inode
= v9fs_destroy_inode
,
358 .statfs
= v9fs_statfs
,
359 .drop_inode
= v9fs_drop_inode
,
360 .evict_inode
= v9fs_evict_inode
,
361 .show_options
= v9fs_show_options
,
362 .umount_begin
= v9fs_umount_begin
,
363 .write_inode
= v9fs_write_inode_dotl
,
366 struct file_system_type v9fs_fs_type
= {
369 .kill_sb
= v9fs_kill_super
,
370 .owner
= THIS_MODULE
,
371 .fs_flags
= FS_RENAME_DOES_D_MOVE
,
373 MODULE_ALIAS_FS("9p");