lustre/lvfs/fsfilt_reiserfs.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  lustre/lib/fsfilt_reiserfs.c
   5  *  Lustre filesystem abstraction routines
   6  *
   7  *  Copyright (C) 2002 Cluster File Systems, Inc.
   8  *   Author: Andreas Dilger <adilger@clusterfs.com>
   9  *
  10  *   This file is part of Lustre, http://www.lustre.org.
  11  *
  12  *   Lustre is free software; you can redistribute it and/or
  13  *   modify it under the terms of version 2 of the GNU General Public
  14  *   License as published by the Free Software Foundation.
  15  *
  16  *   Lustre is distributed in the hope that it will be useful,
  17  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *   GNU General Public License for more details.
  20  *
  21  *   You should have received a copy of the GNU General Public License
  22  *   along with Lustre; if not, write to the Free Software
  23  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 /*
  27  * NOTE - According to Hans Reiser, this could actually be implemented more
  28  *        efficiently than creating a directory and putting ASCII objids in it.
  29  *        Instead, we should return the reiserfs object ID as the lustre objid
  30  *        (although I'm not sure what impact that would have on backup/restore).
  31  */
  32
  33 #define DEBUG_SUBSYSTEM S_FILTER
  34
  35 #include <linux/fs.h>
  36 #include <linux/jbd.h>
  37 #include <linux/slab.h>
  38 #include <linux/pagemap.h>
  39 #include <linux/quotaops.h>
  40 #include <linux/version.h>
  41 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
  42 #include <linux/init.h>
  43 #include <asm/statfs.h>
  44 #endif
  45 #include <linux/kp30.h>
  46 #include <linux/lustre_fsfilt.h>
  47 #include <linux/obd.h>
  48 #include <linux/obd_class.h>
  49 #include <linux/module.h>
  50 #include <linux/init.h>
  51
  52 static void *fsfilt_reiserfs_start(struct inode *inode, int op,
  53                                    void *desc_private)
  54 {
  55         return (void *)0xf00f00be;
  56 }
  57
  58 static void *fsfilt_reiserfs_brw_start(int objcount, struct fsfilt_objinfo *fso,
  59                                        int niocount, void *desc_private)
  60 {
  61         return (void *)0xf00f00be;
  62 }
  63
  64 static int fsfilt_reiserfs_commit(struct inode *inode, void *handle,
  65                                   int force_sync)
  66 {
  67         if (handle != (void *)0xf00f00be) {
  68                 CERROR("bad handle %p", handle);
  69                 return -EINVAL;
  70         }
  71
  72         return 0;
  73 }
  74
  75 static int fsfilt_reiserfs_setattr(struct dentry *dentry, void *handle,
  76                                struct iattr *iattr, int do_trunc)
  77 {
  78         struct inode *inode = dentry->d_inode;
  79         int rc;
  80
  81         lock_kernel();
  82
  83         /* A _really_ horrible hack to avoid removing the data stored
  84          * in the block pointers; this is really the "small" stripe MD data.
  85          * We can avoid further hackery by virtue of the MDS file size being
  86          * zero all the time (which doesn't invoke block truncate at unlink
  87          * time), so we assert we never change the MDS file size from zero.
  88          */
  89         if (iattr->ia_valid & ATTR_SIZE && !do_trunc) {
  90                 /* ATTR_SIZE would invoke truncate: clear it */
  91                 iattr->ia_valid &= ~ATTR_SIZE;
  92                 inode->i_size = iattr->ia_size;
  93
  94                 /* make sure _something_ gets set - so new inode
  95                  * goes to disk (probably won't work over XFS
  96                  */
  97                 if (!iattr->ia_valid & ATTR_MODE) {
  98                         iattr->ia_valid |= ATTR_MODE;
  99                         iattr->ia_mode = inode->i_mode;
 100                 }
 101         }
 102
 103         /* We set these flags on the client, but have already checked perms
 104          * so don't confuse inode_change_ok. */
 105         iattr->ia_valid &= ~(ATTR_MTIME_SET | ATTR_ATIME_SET);
 106
 107         if (inode->i_op->setattr) {
 108                 rc = inode->i_op->setattr(dentry, iattr);
 109         } else {
 110                 rc = inode_change_ok(inode, iattr);
 111                 if (!rc)
 112                         rc = inode_setattr(inode, iattr);
 113         }
 114
 115         unlock_kernel();
 116
 117         return rc;
 118 }
 119
 120 static int fsfilt_reiserfs_set_md(struct inode *inode, void *handle,
 121                                   void *lmm, int lmm_size)
 122 {
 123         /* XXX write stripe data into MDS file itself */
 124         CERROR("not implemented yet\n");
 125
 126         return -ENOSYS;
 127 }
 128
 129 static int fsfilt_reiserfs_get_md(struct inode *inode, void *lmm, int lmm_size)
 130 {
 131         if (lmm == NULL)
 132                 return inode->i_size;
 133
 134         CERROR("not implemented yet\n");
 135         return -ENOSYS;
 136 }
 137
 138 static ssize_t fsfilt_reiserfs_readpage(struct file *file, char *buf, size_t count,
 139                                         loff_t *offset)
 140 {
 141         return file->f_op->read(file, buf, count, offset);
 142 }
 143
 144 static int fsfilt_reiserfs_add_journal_cb(struct obd_device *obd,
 145                                           __u64 last_rcvd, void *handle,
 146                                           fsfilt_cb_t cb_func, void *cb_data)
 147 {
 148         static long next = 0;
 149
 150         if (time_after(jiffies, next)) {
 151                 CERROR("no journal callback kernel patch, faking it...\n");
 152                 next = jiffies + 300 * HZ;
 153         }
 154
 155         cb_func(obd, last_rcvd, cb_data, 0);
 156
 157         return 0;
 158 }
 159
 160 static int fsfilt_reiserfs_statfs(struct super_block *sb,
 161                                   struct obd_statfs *osfs)
 162 {
 163         struct kstatfs sfs;
 164         int rc;
 165
 166         memset(&sfs, 0, sizeof(sfs));
 167
 168         rc = sb->s_op->statfs(sb, &sfs);
 169
 170         statfs_pack(osfs, &sfs);
 171         return rc;
 172 }
 173
 174 static int fsfilt_reiserfs_sync(struct super_block *sb)
 175 {
 176         return fsync_dev(sb->s_dev);
 177 }
 178
 179 static struct fsfilt_operations fsfilt_reiserfs_ops = {
 180         fs_type:                "reiserfs",
 181         fs_owner:               THIS_MODULE,
 182         fs_start:               fsfilt_reiserfs_start,
 183         fs_brw_start:           fsfilt_reiserfs_brw_start,
 184         fs_commit:              fsfilt_reiserfs_commit,
 185         fs_setattr:             fsfilt_reiserfs_setattr,
 186         fs_set_md:              fsfilt_reiserfs_set_md,
 187         fs_get_md:              fsfilt_reiserfs_get_md,
 188         fs_readpage:            fsfilt_reiserfs_readpage,
 189         fs_add_journal_cb:      fsfilt_reiserfs_add_journal_cb,
 190         fs_statfs:              fsfilt_reiserfs_statfs,
 191         fs_sync:                fsfilt_reiserfs_sync,
 192 };
 193
 194 static int __init fsfilt_reiserfs_init(void)
 195 {
 196         return fsfilt_register_ops(&fsfilt_reiserfs_ops);
 197 }
 198
 199 static void __exit fsfilt_reiserfs_exit(void)
 200 {
 201         fsfilt_unregister_ops(&fsfilt_reiserfs_ops);
 202 }
 203
 204 MODULE_AUTHOR("Cluster File Systems, Inc. <info@clusterfs.com>");
 205 MODULE_DESCRIPTION("Lustre reiserfs Filesystem Helper v0.1");
 206 MODULE_LICENSE("GPL");
 207
 208 module_init(fsfilt_reiserfs_init);
 209 module_exit(fsfilt_reiserfs_exit);