blob: 4d8613f65c2c2e27d0b83ccd2cfe8b8fe160b200 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott7b718762005-11-02 14:58:39 +11002 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * 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_dir.h"
27#include "xfs_dir2.h"
28#include "xfs_alloc.h"
29#include "xfs_dmapi.h"
30#include "xfs_quota.h"
31#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110033#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include "xfs_dir_sf.h"
36#include "xfs_dir2_sf.h"
Nathan Scotta844f452005-11-02 14:38:42 +110037#include "xfs_attr_sf.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include "xfs_dinode.h"
39#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110040#include "xfs_btree.h"
41#include "xfs_ialloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include "xfs_bmap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include "xfs_rtalloc.h"
44#include "xfs_error.h"
45#include "xfs_itable.h"
46#include "xfs_rw.h"
47#include "xfs_acl.h"
48#include "xfs_cap.h"
49#include "xfs_mac.h"
50#include "xfs_attr.h"
51#include "xfs_buf_item.h"
52#include "xfs_utils.h"
53#include "xfs_version.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55#include <linux/namei.h>
56#include <linux/init.h>
57#include <linux/mount.h>
Christoph Hellwig0829c362005-09-02 16:58:49 +100058#include <linux/mempool.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <linux/writeback.h>
Christoph Hellwig4df08c52005-09-05 08:34:18 +100060#include <linux/kthread.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62STATIC struct quotactl_ops linvfs_qops;
63STATIC struct super_operations linvfs_sops;
Christoph Hellwig0829c362005-09-02 16:58:49 +100064STATIC kmem_zone_t *xfs_vnode_zone;
65STATIC kmem_zone_t *xfs_ioend_zone;
66mempool_t *xfs_ioend_pool;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
68STATIC struct xfs_mount_args *
69xfs_args_allocate(
70 struct super_block *sb)
71{
72 struct xfs_mount_args *args;
73
74 args = kmem_zalloc(sizeof(struct xfs_mount_args), KM_SLEEP);
75 args->logbufs = args->logbufsize = -1;
76 strncpy(args->fsname, sb->s_id, MAXNAMELEN);
77
78 /* Copy the already-parsed mount(2) flags we're interested in */
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 if (sb->s_flags & MS_DIRSYNC)
80 args->flags |= XFSMNT_DIRSYNC;
81 if (sb->s_flags & MS_SYNCHRONOUS)
82 args->flags |= XFSMNT_WSYNC;
83
84 /* Default to 32 bit inodes on Linux all the time */
85 args->flags |= XFSMNT_32BITINODES;
86
87 return args;
88}
89
90__uint64_t
91xfs_max_file_offset(
92 unsigned int blockshift)
93{
94 unsigned int pagefactor = 1;
95 unsigned int bitshift = BITS_PER_LONG - 1;
96
97 /* Figure out maximum filesize, on Linux this can depend on
98 * the filesystem blocksize (on 32 bit platforms).
99 * __block_prepare_write does this in an [unsigned] long...
100 * page->index << (PAGE_CACHE_SHIFT - bbits)
101 * So, for page sized blocks (4K on 32 bit platforms),
102 * this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is
103 * (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
104 * but for smaller blocksizes it is less (bbits = log2 bsize).
105 * Note1: get_block_t takes a long (implicit cast from above)
106 * Note2: The Large Block Device (LBD and HAVE_SECTOR_T) patch
107 * can optionally convert the [unsigned] long from above into
108 * an [unsigned] long long.
109 */
110
111#if BITS_PER_LONG == 32
112# if defined(CONFIG_LBD)
113 ASSERT(sizeof(sector_t) == 8);
114 pagefactor = PAGE_CACHE_SIZE;
115 bitshift = BITS_PER_LONG;
116# else
117 pagefactor = PAGE_CACHE_SIZE >> (PAGE_CACHE_SHIFT - blockshift);
118# endif
119#endif
120
121 return (((__uint64_t)pagefactor) << bitshift) - 1;
122}
123
124STATIC __inline__ void
125xfs_set_inodeops(
126 struct inode *inode)
127{
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000128 switch (inode->i_mode & S_IFMT) {
129 case S_IFREG:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 inode->i_op = &linvfs_file_inode_operations;
131 inode->i_fop = &linvfs_file_operations;
132 inode->i_mapping->a_ops = &linvfs_aops;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000133 break;
134 case S_IFDIR:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 inode->i_op = &linvfs_dir_inode_operations;
136 inode->i_fop = &linvfs_dir_operations;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000137 break;
138 case S_IFLNK:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 inode->i_op = &linvfs_symlink_inode_operations;
140 if (inode->i_blocks)
141 inode->i_mapping->a_ops = &linvfs_aops;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000142 break;
143 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 inode->i_op = &linvfs_file_inode_operations;
145 init_special_inode(inode, inode->i_mode, inode->i_rdev);
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000146 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 }
148}
149
150STATIC __inline__ void
151xfs_revalidate_inode(
152 xfs_mount_t *mp,
153 vnode_t *vp,
154 xfs_inode_t *ip)
155{
156 struct inode *inode = LINVFS_GET_IP(vp);
157
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000158 inode->i_mode = ip->i_d.di_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 inode->i_nlink = ip->i_d.di_nlink;
160 inode->i_uid = ip->i_d.di_uid;
161 inode->i_gid = ip->i_d.di_gid;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000162
163 switch (inode->i_mode & S_IFMT) {
164 case S_IFBLK:
165 case S_IFCHR:
166 inode->i_rdev =
167 MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
168 sysv_minor(ip->i_df.if_u2.if_rdev));
169 break;
170 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 inode->i_rdev = 0;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000172 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 }
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000174
David Chinnere8c8b3a2005-11-02 10:33:05 +1100175 inode->i_blksize = xfs_preferred_iosize(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 inode->i_generation = ip->i_d.di_gen;
177 i_size_write(inode, ip->i_d.di_size);
178 inode->i_blocks =
179 XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
180 inode->i_atime.tv_sec = ip->i_d.di_atime.t_sec;
181 inode->i_atime.tv_nsec = ip->i_d.di_atime.t_nsec;
182 inode->i_mtime.tv_sec = ip->i_d.di_mtime.t_sec;
183 inode->i_mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
184 inode->i_ctime.tv_sec = ip->i_d.di_ctime.t_sec;
185 inode->i_ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
186 if (ip->i_d.di_flags & XFS_DIFLAG_IMMUTABLE)
187 inode->i_flags |= S_IMMUTABLE;
188 else
189 inode->i_flags &= ~S_IMMUTABLE;
190 if (ip->i_d.di_flags & XFS_DIFLAG_APPEND)
191 inode->i_flags |= S_APPEND;
192 else
193 inode->i_flags &= ~S_APPEND;
194 if (ip->i_d.di_flags & XFS_DIFLAG_SYNC)
195 inode->i_flags |= S_SYNC;
196 else
197 inode->i_flags &= ~S_SYNC;
198 if (ip->i_d.di_flags & XFS_DIFLAG_NOATIME)
199 inode->i_flags |= S_NOATIME;
200 else
201 inode->i_flags &= ~S_NOATIME;
202 vp->v_flag &= ~VMODIFIED;
203}
204
205void
206xfs_initialize_vnode(
207 bhv_desc_t *bdp,
208 vnode_t *vp,
209 bhv_desc_t *inode_bhv,
210 int unlock)
211{
212 xfs_inode_t *ip = XFS_BHVTOI(inode_bhv);
213 struct inode *inode = LINVFS_GET_IP(vp);
214
215 if (!inode_bhv->bd_vobj) {
216 vp->v_vfsp = bhvtovfs(bdp);
217 bhv_desc_init(inode_bhv, ip, vp, &xfs_vnodeops);
218 bhv_insert(VN_BHV_HEAD(vp), inode_bhv);
219 }
220
221 /*
222 * We need to set the ops vectors, and unlock the inode, but if
223 * we have been called during the new inode create process, it is
224 * too early to fill in the Linux inode. We will get called a
225 * second time once the inode is properly set up, and then we can
226 * finish our work.
227 */
228 if (ip->i_d.di_mode != 0 && unlock && (inode->i_state & I_NEW)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 xfs_revalidate_inode(XFS_BHVTOM(bdp), vp, ip);
230 xfs_set_inodeops(inode);
231
232 ip->i_flags &= ~XFS_INEW;
233 barrier();
234
235 unlock_new_inode(inode);
236 }
237}
238
239int
240xfs_blkdev_get(
241 xfs_mount_t *mp,
242 const char *name,
243 struct block_device **bdevp)
244{
245 int error = 0;
246
247 *bdevp = open_bdev_excl(name, 0, mp);
248 if (IS_ERR(*bdevp)) {
249 error = PTR_ERR(*bdevp);
250 printk("XFS: Invalid device [%s], error=%d\n", name, error);
251 }
252
253 return -error;
254}
255
256void
257xfs_blkdev_put(
258 struct block_device *bdev)
259{
260 if (bdev)
261 close_bdev_excl(bdev);
262}
263
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100264/*
265 * Try to write out the superblock using barriers.
266 */
267STATIC int
268xfs_barrier_test(
269 xfs_mount_t *mp)
270{
271 xfs_buf_t *sbp = xfs_getsb(mp, 0);
272 int error;
273
274 XFS_BUF_UNDONE(sbp);
275 XFS_BUF_UNREAD(sbp);
276 XFS_BUF_UNDELAYWRITE(sbp);
277 XFS_BUF_WRITE(sbp);
278 XFS_BUF_UNASYNC(sbp);
279 XFS_BUF_ORDERED(sbp);
280
281 xfsbdstrat(mp, sbp);
282 error = xfs_iowait(sbp);
283
284 /*
285 * Clear all the flags we set and possible error state in the
286 * buffer. We only did the write to try out whether barriers
287 * worked and shouldn't leave any traces in the superblock
288 * buffer.
289 */
290 XFS_BUF_DONE(sbp);
291 XFS_BUF_ERROR(sbp, 0);
292 XFS_BUF_UNORDERED(sbp);
293
294 xfs_buf_relse(sbp);
295 return error;
296}
297
298void
299xfs_mountfs_check_barriers(xfs_mount_t *mp)
300{
301 int error;
302
303 if (mp->m_logdev_targp != mp->m_ddev_targp) {
304 xfs_fs_cmn_err(CE_NOTE, mp,
305 "Disabling barriers, not supported with external log device");
306 mp->m_flags &= ~XFS_MOUNT_BARRIER;
Christoph Hellwig4ef19dd2006-01-11 15:27:18 +1100307 return;
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100308 }
309
Nathan Scottce8e9222006-01-11 15:39:08 +1100310 if (mp->m_ddev_targp->bt_bdev->bd_disk->queue->ordered ==
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100311 QUEUE_ORDERED_NONE) {
312 xfs_fs_cmn_err(CE_NOTE, mp,
313 "Disabling barriers, not supported by the underlying device");
314 mp->m_flags &= ~XFS_MOUNT_BARRIER;
Christoph Hellwig4ef19dd2006-01-11 15:27:18 +1100315 return;
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100316 }
317
318 error = xfs_barrier_test(mp);
319 if (error) {
320 xfs_fs_cmn_err(CE_NOTE, mp,
321 "Disabling barriers, trial barrier write failed");
322 mp->m_flags &= ~XFS_MOUNT_BARRIER;
Christoph Hellwig4ef19dd2006-01-11 15:27:18 +1100323 return;
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100324 }
325}
326
327void
328xfs_blkdev_issue_flush(
329 xfs_buftarg_t *buftarg)
330{
Nathan Scottce8e9222006-01-11 15:39:08 +1100331 blkdev_issue_flush(buftarg->bt_bdev, NULL);
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100332}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
334STATIC struct inode *
335linvfs_alloc_inode(
336 struct super_block *sb)
337{
338 vnode_t *vp;
339
Nathan Scott87582802006-03-14 13:18:19 +1100340 vp = kmem_zone_alloc(xfs_vnode_zone, KM_SLEEP);
341 if (unlikely(!vp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 return NULL;
343 return LINVFS_GET_IP(vp);
344}
345
346STATIC void
347linvfs_destroy_inode(
348 struct inode *inode)
349{
Christoph Hellwig0829c362005-09-02 16:58:49 +1000350 kmem_zone_free(xfs_vnode_zone, LINVFS_GET_VP(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351}
352
353STATIC void
Christoph Hellwig0829c362005-09-02 16:58:49 +1000354linvfs_inode_init_once(
Nathan Scott87582802006-03-14 13:18:19 +1100355 void *vnode,
356 kmem_zone_t *zonep,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 unsigned long flags)
358{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
Nathan Scott87582802006-03-14 13:18:19 +1100360 SLAB_CTOR_CONSTRUCTOR)
361 inode_init_once(LINVFS_GET_IP((vnode_t *)vnode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362}
363
364STATIC int
Nathan Scott87582802006-03-14 13:18:19 +1100365xfs_init_zones(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366{
Nathan Scott87582802006-03-14 13:18:19 +1100367 xfs_vnode_zone = kmem_zone_init_flags(sizeof(vnode_t), "xfs_vnode_t",
Nathan Scotte0cc2322006-03-14 13:19:55 +1100368 KM_ZONE_HWALIGN | KM_ZONE_RECLAIM |
369 KM_ZONE_SPREAD,
Nathan Scott87582802006-03-14 13:18:19 +1100370 linvfs_inode_init_once);
Christoph Hellwig0829c362005-09-02 16:58:49 +1000371 if (!xfs_vnode_zone)
372 goto out;
373
374 xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
375 if (!xfs_ioend_zone)
376 goto out_destroy_vnode_zone;
377
378 xfs_ioend_pool = mempool_create(4 * MAX_BUF_PER_PAGE,
Nathan Scott87582802006-03-14 13:18:19 +1100379 mempool_alloc_slab, mempool_free_slab,
380 xfs_ioend_zone);
Christoph Hellwig0829c362005-09-02 16:58:49 +1000381 if (!xfs_ioend_pool)
382 goto out_free_ioend_zone;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 return 0;
Christoph Hellwig0829c362005-09-02 16:58:49 +1000384
Christoph Hellwig0829c362005-09-02 16:58:49 +1000385 out_free_ioend_zone:
386 kmem_zone_destroy(xfs_ioend_zone);
387 out_destroy_vnode_zone:
388 kmem_zone_destroy(xfs_vnode_zone);
389 out:
390 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391}
392
393STATIC void
Nathan Scott87582802006-03-14 13:18:19 +1100394xfs_destroy_zones(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395{
Christoph Hellwig0829c362005-09-02 16:58:49 +1000396 mempool_destroy(xfs_ioend_pool);
397 kmem_zone_destroy(xfs_vnode_zone);
398 kmem_zone_destroy(xfs_ioend_zone);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399}
400
401/*
402 * Attempt to flush the inode, this will actually fail
403 * if the inode is pinned, but we dirty the inode again
404 * at the point when it is unpinned after a log write,
Nathan Scott87582802006-03-14 13:18:19 +1100405 * since this is when the inode itself becomes flushable.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 */
407STATIC int
408linvfs_write_inode(
409 struct inode *inode,
410 int sync)
411{
412 vnode_t *vp = LINVFS_GET_VP(inode);
413 int error = 0, flags = FLUSH_INODE;
414
415 if (vp) {
416 vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
417 if (sync)
418 flags |= FLUSH_SYNC;
419 VOP_IFLUSH(vp, flags, error);
420 if (error == EAGAIN) {
421 if (sync)
422 VOP_IFLUSH(vp, flags | FLUSH_LOG, error);
423 else
424 error = 0;
425 }
426 }
427
428 return -error;
429}
430
431STATIC void
432linvfs_clear_inode(
433 struct inode *inode)
434{
435 vnode_t *vp = LINVFS_GET_VP(inode);
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000436 int error, cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000438 vn_trace_entry(vp, "clear_inode", (inst_t *)__return_address);
439
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000440 XFS_STATS_INC(vn_rele);
441 XFS_STATS_INC(vn_remove);
442 XFS_STATS_INC(vn_reclaim);
443 XFS_STATS_DEC(vn_active);
444
Christoph Hellwig02ba71d2005-09-05 08:28:02 +1000445 /*
446 * This can happen because xfs_iget_core calls xfs_idestroy if we
447 * find an inode with di_mode == 0 but without IGET_CREATE set.
448 */
449 if (vp->v_fbhv)
450 VOP_INACTIVE(vp, NULL, cache);
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000451
452 VN_LOCK(vp);
453 vp->v_flag &= ~VMODIFIED;
454 VN_UNLOCK(vp, 0);
455
Felix Blyakher0c147f92005-09-05 08:24:49 +1000456 if (vp->v_fbhv) {
457 VOP_RECLAIM(vp, error);
458 if (error)
459 panic("vn_purge: cannot reclaim");
460 }
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000461
462 ASSERT(vp->v_fbhv == NULL);
463
464#ifdef XFS_VNODE_TRACE
465 ktrace_free(vp->v_trace);
466#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467}
468
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469/*
470 * Enqueue a work item to be picked up by the vfs xfssyncd thread.
471 * Doing this has two advantages:
472 * - It saves on stack space, which is tight in certain situations
473 * - It can be used (with care) as a mechanism to avoid deadlocks.
474 * Flushing while allocating in a full filesystem requires both.
475 */
476STATIC void
477xfs_syncd_queue_work(
478 struct vfs *vfs,
479 void *data,
480 void (*syncer)(vfs_t *, void *))
481{
482 vfs_sync_work_t *work;
483
484 work = kmem_alloc(sizeof(struct vfs_sync_work), KM_SLEEP);
485 INIT_LIST_HEAD(&work->w_list);
486 work->w_syncer = syncer;
487 work->w_data = data;
488 work->w_vfs = vfs;
489 spin_lock(&vfs->vfs_sync_lock);
490 list_add_tail(&work->w_list, &vfs->vfs_sync_list);
491 spin_unlock(&vfs->vfs_sync_lock);
492 wake_up_process(vfs->vfs_sync_task);
493}
494
495/*
496 * Flush delayed allocate data, attempting to free up reserved space
497 * from existing allocations. At this point a new allocation attempt
498 * has failed with ENOSPC and we are in the process of scratching our
499 * heads, looking about for more room...
500 */
501STATIC void
502xfs_flush_inode_work(
503 vfs_t *vfs,
504 void *inode)
505{
506 filemap_flush(((struct inode *)inode)->i_mapping);
507 iput((struct inode *)inode);
508}
509
510void
511xfs_flush_inode(
512 xfs_inode_t *ip)
513{
514 struct inode *inode = LINVFS_GET_IP(XFS_ITOV(ip));
515 struct vfs *vfs = XFS_MTOVFS(ip->i_mount);
516
517 igrab(inode);
518 xfs_syncd_queue_work(vfs, inode, xfs_flush_inode_work);
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700519 delay(msecs_to_jiffies(500));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520}
521
522/*
523 * This is the "bigger hammer" version of xfs_flush_inode_work...
524 * (IOW, "If at first you don't succeed, use a Bigger Hammer").
525 */
526STATIC void
527xfs_flush_device_work(
528 vfs_t *vfs,
529 void *inode)
530{
531 sync_blockdev(vfs->vfs_super->s_bdev);
532 iput((struct inode *)inode);
533}
534
535void
536xfs_flush_device(
537 xfs_inode_t *ip)
538{
539 struct inode *inode = LINVFS_GET_IP(XFS_ITOV(ip));
540 struct vfs *vfs = XFS_MTOVFS(ip->i_mount);
541
542 igrab(inode);
543 xfs_syncd_queue_work(vfs, inode, xfs_flush_device_work);
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700544 delay(msecs_to_jiffies(500));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 xfs_log_force(ip->i_mount, (xfs_lsn_t)0, XFS_LOG_FORCE|XFS_LOG_SYNC);
546}
547
548#define SYNCD_FLAGS (SYNC_FSDATA|SYNC_BDFLUSH|SYNC_ATTR)
549STATIC void
550vfs_sync_worker(
551 vfs_t *vfsp,
552 void *unused)
553{
554 int error;
555
556 if (!(vfsp->vfs_flag & VFS_RDONLY))
557 VFS_SYNC(vfsp, SYNCD_FLAGS, NULL, error);
558 vfsp->vfs_sync_seq++;
559 wmb();
560 wake_up(&vfsp->vfs_wait_single_sync_task);
561}
562
563STATIC int
564xfssyncd(
565 void *arg)
566{
567 long timeleft;
568 vfs_t *vfsp = (vfs_t *) arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 struct vfs_sync_work *work, *n;
Christoph Hellwig4df08c52005-09-05 08:34:18 +1000570 LIST_HEAD (tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700572 timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 for (;;) {
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700574 timeleft = schedule_timeout_interruptible(timeleft);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 /* swsusp */
Christoph Lameter3e1d1d22005-06-24 23:13:50 -0700576 try_to_freeze();
Yingping Lu71df0992006-01-11 21:02:29 +1100577 if (kthread_should_stop() && list_empty(&vfsp->vfs_sync_list))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 break;
579
580 spin_lock(&vfsp->vfs_sync_lock);
581 /*
582 * We can get woken by laptop mode, to do a sync -
583 * that's the (only!) case where the list would be
584 * empty with time remaining.
585 */
586 if (!timeleft || list_empty(&vfsp->vfs_sync_list)) {
587 if (!timeleft)
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700588 timeleft = xfs_syncd_centisecs *
589 msecs_to_jiffies(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 INIT_LIST_HEAD(&vfsp->vfs_sync_work.w_list);
591 list_add_tail(&vfsp->vfs_sync_work.w_list,
592 &vfsp->vfs_sync_list);
593 }
594 list_for_each_entry_safe(work, n, &vfsp->vfs_sync_list, w_list)
595 list_move(&work->w_list, &tmp);
596 spin_unlock(&vfsp->vfs_sync_lock);
597
598 list_for_each_entry_safe(work, n, &tmp, w_list) {
599 (*work->w_syncer)(vfsp, work->w_data);
600 list_del(&work->w_list);
601 if (work == &vfsp->vfs_sync_work)
602 continue;
603 kmem_free(work, sizeof(struct vfs_sync_work));
604 }
605 }
606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 return 0;
608}
609
610STATIC int
611linvfs_start_syncd(
612 vfs_t *vfsp)
613{
Christoph Hellwig4df08c52005-09-05 08:34:18 +1000614 vfsp->vfs_sync_work.w_syncer = vfs_sync_worker;
615 vfsp->vfs_sync_work.w_vfs = vfsp;
616 vfsp->vfs_sync_task = kthread_run(xfssyncd, vfsp, "xfssyncd");
617 if (IS_ERR(vfsp->vfs_sync_task))
618 return -PTR_ERR(vfsp->vfs_sync_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 return 0;
620}
621
622STATIC void
623linvfs_stop_syncd(
624 vfs_t *vfsp)
625{
Christoph Hellwig4df08c52005-09-05 08:34:18 +1000626 kthread_stop(vfsp->vfs_sync_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627}
628
629STATIC void
630linvfs_put_super(
631 struct super_block *sb)
632{
633 vfs_t *vfsp = LINVFS_GET_VFS(sb);
634 int error;
635
636 linvfs_stop_syncd(vfsp);
637 VFS_SYNC(vfsp, SYNC_ATTR|SYNC_DELWRI, NULL, error);
638 if (!error)
639 VFS_UNMOUNT(vfsp, 0, NULL, error);
640 if (error) {
641 printk("XFS unmount got error %d\n", error);
642 printk("%s: vfsp/0x%p left dangling!\n", __FUNCTION__, vfsp);
643 return;
644 }
645
646 vfs_deallocate(vfsp);
647}
648
649STATIC void
650linvfs_write_super(
651 struct super_block *sb)
652{
653 vfs_t *vfsp = LINVFS_GET_VFS(sb);
654 int error;
655
656 if (sb->s_flags & MS_RDONLY) {
657 sb->s_dirt = 0; /* paranoia */
658 return;
659 }
660 /* Push the log and superblock a little */
661 VFS_SYNC(vfsp, SYNC_FSDATA, NULL, error);
662 sb->s_dirt = 0;
663}
664
665STATIC int
666linvfs_sync_super(
667 struct super_block *sb,
668 int wait)
669{
670 vfs_t *vfsp = LINVFS_GET_VFS(sb);
671 int error;
672 int flags = SYNC_FSDATA;
673
Christoph Hellwigf898d6c2005-06-21 15:40:48 +1000674 if (unlikely(sb->s_frozen == SB_FREEZE_WRITE))
675 flags = SYNC_QUIESCE;
676 else
677 flags = SYNC_FSDATA | (wait ? SYNC_WAIT : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
679 VFS_SYNC(vfsp, flags, NULL, error);
680 sb->s_dirt = 0;
681
682 if (unlikely(laptop_mode)) {
683 int prev_sync_seq = vfsp->vfs_sync_seq;
684
685 /*
686 * The disk must be active because we're syncing.
687 * We schedule xfssyncd now (now that the disk is
688 * active) instead of later (when it might not be).
689 */
690 wake_up_process(vfsp->vfs_sync_task);
691 /*
692 * We have to wait for the sync iteration to complete.
693 * If we don't, the disk activity caused by the sync
694 * will come after the sync is completed, and that
695 * triggers another sync from laptop mode.
696 */
697 wait_event(vfsp->vfs_wait_single_sync_task,
698 vfsp->vfs_sync_seq != prev_sync_seq);
699 }
700
701 return -error;
702}
703
704STATIC int
705linvfs_statfs(
706 struct super_block *sb,
707 struct kstatfs *statp)
708{
709 vfs_t *vfsp = LINVFS_GET_VFS(sb);
710 int error;
711
712 VFS_STATVFS(vfsp, statp, NULL, error);
713 return -error;
714}
715
716STATIC int
717linvfs_remount(
718 struct super_block *sb,
719 int *flags,
720 char *options)
721{
722 vfs_t *vfsp = LINVFS_GET_VFS(sb);
723 struct xfs_mount_args *args = xfs_args_allocate(sb);
724 int error;
725
726 VFS_PARSEARGS(vfsp, options, args, 1, error);
727 if (!error)
728 VFS_MNTUPDATE(vfsp, flags, args, error);
729 kmem_free(args, sizeof(*args));
730 return -error;
731}
732
733STATIC void
734linvfs_freeze_fs(
735 struct super_block *sb)
736{
737 VFS_FREEZE(LINVFS_GET_VFS(sb));
738}
739
740STATIC int
741linvfs_show_options(
742 struct seq_file *m,
743 struct vfsmount *mnt)
744{
745 struct vfs *vfsp = LINVFS_GET_VFS(mnt->mnt_sb);
746 int error;
747
748 VFS_SHOWARGS(vfsp, m, error);
749 return error;
750}
751
752STATIC int
Nathan Scottee348072005-11-02 10:32:38 +1100753linvfs_quotasync(
754 struct super_block *sb,
755 int type)
756{
757 struct vfs *vfsp = LINVFS_GET_VFS(sb);
758 int error;
759
760 VFS_QUOTACTL(vfsp, Q_XQUOTASYNC, 0, (caddr_t)NULL, error);
761 return -error;
762}
763
764STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765linvfs_getxstate(
766 struct super_block *sb,
767 struct fs_quota_stat *fqs)
768{
769 struct vfs *vfsp = LINVFS_GET_VFS(sb);
770 int error;
771
772 VFS_QUOTACTL(vfsp, Q_XGETQSTAT, 0, (caddr_t)fqs, error);
773 return -error;
774}
775
776STATIC int
777linvfs_setxstate(
778 struct super_block *sb,
779 unsigned int flags,
780 int op)
781{
782 struct vfs *vfsp = LINVFS_GET_VFS(sb);
783 int error;
784
785 VFS_QUOTACTL(vfsp, op, 0, (caddr_t)&flags, error);
786 return -error;
787}
788
789STATIC int
790linvfs_getxquota(
791 struct super_block *sb,
792 int type,
793 qid_t id,
794 struct fs_disk_quota *fdq)
795{
796 struct vfs *vfsp = LINVFS_GET_VFS(sb);
797 int error, getmode;
798
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000799 getmode = (type == USRQUOTA) ? Q_XGETQUOTA :
800 ((type == GRPQUOTA) ? Q_XGETGQUOTA : Q_XGETPQUOTA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 VFS_QUOTACTL(vfsp, getmode, id, (caddr_t)fdq, error);
802 return -error;
803}
804
805STATIC int
806linvfs_setxquota(
807 struct super_block *sb,
808 int type,
809 qid_t id,
810 struct fs_disk_quota *fdq)
811{
812 struct vfs *vfsp = LINVFS_GET_VFS(sb);
813 int error, setmode;
814
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000815 setmode = (type == USRQUOTA) ? Q_XSETQLIM :
816 ((type == GRPQUOTA) ? Q_XSETGQLIM : Q_XSETPQLIM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 VFS_QUOTACTL(vfsp, setmode, id, (caddr_t)fdq, error);
818 return -error;
819}
820
821STATIC int
822linvfs_fill_super(
823 struct super_block *sb,
824 void *data,
825 int silent)
826{
827 vnode_t *rootvp;
828 struct vfs *vfsp = vfs_allocate();
829 struct xfs_mount_args *args = xfs_args_allocate(sb);
830 struct kstatfs statvfs;
831 int error, error2;
832
833 vfsp->vfs_super = sb;
834 LINVFS_SET_VFS(sb, vfsp);
835 if (sb->s_flags & MS_RDONLY)
836 vfsp->vfs_flag |= VFS_RDONLY;
837 bhv_insert_all_vfsops(vfsp);
838
839 VFS_PARSEARGS(vfsp, (char *)data, args, 0, error);
840 if (error) {
841 bhv_remove_all_vfsops(vfsp, 1);
842 goto fail_vfsop;
843 }
844
845 sb_min_blocksize(sb, BBSIZE);
846#ifdef CONFIG_XFS_EXPORT
847 sb->s_export_op = &linvfs_export_ops;
848#endif
849 sb->s_qcop = &linvfs_qops;
850 sb->s_op = &linvfs_sops;
851
852 VFS_MOUNT(vfsp, args, NULL, error);
853 if (error) {
854 bhv_remove_all_vfsops(vfsp, 1);
855 goto fail_vfsop;
856 }
857
858 VFS_STATVFS(vfsp, &statvfs, NULL, error);
859 if (error)
860 goto fail_unmount;
861
862 sb->s_dirt = 1;
863 sb->s_magic = statvfs.f_type;
864 sb->s_blocksize = statvfs.f_bsize;
865 sb->s_blocksize_bits = ffs(statvfs.f_bsize) - 1;
866 sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
867 sb->s_time_gran = 1;
868 set_posix_acl_flag(sb);
869
870 VFS_ROOT(vfsp, &rootvp, error);
871 if (error)
872 goto fail_unmount;
873
874 sb->s_root = d_alloc_root(LINVFS_GET_IP(rootvp));
875 if (!sb->s_root) {
876 error = ENOMEM;
877 goto fail_vnrele;
878 }
879 if (is_bad_inode(sb->s_root->d_inode)) {
880 error = EINVAL;
881 goto fail_vnrele;
882 }
883 if ((error = linvfs_start_syncd(vfsp)))
884 goto fail_vnrele;
885 vn_trace_exit(rootvp, __FUNCTION__, (inst_t *)__return_address);
886
887 kmem_free(args, sizeof(*args));
888 return 0;
889
890fail_vnrele:
891 if (sb->s_root) {
892 dput(sb->s_root);
893 sb->s_root = NULL;
894 } else {
895 VN_RELE(rootvp);
896 }
897
898fail_unmount:
899 VFS_UNMOUNT(vfsp, 0, NULL, error2);
900
901fail_vfsop:
902 vfs_deallocate(vfsp);
903 kmem_free(args, sizeof(*args));
904 return -error;
905}
906
907STATIC struct super_block *
908linvfs_get_sb(
909 struct file_system_type *fs_type,
910 int flags,
911 const char *dev_name,
912 void *data)
913{
914 return get_sb_bdev(fs_type, flags, dev_name, data, linvfs_fill_super);
915}
916
917STATIC struct super_operations linvfs_sops = {
918 .alloc_inode = linvfs_alloc_inode,
919 .destroy_inode = linvfs_destroy_inode,
920 .write_inode = linvfs_write_inode,
921 .clear_inode = linvfs_clear_inode,
922 .put_super = linvfs_put_super,
923 .write_super = linvfs_write_super,
924 .sync_fs = linvfs_sync_super,
925 .write_super_lockfs = linvfs_freeze_fs,
926 .statfs = linvfs_statfs,
927 .remount_fs = linvfs_remount,
928 .show_options = linvfs_show_options,
929};
930
931STATIC struct quotactl_ops linvfs_qops = {
Nathan Scottee348072005-11-02 10:32:38 +1100932 .quota_sync = linvfs_quotasync,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 .get_xstate = linvfs_getxstate,
934 .set_xstate = linvfs_setxstate,
935 .get_xquota = linvfs_getxquota,
936 .set_xquota = linvfs_setxquota,
937};
938
939STATIC struct file_system_type xfs_fs_type = {
940 .owner = THIS_MODULE,
941 .name = "xfs",
942 .get_sb = linvfs_get_sb,
943 .kill_sb = kill_block_super,
944 .fs_flags = FS_REQUIRES_DEV,
945};
946
947
948STATIC int __init
949init_xfs_fs( void )
950{
951 int error;
952 struct sysinfo si;
953 static char message[] __initdata = KERN_INFO \
954 XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled\n";
955
956 printk(message);
957
958 si_meminfo(&si);
959 xfs_physmem = si.totalram;
960
961 ktrace_init(64);
962
Nathan Scott87582802006-03-14 13:18:19 +1100963 error = xfs_init_zones();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 if (error < 0)
Christoph Hellwig0829c362005-09-02 16:58:49 +1000965 goto undo_zones;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966
Nathan Scottce8e9222006-01-11 15:39:08 +1100967 error = xfs_buf_init();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 if (error < 0)
Nathan Scottce8e9222006-01-11 15:39:08 +1100969 goto undo_buffers;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970
971 vn_init();
972 xfs_init();
973 uuid_init();
974 vfs_initquota();
975
976 error = register_filesystem(&xfs_fs_type);
977 if (error)
978 goto undo_register;
979 XFS_DM_INIT(&xfs_fs_type);
980 return 0;
981
982undo_register:
Nathan Scottce8e9222006-01-11 15:39:08 +1100983 xfs_buf_terminate();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984
Nathan Scottce8e9222006-01-11 15:39:08 +1100985undo_buffers:
Nathan Scott87582802006-03-14 13:18:19 +1100986 xfs_destroy_zones();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987
Christoph Hellwig0829c362005-09-02 16:58:49 +1000988undo_zones:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 return error;
990}
991
992STATIC void __exit
993exit_xfs_fs( void )
994{
995 vfs_exitquota();
996 XFS_DM_EXIT(&xfs_fs_type);
997 unregister_filesystem(&xfs_fs_type);
998 xfs_cleanup();
Nathan Scottce8e9222006-01-11 15:39:08 +1100999 xfs_buf_terminate();
Nathan Scott87582802006-03-14 13:18:19 +11001000 xfs_destroy_zones();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 ktrace_uninit();
1002}
1003
1004module_init(init_xfs_fs);
1005module_exit(exit_xfs_fs);
1006
1007MODULE_AUTHOR("Silicon Graphics, Inc.");
1008MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
1009MODULE_LICENSE("GPL");