lustre/smfs/fsfilt.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  lustre/lib/fsfilt_smfs.c
   5  *  Lustre filesystem abstraction routines
   6  *
   7  *  Copyright (C) 2004 Cluster File Systems, Inc.
   8  *   Author: Wang Di <wangdi@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 #define DEBUG_SUBSYSTEM S_SM
  27
  28 #include <linux/fs.h>
  29 #include <linux/jbd.h>
  30 #include <linux/slab.h>
  31 #include <linux/pagemap.h>
  32 #include <linux/quotaops.h>
  33 #include <linux/version.h>
  34 #include <libcfs/kp30.h>
  35 #include <linux/obd.h>
  36 #include <linux/obd_class.h>
  37
  38 #include <linux/lustre_fsfilt.h>
  39 #include <linux/lustre_smfs.h>
  40 #include <linux/lustre_snap.h>
  41
  42 #include "smfs_internal.h"
  43
  44 static void *fsfilt_smfs_start(struct inode *inode, int op,
  45                                void *desc_private, int logs)
  46 {
  47         void *handle;
  48         struct inode *cache_inode = I2CI(inode);
  49         struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
  50         int extra = 0;
  51         int opcode = op;
  52
  53         if (cache_fsfilt == NULL)
  54                 return NULL;
  55
  56         if (!cache_fsfilt->fs_start)
  57                 return ERR_PTR(-ENOSYS);
  58
  59         //opcode can be changed here.
  60         //For example, unlink is rename in nature for undo plugin
  61         extra = SMFS_PLG_HELP(inode->i_sb, PLG_TRANS_SIZE, &opcode);
  62
  63         handle = cache_fsfilt->fs_start(cache_inode, op, desc_private,
  64                                         logs + extra);
  65
  66         return handle;
  67 }
  68
  69 static void *fsfilt_smfs_brw_start(int objcount, struct fsfilt_objinfo *fso,
  70                                    int niocount, struct niobuf_local *nb,
  71                                    void *desc_private, int logs)
  72 {
  73         struct fsfilt_operations *cache_fsfilt;
  74         struct dentry *cache_dentry = NULL;
  75         struct inode *cache_inode = NULL;
  76         struct fsfilt_objinfo cache_fso;
  77         void   *rc = NULL;
  78
  79         ENTRY;
  80
  81         cache_fsfilt = I2FOPS(fso->fso_dentry->d_inode);
  82         if (cache_fsfilt == NULL)
  83                 RETURN(NULL);
  84
  85         cache_inode = I2CI(fso->fso_dentry->d_inode);
  86         cache_dentry = pre_smfs_dentry(NULL, cache_inode, fso->fso_dentry);
  87         if (!cache_dentry)
  88                 RETURN(ERR_PTR(-ENOMEM));
  89
  90         cache_fso.fso_dentry = cache_dentry;
  91         cache_fso.fso_bufcnt = fso->fso_bufcnt;
  92
  93         if (!cache_fsfilt->fs_brw_start) {
  94                 rc =  ERR_PTR(-ENOSYS);
  95                 goto exit;
  96         }
  97
  98         rc = cache_fsfilt->fs_brw_start(objcount, &cache_fso, niocount, nb,
  99                                         desc_private, logs);
 100 exit:
 101         post_smfs_dentry(cache_dentry);
 102         RETURN(rc);
 103 }
 104
 105 /* FIXME-WANGDI: here we can easily have inode == NULL due to
 106    mds_open() behavior. It passes NULL inode to mds_finish_transno()
 107    sometimes. Probably we should have spare way to get cache fsfilt
 108    operations. */
 109 static int fsfilt_smfs_commit(struct super_block *sb, struct inode *inode,
 110                               void *h, int force_sync)
 111 {
 112         struct fsfilt_operations *cache_fsfilt = S2SMI(sb)->sm_cache_fsfilt;
 113         struct super_block *csb = S2CSB(sb);
 114         struct inode *cache_inode = NULL;
 115         int    rc = -EIO;
 116
 117         ENTRY;
 118
 119         if (inode)
 120                 cache_inode = I2CI(inode);
 121
 122         if (cache_fsfilt == NULL)
 123                 RETURN(rc);
 124
 125         if (!cache_fsfilt->fs_commit)
 126                 RETURN(-ENOSYS);
 127
 128         rc = cache_fsfilt->fs_commit(csb, cache_inode, h, force_sync);
 129
 130         RETURN(rc);
 131 }
 132
 133 static int fsfilt_smfs_commit_async(struct inode *inode, void *h,
 134                                     void **wait_handle)
 135 {
 136         struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
 137         struct inode *cache_inode = NULL;
 138         int    rc = -EIO;
 139
 140         cache_inode = I2CI(inode);
 141         if (cache_fsfilt == NULL)
 142                 RETURN(-EINVAL);
 143
 144         if (!cache_fsfilt->fs_commit_async)
 145                 RETURN(-ENOSYS);
 146
 147         rc = cache_fsfilt->fs_commit_async(cache_inode, h, wait_handle);
 148
 149         RETURN(rc);
 150 }
 151
 152 static int fsfilt_smfs_commit_wait(struct inode *inode, void *h)
 153 {
 154         struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
 155         struct inode *cache_inode = NULL;
 156         int    rc = -EIO;
 157
 158         cache_inode = I2CI(inode);
 159         if (cache_fsfilt == NULL)
 160                 RETURN(-EINVAL);
 161
 162         if (!cache_fsfilt->fs_commit_wait)
 163                 RETURN(-ENOSYS);
 164
 165         rc = cache_fsfilt->fs_commit_wait(cache_inode, h);
 166
 167         RETURN(rc);
 168 }
 169
 170 static int fsfilt_smfs_iocontrol(struct inode *inode, struct file *file,
 171                                  unsigned int cmd, unsigned long arg)
 172 {
 173         struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
 174         struct inode *cache_inode = I2CI(inode);
 175         struct smfs_file_info *sfi = NULL;
 176         struct file * cache_file = NULL;
 177         int    rc = -EIO;
 178         ENTRY;
 179
 180         if (!cache_fsfilt || !cache_inode)
 181                 RETURN(rc);
 182
 183         if (!cache_fsfilt->fs_iocontrol)
 184                 RETURN(-ENOSYS);
 185
 186
 187         if (file != NULL) {
 188                 sfi = F2SMFI(file);
 189                 if (sfi->magic != SMFS_FILE_MAGIC)
 190                         BUG();
 191                 cache_file = sfi->c_file;
 192         }
 193
 194         pre_smfs_inode(inode, cache_inode);
 195
 196         rc = cache_fsfilt->fs_iocontrol(cache_inode, cache_file, cmd, arg);
 197
 198         post_smfs_inode(inode, cache_inode);
 199
 200         RETURN(rc);
 201 }
 202
 203 static int fsfilt_smfs_send_bio(int rw, struct inode *inode, void *bio)
 204 {
 205         struct inode *cache_inode;
 206         struct fsfilt_operations *cache_fsfilt;
 207
 208         ENTRY;
 209
 210         cache_fsfilt = I2FOPS(inode);
 211         if (!cache_fsfilt)
 212                 RETURN(-EINVAL);
 213
 214         cache_inode = I2CI(inode);
 215         if (!cache_inode)
 216                 RETURN(-EINVAL);
 217
 218         if (!cache_fsfilt->fs_send_bio)
 219                 RETURN(-ENOSYS);
 220
 221         return cache_fsfilt->fs_send_bio(rw, cache_inode, bio);
 222 }
 223
 224 static struct page * fsfilt_smfs_getpage(struct inode *inode, long int index)
 225 {
 226         struct  fsfilt_operations *cache_fsfilt;
 227         struct  inode *cache_inode;
 228         ENTRY;
 229         cache_fsfilt = I2FOPS(inode);
 230         if (!cache_fsfilt)
 231                 RETURN(ERR_PTR(-EINVAL));
 232
 233         cache_inode = I2CI(inode);
 234         if (!cache_inode)
 235                 RETURN(ERR_PTR(-EINVAL));
 236
 237         if (!cache_fsfilt->fs_getpage)
 238                 RETURN(ERR_PTR(-ENOSYS));
 239 #if CONFIG_SNAPFS
 240         if (SMFS_DO_COW(S2SMI(inode->i_sb))) {
 241                 struct address_space_operations *aops =
 242                                 cache_inode->i_mapping->a_ops;
 243                 if (aops->bmap(cache_inode->i_mapping, index)) {
 244                         struct inode *ind_inode = NULL;
 245                         struct inode *cache_ind = NULL;
 246                         struct page  *page = NULL;
 247
 248                         ind_inode = smfs_cow_get_ind(inode, index);
 249                         if (!ind_inode) {
 250                                 RETURN(ERR_PTR(-EIO));
 251                         }
 252                         cache_ind = I2CI(ind_inode);
 253                         /*FIXME cow inode should be bottom fs inode */
 254                         page = cache_fsfilt->fs_getpage(cache_ind, index);
 255                         iput(ind_inode);
 256                         RETURN(page);
 257                 }
 258         }
 259 #endif
 260         return cache_fsfilt->fs_getpage(cache_inode, index);
 261 }
 262
 263 static ssize_t fsfilt_smfs_readpage(struct file *file, char *buf,
 264                                     size_t count, loff_t *off)
 265 {
 266         struct fsfilt_operations *cache_fsfilt;
 267         struct smfs_file_info *sfi;
 268         struct inode *cache_inode;
 269         loff_t tmp_ppos;
 270         loff_t *cache_ppos;
 271         ssize_t rc = -EIO;
 272         struct hook_msg msg = {
 273                 .dentry = file->f_dentry,
 274         };
 275
 276         ENTRY;
 277
 278         cache_fsfilt = I2FOPS(file->f_dentry->d_inode);
 279         if (!cache_fsfilt)
 280                 RETURN(rc);
 281
 282         cache_inode = I2CI(file->f_dentry->d_inode);
 283         if (!cache_inode)
 284                 RETURN(rc);
 285
 286         sfi = F2SMFI(file);
 287         if (sfi->magic != SMFS_FILE_MAGIC)
 288                 BUG();
 289
 290         if (off != &(file->f_pos))
 291                 cache_ppos = &tmp_ppos;
 292         else
 293                 cache_ppos = &sfi->c_file->f_pos;
 294         *cache_ppos = *off;
 295
 296         pre_smfs_inode(file->f_dentry->d_inode, cache_inode);
 297         SMFS_PRE_HOOK(file->f_dentry->d_inode, HOOK_READDIR, &msg);
 298
 299 #if CONFIG_SNAPFS
 300         /*readdir page*/
 301         if (smfs_dotsnap_inode(file->f_dentry->d_inode)) {
 302                 struct fsfilt_operations *snapops =
 303                                         I2SNAPOPS(file->f_dentry->d_inode);
 304
 305                 LASSERT(S_ISDIR(file->f_dentry->d_inode->i_mode));
 306
 307                 rc = snapops->fs_read_dotsnap_dir_page(sfi->c_file, buf, count,
 308                                                        cache_ppos);
 309         } else {
 310                 if (cache_fsfilt->fs_readpage)
 311                         rc = cache_fsfilt->fs_readpage(sfi->c_file, buf, count,
 312                                                        cache_ppos);
 313         }
 314 #else
 315         if (cache_fsfilt->fs_readpage)
 316                 rc = cache_fsfilt->fs_readpage(sfi->c_file, buf, count,
 317                                                cache_ppos);
 318
 319 #endif
 320         SMFS_POST_HOOK(file->f_dentry->d_inode, HOOK_READDIR, &msg, rc);
 321         *off = *cache_ppos;
 322         post_smfs_inode(file->f_dentry->d_inode, cache_inode);
 323         duplicate_file(file, sfi->c_file);
 324
 325         RETURN(rc);
 326 }
 327
 328
 329 static int fsfilt_smfs_add_journal_cb(struct obd_device *obd,
 330                                       struct super_block *sb, __u64 last_rcvd,
 331                                       void *handle, fsfilt_cb_t cb_func,
 332                                       void *cb_data)
 333 {
 334         struct fsfilt_operations *cache_fsfilt = S2SMI(sb)->sm_cache_fsfilt;
 335         struct super_block *csb = S2CSB(sb);
 336         int rc = -EIO;
 337
 338         ENTRY;
 339
 340         if (!cache_fsfilt)
 341                  RETURN(rc);
 342         if (cache_fsfilt->fs_add_journal_cb)
 343                 rc = cache_fsfilt->fs_add_journal_cb(obd, csb, last_rcvd,
 344                                                      handle, cb_func, cb_data);
 345         RETURN(rc);
 346 }
 347
 348 static int fsfilt_smfs_statfs(struct super_block *sb, struct obd_statfs *osfs)
 349 {
 350         struct fsfilt_operations *cache_fsfilt = S2SMI(sb)->sm_cache_fsfilt;
 351         struct super_block *csb = S2CSB(sb);
 352         int rc = -EIO;
 353
 354         ENTRY;
 355
 356         if (!cache_fsfilt)
 357                 RETURN(rc);
 358
 359         if (!cache_fsfilt->fs_statfs)
 360                 RETURN(-ENOSYS);
 361
 362         rc = cache_fsfilt->fs_statfs(csb, osfs);
 363         duplicate_sb(csb, sb);
 364
 365         RETURN(rc);
 366 }
 367
 368 static int fsfilt_smfs_sync(struct super_block *sb)
 369 {
 370         struct fsfilt_operations *cache_fsfilt = S2SMI(sb)->sm_cache_fsfilt;
 371         struct super_block *csb = S2CSB(sb);
 372         int    rc = -ENOSYS;
 373
 374         if (!cache_fsfilt)
 375                 RETURN(-EINVAL);
 376
 377         if (cache_fsfilt->fs_sync)
 378                 rc = cache_fsfilt->fs_sync(csb);
 379
 380         RETURN(rc);
 381 }
 382
 383 int fsfilt_smfs_map_inode_pages(struct inode *inode, struct page **page,
 384                                 int pages, unsigned long *blocks, int *created,
 385                                 int create, struct semaphore *sem)
 386 {
 387         struct  fsfilt_operations *cache_fsfilt = I2FOPS(inode);
 388         struct  inode *cache_inode = NULL;
 389         int     rc = -EIO;
 390         /*
 391         struct hook_rw_msg  msg = {
 392                 .write = create,
 393         };
 394         */
 395         ENTRY;
 396
 397         if (!cache_fsfilt)
 398                 RETURN(-EINVAL);
 399
 400         cache_inode = I2CI(inode);
 401
 402         if (!cache_inode)
 403                 RETURN(rc);
 404
 405         if (!cache_fsfilt->fs_map_inode_pages)
 406                 RETURN(-ENOSYS);
 407
 408         down(&cache_inode->i_sem);
 409         //SMFS_PRE_HOOK(inode, HOOK_MAP_PAGES, &msg);
 410
 411         rc = cache_fsfilt->fs_map_inode_pages(cache_inode, page, pages, blocks,
 412                                               created, create, sem);
 413
 414         up(&cache_inode->i_sem);
 415
 416         RETURN(rc);
 417 }
 418
 419 static int fsfilt_smfs_prep_san_write(struct inode *inode, long *blocks,
 420                                       int nblocks, loff_t newsize)
 421 {
 422         struct  fsfilt_operations *cache_fsfilt = I2FOPS(inode);
 423         struct  inode *cache_inode = NULL;
 424         int     rc = -EIO;
 425
 426         if (!cache_fsfilt)
 427                 RETURN(-EINVAL);
 428
 429         cache_inode = I2CI(inode);
 430
 431         if (!cache_inode)
 432                 RETURN(-EINVAL);
 433
 434         if (!cache_fsfilt->fs_prep_san_write)
 435                 RETURN(-ENOSYS);
 436
 437         down(&cache_inode->i_sem);
 438         rc = cache_fsfilt->fs_prep_san_write(cache_inode, blocks, nblocks,
 439                                              newsize);
 440         up(&cache_inode->i_sem);
 441
 442         RETURN(rc);
 443 }
 444
 445 static int fsfilt_smfs_read_record(struct file * file, void *buf,
 446                                    int size, loff_t *offs)
 447 {
 448         struct  fsfilt_operations *cache_fsfilt;
 449         struct  inode *cache_inode;
 450         struct  smfs_file_info *sfi;
 451         loff_t  tmp_ppos;
 452         loff_t  *cache_ppos;
 453         ssize_t rc;
 454
 455         ENTRY;
 456         cache_fsfilt = I2FOPS(file->f_dentry->d_inode);
 457         if (!cache_fsfilt)
 458                 RETURN(-EINVAL);
 459
 460         cache_inode = I2CI(file->f_dentry->d_inode);
 461
 462         if (!cache_inode)
 463                 RETURN(-EINVAL);
 464
 465         sfi = F2SMFI(file);
 466         if (sfi->magic != SMFS_FILE_MAGIC) BUG();
 467
 468         if (offs != &(file->f_pos))
 469                 cache_ppos = &tmp_ppos;
 470         else
 471                 cache_ppos = &sfi->c_file->f_pos;
 472         *cache_ppos = *offs;
 473
 474         pre_smfs_inode(file->f_dentry->d_inode, cache_inode);
 475
 476         if (!cache_fsfilt->fs_read_record)
 477                 RETURN(-ENOSYS);
 478
 479         rc = cache_fsfilt->fs_read_record(sfi->c_file, buf, size, cache_ppos);
 480
 481         *offs = *cache_ppos;
 482         post_smfs_inode(file->f_dentry->d_inode, cache_inode);
 483         duplicate_file(file, sfi->c_file);
 484
 485         RETURN(rc);
 486 }
 487
 488 static int fsfilt_smfs_write_record(struct file *file, void *buf, int bufsize,
 489                                     loff_t *offs, int force_sync)
 490 {
 491         struct  fsfilt_operations *cache_fsfilt;
 492         struct  inode *cache_inode;
 493         struct  smfs_file_info *sfi;
 494         loff_t  tmp_ppos;
 495         loff_t  *cache_ppos;
 496         ssize_t rc = -EIO;
 497
 498         ENTRY;
 499
 500         cache_fsfilt = I2FOPS(file->f_dentry->d_inode);
 501         if (!cache_fsfilt)
 502                 RETURN(-EINVAL);
 503
 504         cache_inode = I2CI(file->f_dentry->d_inode);
 505
 506         if (!cache_inode)
 507                 RETURN(-EINVAL);
 508
 509         sfi = F2SMFI(file);
 510         if (sfi->magic != SMFS_FILE_MAGIC)
 511                 BUG();
 512
 513         if (offs != &(file->f_pos))
 514                 cache_ppos = &tmp_ppos;
 515         else
 516                 cache_ppos = &sfi->c_file->f_pos;
 517         *cache_ppos = *offs;
 518
 519         pre_smfs_inode(file->f_dentry->d_inode, cache_inode);
 520
 521         if (!cache_fsfilt->fs_write_record)
 522                 RETURN(-ENOSYS);
 523
 524         rc = cache_fsfilt->fs_write_record(sfi->c_file, buf,
 525                                            bufsize, cache_ppos, force_sync);
 526         *offs = *cache_ppos;
 527         post_smfs_inode(file->f_dentry->d_inode, cache_inode);
 528         duplicate_file(file, sfi->c_file);
 529
 530         RETURN(rc);
 531 }
 532
 533 static int fsfilt_smfs_post_setup(struct obd_device *obd, struct vfsmount *mnt,
 534                                   struct dentry *root_dentry)//, void *data)
 535 {
 536         struct super_block *sb = NULL;
 537         int rc = 0;
 538
 539         ENTRY;
 540
 541         if (mnt) {
 542                 sb = mnt->mnt_sb;
 543
 544                 LASSERT(obd);
 545                 S2SMI(sb)->smsi_exp = obd->obd_self_export;
 546
 547                 rc = smfs_post_setup(obd, mnt, root_dentry);//, data);
 548                 if (rc) {
 549                         CERROR("post_setup fails in obd %p rc=%d", obd, rc);
 550                 }
 551         }
 552
 553         RETURN(rc);
 554 }
 555
 556 static int fsfilt_smfs_post_cleanup(struct obd_device *obd,
 557                                     struct vfsmount *mnt)
 558 {
 559         struct super_block *sb = NULL;
 560         int rc = 0;
 561         ENTRY;
 562
 563         if (mnt) {
 564                 sb = mnt->mnt_sb;
 565                 smfs_post_cleanup(sb);
 566         }
 567
 568         RETURN(rc);
 569 }
 570
 571 static int fsfilt_smfs_set_fs_flags(struct inode *inode, int flags)
 572 {
 573         int rc = 0;
 574         ENTRY;
 575
 576         if (flags & SM_ALL_PLG) /* enable all plugins */
 577                 SMFS_SET(I2SMI(inode)->smi_flags, SMFS_PLG_ALL);
 578 #if 0
 579         if (SMFS_DO_COW(S2SMI(inode->i_sb)) && (flags & SM_DO_COW))
 580                 SMFS_SET_INODE_COW(inode);
 581 #endif
 582         RETURN(rc);
 583 }
 584
 585 static int fsfilt_smfs_clear_fs_flags(struct inode *inode, int flags)
 586 {
 587         int rc = 0;
 588         ENTRY;
 589         /*
 590         if (SMFS_DO_REC(S2SMI(inode->i_sb)) && (flags & SM_DO_REC))
 591                 SMFS_CLEAN_INODE_REC(inode);
 592         if (SMFS_DO_COW(S2SMI(inode->i_sb)) && (flags & SM_DO_COW))
 593                 SMFS_CLEAN_INODE_COW(inode);
 594         */
 595         if(flags & SM_ALL_PLG) /* disable all plugins */
 596                 SMFS_CLEAR(I2SMI(inode)->smi_flags, SMFS_PLG_ALL);
 597         RETURN(rc);
 598 }
 599
 600 static int fsfilt_smfs_get_fs_flags(struct dentry *de)
 601 {
 602         struct inode *inode = de->d_inode;
 603         int flags = 0;
 604         ENTRY;
 605
 606         LASSERT(inode);
 607
 608         flags = I2SMI(inode)->smi_flags & S2SMI(inode->i_sb)->plg_flags;
 609
 610         RETURN(flags);
 611 }
 612
 613 static int fsfilt_smfs_set_ost_flags(struct super_block *sb)
 614 {
 615         return 0;
 616 }
 617
 618 static int fsfilt_smfs_set_mds_flags(struct super_block *sb)
 619 {
 620         return 0;
 621 }
 622
 623 #if 0
 624 static int fsfilt_smfs_get_reint_log_ctxt(struct super_block *sb,
 625                                           struct llog_ctxt **ctxt)
 626 {
 627         struct smfs_super_info *smfs_info = S2SMI(sb);
 628         int rc = 0;
 629
 630         *ctxt = smfs_info->smsi_kml_log;
 631         RETURN(rc);
 632 }
 633 #endif
 634
 635 static int fsfilt_smfs_setup(struct obd_device *obd, struct super_block *sb)
 636 {
 637         struct smfs_super_info *smfs_info = S2SMI(sb);
 638         struct fsfilt_operations *cache_fsfilt;
 639         struct super_block *csb;
 640         int rc = 0;
 641
 642         ENTRY;
 643
 644         /* It should be initialized olready by smfs_read_super(). */
 645         if (!(cache_fsfilt = smfs_info->sm_cache_fsfilt))
 646                     cache_fsfilt = fsfilt_get_ops(smfs_info->smsi_cache_ftype);
 647
 648         if (!cache_fsfilt)
 649                 RETURN(-ENOENT);
 650
 651         csb = S2CSB(sb);
 652         if (cache_fsfilt->fs_setup)
 653                 rc = cache_fsfilt->fs_setup(obd, csb);
 654
 655         duplicate_sb(sb, csb);
 656
 657         RETURN(rc);
 658 }
 659
 660 static int fsfilt_smfs_setattr(struct dentry *dentry, void *handle,
 661                                struct iattr *iattr, int do_trunc)
 662 {
 663         struct fsfilt_operations *cache_fsfilt = I2FOPS(dentry->d_inode);
 664         struct dentry *cache_dentry = NULL;
 665         struct inode *cache_inode = I2CI(dentry->d_inode);
 666         struct smfs_super_info *sbi = S2SMI(dentry->d_inode->i_sb);
 667         struct hook_attr_msg msg = {
 668                 .dentry = dentry,
 669                 .attr = iattr
 670         };
 671         int    rc = -EIO;
 672
 673         if (!cache_fsfilt)
 674                 RETURN(rc);
 675
 676         if (!cache_fsfilt->fs_setattr)
 677                 RETURN(-ENOSYS);
 678
 679         cache_dentry = pre_smfs_dentry(NULL, cache_inode, dentry);
 680         if (!cache_dentry)
 681                 RETURN(-ENOMEM);
 682
 683         pre_smfs_inode(dentry->d_inode, cache_inode);
 684
 685         SMFS_PRE_HOOK(dentry->d_inode, HOOK_F_SETATTR, &msg);
 686
 687         if (SMFS_DO_HND_IBLOCKS(sbi)) {
 688                 /* size-on-mds changes i_blocks directly to reflect
 689                  * aggregated i_blocks from all OSTs -bzzz */
 690                 cache_inode->i_blocks = dentry->d_inode->i_blocks;
 691         }
 692
 693         rc = cache_fsfilt->fs_setattr(cache_dentry, handle, iattr, do_trunc);
 694
 695         SMFS_POST_HOOK(dentry->d_inode, HOOK_F_SETATTR, &msg, rc);
 696         post_smfs_inode(dentry->d_inode, cache_inode);
 697
 698         post_smfs_dentry(cache_dentry);
 699         RETURN(rc);
 700 }
 701
 702 static int fsfilt_smfs_set_xattr(struct inode *inode, void *handle, char *name,
 703                                  void *buffer, int buffer_size)
 704 {
 705         struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
 706         struct inode *cache_inode = NULL;
 707         struct hook_xattr_msg msg = {
 708                 .name = name,
 709                 .buffer = buffer,
 710                 .buffer_size = buffer_size
 711         };
 712         int    rc = -EIO;
 713         int    lov = 0;
 714
 715         ENTRY;
 716
 717         if (!cache_fsfilt)
 718                 RETURN(-EIO);
 719
 720         cache_inode = I2CI(inode);
 721         if (!cache_inode)
 722                 RETURN(rc);
 723
 724         lov = (!strcmp(name, XATTR_LUSTRE_MDS_LOV_EA));
 725         pre_smfs_inode(inode, cache_inode);
 726         SMFS_PRE_HOOK(inode, HOOK_F_SETXATTR, &msg);
 727         if (cache_fsfilt->fs_set_xattr)
 728                 rc = cache_fsfilt->fs_set_xattr(cache_inode, handle, name,
 729                                                 buffer, buffer_size);
 730
 731         SMFS_POST_HOOK(inode, HOOK_F_SETXATTR, &msg, rc);
 732         post_smfs_inode(inode, cache_inode);
 733
 734         RETURN(rc);
 735 }
 736
 737 static int fsfilt_smfs_get_xattr(struct inode *inode, char *name,
 738                                  void *buffer, int buffer_size)
 739 {
 740         struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
 741         struct inode *cache_inode = NULL;
 742         int    rc = -EIO;
 743
 744         if (!cache_fsfilt)
 745                 RETURN(rc);
 746
 747         cache_inode = I2CI(inode);
 748         if (!cache_inode)
 749                 RETURN(rc);
 750
 751         pre_smfs_inode(inode, cache_inode);
 752         if (cache_fsfilt->fs_get_xattr)
 753                 rc = cache_fsfilt->fs_get_xattr(cache_inode, name,
 754                                                 buffer, buffer_size);
 755         post_smfs_inode(inode, cache_inode);
 756         RETURN(rc);
 757 }
 758
 759 static int fsfilt_smfs_set_md(struct inode *inode, void *handle,
 760                               void *lmm, int lmm_size, enum ea_type type)
 761 {
 762         int rc;
 763
 764         switch(type) {
 765         case EA_LOV:
 766                 rc = fsfilt_smfs_set_xattr(inode, handle,
 767                                            XATTR_LUSTRE_MDS_LOV_EA,
 768                                            lmm, lmm_size);
 769                 break;
 770         case EA_MEA:
 771                 rc = fsfilt_smfs_set_xattr(inode, handle,
 772                                            XATTR_LUSTRE_MDS_MEA_EA,
 773                                            lmm, lmm_size);
 774                 break;
 775         case EA_SID:
 776                 rc = fsfilt_smfs_set_xattr(inode, handle,
 777                                            XATTR_LUSTRE_MDS_SID_EA,
 778                                            lmm, lmm_size);
 779                 break;
 780         case EA_PID:
 781                 rc = fsfilt_smfs_set_xattr(inode, handle,
 782                                            XATTR_LUSTRE_MDS_PID_EA,
 783                                            lmm, lmm_size);
 784                 break;
 785         case EA_KEY:
 786                 rc = fsfilt_smfs_set_xattr(inode, handle,
 787                                            XATTR_LUSTRE_MDS_KEY_EA,
 788                                            lmm, lmm_size);
 789                 break;
 790         default:
 791                 rc = -EINVAL;
 792         }
 793
 794         return rc;
 795 }
 796
 797 static int fsfilt_smfs_get_md(struct inode *inode, void *lmm,
 798                               int lmm_size, enum ea_type type)
 799 {
 800         int rc;
 801
 802         switch (type) {
 803         case EA_LOV:
 804                 rc = fsfilt_smfs_get_xattr(inode,
 805                                            XATTR_LUSTRE_MDS_LOV_EA,
 806                                            lmm, lmm_size);
 807                 break;
 808         case EA_MEA:
 809                 rc = fsfilt_smfs_get_xattr(inode,
 810                                            XATTR_LUSTRE_MDS_MEA_EA,
 811                                            lmm, lmm_size);
 812                 break;
 813         case EA_SID:
 814                 rc = fsfilt_smfs_get_xattr(inode,
 815                                            XATTR_LUSTRE_MDS_SID_EA,
 816                                            lmm, lmm_size);
 817                 break;
 818         case EA_PID:
 819                 rc = fsfilt_smfs_get_xattr(inode,
 820                                            XATTR_LUSTRE_MDS_PID_EA,
 821                                            lmm, lmm_size);
 822                 break;
 823         case EA_KEY:
 824                 rc = fsfilt_smfs_get_xattr(inode,
 825                                            XATTR_LUSTRE_MDS_KEY_EA,
 826                                            lmm, lmm_size);
 827                 break;
 828         default:
 829                 rc = -EINVAL;
 830         }
 831
 832         return rc;
 833 }
 834
 835 static int fsfilt_smfs_insert_extents_ea(struct inode *inode,
 836                                          unsigned long from, unsigned long num)
 837 {
 838         struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
 839         struct inode *cache_inode = NULL;
 840         int    rc = -EIO;
 841
 842         if (!cache_fsfilt)
 843                 RETURN(rc);
 844
 845         cache_inode = I2CI(inode);
 846         if (!cache_inode)
 847                 RETURN(rc);
 848
 849         pre_smfs_inode(inode, cache_inode);
 850
 851         if (cache_fsfilt->fs_insert_extents_ea)
 852                 rc = cache_fsfilt->fs_insert_extents_ea(cache_inode, from, num);
 853
 854         post_smfs_inode(inode, cache_inode);
 855         return rc;
 856 }
 857
 858 static int fsfilt_smfs_remove_extents_ea(struct inode *inode,
 859                                          unsigned long from, unsigned long num)
 860 {
 861         struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
 862         struct inode *cache_inode = NULL;
 863         int    rc = -EIO;
 864
 865         if (!cache_fsfilt)
 866                 RETURN(rc);
 867
 868         cache_inode = I2CI(inode);
 869         if (!cache_inode)
 870                 RETURN(rc);
 871
 872         pre_smfs_inode(inode, cache_inode);
 873
 874         if (cache_fsfilt->fs_remove_extents_ea)
 875                 rc = cache_fsfilt->fs_remove_extents_ea(cache_inode, from, num);
 876
 877         post_smfs_inode(inode, cache_inode);
 878         return rc;
 879 }
 880
 881 static int fsfilt_smfs_init_extents_ea(struct inode *inode)
 882 {
 883         struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
 884         struct inode *cache_inode = NULL;
 885         int    rc = -EIO;
 886         ENTRY;
 887
 888         if (!cache_fsfilt)
 889                 RETURN(rc);
 890
 891         cache_inode = I2CI(inode);
 892         if (!cache_inode)
 893                 RETURN(rc);
 894
 895         pre_smfs_inode(inode, cache_inode);
 896
 897         if (cache_fsfilt->fs_init_extents_ea)
 898                 rc = cache_fsfilt->fs_init_extents_ea(cache_inode);
 899
 900         post_smfs_inode(inode, cache_inode);
 901         return rc;
 902 }
 903
 904 static int fsfilt_smfs_free_extents(struct super_block *sb, ino_t ino,
 905                                     char *pbuf, int size)
 906 {
 907         OBD_FREE(pbuf, size * (sizeof(struct ldlm_extent)));
 908         return 0;
 909 }
 910
 911 static int fsfilt_smfs_write_extents(struct dentry *dentry,
 912                                      unsigned long from, unsigned long num)
 913 {
 914         /* TODO: fix this later */
 915 #if 0
 916         int rc = 0;
 917         struct inode * cache_inode = I2CI(dentry->d_inode);
 918         struct hook_write_msg msg = {
 919                 .dentry = dentry,
 920                 .count = num,
 921                 .pos = from
 922         };
 923
 924         ENTRY;
 925
 926         pre_smfs_inode(dentry->d_inode, cache_inode);
 927
 928         SMFS_PRE_HOOK(dentry->d_inode, HOOK_WRITE, &msg);
 929
 930         rc = smfs_write_extents(dentry->d_inode, dentry, from, num);
 931         SMFS_POST_HOOK(dentry->d_inode, HOOK_WRITE, &msg, rc);
 932         post_smfs_inode(dentry->d_inode, cache_inode);
 933
 934         RETURN(rc);
 935 #endif
 936         ENTRY;
 937         RETURN(0);
 938 }
 939
 940 static int fsfilt_smfs_precreate_rec(struct dentry *dentry, int *count,
 941                                      struct obdo *oa)
 942 {
 943         int rc = 0;
 944         /* Why to log precreate?? MDS will do this in any case
 945         if (SMFS_DO_REC(S2SMI(dentry->d_inode->i_sb)))
 946                 rc = smfs_rec_precreate(dentry, count, oa);
 947         */
 948         return rc;
 949 }
 950
 951 // should be rewrote when needed
 952 static int fsfilt_smfs_get_ino_write_extents(struct super_block *sb, ino_t ino,
 953                                              char **pbuf, int *size)
 954 {
 955         int rc = 0;
 956 #if 0
 957         struct fs_extent *fs_extents;
 958         struct ldlm_extent *extents = NULL;
 959         struct inode *inode;
 960         struct inode *cache_inode;
 961         struct fsfilt_operations *cache_fsfilt = NULL;
 962         struct lvfs_run_ctxt saved;
 963         int    fs_ex_size, ex_num, flags;
 964         char   *buf = NULL, *ex_buf = NULL;
 965         ENTRY;
 966
 967         push_ctxt(&saved, S2SMI(sb)->smsi_ctxt, NULL);
 968
 969         inode = iget(sb, ino);
 970
 971         if (!inode || is_bad_inode(inode)) {
 972                 CWARN("Can not get inode %lu ino\n", ino);
 973                 GOTO(out, rc = 0);
 974         }
 975         cache_inode = I2CI(inode);
 976         cache_fsfilt = I2FOPS(inode);
 977
 978         rc = cache_fsfilt->fs_get_xattr(cache_inode, REINT_EXTENTS_FLAGS,
 979                                         &flags, sizeof(int));
 980         if (!(flags & SMFS_OVER_WRITE) && !(flags & SMFS_DIRTY_WRITE)) {
 981                 GOTO(out, rc = 0);
 982         } else if (flags & SMFS_OVER_WRITE) {
 983                 *size = 1;
 984                 OBD_ALLOC(ex_buf, sizeof(struct ldlm_extent));
 985                 if (!ex_buf)
 986                         GOTO(out, rc=-ENOMEM);
 987                 extents = (struct ldlm_extent*)(ex_buf);
 988                 extents->start = 0;
 989                 extents->end = 0xffffffff;
 990         }
 991         if (rc < 0)
 992                 GOTO(out, rc);
 993         rc = cache_fsfilt->fs_get_write_extents_num(cache_inode, &fs_ex_size);
 994         if (rc)
 995                 GOTO(out, rc);
 996         OBD_ALLOC(buf, fs_ex_size);
 997         if (!buf)
 998                 GOTO(out, rc=-ENOMEM);
 999
1000         rc = cache_fsfilt->fs_get_inode_write_extents(cache_inode, &buf,
1001                                                       &fs_ex_size);
1002         if (rc < 0)
1003                 GOTO(out, rc);
1004         rc = 0;
1005         ex_num = fs_ex_size / sizeof(struct fs_extent);
1006         *size =  ex_num;
1007         OBD_ALLOC(ex_buf, ex_num* sizeof(struct ldlm_extent));
1008         if (!ex_buf)
1009                 GOTO(out, rc=-ENOMEM);
1010
1011         fs_extents = (struct fs_extent*)(buf);
1012         extents = (struct ldlm_extent*)(ex_buf);
1013         while (ex_num > 0) {
1014                 int blk_size = I2CI(inode)->i_blksize;
1015
1016                 extents->start = fs_extents->e_block * blk_size;
1017                 extents->end = extents->start + fs_extents->e_num * blk_size;
1018                 fs_extents++;
1019                 extents++;
1020                 ex_num--;
1021         }
1022         *pbuf = ex_buf;
1023 out:
1024         iput(inode);
1025         if (buf)
1026                 OBD_FREE(buf, fs_ex_size);
1027         if (rc && extents)
1028                 OBD_FREE(ex_buf, (*size) * (sizeof(struct ldlm_extent)));
1029         pop_ctxt(&saved, S2SMI(sb)->smsi_ctxt, NULL);
1030 #endif
1031         return rc;
1032 }
1033
1034 static int fsfilt_smfs_set_snap_item(struct super_block *sb, char *name)
1035 {
1036         int rc = 0;
1037
1038         ENTRY;
1039 #if CONFIG_SNAPFS
1040 #warning "still not implement for add snap item -wangdi"
1041 #endif
1042         RETURN(rc);
1043 }
1044 static int fsfilt_smfs_do_write_cow(struct dentry *de, void *extents,
1045                                     int num_extents)
1046 {
1047         int rc = 0;
1048 #if CONFIG_SNAPFS
1049         struct write_extents *w_ext = (struct write_extents *)extents;
1050         int i = 0;
1051         ENTRY;
1052         for (i = 0; i < num_extents; i++) {
1053                size_t count = w_ext->w_count;
1054                loff_t off = w_ext->w_pos;
1055                rc = smfs_cow_write_pre(de->d_inode, de, &count, &off);
1056                if (rc)
1057                         RETURN(rc);
1058                w_ext ++;
1059         }
1060 #endif
1061         RETURN(rc);
1062 }
1063
1064 static int fsfilt_smfs_add_dir_entry(struct obd_device * obd,
1065                                      struct dentry * parent, char* name,
1066                                      int namelen, unsigned long ino,
1067                                      unsigned long generation,
1068                                      unsigned long mds,
1069                                      unsigned long fid)
1070 {
1071         struct fsfilt_operations *cache_fsfilt = I2FOPS(parent->d_inode);
1072         struct dentry *cache_dentry = NULL, *dentry = NULL;
1073         struct inode *cache_parent = I2CI(parent->d_inode);
1074         int    rc = -EIO;
1075
1076         ENTRY;
1077
1078         if (!cache_fsfilt)
1079                 RETURN(rc);
1080
1081         if (!cache_fsfilt->fs_add_dir_entry)
1082                 RETURN(-ENOSYS);
1083
1084         dentry = ll_lookup_one_len(name, parent, namelen);
1085         if (IS_ERR(dentry)) {
1086                 CERROR("can't lookup %*s in %lu/%lu: %d\n", namelen,
1087                        name, parent->d_inode->i_ino,
1088                        (unsigned long) parent->d_inode->i_generation,
1089                        (int) PTR_ERR(dentry));
1090                 RETURN(PTR_ERR(dentry));
1091         }
1092         if (dentry->d_inode != NULL || dentry->d_flags & DCACHE_CROSS_REF) {
1093                 CERROR("dentry %*s(0x%p) found\n", dentry->d_name.len,
1094                        dentry->d_name.name, dentry);
1095                 l_dput(dentry);
1096                 RETURN(-EEXIST);
1097         }
1098         /* mds_reint_rename() may use this method to add dir entry
1099          * that points onto local inode. and we don't want to find
1100          * it cross-ref by subsequent lookups */
1101         d_drop(dentry);
1102
1103         dentry->d_flags |= DCACHE_CROSS_REF;
1104         dentry->d_inum = ino;
1105         dentry->d_mdsnum = mds;
1106         dentry->d_generation = generation;
1107         dentry->d_fid = fid;
1108         l_dput(dentry);
1109
1110         cache_dentry = pre_smfs_dentry(NULL, cache_parent, parent);
1111         if (!cache_dentry) {
1112                 RETURN(-ENOMEM);
1113         }
1114
1115         pre_smfs_inode(parent->d_inode, cache_parent);
1116
1117         rc = cache_fsfilt->fs_add_dir_entry(obd, cache_dentry, name, namelen,
1118                                             ino, generation, mds, fid);
1119
1120         post_smfs_inode(parent->d_inode, cache_parent);
1121
1122         post_smfs_dentry(cache_dentry);
1123
1124         RETURN(rc);
1125
1126 }
1127
1128 static int fsfilt_smfs_del_dir_entry(struct obd_device * obd,
1129                                      struct dentry * dentry)
1130 {
1131         struct fsfilt_operations *cache_fsfilt = I2FOPS(dentry->d_parent->d_inode);
1132         struct dentry *cache_dentry = NULL, *cache_parent = NULL;
1133         struct inode * cache_dir = I2CI(dentry->d_parent->d_inode);
1134         struct inode * cache_inode = NULL;
1135         int    rc = -EIO;
1136
1137         ENTRY;
1138
1139         if (!cache_fsfilt)
1140                 RETURN(rc);
1141
1142         if (!cache_fsfilt->fs_del_dir_entry)
1143                 RETURN(-ENOSYS);
1144
1145         if (dentry->d_inode)
1146                 cache_inode = I2CI(dentry->d_inode);
1147
1148         cache_parent = pre_smfs_dentry(NULL, cache_dir, dentry->d_parent);
1149         cache_dentry = pre_smfs_dentry(cache_parent, cache_inode, dentry);
1150         if (!cache_parent || !cache_dentry) {
1151                 rc = (-ENOMEM);
1152                 goto exit;
1153         }
1154
1155         pre_smfs_inode(dentry->d_parent->d_inode, cache_dir);
1156         pre_smfs_inode(dentry->d_inode, cache_inode);
1157
1158         rc = cache_fsfilt->fs_del_dir_entry(obd, cache_dentry);
1159
1160         if (!rc) {
1161                 d_drop(dentry);
1162                 if (cache_inode) {
1163                         post_smfs_inode(dentry->d_inode, cache_inode);
1164                         if (S_ISDIR(dentry->d_inode->i_mode))
1165                                 dentry->d_parent->d_inode->i_nlink--;
1166                 }
1167                 post_smfs_inode(dentry->d_parent->d_inode, cache_dir);
1168         }
1169 exit:
1170         post_smfs_dentry(cache_dentry);
1171         post_smfs_dentry(cache_parent);
1172         RETURN(rc);
1173
1174 }
1175
1176 static int fsfilt_smfs_set_info (struct super_block *sb, struct inode * inode,
1177                                  __u32 keylen, void *key,
1178                                  __u32 valsize, void *val)
1179 {
1180         int rc = 0;
1181         struct plg_info_msg msg = {
1182                 .key = key,
1183                 .val = val,
1184         };
1185         ENTRY;
1186
1187         if (keylen >= 9 && memcmp(key, "file_read", 9) == 0) {
1188                 /*
1189                  * this key used to inform smfs on OST about incoming r/w
1190                  */
1191                 struct lustre_id * id = val;
1192                 struct hook_rw_msg msg = {
1193                         .write = 0,
1194                         .id = id,
1195                 };
1196                 if (inode)
1197                         SMFS_POST_HOOK(inode, HOOK_SI_READ, &msg, rc);
1198         }
1199         else if (keylen >= 10 && memcmp(key, "file_write", 10) == 0) {
1200                 /*
1201                  * this key used to inform smfs on OST about incoming r/w
1202                  */
1203                 struct lustre_id * id = val;
1204                 struct hook_rw_msg msg = {
1205                         .write = 1,
1206                         .id = id,
1207                 };
1208                 if (inode)
1209                         SMFS_POST_HOOK(inode, HOOK_SI_WRITE, &msg, rc);
1210         }
1211         else if (keylen >= 10 && memcmp(key, "audit_info", 10) == 0) {
1212                 /* this key used to pass audit data on MDS */
1213                 struct audit_info * info = val;
1214
1215                 SMFS_POST_HOOK(inode, HOOK_SPECIAL, info, info->m.result);
1216         }
1217         else if (keylen >= 8 && memcmp(key, "auditlog", 8) == 0) {
1218                 /*
1219                  * this key used to inform smfs on OST about client audit data
1220                  */
1221
1222                 audit_client_log(sb, val);
1223         }
1224         else if (keylen == 5 && memcmp(key, "audit", 5) == 0) {
1225                 smfs_set_audit(sb, inode, (__u64 *)val);
1226         }
1227         else if (keylen == 7 && memcmp(key, "id2name", 7) == 0) {
1228                 rc = SMFS_PLG_HELP(sb, PLG_SET_INFO, &msg);
1229         }
1230         else
1231                 rc = -ENOENT;
1232
1233         RETURN(rc);
1234 }
1235
1236 static int fsfilt_smfs_get_info (struct super_block *sb, struct inode * inode,
1237                                  __u32 keylen, void *key,
1238                                  __u32 *valsize, void *val)
1239 {
1240         int rc = -ENOENT;
1241
1242         ENTRY;
1243
1244         if (keylen == 5 && strcmp(key, "audit") == 0) {
1245                 __u64 * mask = val;
1246                 rc = smfs_get_audit(sb, inode, NULL, mask);
1247         }
1248
1249         RETURN(rc);
1250 }
1251
1252 static struct fsfilt_operations fsfilt_smfs_ops = {
1253         .fs_type                = "smfs",
1254         .fs_owner               = THIS_MODULE,
1255         .fs_start               = fsfilt_smfs_start,
1256         .fs_brw_start           = fsfilt_smfs_brw_start,
1257         .fs_commit              = fsfilt_smfs_commit,
1258         .fs_commit_async        = fsfilt_smfs_commit_async,
1259         .fs_commit_wait         = fsfilt_smfs_commit_wait,
1260         .fs_setattr             = fsfilt_smfs_setattr,
1261         .fs_iocontrol           = fsfilt_smfs_iocontrol,
1262         .fs_set_md              = fsfilt_smfs_set_md,
1263         .fs_get_md              = fsfilt_smfs_get_md,
1264         .fs_readpage            = fsfilt_smfs_readpage,
1265         .fs_getpage             = fsfilt_smfs_getpage,
1266         .fs_add_journal_cb      = fsfilt_smfs_add_journal_cb,
1267         .fs_statfs              = fsfilt_smfs_statfs,
1268         .fs_sync                = fsfilt_smfs_sync,
1269         .fs_map_inode_pages     = fsfilt_smfs_map_inode_pages,
1270         .fs_prep_san_write      = fsfilt_smfs_prep_san_write,
1271         .fs_write_record        = fsfilt_smfs_write_record,
1272         .fs_read_record         = fsfilt_smfs_read_record,
1273         .fs_setup               = fsfilt_smfs_setup,
1274         .fs_send_bio            = fsfilt_smfs_send_bio,
1275         .fs_set_xattr           = fsfilt_smfs_set_xattr,
1276         .fs_get_xattr           = fsfilt_smfs_get_xattr,
1277         .fs_get_op_len          = NULL,
1278         .fs_del_dir_entry       = fsfilt_smfs_del_dir_entry,
1279         .fs_add_dir_entry       = fsfilt_smfs_add_dir_entry,
1280         .fs_insert_extents_ea   = fsfilt_smfs_insert_extents_ea,
1281         .fs_remove_extents_ea   = fsfilt_smfs_remove_extents_ea,
1282         .fs_init_extents_ea     = fsfilt_smfs_init_extents_ea,
1283         .fs_get_ino_write_extents = fsfilt_smfs_get_ino_write_extents,
1284         .fs_get_write_extents_num = NULL,
1285
1286         .fs_free_write_extents  = fsfilt_smfs_free_extents,
1287         .fs_write_extents       = fsfilt_smfs_write_extents,
1288         .fs_post_setup          = fsfilt_smfs_post_setup,
1289         .fs_post_cleanup        = fsfilt_smfs_post_cleanup,
1290         .fs_set_fs_flags        = fsfilt_smfs_set_fs_flags,
1291         .fs_clear_fs_flags      = fsfilt_smfs_clear_fs_flags,
1292         .fs_get_fs_flags        = fsfilt_smfs_get_fs_flags,
1293         .fs_set_ost_flags       = fsfilt_smfs_set_ost_flags,
1294         .fs_set_mds_flags       = fsfilt_smfs_set_mds_flags,
1295         .fs_precreate_rec       = fsfilt_smfs_precreate_rec,
1296         .fs_set_info            = fsfilt_smfs_set_info,
1297         .fs_get_info            = fsfilt_smfs_get_info,
1298         .fs_set_snap_item       = fsfilt_smfs_set_snap_item,
1299         .fs_do_write_cow        = fsfilt_smfs_do_write_cow,
1300 };
1301
1302 struct fsfilt_operations *get_smfs_fs_ops(void)
1303 {
1304         return (&fsfilt_smfs_ops);
1305 }
1306 EXPORT_SYMBOL(get_smfs_fs_ops);
1307
1308