fs/xfs/linux-2.6/xfs_vfs.c

   1 /*
   2  * Copyright (c) 2000-2004 Silicon Graphics, Inc.  All Rights Reserved.
   3  *
   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 #include "xfs_fs.h"
  35 #include "xfs_macros.h"
  36 #include "xfs_inum.h"
  37 #include "xfs_log.h"
  38 #include "xfs_clnt.h"
  39 #include "xfs_trans.h"
  40 #include "xfs_sb.h"
  41 #include "xfs_ag.h"
  42 #include "xfs_dir.h"
  43 #include "xfs_dir2.h"
  44 #include "xfs_imap.h"
  45 #include "xfs_alloc.h"
  46 #include "xfs_dmapi.h"
  47 #include "xfs_mount.h"
  48 #include "xfs_quota.h"
  49
  50 int
  51 vfs_mount(
  52         struct bhv_desc         *bdp,
  53         struct xfs_mount_args   *args,
  54         struct cred             *cr)
  55 {
  56         struct bhv_desc         *next = bdp;
  57
  58         ASSERT(next);
  59         while (! (bhvtovfsops(next))->vfs_mount)
  60                 next = BHV_NEXT(next);
  61         return ((*bhvtovfsops(next)->vfs_mount)(next, args, cr));
  62 }
  63
  64 int
  65 vfs_parseargs(
  66         struct bhv_desc         *bdp,
  67         char                    *s,
  68         struct xfs_mount_args   *args,
  69         int                     f)
  70 {
  71         struct bhv_desc         *next = bdp;
  72
  73         ASSERT(next);
  74         while (! (bhvtovfsops(next))->vfs_parseargs)
  75                 next = BHV_NEXT(next);
  76         return ((*bhvtovfsops(next)->vfs_parseargs)(next, s, args, f));
  77 }
  78
  79 int
  80 vfs_showargs(
  81         struct bhv_desc         *bdp,
  82         struct seq_file         *m)
  83 {
  84         struct bhv_desc         *next = bdp;
  85
  86         ASSERT(next);
  87         while (! (bhvtovfsops(next))->vfs_showargs)
  88                 next = BHV_NEXT(next);
  89         return ((*bhvtovfsops(next)->vfs_showargs)(next, m));
  90 }
  91
  92 int
  93 vfs_unmount(
  94         struct bhv_desc         *bdp,
  95         int                     fl,
  96         struct cred             *cr)
  97 {
  98         struct bhv_desc         *next = bdp;
  99
 100         ASSERT(next);
 101         while (! (bhvtovfsops(next))->vfs_unmount)
 102                 next = BHV_NEXT(next);
 103         return ((*bhvtovfsops(next)->vfs_unmount)(next, fl, cr));
 104 }
 105
 106 int
 107 vfs_mntupdate(
 108         struct bhv_desc         *bdp,
 109         int                     *fl,
 110         struct xfs_mount_args   *args)
 111 {
 112         struct bhv_desc         *next = bdp;
 113
 114         ASSERT(next);
 115         while (! (bhvtovfsops(next))->vfs_mntupdate)
 116                 next = BHV_NEXT(next);
 117         return ((*bhvtovfsops(next)->vfs_mntupdate)(next, fl, args));
 118 }
 119
 120 int
 121 vfs_root(
 122         struct bhv_desc         *bdp,
 123         struct vnode            **vpp)
 124 {
 125         struct bhv_desc         *next = bdp;
 126
 127         ASSERT(next);
 128         while (! (bhvtovfsops(next))->vfs_root)
 129                 next = BHV_NEXT(next);
 130         return ((*bhvtovfsops(next)->vfs_root)(next, vpp));
 131 }
 132
 133 int
 134 vfs_statvfs(
 135         struct bhv_desc         *bdp,
 136         xfs_statfs_t            *sp,
 137         struct vnode            *vp)
 138 {
 139         struct bhv_desc         *next = bdp;
 140
 141         ASSERT(next);
 142         while (! (bhvtovfsops(next))->vfs_statvfs)
 143                 next = BHV_NEXT(next);
 144         return ((*bhvtovfsops(next)->vfs_statvfs)(next, sp, vp));
 145 }
 146
 147 int
 148 vfs_sync(
 149         struct bhv_desc         *bdp,
 150         int                     fl,
 151         struct cred             *cr)
 152 {
 153         struct bhv_desc         *next = bdp;
 154
 155         ASSERT(next);
 156         while (! (bhvtovfsops(next))->vfs_sync)
 157                 next = BHV_NEXT(next);
 158         return ((*bhvtovfsops(next)->vfs_sync)(next, fl, cr));
 159 }
 160
 161 int
 162 vfs_vget(
 163         struct bhv_desc         *bdp,
 164         struct vnode            **vpp,
 165         struct fid              *fidp)
 166 {
 167         struct bhv_desc         *next = bdp;
 168
 169         ASSERT(next);
 170         while (! (bhvtovfsops(next))->vfs_vget)
 171                 next = BHV_NEXT(next);
 172         return ((*bhvtovfsops(next)->vfs_vget)(next, vpp, fidp));
 173 }
 174
 175 int
 176 vfs_dmapiops(
 177         struct bhv_desc         *bdp,
 178         caddr_t                 addr)
 179 {
 180         struct bhv_desc         *next = bdp;
 181
 182         ASSERT(next);
 183         while (! (bhvtovfsops(next))->vfs_dmapiops)
 184                 next = BHV_NEXT(next);
 185         return ((*bhvtovfsops(next)->vfs_dmapiops)(next, addr));
 186 }
 187
 188 int
 189 vfs_quotactl(
 190         struct bhv_desc         *bdp,
 191         int                     cmd,
 192         int                     id,
 193         caddr_t                 addr)
 194 {
 195         struct bhv_desc         *next = bdp;
 196
 197         ASSERT(next);
 198         while (! (bhvtovfsops(next))->vfs_quotactl)
 199                 next = BHV_NEXT(next);
 200         return ((*bhvtovfsops(next)->vfs_quotactl)(next, cmd, id, addr));
 201 }
 202
 203 void
 204 vfs_init_vnode(
 205         struct bhv_desc         *bdp,
 206         struct vnode            *vp,
 207         struct bhv_desc         *bp,
 208         int                     unlock)
 209 {
 210         struct bhv_desc         *next = bdp;
 211
 212         ASSERT(next);
 213         while (! (bhvtovfsops(next))->vfs_init_vnode)
 214                 next = BHV_NEXT(next);
 215         ((*bhvtovfsops(next)->vfs_init_vnode)(next, vp, bp, unlock));
 216 }
 217
 218 void
 219 vfs_force_shutdown(
 220         struct bhv_desc         *bdp,
 221         int                     fl,
 222         char                    *file,
 223         int                     line)
 224 {
 225         struct bhv_desc         *next = bdp;
 226
 227         ASSERT(next);
 228         while (! (bhvtovfsops(next))->vfs_force_shutdown)
 229                 next = BHV_NEXT(next);
 230         ((*bhvtovfsops(next)->vfs_force_shutdown)(next, fl, file, line));
 231 }
 232
 233 void
 234 vfs_freeze(
 235         struct bhv_desc         *bdp)
 236 {
 237         struct bhv_desc         *next = bdp;
 238
 239         ASSERT(next);
 240         while (! (bhvtovfsops(next))->vfs_freeze)
 241                 next = BHV_NEXT(next);
 242         ((*bhvtovfsops(next)->vfs_freeze)(next));
 243 }
 244
 245 vfs_t *
 246 vfs_allocate( void )
 247 {
 248         struct vfs              *vfsp;
 249
 250         vfsp = kmem_zalloc(sizeof(vfs_t), KM_SLEEP);
 251         bhv_head_init(VFS_BHVHEAD(vfsp), "vfs");
 252         INIT_LIST_HEAD(&vfsp->vfs_sync_list);
 253         spin_lock_init(&vfsp->vfs_sync_lock);
 254         init_waitqueue_head(&vfsp->vfs_wait_sync_task);
 255         init_waitqueue_head(&vfsp->vfs_wait_single_sync_task);
 256         return vfsp;
 257 }
 258
 259 void
 260 vfs_deallocate(
 261         struct vfs              *vfsp)
 262 {
 263         bhv_head_destroy(VFS_BHVHEAD(vfsp));
 264         kmem_free(vfsp, sizeof(vfs_t));
 265 }
 266
 267 void
 268 vfs_insertops(
 269         struct vfs              *vfsp,
 270         struct bhv_vfsops       *vfsops)
 271 {
 272         struct bhv_desc         *bdp;
 273
 274         bdp = kmem_alloc(sizeof(struct bhv_desc), KM_SLEEP);
 275         bhv_desc_init(bdp, NULL, vfsp, vfsops);
 276         bhv_insert(&vfsp->vfs_bh, bdp);
 277 }
 278
 279 void
 280 vfs_insertbhv(
 281         struct vfs              *vfsp,
 282         struct bhv_desc         *bdp,
 283         struct vfsops           *vfsops,
 284         void                    *mount)
 285 {
 286         bhv_desc_init(bdp, mount, vfsp, vfsops);
 287         bhv_insert_initial(&vfsp->vfs_bh, bdp);
 288 }
 289
 290 void
 291 bhv_remove_vfsops(
 292         struct vfs              *vfsp,
 293         int                     pos)
 294 {
 295         struct bhv_desc         *bhv;
 296
 297         bhv = bhv_lookup_range(&vfsp->vfs_bh, pos, pos);
 298         if (!bhv)
 299                 return;
 300         bhv_remove(&vfsp->vfs_bh, bhv);
 301         kmem_free(bhv, sizeof(*bhv));
 302 }
 303
 304 void
 305 bhv_remove_all_vfsops(
 306         struct vfs              *vfsp,
 307         int                     freebase)
 308 {
 309         struct xfs_mount        *mp;
 310
 311         bhv_remove_vfsops(vfsp, VFS_POSITION_QM);
 312         bhv_remove_vfsops(vfsp, VFS_POSITION_DM);
 313         if (!freebase)
 314                 return;
 315         mp = XFS_BHVTOM(bhv_lookup(VFS_BHVHEAD(vfsp), &xfs_vfsops));
 316         VFS_REMOVEBHV(vfsp, &mp->m_bhv);
 317         xfs_mount_free(mp, 0);
 318 }
 319
 320 void
 321 bhv_insert_all_vfsops(
 322         struct vfs              *vfsp)
 323 {
 324         struct xfs_mount        *mp;
 325
 326         mp = xfs_mount_init();
 327         vfs_insertbhv(vfsp, &mp->m_bhv, &xfs_vfsops, mp);
 328         vfs_insertdmapi(vfsp);
 329         vfs_insertquota(vfsp);
 330 }