SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/xfs/linux-2.6/xfs_super.c

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