blob: fa87279405d85f5641b71b0b9b191480e13e2534 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scottd3870392005-05-06 06:44:46 -07002 * Copyright (c) 2000-2005 Silicon Graphics, Inc. All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of version 2 of the GNU General Public License as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it would be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 *
12 * Further, this software is distributed without any warranty that it is
13 * free of the rightful claim of any third person regarding infringement
14 * or the like. Any license provided herein, whether implied or
15 * otherwise, applies only to this software file. Patent licenses, if
16 * any, provided herein do not apply to combinations of this program with
17 * other software, or any other product whatsoever.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program; if not, write the Free Software Foundation, Inc., 59
21 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
22 *
23 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24 * Mountain View, CA 94043, or:
25 *
26 * http://www.sgi.com
27 *
28 * For further information regarding this notice, see:
29 *
30 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
31 */
32
33#include "xfs.h"
34
35#include "xfs_inum.h"
36#include "xfs_log.h"
37#include "xfs_clnt.h"
38#include "xfs_trans.h"
39#include "xfs_sb.h"
40#include "xfs_dir.h"
41#include "xfs_dir2.h"
42#include "xfs_alloc.h"
43#include "xfs_dmapi.h"
44#include "xfs_quota.h"
45#include "xfs_mount.h"
46#include "xfs_alloc_btree.h"
47#include "xfs_bmap_btree.h"
48#include "xfs_ialloc_btree.h"
49#include "xfs_btree.h"
50#include "xfs_ialloc.h"
51#include "xfs_attr_sf.h"
52#include "xfs_dir_sf.h"
53#include "xfs_dir2_sf.h"
54#include "xfs_dinode.h"
55#include "xfs_inode.h"
56#include "xfs_bmap.h"
57#include "xfs_bit.h"
58#include "xfs_rtalloc.h"
59#include "xfs_error.h"
60#include "xfs_itable.h"
61#include "xfs_rw.h"
62#include "xfs_acl.h"
63#include "xfs_cap.h"
64#include "xfs_mac.h"
65#include "xfs_attr.h"
66#include "xfs_buf_item.h"
67#include "xfs_utils.h"
68#include "xfs_version.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
70#include <linux/namei.h>
71#include <linux/init.h>
72#include <linux/mount.h>
Christoph Hellwig0829c362005-09-02 16:58:49 +100073#include <linux/mempool.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#include <linux/writeback.h>
Christoph Hellwig4df08c52005-09-05 08:34:18 +100075#include <linux/kthread.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
77STATIC struct quotactl_ops linvfs_qops;
78STATIC struct super_operations linvfs_sops;
Christoph Hellwig0829c362005-09-02 16:58:49 +100079STATIC kmem_zone_t *xfs_vnode_zone;
80STATIC kmem_zone_t *xfs_ioend_zone;
81mempool_t *xfs_ioend_pool;
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
83STATIC struct xfs_mount_args *
84xfs_args_allocate(
85 struct super_block *sb)
86{
87 struct xfs_mount_args *args;
88
89 args = kmem_zalloc(sizeof(struct xfs_mount_args), KM_SLEEP);
90 args->logbufs = args->logbufsize = -1;
91 strncpy(args->fsname, sb->s_id, MAXNAMELEN);
92
93 /* Copy the already-parsed mount(2) flags we're interested in */
94 if (sb->s_flags & MS_NOATIME)
95 args->flags |= XFSMNT_NOATIME;
96 if (sb->s_flags & MS_DIRSYNC)
97 args->flags |= XFSMNT_DIRSYNC;
98 if (sb->s_flags & MS_SYNCHRONOUS)
99 args->flags |= XFSMNT_WSYNC;
100
101 /* Default to 32 bit inodes on Linux all the time */
102 args->flags |= XFSMNT_32BITINODES;
103
104 return args;
105}
106
107__uint64_t
108xfs_max_file_offset(
109 unsigned int blockshift)
110{
111 unsigned int pagefactor = 1;
112 unsigned int bitshift = BITS_PER_LONG - 1;
113
114 /* Figure out maximum filesize, on Linux this can depend on
115 * the filesystem blocksize (on 32 bit platforms).
116 * __block_prepare_write does this in an [unsigned] long...
117 * page->index << (PAGE_CACHE_SHIFT - bbits)
118 * So, for page sized blocks (4K on 32 bit platforms),
119 * this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is
120 * (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
121 * but for smaller blocksizes it is less (bbits = log2 bsize).
122 * Note1: get_block_t takes a long (implicit cast from above)
123 * Note2: The Large Block Device (LBD and HAVE_SECTOR_T) patch
124 * can optionally convert the [unsigned] long from above into
125 * an [unsigned] long long.
126 */
127
128#if BITS_PER_LONG == 32
129# if defined(CONFIG_LBD)
130 ASSERT(sizeof(sector_t) == 8);
131 pagefactor = PAGE_CACHE_SIZE;
132 bitshift = BITS_PER_LONG;
133# else
134 pagefactor = PAGE_CACHE_SIZE >> (PAGE_CACHE_SHIFT - blockshift);
135# endif
136#endif
137
138 return (((__uint64_t)pagefactor) << bitshift) - 1;
139}
140
141STATIC __inline__ void
142xfs_set_inodeops(
143 struct inode *inode)
144{
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000145 switch (inode->i_mode & S_IFMT) {
146 case S_IFREG:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 inode->i_op = &linvfs_file_inode_operations;
148 inode->i_fop = &linvfs_file_operations;
149 inode->i_mapping->a_ops = &linvfs_aops;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000150 break;
151 case S_IFDIR:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 inode->i_op = &linvfs_dir_inode_operations;
153 inode->i_fop = &linvfs_dir_operations;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000154 break;
155 case S_IFLNK:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 inode->i_op = &linvfs_symlink_inode_operations;
157 if (inode->i_blocks)
158 inode->i_mapping->a_ops = &linvfs_aops;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000159 break;
160 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 inode->i_op = &linvfs_file_inode_operations;
162 init_special_inode(inode, inode->i_mode, inode->i_rdev);
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000163 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 }
165}
166
167STATIC __inline__ void
168xfs_revalidate_inode(
169 xfs_mount_t *mp,
170 vnode_t *vp,
171 xfs_inode_t *ip)
172{
173 struct inode *inode = LINVFS_GET_IP(vp);
174
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000175 inode->i_mode = ip->i_d.di_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 inode->i_nlink = ip->i_d.di_nlink;
177 inode->i_uid = ip->i_d.di_uid;
178 inode->i_gid = ip->i_d.di_gid;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000179
180 switch (inode->i_mode & S_IFMT) {
181 case S_IFBLK:
182 case S_IFCHR:
183 inode->i_rdev =
184 MKDEV(sysv_major(ip->i_df.if_u2.if_rdev) & 0x1ff,
185 sysv_minor(ip->i_df.if_u2.if_rdev));
186 break;
187 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 inode->i_rdev = 0;
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000189 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 }
Christoph Hellwig0432dab2005-09-02 16:46:51 +1000191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 inode->i_blksize = PAGE_CACHE_SIZE;
193 inode->i_generation = ip->i_d.di_gen;
194 i_size_write(inode, ip->i_d.di_size);
195 inode->i_blocks =
196 XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
197 inode->i_atime.tv_sec = ip->i_d.di_atime.t_sec;
198 inode->i_atime.tv_nsec = ip->i_d.di_atime.t_nsec;
199 inode->i_mtime.tv_sec = ip->i_d.di_mtime.t_sec;
200 inode->i_mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
201 inode->i_ctime.tv_sec = ip->i_d.di_ctime.t_sec;
202 inode->i_ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
203 if (ip->i_d.di_flags & XFS_DIFLAG_IMMUTABLE)
204 inode->i_flags |= S_IMMUTABLE;
205 else
206 inode->i_flags &= ~S_IMMUTABLE;
207 if (ip->i_d.di_flags & XFS_DIFLAG_APPEND)
208 inode->i_flags |= S_APPEND;
209 else
210 inode->i_flags &= ~S_APPEND;
211 if (ip->i_d.di_flags & XFS_DIFLAG_SYNC)
212 inode->i_flags |= S_SYNC;
213 else
214 inode->i_flags &= ~S_SYNC;
215 if (ip->i_d.di_flags & XFS_DIFLAG_NOATIME)
216 inode->i_flags |= S_NOATIME;
217 else
218 inode->i_flags &= ~S_NOATIME;
219 vp->v_flag &= ~VMODIFIED;
220}
221
222void
223xfs_initialize_vnode(
224 bhv_desc_t *bdp,
225 vnode_t *vp,
226 bhv_desc_t *inode_bhv,
227 int unlock)
228{
229 xfs_inode_t *ip = XFS_BHVTOI(inode_bhv);
230 struct inode *inode = LINVFS_GET_IP(vp);
231
232 if (!inode_bhv->bd_vobj) {
233 vp->v_vfsp = bhvtovfs(bdp);
234 bhv_desc_init(inode_bhv, ip, vp, &xfs_vnodeops);
235 bhv_insert(VN_BHV_HEAD(vp), inode_bhv);
236 }
237
238 /*
239 * We need to set the ops vectors, and unlock the inode, but if
240 * we have been called during the new inode create process, it is
241 * too early to fill in the Linux inode. We will get called a
242 * second time once the inode is properly set up, and then we can
243 * finish our work.
244 */
245 if (ip->i_d.di_mode != 0 && unlock && (inode->i_state & I_NEW)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 xfs_revalidate_inode(XFS_BHVTOM(bdp), vp, ip);
247 xfs_set_inodeops(inode);
248
249 ip->i_flags &= ~XFS_INEW;
250 barrier();
251
252 unlock_new_inode(inode);
253 }
254}
255
256int
257xfs_blkdev_get(
258 xfs_mount_t *mp,
259 const char *name,
260 struct block_device **bdevp)
261{
262 int error = 0;
263
264 *bdevp = open_bdev_excl(name, 0, mp);
265 if (IS_ERR(*bdevp)) {
266 error = PTR_ERR(*bdevp);
267 printk("XFS: Invalid device [%s], error=%d\n", name, error);
268 }
269
270 return -error;
271}
272
273void
274xfs_blkdev_put(
275 struct block_device *bdev)
276{
277 if (bdev)
278 close_bdev_excl(bdev);
279}
280
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100281/*
282 * Try to write out the superblock using barriers.
283 */
284STATIC int
285xfs_barrier_test(
286 xfs_mount_t *mp)
287{
288 xfs_buf_t *sbp = xfs_getsb(mp, 0);
289 int error;
290
291 XFS_BUF_UNDONE(sbp);
292 XFS_BUF_UNREAD(sbp);
293 XFS_BUF_UNDELAYWRITE(sbp);
294 XFS_BUF_WRITE(sbp);
295 XFS_BUF_UNASYNC(sbp);
296 XFS_BUF_ORDERED(sbp);
297
298 xfsbdstrat(mp, sbp);
299 error = xfs_iowait(sbp);
300
301 /*
302 * Clear all the flags we set and possible error state in the
303 * buffer. We only did the write to try out whether barriers
304 * worked and shouldn't leave any traces in the superblock
305 * buffer.
306 */
307 XFS_BUF_DONE(sbp);
308 XFS_BUF_ERROR(sbp, 0);
309 XFS_BUF_UNORDERED(sbp);
310
311 xfs_buf_relse(sbp);
312 return error;
313}
314
315void
316xfs_mountfs_check_barriers(xfs_mount_t *mp)
317{
318 int error;
319
320 if (mp->m_logdev_targp != mp->m_ddev_targp) {
321 xfs_fs_cmn_err(CE_NOTE, mp,
322 "Disabling barriers, not supported with external log device");
323 mp->m_flags &= ~XFS_MOUNT_BARRIER;
324 }
325
326 if (mp->m_ddev_targp->pbr_bdev->bd_disk->queue->ordered ==
327 QUEUE_ORDERED_NONE) {
328 xfs_fs_cmn_err(CE_NOTE, mp,
329 "Disabling barriers, not supported by the underlying device");
330 mp->m_flags &= ~XFS_MOUNT_BARRIER;
331 }
332
333 error = xfs_barrier_test(mp);
334 if (error) {
335 xfs_fs_cmn_err(CE_NOTE, mp,
336 "Disabling barriers, trial barrier write failed");
337 mp->m_flags &= ~XFS_MOUNT_BARRIER;
338 }
339}
340
341void
342xfs_blkdev_issue_flush(
343 xfs_buftarg_t *buftarg)
344{
345 blkdev_issue_flush(buftarg->pbr_bdev, NULL);
346}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
348STATIC struct inode *
349linvfs_alloc_inode(
350 struct super_block *sb)
351{
352 vnode_t *vp;
353
Christoph Hellwig0829c362005-09-02 16:58:49 +1000354 vp = kmem_cache_alloc(xfs_vnode_zone, kmem_flags_convert(KM_SLEEP));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 if (!vp)
356 return NULL;
357 return LINVFS_GET_IP(vp);
358}
359
360STATIC void
361linvfs_destroy_inode(
362 struct inode *inode)
363{
Christoph Hellwig0829c362005-09-02 16:58:49 +1000364 kmem_zone_free(xfs_vnode_zone, LINVFS_GET_VP(inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365}
366
367STATIC void
Christoph Hellwig0829c362005-09-02 16:58:49 +1000368linvfs_inode_init_once(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 void *data,
370 kmem_cache_t *cachep,
371 unsigned long flags)
372{
373 vnode_t *vp = (vnode_t *)data;
374
375 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
376 SLAB_CTOR_CONSTRUCTOR)
377 inode_init_once(LINVFS_GET_IP(vp));
378}
379
380STATIC int
Christoph Hellwig0829c362005-09-02 16:58:49 +1000381linvfs_init_zones(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382{
Christoph Hellwig0829c362005-09-02 16:58:49 +1000383 xfs_vnode_zone = kmem_cache_create("xfs_vnode",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 sizeof(vnode_t), 0, SLAB_RECLAIM_ACCOUNT,
Christoph Hellwig0829c362005-09-02 16:58:49 +1000385 linvfs_inode_init_once, NULL);
386 if (!xfs_vnode_zone)
387 goto out;
388
389 xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
390 if (!xfs_ioend_zone)
391 goto out_destroy_vnode_zone;
392
393 xfs_ioend_pool = mempool_create(4 * MAX_BUF_PER_PAGE,
394 mempool_alloc_slab, mempool_free_slab,
395 xfs_ioend_zone);
396 if (!xfs_ioend_pool)
397 goto out_free_ioend_zone;
398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 return 0;
Christoph Hellwig0829c362005-09-02 16:58:49 +1000400
401
402 out_free_ioend_zone:
403 kmem_zone_destroy(xfs_ioend_zone);
404 out_destroy_vnode_zone:
405 kmem_zone_destroy(xfs_vnode_zone);
406 out:
407 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408}
409
410STATIC void
Christoph Hellwig0829c362005-09-02 16:58:49 +1000411linvfs_destroy_zones(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412{
Christoph Hellwig0829c362005-09-02 16:58:49 +1000413 mempool_destroy(xfs_ioend_pool);
414 kmem_zone_destroy(xfs_vnode_zone);
415 kmem_zone_destroy(xfs_ioend_zone);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416}
417
418/*
419 * Attempt to flush the inode, this will actually fail
420 * if the inode is pinned, but we dirty the inode again
421 * at the point when it is unpinned after a log write,
422 * since this is when the inode itself becomes flushable.
423 */
424STATIC int
425linvfs_write_inode(
426 struct inode *inode,
427 int sync)
428{
429 vnode_t *vp = LINVFS_GET_VP(inode);
430 int error = 0, flags = FLUSH_INODE;
431
432 if (vp) {
433 vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
434 if (sync)
435 flags |= FLUSH_SYNC;
436 VOP_IFLUSH(vp, flags, error);
437 if (error == EAGAIN) {
438 if (sync)
439 VOP_IFLUSH(vp, flags | FLUSH_LOG, error);
440 else
441 error = 0;
442 }
443 }
444
445 return -error;
446}
447
448STATIC void
449linvfs_clear_inode(
450 struct inode *inode)
451{
452 vnode_t *vp = LINVFS_GET_VP(inode);
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000453 int error, cache;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000455 vn_trace_entry(vp, "clear_inode", (inst_t *)__return_address);
456
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000457 XFS_STATS_INC(vn_rele);
458 XFS_STATS_INC(vn_remove);
459 XFS_STATS_INC(vn_reclaim);
460 XFS_STATS_DEC(vn_active);
461
Christoph Hellwig02ba71d2005-09-05 08:28:02 +1000462 /*
463 * This can happen because xfs_iget_core calls xfs_idestroy if we
464 * find an inode with di_mode == 0 but without IGET_CREATE set.
465 */
466 if (vp->v_fbhv)
467 VOP_INACTIVE(vp, NULL, cache);
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000468
469 VN_LOCK(vp);
470 vp->v_flag &= ~VMODIFIED;
471 VN_UNLOCK(vp, 0);
472
Felix Blyakher0c147f92005-09-05 08:24:49 +1000473 if (vp->v_fbhv) {
474 VOP_RECLAIM(vp, error);
475 if (error)
476 panic("vn_purge: cannot reclaim");
477 }
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000478
479 ASSERT(vp->v_fbhv == NULL);
480
481#ifdef XFS_VNODE_TRACE
482 ktrace_free(vp->v_trace);
483#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484}
485
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486/*
487 * Enqueue a work item to be picked up by the vfs xfssyncd thread.
488 * Doing this has two advantages:
489 * - It saves on stack space, which is tight in certain situations
490 * - It can be used (with care) as a mechanism to avoid deadlocks.
491 * Flushing while allocating in a full filesystem requires both.
492 */
493STATIC void
494xfs_syncd_queue_work(
495 struct vfs *vfs,
496 void *data,
497 void (*syncer)(vfs_t *, void *))
498{
499 vfs_sync_work_t *work;
500
501 work = kmem_alloc(sizeof(struct vfs_sync_work), KM_SLEEP);
502 INIT_LIST_HEAD(&work->w_list);
503 work->w_syncer = syncer;
504 work->w_data = data;
505 work->w_vfs = vfs;
506 spin_lock(&vfs->vfs_sync_lock);
507 list_add_tail(&work->w_list, &vfs->vfs_sync_list);
508 spin_unlock(&vfs->vfs_sync_lock);
509 wake_up_process(vfs->vfs_sync_task);
510}
511
512/*
513 * Flush delayed allocate data, attempting to free up reserved space
514 * from existing allocations. At this point a new allocation attempt
515 * has failed with ENOSPC and we are in the process of scratching our
516 * heads, looking about for more room...
517 */
518STATIC void
519xfs_flush_inode_work(
520 vfs_t *vfs,
521 void *inode)
522{
523 filemap_flush(((struct inode *)inode)->i_mapping);
524 iput((struct inode *)inode);
525}
526
527void
528xfs_flush_inode(
529 xfs_inode_t *ip)
530{
531 struct inode *inode = LINVFS_GET_IP(XFS_ITOV(ip));
532 struct vfs *vfs = XFS_MTOVFS(ip->i_mount);
533
534 igrab(inode);
535 xfs_syncd_queue_work(vfs, inode, xfs_flush_inode_work);
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700536 delay(msecs_to_jiffies(500));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537}
538
539/*
540 * This is the "bigger hammer" version of xfs_flush_inode_work...
541 * (IOW, "If at first you don't succeed, use a Bigger Hammer").
542 */
543STATIC void
544xfs_flush_device_work(
545 vfs_t *vfs,
546 void *inode)
547{
548 sync_blockdev(vfs->vfs_super->s_bdev);
549 iput((struct inode *)inode);
550}
551
552void
553xfs_flush_device(
554 xfs_inode_t *ip)
555{
556 struct inode *inode = LINVFS_GET_IP(XFS_ITOV(ip));
557 struct vfs *vfs = XFS_MTOVFS(ip->i_mount);
558
559 igrab(inode);
560 xfs_syncd_queue_work(vfs, inode, xfs_flush_device_work);
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700561 delay(msecs_to_jiffies(500));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 xfs_log_force(ip->i_mount, (xfs_lsn_t)0, XFS_LOG_FORCE|XFS_LOG_SYNC);
563}
564
565#define SYNCD_FLAGS (SYNC_FSDATA|SYNC_BDFLUSH|SYNC_ATTR)
566STATIC void
567vfs_sync_worker(
568 vfs_t *vfsp,
569 void *unused)
570{
571 int error;
572
573 if (!(vfsp->vfs_flag & VFS_RDONLY))
574 VFS_SYNC(vfsp, SYNCD_FLAGS, NULL, error);
575 vfsp->vfs_sync_seq++;
576 wmb();
577 wake_up(&vfsp->vfs_wait_single_sync_task);
578}
579
580STATIC int
581xfssyncd(
582 void *arg)
583{
584 long timeleft;
585 vfs_t *vfsp = (vfs_t *) arg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 struct vfs_sync_work *work, *n;
Christoph Hellwig4df08c52005-09-05 08:34:18 +1000587 LIST_HEAD (tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700589 timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 for (;;) {
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700591 timeleft = schedule_timeout_interruptible(timeleft);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 /* swsusp */
Christoph Lameter3e1d1d22005-06-24 23:13:50 -0700593 try_to_freeze();
Christoph Hellwig4df08c52005-09-05 08:34:18 +1000594 if (kthread_should_stop())
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 break;
596
597 spin_lock(&vfsp->vfs_sync_lock);
598 /*
599 * We can get woken by laptop mode, to do a sync -
600 * that's the (only!) case where the list would be
601 * empty with time remaining.
602 */
603 if (!timeleft || list_empty(&vfsp->vfs_sync_list)) {
604 if (!timeleft)
Nishanth Aravamudan041e0e32005-09-10 00:27:23 -0700605 timeleft = xfs_syncd_centisecs *
606 msecs_to_jiffies(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 INIT_LIST_HEAD(&vfsp->vfs_sync_work.w_list);
608 list_add_tail(&vfsp->vfs_sync_work.w_list,
609 &vfsp->vfs_sync_list);
610 }
611 list_for_each_entry_safe(work, n, &vfsp->vfs_sync_list, w_list)
612 list_move(&work->w_list, &tmp);
613 spin_unlock(&vfsp->vfs_sync_lock);
614
615 list_for_each_entry_safe(work, n, &tmp, w_list) {
616 (*work->w_syncer)(vfsp, work->w_data);
617 list_del(&work->w_list);
618 if (work == &vfsp->vfs_sync_work)
619 continue;
620 kmem_free(work, sizeof(struct vfs_sync_work));
621 }
622 }
623
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 return 0;
625}
626
627STATIC int
628linvfs_start_syncd(
629 vfs_t *vfsp)
630{
Christoph Hellwig4df08c52005-09-05 08:34:18 +1000631 vfsp->vfs_sync_work.w_syncer = vfs_sync_worker;
632 vfsp->vfs_sync_work.w_vfs = vfsp;
633 vfsp->vfs_sync_task = kthread_run(xfssyncd, vfsp, "xfssyncd");
634 if (IS_ERR(vfsp->vfs_sync_task))
635 return -PTR_ERR(vfsp->vfs_sync_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 return 0;
637}
638
639STATIC void
640linvfs_stop_syncd(
641 vfs_t *vfsp)
642{
Christoph Hellwig4df08c52005-09-05 08:34:18 +1000643 kthread_stop(vfsp->vfs_sync_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644}
645
646STATIC void
647linvfs_put_super(
648 struct super_block *sb)
649{
650 vfs_t *vfsp = LINVFS_GET_VFS(sb);
651 int error;
652
653 linvfs_stop_syncd(vfsp);
654 VFS_SYNC(vfsp, SYNC_ATTR|SYNC_DELWRI, NULL, error);
655 if (!error)
656 VFS_UNMOUNT(vfsp, 0, NULL, error);
657 if (error) {
658 printk("XFS unmount got error %d\n", error);
659 printk("%s: vfsp/0x%p left dangling!\n", __FUNCTION__, vfsp);
660 return;
661 }
662
663 vfs_deallocate(vfsp);
664}
665
666STATIC void
667linvfs_write_super(
668 struct super_block *sb)
669{
670 vfs_t *vfsp = LINVFS_GET_VFS(sb);
671 int error;
672
673 if (sb->s_flags & MS_RDONLY) {
674 sb->s_dirt = 0; /* paranoia */
675 return;
676 }
677 /* Push the log and superblock a little */
678 VFS_SYNC(vfsp, SYNC_FSDATA, NULL, error);
679 sb->s_dirt = 0;
680}
681
682STATIC int
683linvfs_sync_super(
684 struct super_block *sb,
685 int wait)
686{
687 vfs_t *vfsp = LINVFS_GET_VFS(sb);
688 int error;
689 int flags = SYNC_FSDATA;
690
Christoph Hellwigf898d6c2005-06-21 15:40:48 +1000691 if (unlikely(sb->s_frozen == SB_FREEZE_WRITE))
692 flags = SYNC_QUIESCE;
693 else
694 flags = SYNC_FSDATA | (wait ? SYNC_WAIT : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695
696 VFS_SYNC(vfsp, flags, NULL, error);
697 sb->s_dirt = 0;
698
699 if (unlikely(laptop_mode)) {
700 int prev_sync_seq = vfsp->vfs_sync_seq;
701
702 /*
703 * The disk must be active because we're syncing.
704 * We schedule xfssyncd now (now that the disk is
705 * active) instead of later (when it might not be).
706 */
707 wake_up_process(vfsp->vfs_sync_task);
708 /*
709 * We have to wait for the sync iteration to complete.
710 * If we don't, the disk activity caused by the sync
711 * will come after the sync is completed, and that
712 * triggers another sync from laptop mode.
713 */
714 wait_event(vfsp->vfs_wait_single_sync_task,
715 vfsp->vfs_sync_seq != prev_sync_seq);
716 }
717
718 return -error;
719}
720
721STATIC int
722linvfs_statfs(
723 struct super_block *sb,
724 struct kstatfs *statp)
725{
726 vfs_t *vfsp = LINVFS_GET_VFS(sb);
727 int error;
728
729 VFS_STATVFS(vfsp, statp, NULL, error);
730 return -error;
731}
732
733STATIC int
734linvfs_remount(
735 struct super_block *sb,
736 int *flags,
737 char *options)
738{
739 vfs_t *vfsp = LINVFS_GET_VFS(sb);
740 struct xfs_mount_args *args = xfs_args_allocate(sb);
741 int error;
742
743 VFS_PARSEARGS(vfsp, options, args, 1, error);
744 if (!error)
745 VFS_MNTUPDATE(vfsp, flags, args, error);
746 kmem_free(args, sizeof(*args));
747 return -error;
748}
749
750STATIC void
751linvfs_freeze_fs(
752 struct super_block *sb)
753{
754 VFS_FREEZE(LINVFS_GET_VFS(sb));
755}
756
757STATIC int
758linvfs_show_options(
759 struct seq_file *m,
760 struct vfsmount *mnt)
761{
762 struct vfs *vfsp = LINVFS_GET_VFS(mnt->mnt_sb);
763 int error;
764
765 VFS_SHOWARGS(vfsp, m, error);
766 return error;
767}
768
769STATIC int
Nathan Scottee348072005-11-02 10:32:38 +1100770linvfs_quotasync(
771 struct super_block *sb,
772 int type)
773{
774 struct vfs *vfsp = LINVFS_GET_VFS(sb);
775 int error;
776
777 VFS_QUOTACTL(vfsp, Q_XQUOTASYNC, 0, (caddr_t)NULL, error);
778 return -error;
779}
780
781STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782linvfs_getxstate(
783 struct super_block *sb,
784 struct fs_quota_stat *fqs)
785{
786 struct vfs *vfsp = LINVFS_GET_VFS(sb);
787 int error;
788
789 VFS_QUOTACTL(vfsp, Q_XGETQSTAT, 0, (caddr_t)fqs, error);
790 return -error;
791}
792
793STATIC int
794linvfs_setxstate(
795 struct super_block *sb,
796 unsigned int flags,
797 int op)
798{
799 struct vfs *vfsp = LINVFS_GET_VFS(sb);
800 int error;
801
802 VFS_QUOTACTL(vfsp, op, 0, (caddr_t)&flags, error);
803 return -error;
804}
805
806STATIC int
807linvfs_getxquota(
808 struct super_block *sb,
809 int type,
810 qid_t id,
811 struct fs_disk_quota *fdq)
812{
813 struct vfs *vfsp = LINVFS_GET_VFS(sb);
814 int error, getmode;
815
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000816 getmode = (type == USRQUOTA) ? Q_XGETQUOTA :
817 ((type == GRPQUOTA) ? Q_XGETGQUOTA : Q_XGETPQUOTA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 VFS_QUOTACTL(vfsp, getmode, id, (caddr_t)fdq, error);
819 return -error;
820}
821
822STATIC int
823linvfs_setxquota(
824 struct super_block *sb,
825 int type,
826 qid_t id,
827 struct fs_disk_quota *fdq)
828{
829 struct vfs *vfsp = LINVFS_GET_VFS(sb);
830 int error, setmode;
831
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000832 setmode = (type == USRQUOTA) ? Q_XSETQLIM :
833 ((type == GRPQUOTA) ? Q_XSETGQLIM : Q_XSETPQLIM);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 VFS_QUOTACTL(vfsp, setmode, id, (caddr_t)fdq, error);
835 return -error;
836}
837
838STATIC int
839linvfs_fill_super(
840 struct super_block *sb,
841 void *data,
842 int silent)
843{
844 vnode_t *rootvp;
845 struct vfs *vfsp = vfs_allocate();
846 struct xfs_mount_args *args = xfs_args_allocate(sb);
847 struct kstatfs statvfs;
848 int error, error2;
849
850 vfsp->vfs_super = sb;
851 LINVFS_SET_VFS(sb, vfsp);
852 if (sb->s_flags & MS_RDONLY)
853 vfsp->vfs_flag |= VFS_RDONLY;
854 bhv_insert_all_vfsops(vfsp);
855
856 VFS_PARSEARGS(vfsp, (char *)data, args, 0, error);
857 if (error) {
858 bhv_remove_all_vfsops(vfsp, 1);
859 goto fail_vfsop;
860 }
861
862 sb_min_blocksize(sb, BBSIZE);
863#ifdef CONFIG_XFS_EXPORT
864 sb->s_export_op = &linvfs_export_ops;
865#endif
866 sb->s_qcop = &linvfs_qops;
867 sb->s_op = &linvfs_sops;
868
869 VFS_MOUNT(vfsp, args, NULL, error);
870 if (error) {
871 bhv_remove_all_vfsops(vfsp, 1);
872 goto fail_vfsop;
873 }
874
875 VFS_STATVFS(vfsp, &statvfs, NULL, error);
876 if (error)
877 goto fail_unmount;
878
879 sb->s_dirt = 1;
880 sb->s_magic = statvfs.f_type;
881 sb->s_blocksize = statvfs.f_bsize;
882 sb->s_blocksize_bits = ffs(statvfs.f_bsize) - 1;
883 sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
884 sb->s_time_gran = 1;
885 set_posix_acl_flag(sb);
886
887 VFS_ROOT(vfsp, &rootvp, error);
888 if (error)
889 goto fail_unmount;
890
891 sb->s_root = d_alloc_root(LINVFS_GET_IP(rootvp));
892 if (!sb->s_root) {
893 error = ENOMEM;
894 goto fail_vnrele;
895 }
896 if (is_bad_inode(sb->s_root->d_inode)) {
897 error = EINVAL;
898 goto fail_vnrele;
899 }
900 if ((error = linvfs_start_syncd(vfsp)))
901 goto fail_vnrele;
902 vn_trace_exit(rootvp, __FUNCTION__, (inst_t *)__return_address);
903
904 kmem_free(args, sizeof(*args));
905 return 0;
906
907fail_vnrele:
908 if (sb->s_root) {
909 dput(sb->s_root);
910 sb->s_root = NULL;
911 } else {
912 VN_RELE(rootvp);
913 }
914
915fail_unmount:
916 VFS_UNMOUNT(vfsp, 0, NULL, error2);
917
918fail_vfsop:
919 vfs_deallocate(vfsp);
920 kmem_free(args, sizeof(*args));
921 return -error;
922}
923
924STATIC struct super_block *
925linvfs_get_sb(
926 struct file_system_type *fs_type,
927 int flags,
928 const char *dev_name,
929 void *data)
930{
931 return get_sb_bdev(fs_type, flags, dev_name, data, linvfs_fill_super);
932}
933
934STATIC struct super_operations linvfs_sops = {
935 .alloc_inode = linvfs_alloc_inode,
936 .destroy_inode = linvfs_destroy_inode,
937 .write_inode = linvfs_write_inode,
938 .clear_inode = linvfs_clear_inode,
939 .put_super = linvfs_put_super,
940 .write_super = linvfs_write_super,
941 .sync_fs = linvfs_sync_super,
942 .write_super_lockfs = linvfs_freeze_fs,
943 .statfs = linvfs_statfs,
944 .remount_fs = linvfs_remount,
945 .show_options = linvfs_show_options,
946};
947
948STATIC struct quotactl_ops linvfs_qops = {
Nathan Scottee348072005-11-02 10:32:38 +1100949 .quota_sync = linvfs_quotasync,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 .get_xstate = linvfs_getxstate,
951 .set_xstate = linvfs_setxstate,
952 .get_xquota = linvfs_getxquota,
953 .set_xquota = linvfs_setxquota,
954};
955
956STATIC struct file_system_type xfs_fs_type = {
957 .owner = THIS_MODULE,
958 .name = "xfs",
959 .get_sb = linvfs_get_sb,
960 .kill_sb = kill_block_super,
961 .fs_flags = FS_REQUIRES_DEV,
962};
963
964
965STATIC int __init
966init_xfs_fs( void )
967{
968 int error;
969 struct sysinfo si;
970 static char message[] __initdata = KERN_INFO \
971 XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled\n";
972
973 printk(message);
974
975 si_meminfo(&si);
976 xfs_physmem = si.totalram;
977
978 ktrace_init(64);
979
Christoph Hellwig0829c362005-09-02 16:58:49 +1000980 error = linvfs_init_zones();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 if (error < 0)
Christoph Hellwig0829c362005-09-02 16:58:49 +1000982 goto undo_zones;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
984 error = pagebuf_init();
985 if (error < 0)
986 goto undo_pagebuf;
987
988 vn_init();
989 xfs_init();
990 uuid_init();
991 vfs_initquota();
992
993 error = register_filesystem(&xfs_fs_type);
994 if (error)
995 goto undo_register;
996 XFS_DM_INIT(&xfs_fs_type);
997 return 0;
998
999undo_register:
1000 pagebuf_terminate();
1001
1002undo_pagebuf:
Christoph Hellwig0829c362005-09-02 16:58:49 +10001003 linvfs_destroy_zones();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004
Christoph Hellwig0829c362005-09-02 16:58:49 +10001005undo_zones:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 return error;
1007}
1008
1009STATIC void __exit
1010exit_xfs_fs( void )
1011{
1012 vfs_exitquota();
1013 XFS_DM_EXIT(&xfs_fs_type);
1014 unregister_filesystem(&xfs_fs_type);
1015 xfs_cleanup();
1016 pagebuf_terminate();
Christoph Hellwig0829c362005-09-02 16:58:49 +10001017 linvfs_destroy_zones();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 ktrace_uninit();
1019}
1020
1021module_init(init_xfs_fs);
1022module_exit(exit_xfs_fs);
1023
1024MODULE_AUTHOR("Silicon Graphics, Inc.");
1025MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
1026MODULE_LICENSE("GPL");