blob: 9bdef9d519005c9c4fad27d9eb0d404cc09adcc4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scotta805bad2006-06-19 08:40:27 +10002 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
Nathan Scott7b718762005-11-02 14:58:39 +11003 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110019#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs_log.h"
21#include "xfs_clnt.h"
Nathan Scotta844f452005-11-02 14:38:42 +110022#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include "xfs_trans.h"
24#include "xfs_sb.h"
Nathan Scotta844f452005-11-02 14:38:42 +110025#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "xfs_dir2.h"
27#include "xfs_alloc.h"
28#include "xfs_dmapi.h"
29#include "xfs_quota.h"
30#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110032#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_dir2_sf.h"
Nathan Scotta844f452005-11-02 14:38:42 +110035#include "xfs_attr_sf.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include "xfs_dinode.h"
37#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110038#include "xfs_btree.h"
39#include "xfs_ialloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "xfs_bmap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include "xfs_rtalloc.h"
42#include "xfs_error.h"
43#include "xfs_itable.h"
44#include "xfs_rw.h"
45#include "xfs_acl.h"
46#include "xfs_cap.h"
47#include "xfs_mac.h"
48#include "xfs_attr.h"
49#include "xfs_buf_item.h"
50#include "xfs_utils.h"
51#include "xfs_version.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
53#include <linux/namei.h>
54#include <linux/init.h>
55#include <linux/mount.h>
Christoph Hellwig0829c362005-09-02 16:58:49 +100056#include <linux/mempool.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#include <linux/writeback.h>
Christoph Hellwig4df08c52005-09-05 08:34:18 +100058#include <linux/kthread.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Nathan Scotta50cd262006-03-14 14:06:18 +110060STATIC struct quotactl_ops xfs_quotactl_operations;
61STATIC struct super_operations xfs_super_operations;
Christoph Hellwig0829c362005-09-02 16:58:49 +100062STATIC kmem_zone_t *xfs_vnode_zone;
63STATIC kmem_zone_t *xfs_ioend_zone;
64mempool_t *xfs_ioend_pool;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
66STATIC struct xfs_mount_args *
67xfs_args_allocate(
Nathan Scott764d1f82006-03-31 13:04:17 +100068 struct super_block *sb,
69 int silent)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{
71 struct xfs_mount_args *args;
72
73 args = kmem_zalloc(sizeof(struct xfs_mount_args), KM_SLEEP);
74 args->logbufs = args->logbufsize = -1;
75 strncpy(args->fsname, sb->s_id, MAXNAMELEN);
76
77 /* Copy the already-parsed mount(2) flags we're interested in */
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 if (sb->s_flags & MS_DIRSYNC)
79 args->flags |= XFSMNT_DIRSYNC;
80 if (sb->s_flags & MS_SYNCHRONOUS)
81 args->flags |= XFSMNT_WSYNC;
Nathan Scott764d1f82006-03-31 13:04:17 +100082 if (silent)
83 args->flags |= XFSMNT_QUIET;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 args->flags |= XFSMNT_32BITINODES;
85
86 return args;
87}
88
89__uint64_t
90xfs_max_file_offset(
91 unsigned int blockshift)
92{
93 unsigned int pagefactor = 1;
94 unsigned int bitshift = BITS_PER_LONG - 1;
95
96 /* Figure out maximum filesize, on Linux this can depend on
97 * the filesystem blocksize (on 32 bit platforms).
98 * __block_prepare_write does this in an [unsigned] long...
99 * page->index << (PAGE_CACHE_SHIFT - bbits)
100 * So, for page sized blocks (4K on 32 bit platforms),
101 * this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is
102 * (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
103 * but for smaller blocksizes it is less (bbits = log2 bsize).
104 * Note1: get_block_t takes a long (implicit cast from above)
105 * Note2: The Large Block Device (LBD and HAVE_SECTOR_T) patch
106 * can optionally convert the [unsigned] long from above into
107 * an [unsigned] long long.
108 */
109
110#if BITS_PER_LONG == 32
111# if defined(CONFIG_LBD)
112 ASSERT(sizeof(sector_t) == 8);
113 pagefactor = PAGE_CACHE_SIZE;
114 bitshift = BITS_PER_LONG;
115# else
116 pagefactor = PAGE_CACHE_SIZE >> (PAGE_CACHE_SHIFT - blockshift);
117# endif
118#endif
119
120 return (((__uint64_t)pagefactor) << bitshift) - 1;
121}
122
123STATIC __inline__ void
124xfs_set_inodeops(
125 struct inode *inode)
126{
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000127 switch (inode->i_mode & S_IFMT) {
128 case S_IFREG:
Nathan Scott416c6d52006-03-14 14:00:51 +1100129 inode->i_op = &xfs_inode_operations;
Nathan Scott3562fd42006-03-14 14:00:35 +1100130 inode->i_fop = &xfs_file_operations;
Nathan Scotte4c573b2006-03-14 13:54:26 +1100131 inode->i_mapping->a_ops = &xfs_address_space_operations;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000132 break;
133 case S_IFDIR:
Nathan Scott416c6d52006-03-14 14:00:51 +1100134 inode->i_op = &xfs_dir_inode_operations;
Nathan Scott3562fd42006-03-14 14:00:35 +1100135 inode->i_fop = &xfs_dir_file_operations;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000136 break;
137 case S_IFLNK:
Nathan Scott416c6d52006-03-14 14:00:51 +1100138 inode->i_op = &xfs_symlink_inode_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 if (inode->i_blocks)
Nathan Scotte4c573b2006-03-14 13:54:26 +1100140 inode->i_mapping->a_ops = &xfs_address_space_operations;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000141 break;
142 default:
Nathan Scott416c6d52006-03-14 14:00:51 +1100143 inode->i_op = &xfs_inode_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 init_special_inode(inode, inode->i_mode, inode->i_rdev);
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000145 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 }
147}
148
149STATIC __inline__ void
150xfs_revalidate_inode(
151 xfs_mount_t *mp,
Nathan Scott67fcaa72006-06-09 17:00:52 +1000152 bhv_vnode_t *vp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 xfs_inode_t *ip)
154{
Nathan Scottec86dc02006-03-17 17:25:36 +1100155 struct inode *inode = vn_to_inode(vp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000157 inode->i_mode = ip->i_d.di_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 inode->i_nlink = ip->i_d.di_nlink;
159 inode->i_uid = ip->i_d.di_uid;
160 inode->i_gid = ip->i_d.di_gid;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000161
162 switch (inode->i_mode & S_IFMT) {
163 case S_IFBLK:
164 case S_IFCHR:
165 inode->i_rdev =
166 MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
167 sysv_minor(ip->i_df.if_u2.if_rdev));
168 break;
169 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 inode->i_rdev = 0;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000171 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 }
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000173
David Chinnere8c8b3a2005-11-02 10:33:05 +1100174 inode->i_blksize = xfs_preferred_iosize(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 inode->i_generation = ip->i_d.di_gen;
176 i_size_write(inode, ip->i_d.di_size);
177 inode->i_blocks =
178 XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
179 inode->i_atime.tv_sec = ip->i_d.di_atime.t_sec;
180 inode->i_atime.tv_nsec = ip->i_d.di_atime.t_nsec;
181 inode->i_mtime.tv_sec = ip->i_d.di_mtime.t_sec;
182 inode->i_mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
183 inode->i_ctime.tv_sec = ip->i_d.di_ctime.t_sec;
184 inode->i_ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
185 if (ip->i_d.di_flags & XFS_DIFLAG_IMMUTABLE)
186 inode->i_flags |= S_IMMUTABLE;
187 else
188 inode->i_flags &= ~S_IMMUTABLE;
189 if (ip->i_d.di_flags & XFS_DIFLAG_APPEND)
190 inode->i_flags |= S_APPEND;
191 else
192 inode->i_flags &= ~S_APPEND;
193 if (ip->i_d.di_flags & XFS_DIFLAG_SYNC)
194 inode->i_flags |= S_SYNC;
195 else
196 inode->i_flags &= ~S_SYNC;
197 if (ip->i_d.di_flags & XFS_DIFLAG_NOATIME)
198 inode->i_flags |= S_NOATIME;
199 else
200 inode->i_flags &= ~S_NOATIME;
201 vp->v_flag &= ~VMODIFIED;
202}
203
204void
205xfs_initialize_vnode(
206 bhv_desc_t *bdp,
Nathan Scott67fcaa72006-06-09 17:00:52 +1000207 bhv_vnode_t *vp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 bhv_desc_t *inode_bhv,
209 int unlock)
210{
211 xfs_inode_t *ip = XFS_BHVTOI(inode_bhv);
Nathan Scottec86dc02006-03-17 17:25:36 +1100212 struct inode *inode = vn_to_inode(vp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
214 if (!inode_bhv->bd_vobj) {
215 vp->v_vfsp = bhvtovfs(bdp);
216 bhv_desc_init(inode_bhv, ip, vp, &xfs_vnodeops);
217 bhv_insert(VN_BHV_HEAD(vp), inode_bhv);
218 }
219
220 /*
221 * We need to set the ops vectors, and unlock the inode, but if
222 * we have been called during the new inode create process, it is
223 * too early to fill in the Linux inode. We will get called a
224 * second time once the inode is properly set up, and then we can
225 * finish our work.
226 */
227 if (ip->i_d.di_mode != 0 && unlock && (inode->i_state & I_NEW)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 xfs_revalidate_inode(XFS_BHVTOM(bdp), vp, ip);
229 xfs_set_inodeops(inode);
Nathan Scottec86dc02006-03-17 17:25:36 +1100230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 ip->i_flags &= ~XFS_INEW;
232 barrier();
233
234 unlock_new_inode(inode);
235 }
236}
237
238int
239xfs_blkdev_get(
240 xfs_mount_t *mp,
241 const char *name,
242 struct block_device **bdevp)
243{
244 int error = 0;
245
246 *bdevp = open_bdev_excl(name, 0, mp);
247 if (IS_ERR(*bdevp)) {
248 error = PTR_ERR(*bdevp);
249 printk("XFS: Invalid device [%s], error=%d\n", name, error);
250 }
251
252 return -error;
253}
254
255void
256xfs_blkdev_put(
257 struct block_device *bdev)
258{
259 if (bdev)
260 close_bdev_excl(bdev);
261}
262
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100263/*
264 * Try to write out the superblock using barriers.
265 */
266STATIC int
267xfs_barrier_test(
268 xfs_mount_t *mp)
269{
270 xfs_buf_t *sbp = xfs_getsb(mp, 0);
271 int error;
272
273 XFS_BUF_UNDONE(sbp);
274 XFS_BUF_UNREAD(sbp);
275 XFS_BUF_UNDELAYWRITE(sbp);
276 XFS_BUF_WRITE(sbp);
277 XFS_BUF_UNASYNC(sbp);
278 XFS_BUF_ORDERED(sbp);
279
280 xfsbdstrat(mp, sbp);
281 error = xfs_iowait(sbp);
282
283 /*
284 * Clear all the flags we set and possible error state in the
285 * buffer. We only did the write to try out whether barriers
286 * worked and shouldn't leave any traces in the superblock
287 * buffer.
288 */
289 XFS_BUF_DONE(sbp);
290 XFS_BUF_ERROR(sbp, 0);
291 XFS_BUF_UNORDERED(sbp);
292
293 xfs_buf_relse(sbp);
294 return error;
295}
296
297void
298xfs_mountfs_check_barriers(xfs_mount_t *mp)
299{
300 int error;
301
302 if (mp->m_logdev_targp != mp->m_ddev_targp) {
303 xfs_fs_cmn_err(CE_NOTE, mp,
304 "Disabling barriers, not supported with external log device");
305 mp->m_flags &= ~XFS_MOUNT_BARRIER;
Christoph Hellwig4ef19dd2006-01-11 15:27:18 +1100306 return;
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100307 }
308
Nathan Scottce8e9222006-01-11 15:39:08 +1100309 if (mp->m_ddev_targp->bt_bdev->bd_disk->queue->ordered ==
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100310 QUEUE_ORDERED_NONE) {
311 xfs_fs_cmn_err(CE_NOTE, mp,
312 "Disabling barriers, not supported by the underlying device");
313 mp->m_flags &= ~XFS_MOUNT_BARRIER;
Christoph Hellwig4ef19dd2006-01-11 15:27:18 +1100314 return;
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100315 }
316
317 error = xfs_barrier_test(mp);
318 if (error) {
319 xfs_fs_cmn_err(CE_NOTE, mp,
320 "Disabling barriers, trial barrier write failed");
321 mp->m_flags &= ~XFS_MOUNT_BARRIER;
Christoph Hellwig4ef19dd2006-01-11 15:27:18 +1100322 return;
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100323 }
324}
325
326void
327xfs_blkdev_issue_flush(
328 xfs_buftarg_t *buftarg)
329{
Nathan Scottce8e9222006-01-11 15:39:08 +1100330 blkdev_issue_flush(buftarg->bt_bdev, NULL);
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100331}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
333STATIC struct inode *
Nathan Scotta50cd262006-03-14 14:06:18 +1100334xfs_fs_alloc_inode(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 struct super_block *sb)
336{
Nathan Scott67fcaa72006-06-09 17:00:52 +1000337 bhv_vnode_t *vp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Nathan Scott87582802006-03-14 13:18:19 +1100339 vp = kmem_zone_alloc(xfs_vnode_zone, KM_SLEEP);
340 if (unlikely(!vp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 return NULL;
Nathan Scottec86dc02006-03-17 17:25:36 +1100342 return vn_to_inode(vp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343}
344
345STATIC void
Nathan Scotta50cd262006-03-14 14:06:18 +1100346xfs_fs_destroy_inode(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 struct inode *inode)
348{
Nathan Scottec86dc02006-03-17 17:25:36 +1100349 kmem_zone_free(xfs_vnode_zone, vn_from_inode(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350}
351
352STATIC void
Nathan Scotta50cd262006-03-14 14:06:18 +1100353xfs_fs_inode_init_once(
Nathan Scott87582802006-03-14 13:18:19 +1100354 void *vnode,
355 kmem_zone_t *zonep,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 unsigned long flags)
357{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
Nathan Scott87582802006-03-14 13:18:19 +1100359 SLAB_CTOR_CONSTRUCTOR)
Nathan Scott67fcaa72006-06-09 17:00:52 +1000360 inode_init_once(vn_to_inode((bhv_vnode_t *)vnode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361}
362
363STATIC int
Nathan Scott87582802006-03-14 13:18:19 +1100364xfs_init_zones(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365{
Nathan Scott67fcaa72006-06-09 17:00:52 +1000366 xfs_vnode_zone = kmem_zone_init_flags(sizeof(bhv_vnode_t), "xfs_vnode",
Nathan Scotte0cc2322006-03-14 13:19:55 +1100367 KM_ZONE_HWALIGN | KM_ZONE_RECLAIM |
368 KM_ZONE_SPREAD,
Nathan Scotta50cd262006-03-14 14:06:18 +1100369 xfs_fs_inode_init_once);
Christoph Hellwig0829c362005-09-02 16:58:49 +1000370 if (!xfs_vnode_zone)
371 goto out;
372
373 xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
374 if (!xfs_ioend_zone)
375 goto out_destroy_vnode_zone;
376
Matthew Dobson93d23412006-03-26 01:37:50 -0800377 xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
378 xfs_ioend_zone);
Christoph Hellwig0829c362005-09-02 16:58:49 +1000379 if (!xfs_ioend_pool)
380 goto out_free_ioend_zone;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 return 0;
Christoph Hellwig0829c362005-09-02 16:58:49 +1000382
Christoph Hellwig0829c362005-09-02 16:58:49 +1000383 out_free_ioend_zone:
384 kmem_zone_destroy(xfs_ioend_zone);
385 out_destroy_vnode_zone:
386 kmem_zone_destroy(xfs_vnode_zone);
387 out:
388 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389}
390
391STATIC void
Nathan Scott87582802006-03-14 13:18:19 +1100392xfs_destroy_zones(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393{
Christoph Hellwig0829c362005-09-02 16:58:49 +1000394 mempool_destroy(xfs_ioend_pool);
395 kmem_zone_destroy(xfs_vnode_zone);
396 kmem_zone_destroy(xfs_ioend_zone);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397}
398
399/*
400 * Attempt to flush the inode, this will actually fail
401 * if the inode is pinned, but we dirty the inode again
402 * at the point when it is unpinned after a log write,
Nathan Scott87582802006-03-14 13:18:19 +1100403 * since this is when the inode itself becomes flushable.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 */
405STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100406xfs_fs_write_inode(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 struct inode *inode,
408 int sync)
409{
Nathan Scott67fcaa72006-06-09 17:00:52 +1000410 bhv_vnode_t *vp = vn_from_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 int error = 0, flags = FLUSH_INODE;
412
413 if (vp) {
414 vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
415 if (sync)
416 flags |= FLUSH_SYNC;
Nathan Scott67fcaa72006-06-09 17:00:52 +1000417 error = bhv_vop_iflush(vp, flags);
418 if (error == EAGAIN)
419 error = sync? bhv_vop_iflush(vp, flags | FLUSH_LOG) : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 return -error;
422}
423
424STATIC void
Nathan Scotta50cd262006-03-14 14:06:18 +1100425xfs_fs_clear_inode(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 struct inode *inode)
427{
Nathan Scott67fcaa72006-06-09 17:00:52 +1000428 bhv_vnode_t *vp = vn_from_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Nathan Scotta50cd262006-03-14 14:06:18 +1100430 vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000431
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000432 XFS_STATS_INC(vn_rele);
433 XFS_STATS_INC(vn_remove);
434 XFS_STATS_INC(vn_reclaim);
435 XFS_STATS_DEC(vn_active);
436
Christoph Hellwig02ba71d2005-09-05 08:28:02 +1000437 /*
438 * This can happen because xfs_iget_core calls xfs_idestroy if we
439 * find an inode with di_mode == 0 but without IGET_CREATE set.
440 */
Nathan Scott67fcaa72006-06-09 17:00:52 +1000441 if (VNHEAD(vp))
442 bhv_vop_inactive(vp, NULL);
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000443
444 VN_LOCK(vp);
445 vp->v_flag &= ~VMODIFIED;
446 VN_UNLOCK(vp, 0);
447
Nathan Scott67fcaa72006-06-09 17:00:52 +1000448 if (VNHEAD(vp))
449 if (bhv_vop_reclaim(vp))
450 panic("%s: cannot reclaim 0x%p\n", __FUNCTION__, vp);
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000451
Nathan Scott67fcaa72006-06-09 17:00:52 +1000452 ASSERT(VNHEAD(vp) == NULL);
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000453
454#ifdef XFS_VNODE_TRACE
455 ktrace_free(vp->v_trace);
456#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457}
458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459/*
460 * Enqueue a work item to be picked up by the vfs xfssyncd thread.
461 * Doing this has two advantages:
462 * - It saves on stack space, which is tight in certain situations
463 * - It can be used (with care) as a mechanism to avoid deadlocks.
464 * Flushing while allocating in a full filesystem requires both.
465 */
466STATIC void
467xfs_syncd_queue_work(
Nathan Scottb83bd132006-06-09 16:48:30 +1000468 struct bhv_vfs *vfs,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 void *data,
Nathan Scottb83bd132006-06-09 16:48:30 +1000470 void (*syncer)(bhv_vfs_t *, void *))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471{
Nathan Scottb83bd132006-06-09 16:48:30 +1000472 struct bhv_vfs_sync_work *work;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473
Nathan Scottb83bd132006-06-09 16:48:30 +1000474 work = kmem_alloc(sizeof(struct bhv_vfs_sync_work), KM_SLEEP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 INIT_LIST_HEAD(&work->w_list);
476 work->w_syncer = syncer;
477 work->w_data = data;
478 work->w_vfs = vfs;
479 spin_lock(&vfs->vfs_sync_lock);
480 list_add_tail(&work->w_list, &vfs->vfs_sync_list);
481 spin_unlock(&vfs->vfs_sync_lock);
482 wake_up_process(vfs->vfs_sync_task);
483}
484
485/*
486 * Flush delayed allocate data, attempting to free up reserved space
487 * from existing allocations. At this point a new allocation attempt
488 * has failed with ENOSPC and we are in the process of scratching our
489 * heads, looking about for more room...
490 */
491STATIC void
492xfs_flush_inode_work(
Nathan Scottb83bd132006-06-09 16:48:30 +1000493 bhv_vfs_t *vfs,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 void *inode)
495{
496 filemap_flush(((struct inode *)inode)->i_mapping);
497 iput((struct inode *)inode);
498}
499
500void
501xfs_flush_inode(
502 xfs_inode_t *ip)
503{
Nathan Scottec86dc02006-03-17 17:25:36 +1100504 struct inode *inode = vn_to_inode(XFS_ITOV(ip));
Nathan Scottb83bd132006-06-09 16:48:30 +1000505 struct bhv_vfs *vfs = XFS_MTOVFS(ip->i_mount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
507 igrab(inode);
508 xfs_syncd_queue_work(vfs, inode, xfs_flush_inode_work);
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700509 delay(msecs_to_jiffies(500));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510}
511
512/*
513 * This is the "bigger hammer" version of xfs_flush_inode_work...
514 * (IOW, "If at first you don't succeed, use a Bigger Hammer").
515 */
516STATIC void
517xfs_flush_device_work(
Nathan Scottb83bd132006-06-09 16:48:30 +1000518 bhv_vfs_t *vfs,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 void *inode)
520{
521 sync_blockdev(vfs->vfs_super->s_bdev);
522 iput((struct inode *)inode);
523}
524
525void
526xfs_flush_device(
527 xfs_inode_t *ip)
528{
Nathan Scottec86dc02006-03-17 17:25:36 +1100529 struct inode *inode = vn_to_inode(XFS_ITOV(ip));
Nathan Scottb83bd132006-06-09 16:48:30 +1000530 struct bhv_vfs *vfs = XFS_MTOVFS(ip->i_mount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531
532 igrab(inode);
533 xfs_syncd_queue_work(vfs, inode, xfs_flush_device_work);
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700534 delay(msecs_to_jiffies(500));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 xfs_log_force(ip->i_mount, (xfs_lsn_t)0, XFS_LOG_FORCE|XFS_LOG_SYNC);
536}
537
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538STATIC void
539vfs_sync_worker(
Nathan Scottb83bd132006-06-09 16:48:30 +1000540 bhv_vfs_t *vfsp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 void *unused)
542{
543 int error;
544
545 if (!(vfsp->vfs_flag & VFS_RDONLY))
Nathan Scottb83bd132006-06-09 16:48:30 +1000546 error = bhv_vfs_sync(vfsp, SYNC_FSDATA | SYNC_BDFLUSH | \
547 SYNC_ATTR | SYNC_REFCACHE, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 vfsp->vfs_sync_seq++;
549 wmb();
550 wake_up(&vfsp->vfs_wait_single_sync_task);
551}
552
553STATIC int
554xfssyncd(
555 void *arg)
556{
557 long timeleft;
Nathan Scottb83bd132006-06-09 16:48:30 +1000558 bhv_vfs_t *vfsp = (bhv_vfs_t *) arg;
559 bhv_vfs_sync_work_t *work, *n;
Christoph Hellwig4df08c52005-09-05 08:34:18 +1000560 LIST_HEAD (tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700562 timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 for (;;) {
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700564 timeleft = schedule_timeout_interruptible(timeleft);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 /* swsusp */
Christoph Lameter3e1d1d22005-06-24 23:13:50 -0700566 try_to_freeze();
Yingping Lu71df0992006-01-11 21:02:29 +1100567 if (kthread_should_stop() && list_empty(&vfsp->vfs_sync_list))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 break;
569
570 spin_lock(&vfsp->vfs_sync_lock);
571 /*
572 * We can get woken by laptop mode, to do a sync -
573 * that's the (only!) case where the list would be
574 * empty with time remaining.
575 */
576 if (!timeleft || list_empty(&vfsp->vfs_sync_list)) {
577 if (!timeleft)
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700578 timeleft = xfs_syncd_centisecs *
579 msecs_to_jiffies(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 INIT_LIST_HEAD(&vfsp->vfs_sync_work.w_list);
581 list_add_tail(&vfsp->vfs_sync_work.w_list,
582 &vfsp->vfs_sync_list);
583 }
584 list_for_each_entry_safe(work, n, &vfsp->vfs_sync_list, w_list)
585 list_move(&work->w_list, &tmp);
586 spin_unlock(&vfsp->vfs_sync_lock);
587
588 list_for_each_entry_safe(work, n, &tmp, w_list) {
589 (*work->w_syncer)(vfsp, work->w_data);
590 list_del(&work->w_list);
591 if (work == &vfsp->vfs_sync_work)
592 continue;
Nathan Scottb83bd132006-06-09 16:48:30 +1000593 kmem_free(work, sizeof(struct bhv_vfs_sync_work));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 }
595 }
596
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 return 0;
598}
599
600STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100601xfs_fs_start_syncd(
Nathan Scottb83bd132006-06-09 16:48:30 +1000602 bhv_vfs_t *vfsp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603{
Christoph Hellwig4df08c52005-09-05 08:34:18 +1000604 vfsp->vfs_sync_work.w_syncer = vfs_sync_worker;
605 vfsp->vfs_sync_work.w_vfs = vfsp;
606 vfsp->vfs_sync_task = kthread_run(xfssyncd, vfsp, "xfssyncd");
607 if (IS_ERR(vfsp->vfs_sync_task))
608 return -PTR_ERR(vfsp->vfs_sync_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 return 0;
610}
611
612STATIC void
Nathan Scotta50cd262006-03-14 14:06:18 +1100613xfs_fs_stop_syncd(
Nathan Scottb83bd132006-06-09 16:48:30 +1000614 bhv_vfs_t *vfsp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615{
Christoph Hellwig4df08c52005-09-05 08:34:18 +1000616 kthread_stop(vfsp->vfs_sync_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617}
618
619STATIC void
Nathan Scotta50cd262006-03-14 14:06:18 +1100620xfs_fs_put_super(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 struct super_block *sb)
622{
Nathan Scottb83bd132006-06-09 16:48:30 +1000623 bhv_vfs_t *vfsp = vfs_from_sb(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 int error;
625
Nathan Scotta50cd262006-03-14 14:06:18 +1100626 xfs_fs_stop_syncd(vfsp);
Nathan Scottb83bd132006-06-09 16:48:30 +1000627 bhv_vfs_sync(vfsp, SYNC_ATTR | SYNC_DELWRI, NULL);
628 error = bhv_vfs_unmount(vfsp, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 if (error) {
Nathan Scottb83bd132006-06-09 16:48:30 +1000630 printk("XFS: unmount got error=%d\n", error);
631 printk("%s: vfs=0x%p left dangling!\n", __FUNCTION__, vfsp);
632 } else {
633 vfs_deallocate(vfsp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635}
636
637STATIC void
Nathan Scotta50cd262006-03-14 14:06:18 +1100638xfs_fs_write_super(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 struct super_block *sb)
640{
Nathan Scottb83bd132006-06-09 16:48:30 +1000641 if (!(sb->s_flags & MS_RDONLY))
642 bhv_vfs_sync(vfs_from_sb(sb), SYNC_FSDATA, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 sb->s_dirt = 0;
644}
645
646STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100647xfs_fs_sync_super(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 struct super_block *sb,
649 int wait)
650{
Nathan Scottb83bd132006-06-09 16:48:30 +1000651 bhv_vfs_t *vfsp = vfs_from_sb(sb);
652 int error;
653 int flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
Christoph Hellwigf898d6c2005-06-21 15:40:48 +1000655 if (unlikely(sb->s_frozen == SB_FREEZE_WRITE))
656 flags = SYNC_QUIESCE;
657 else
658 flags = SYNC_FSDATA | (wait ? SYNC_WAIT : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659
Nathan Scottb83bd132006-06-09 16:48:30 +1000660 error = bhv_vfs_sync(vfsp, flags, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 sb->s_dirt = 0;
662
663 if (unlikely(laptop_mode)) {
664 int prev_sync_seq = vfsp->vfs_sync_seq;
665
666 /*
667 * The disk must be active because we're syncing.
668 * We schedule xfssyncd now (now that the disk is
669 * active) instead of later (when it might not be).
670 */
671 wake_up_process(vfsp->vfs_sync_task);
672 /*
673 * We have to wait for the sync iteration to complete.
674 * If we don't, the disk activity caused by the sync
675 * will come after the sync is completed, and that
676 * triggers another sync from laptop mode.
677 */
678 wait_event(vfsp->vfs_wait_single_sync_task,
679 vfsp->vfs_sync_seq != prev_sync_seq);
680 }
681
682 return -error;
683}
684
685STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100686xfs_fs_statfs(
David Howells726c3342006-06-23 02:02:58 -0700687 struct dentry *dentry,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 struct kstatfs *statp)
689{
David Howellsd6938d12006-06-23 02:02:59 -0700690 return -bhv_vfs_statvfs(vfs_from_sb(dentry->d_sb), statp,
691 vn_from_inode(dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692}
693
694STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100695xfs_fs_remount(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 struct super_block *sb,
697 int *flags,
698 char *options)
699{
Nathan Scottb83bd132006-06-09 16:48:30 +1000700 bhv_vfs_t *vfsp = vfs_from_sb(sb);
Nathan Scott764d1f82006-03-31 13:04:17 +1000701 struct xfs_mount_args *args = xfs_args_allocate(sb, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 int error;
703
Nathan Scottb83bd132006-06-09 16:48:30 +1000704 error = bhv_vfs_parseargs(vfsp, options, args, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 if (!error)
Nathan Scottb83bd132006-06-09 16:48:30 +1000706 error = bhv_vfs_mntupdate(vfsp, flags, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 kmem_free(args, sizeof(*args));
708 return -error;
709}
710
711STATIC void
Nathan Scotta50cd262006-03-14 14:06:18 +1100712xfs_fs_lockfs(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 struct super_block *sb)
714{
Nathan Scottb83bd132006-06-09 16:48:30 +1000715 bhv_vfs_freeze(vfs_from_sb(sb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716}
717
718STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100719xfs_fs_show_options(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 struct seq_file *m,
721 struct vfsmount *mnt)
722{
Nathan Scottb83bd132006-06-09 16:48:30 +1000723 return -bhv_vfs_showargs(vfs_from_sb(mnt->mnt_sb), m);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724}
725
726STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100727xfs_fs_quotasync(
Nathan Scottee348072005-11-02 10:32:38 +1100728 struct super_block *sb,
729 int type)
730{
Nathan Scottb83bd132006-06-09 16:48:30 +1000731 return -bhv_vfs_quotactl(vfs_from_sb(sb), Q_XQUOTASYNC, 0, NULL);
Nathan Scottee348072005-11-02 10:32:38 +1100732}
733
734STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100735xfs_fs_getxstate(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 struct super_block *sb,
737 struct fs_quota_stat *fqs)
738{
Nathan Scottb83bd132006-06-09 16:48:30 +1000739 return -bhv_vfs_quotactl(vfs_from_sb(sb), Q_XGETQSTAT, 0, (caddr_t)fqs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740}
741
742STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100743xfs_fs_setxstate(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 struct super_block *sb,
745 unsigned int flags,
746 int op)
747{
Nathan Scottb83bd132006-06-09 16:48:30 +1000748 return -bhv_vfs_quotactl(vfs_from_sb(sb), op, 0, (caddr_t)&flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749}
750
751STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100752xfs_fs_getxquota(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 struct super_block *sb,
754 int type,
755 qid_t id,
756 struct fs_disk_quota *fdq)
757{
Nathan Scottb83bd132006-06-09 16:48:30 +1000758 return -bhv_vfs_quotactl(vfs_from_sb(sb),
759 (type == USRQUOTA) ? Q_XGETQUOTA :
760 ((type == GRPQUOTA) ? Q_XGETGQUOTA :
761 Q_XGETPQUOTA), id, (caddr_t)fdq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762}
763
764STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100765xfs_fs_setxquota(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 struct super_block *sb,
767 int type,
768 qid_t id,
769 struct fs_disk_quota *fdq)
770{
Nathan Scottb83bd132006-06-09 16:48:30 +1000771 return -bhv_vfs_quotactl(vfs_from_sb(sb),
772 (type == USRQUOTA) ? Q_XSETQLIM :
773 ((type == GRPQUOTA) ? Q_XSETGQLIM :
774 Q_XSETPQLIM), id, (caddr_t)fdq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775}
776
777STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100778xfs_fs_fill_super(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 struct super_block *sb,
780 void *data,
781 int silent)
782{
Nathan Scott67fcaa72006-06-09 17:00:52 +1000783 struct bhv_vnode *rootvp;
Nathan Scottb83bd132006-06-09 16:48:30 +1000784 struct bhv_vfs *vfsp = vfs_allocate(sb);
Nathan Scott764d1f82006-03-31 13:04:17 +1000785 struct xfs_mount_args *args = xfs_args_allocate(sb, silent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 struct kstatfs statvfs;
Nathan Scottb83bd132006-06-09 16:48:30 +1000787 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 bhv_insert_all_vfsops(vfsp);
790
Nathan Scottb83bd132006-06-09 16:48:30 +1000791 error = bhv_vfs_parseargs(vfsp, (char *)data, args, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 if (error) {
793 bhv_remove_all_vfsops(vfsp, 1);
794 goto fail_vfsop;
795 }
796
797 sb_min_blocksize(sb, BBSIZE);
Nathan Scotta50cd262006-03-14 14:06:18 +1100798 sb->s_export_op = &xfs_export_operations;
Nathan Scotta50cd262006-03-14 14:06:18 +1100799 sb->s_qcop = &xfs_quotactl_operations;
800 sb->s_op = &xfs_super_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
Nathan Scottb83bd132006-06-09 16:48:30 +1000802 error = bhv_vfs_mount(vfsp, args, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 if (error) {
804 bhv_remove_all_vfsops(vfsp, 1);
805 goto fail_vfsop;
806 }
807
Nathan Scottb83bd132006-06-09 16:48:30 +1000808 error = bhv_vfs_statvfs(vfsp, &statvfs, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 if (error)
810 goto fail_unmount;
811
812 sb->s_dirt = 1;
813 sb->s_magic = statvfs.f_type;
814 sb->s_blocksize = statvfs.f_bsize;
815 sb->s_blocksize_bits = ffs(statvfs.f_bsize) - 1;
816 sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
817 sb->s_time_gran = 1;
818 set_posix_acl_flag(sb);
819
Nathan Scottb83bd132006-06-09 16:48:30 +1000820 error = bhv_vfs_root(vfsp, &rootvp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 if (error)
822 goto fail_unmount;
823
Nathan Scottec86dc02006-03-17 17:25:36 +1100824 sb->s_root = d_alloc_root(vn_to_inode(rootvp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 if (!sb->s_root) {
826 error = ENOMEM;
827 goto fail_vnrele;
828 }
829 if (is_bad_inode(sb->s_root->d_inode)) {
830 error = EINVAL;
831 goto fail_vnrele;
832 }
Nathan Scotta50cd262006-03-14 14:06:18 +1100833 if ((error = xfs_fs_start_syncd(vfsp)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 goto fail_vnrele;
835 vn_trace_exit(rootvp, __FUNCTION__, (inst_t *)__return_address);
836
837 kmem_free(args, sizeof(*args));
838 return 0;
839
840fail_vnrele:
841 if (sb->s_root) {
842 dput(sb->s_root);
843 sb->s_root = NULL;
844 } else {
845 VN_RELE(rootvp);
846 }
847
848fail_unmount:
Nathan Scottb83bd132006-06-09 16:48:30 +1000849 bhv_vfs_unmount(vfsp, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850
851fail_vfsop:
852 vfs_deallocate(vfsp);
853 kmem_free(args, sizeof(*args));
854 return -error;
855}
856
David Howells454e2392006-06-23 02:02:57 -0700857STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +1100858xfs_fs_get_sb(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 struct file_system_type *fs_type,
860 int flags,
861 const char *dev_name,
David Howells454e2392006-06-23 02:02:57 -0700862 void *data,
863 struct vfsmount *mnt)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864{
David Howells454e2392006-06-23 02:02:57 -0700865 return get_sb_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super,
866 mnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867}
868
Nathan Scotta50cd262006-03-14 14:06:18 +1100869STATIC struct super_operations xfs_super_operations = {
870 .alloc_inode = xfs_fs_alloc_inode,
871 .destroy_inode = xfs_fs_destroy_inode,
872 .write_inode = xfs_fs_write_inode,
873 .clear_inode = xfs_fs_clear_inode,
874 .put_super = xfs_fs_put_super,
875 .write_super = xfs_fs_write_super,
876 .sync_fs = xfs_fs_sync_super,
877 .write_super_lockfs = xfs_fs_lockfs,
878 .statfs = xfs_fs_statfs,
879 .remount_fs = xfs_fs_remount,
880 .show_options = xfs_fs_show_options,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881};
882
Nathan Scotta50cd262006-03-14 14:06:18 +1100883STATIC struct quotactl_ops xfs_quotactl_operations = {
884 .quota_sync = xfs_fs_quotasync,
885 .get_xstate = xfs_fs_getxstate,
886 .set_xstate = xfs_fs_setxstate,
887 .get_xquota = xfs_fs_getxquota,
888 .set_xquota = xfs_fs_setxquota,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889};
890
891STATIC struct file_system_type xfs_fs_type = {
892 .owner = THIS_MODULE,
893 .name = "xfs",
Nathan Scotta50cd262006-03-14 14:06:18 +1100894 .get_sb = xfs_fs_get_sb,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 .kill_sb = kill_block_super,
896 .fs_flags = FS_REQUIRES_DEV,
897};
898
899
900STATIC int __init
901init_xfs_fs( void )
902{
903 int error;
904 struct sysinfo si;
905 static char message[] __initdata = KERN_INFO \
906 XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled\n";
907
908 printk(message);
909
910 si_meminfo(&si);
911 xfs_physmem = si.totalram;
912
913 ktrace_init(64);
914
Nathan Scott87582802006-03-14 13:18:19 +1100915 error = xfs_init_zones();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 if (error < 0)
Christoph Hellwig0829c362005-09-02 16:58:49 +1000917 goto undo_zones;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918
Nathan Scottce8e9222006-01-11 15:39:08 +1100919 error = xfs_buf_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 if (error < 0)
Nathan Scottce8e9222006-01-11 15:39:08 +1100921 goto undo_buffers;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
923 vn_init();
924 xfs_init();
925 uuid_init();
926 vfs_initquota();
927
928 error = register_filesystem(&xfs_fs_type);
929 if (error)
930 goto undo_register;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 return 0;
932
933undo_register:
Nathan Scottce8e9222006-01-11 15:39:08 +1100934 xfs_buf_terminate();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
Nathan Scottce8e9222006-01-11 15:39:08 +1100936undo_buffers:
Nathan Scott87582802006-03-14 13:18:19 +1100937 xfs_destroy_zones();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
Christoph Hellwig0829c362005-09-02 16:58:49 +1000939undo_zones:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 return error;
941}
942
943STATIC void __exit
944exit_xfs_fs( void )
945{
946 vfs_exitquota();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 unregister_filesystem(&xfs_fs_type);
948 xfs_cleanup();
Nathan Scottce8e9222006-01-11 15:39:08 +1100949 xfs_buf_terminate();
Nathan Scott87582802006-03-14 13:18:19 +1100950 xfs_destroy_zones();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 ktrace_uninit();
952}
953
954module_init(init_xfs_fs);
955module_exit(exit_xfs_fs);
956
957MODULE_AUTHOR("Silicon Graphics, Inc.");
958MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
959MODULE_LICENSE("GPL");