1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * lustre/lib/fsfilt_smfs.c
5 * Lustre filesystem abstraction routines
7 * Copyright (C) 2004 Cluster File Systems, Inc.
8 * Author: Wang Di <wangdi@clusterfs.com>
10 * This file is part of Lustre, http://www.lustre.org.
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.
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.
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.
26 #define DEBUG_SUBSYSTEM S_FILTER
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 <linux/kp30.h>
35 #include <linux/lustre_fsfilt.h>
36 #include <linux/lustre_smfs.h>
37 #include <linux/obd.h>
38 #include <linux/obd_class.h>
39 #include <linux/module.h>
40 #include <linux/init.h>
42 static void *fsfilt_smfs_start(struct inode *inode, int op,
43 void *desc_private, int logs)
46 struct inode *cache_inode = I2CI(inode);
47 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
49 if (cache_fsfilt == NULL)
52 SMFS_TRANS_OP(inode, op);
54 if (!cache_fsfilt->fs_start)
55 return ERR_PTR(-ENOSYS);
57 handle = cache_fsfilt->fs_start(cache_inode, op, desc_private, logs);
61 static void *fsfilt_smfs_brw_start(int objcount, struct fsfilt_objinfo *fso,
62 int niocount, struct niobuf_local *nb,
63 void *desc_private, int logs)
65 struct fsfilt_operations *cache_fsfilt;
66 struct dentry *cache_dentry = NULL;
67 struct inode *cache_inode = NULL;
68 struct fsfilt_objinfo cache_fso;
72 cache_fsfilt = I2FOPS(fso->fso_dentry->d_inode);
73 if (cache_fsfilt == NULL)
76 cache_inode = I2CI(fso->fso_dentry->d_inode);
77 cache_dentry = pre_smfs_dentry(NULL, cache_inode, fso->fso_dentry);
80 GOTO(exit, rc = ERR_PTR(-ENOMEM));
82 cache_fso.fso_dentry = cache_dentry;
83 cache_fso.fso_bufcnt = fso->fso_bufcnt;
85 if (!cache_fsfilt->fs_brw_start)
86 return ERR_PTR(-ENOSYS);
88 rc = cache_fsfilt->fs_brw_start(objcount, &cache_fso, niocount, nb,
91 post_smfs_dentry(cache_dentry);
95 /* FIXME-WANGDI: here we can easily have inode == NULL due to
96 mds_open() behavior. It passes NULL inode to mds_finish_transno()
97 sometimes. Probably we should have spare way to get cache fsfilt
99 static int fsfilt_smfs_commit(struct inode *inode, void *h, int force_sync)
101 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
102 struct inode *cache_inode = NULL;
105 cache_inode = I2CI(inode);
107 if (cache_fsfilt == NULL)
110 if (!cache_fsfilt->fs_commit)
113 rc = cache_fsfilt->fs_commit(cache_inode, h, force_sync);
118 static int fsfilt_smfs_commit_async(struct inode *inode, void *h,
121 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
122 struct inode *cache_inode = NULL;
125 cache_inode = I2CI(inode);
126 if (cache_fsfilt == NULL)
129 if (!cache_fsfilt->fs_commit_async)
132 rc = cache_fsfilt->fs_commit_async(cache_inode, h, wait_handle);
137 static int fsfilt_smfs_commit_wait(struct inode *inode, void *h)
139 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
140 struct inode *cache_inode = NULL;
143 cache_inode = I2CI(inode);
144 if (cache_fsfilt == NULL)
147 if (!cache_fsfilt->fs_commit_wait)
150 rc = cache_fsfilt->fs_commit_wait(cache_inode, h);
155 static int fsfilt_smfs_setattr(struct dentry *dentry, void *handle,
156 struct iattr *iattr, int do_trunc)
158 struct fsfilt_operations *cache_fsfilt = I2FOPS(dentry->d_inode);
159 struct dentry *cache_dentry = NULL;
160 struct inode *cache_inode = NULL;
166 cache_inode = I2CI(dentry->d_inode);
168 cache_dentry = pre_smfs_dentry(NULL, cache_inode, dentry);
170 GOTO(exit, rc = -ENOMEM);
172 pre_smfs_inode(dentry->d_inode, cache_inode);
174 if (!cache_fsfilt->fs_setattr)
177 rc = cache_fsfilt->fs_setattr(cache_dentry, handle, iattr, do_trunc);
179 post_smfs_inode(dentry->d_inode, cache_inode);
182 struct super_block *sb = dentry->d_inode->i_sb;
184 if (SMFS_DO_REC(S2SMI(sb)) &&
185 SMFS_DO_INODE_REC(dentry->d_inode)) {
186 rc = smfs_rec_setattr(dentry->d_inode, dentry, iattr);
190 post_smfs_dentry(cache_dentry);
194 static int fsfilt_smfs_iocontrol(struct inode *inode, struct file *file,
195 unsigned int cmd, unsigned long arg)
197 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
198 struct inode *cache_inode = NULL;
199 struct smfs_file_info *sfi = NULL;
206 cache_inode = I2CI(inode);
214 if (sfi->magic != SMFS_FILE_MAGIC)
220 if (!cache_fsfilt->fs_iocontrol)
224 rc = cache_fsfilt->fs_iocontrol(cache_inode, sfi->c_file, cmd,
227 rc = cache_fsfilt->fs_iocontrol(cache_inode, NULL, cmd, arg);
230 /* FIXME-UMKA: Should this be in duplicate_inode()? */
231 if (rc == 0 && cmd == EXT3_IOC_SETFLAGS)
232 inode->i_flags = cache_inode->i_flags;
234 post_smfs_inode(inode, cache_inode);
239 static int fsfilt_smfs_set_md(struct inode *inode, void *handle,
240 void *lmm, int lmm_size)
242 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
243 struct inode *cache_inode = NULL;
249 cache_inode = I2CI(inode);
254 pre_smfs_inode(inode, cache_inode);
256 if (!cache_fsfilt->fs_set_md)
259 down(&cache_inode->i_sem);
260 rc = cache_fsfilt->fs_set_md(cache_inode, handle, lmm, lmm_size);
261 up(&cache_inode->i_sem);
263 post_smfs_inode(inode, cache_inode);
265 smfs_rec_md(inode, lmm, lmm_size);
270 /* Must be called with i_sem held */
271 static int fsfilt_smfs_get_md(struct inode *inode, void *lmm, int lmm_size)
273 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
274 struct inode *cache_inode = NULL;
280 cache_inode = I2CI(inode);
285 pre_smfs_inode(inode, cache_inode);
287 if (!cache_fsfilt->fs_get_md)
290 down(&cache_inode->i_sem);
291 rc = cache_fsfilt->fs_get_md(cache_inode, lmm, lmm_size);
292 up(&cache_inode->i_sem);
294 post_smfs_inode(inode, cache_inode);
299 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
300 static int fsfilt_smfs_send_bio(struct inode *inode, struct bio *bio)
302 static int fsfilt_smfs_send_bio(struct inode *inode, struct kiobuf *bio)
305 struct inode *cache_inode;
306 struct fsfilt_operations *cache_fsfilt;
308 cache_fsfilt = I2FOPS(inode);
312 cache_inode = I2CI(inode);
316 if (!cache_fsfilt->fs_send_bio)
319 return cache_fsfilt->fs_send_bio(cache_inode, bio);
323 fsfilt_smfs_getpage(struct inode *inode, long int index)
325 struct fsfilt_operations *cache_fsfilt;
326 struct inode *cache_inode;
328 cache_fsfilt = I2FOPS(inode);
330 RETURN(ERR_PTR(-EINVAL));
332 cache_inode = I2CI(inode);
334 RETURN(ERR_PTR(-EINVAL));
336 if (!cache_fsfilt->fs_getpage)
337 RETURN(ERR_PTR(-ENOSYS));
339 return cache_fsfilt->fs_getpage(cache_inode, index);
342 static ssize_t fsfilt_smfs_readpage(struct file *file, char *buf,
343 size_t count, loff_t *off)
345 struct fsfilt_operations *cache_fsfilt;
346 struct smfs_file_info *sfi;
347 struct inode *cache_inode;
354 cache_fsfilt = I2FOPS(file->f_dentry->d_inode);
358 cache_inode = I2CI(file->f_dentry->d_inode);
363 if (sfi->magic != SMFS_FILE_MAGIC)
366 if (off != &(file->f_pos))
367 cache_ppos = &tmp_ppos;
369 cache_ppos = &sfi->c_file->f_pos;
372 pre_smfs_inode(file->f_dentry->d_inode, cache_inode);
374 if (cache_fsfilt->fs_readpage)
375 rc = cache_fsfilt->fs_readpage(sfi->c_file, buf, count,
379 post_smfs_inode(file->f_dentry->d_inode, cache_inode);
380 duplicate_file(file, sfi->c_file);
386 static int fsfilt_smfs_add_journal_cb(struct obd_device *obd,
387 struct super_block *sb, __u64 last_rcvd,
388 void *handle, fsfilt_cb_t cb_func,
391 struct fsfilt_operations *cache_fsfilt = S2SMI(sb)->sm_cache_fsfilt;
392 struct super_block *csb = S2CSB(sb);
397 if (cache_fsfilt->fs_add_journal_cb)
398 rc = cache_fsfilt->fs_add_journal_cb(obd, csb, last_rcvd,
399 handle, cb_func, cb_data);
403 static int fsfilt_smfs_statfs(struct super_block *sb, struct obd_statfs *osfs)
405 struct fsfilt_operations *cache_fsfilt = S2SMI(sb)->sm_cache_fsfilt;
406 struct super_block *csb = S2CSB(sb);
412 if (!cache_fsfilt->fs_statfs)
415 rc = cache_fsfilt->fs_statfs(csb, osfs);
416 duplicate_sb(csb, sb);
421 static int fsfilt_smfs_sync(struct super_block *sb)
423 struct fsfilt_operations *cache_fsfilt = S2SMI(sb)->sm_cache_fsfilt;
424 struct super_block *csb = S2CSB(sb);
430 if (!cache_fsfilt->fs_sync)
433 rc = cache_fsfilt->fs_sync(csb);
438 int fsfilt_smfs_map_inode_pages(struct inode *inode, struct page **page,
439 int pages, unsigned long *blocks, int *created,
440 int create, struct semaphore *sem)
442 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
443 struct inode *cache_inode = NULL;
449 cache_inode = I2CI(inode);
454 if (!cache_fsfilt->fs_map_inode_pages)
457 down(&cache_inode->i_sem);
458 rc = cache_fsfilt->fs_map_inode_pages(cache_inode, page, pages, blocks,
459 created, create, sem);
460 up(&cache_inode->i_sem);
465 static int fsfilt_smfs_prep_san_write(struct inode *inode, long *blocks,
466 int nblocks, loff_t newsize)
468 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
469 struct inode *cache_inode = NULL;
475 cache_inode = I2CI(inode);
480 if (!cache_fsfilt->fs_prep_san_write)
483 down(&cache_inode->i_sem);
484 rc = cache_fsfilt->fs_prep_san_write(cache_inode, blocks, nblocks,
486 up(&cache_inode->i_sem);
491 static int fsfilt_smfs_read_record(struct file * file, void *buf,
492 int size, loff_t *offs)
494 struct fsfilt_operations *cache_fsfilt;
495 struct inode *cache_inode;
496 struct smfs_file_info *sfi;
502 cache_fsfilt = I2FOPS(file->f_dentry->d_inode);
506 cache_inode = I2CI(file->f_dentry->d_inode);
512 if (sfi->magic != SMFS_FILE_MAGIC) BUG();
514 if (offs != &(file->f_pos))
515 cache_ppos = &tmp_ppos;
517 cache_ppos = &sfi->c_file->f_pos;
520 pre_smfs_inode(file->f_dentry->d_inode, cache_inode);
522 if (!cache_fsfilt->fs_read_record)
525 rc = cache_fsfilt->fs_read_record(sfi->c_file, buf, size, cache_ppos);
528 post_smfs_inode(file->f_dentry->d_inode, cache_inode);
529 duplicate_file(file, sfi->c_file);
534 static int fsfilt_smfs_write_record(struct file *file, void *buf, int bufsize,
535 loff_t *offs, int force_sync)
537 struct fsfilt_operations *cache_fsfilt;
538 struct inode *cache_inode;
539 struct smfs_file_info *sfi;
546 cache_fsfilt = I2FOPS(file->f_dentry->d_inode);
550 cache_inode = I2CI(file->f_dentry->d_inode);
556 if (sfi->magic != SMFS_FILE_MAGIC)
559 if (offs != &(file->f_pos))
560 cache_ppos = &tmp_ppos;
562 cache_ppos = &sfi->c_file->f_pos;
565 pre_smfs_inode(file->f_dentry->d_inode, cache_inode);
567 if (!cache_fsfilt->fs_write_record)
570 rc = cache_fsfilt->fs_write_record(sfi->c_file, buf,
571 bufsize, cache_ppos, force_sync);
573 post_smfs_inode(file->f_dentry->d_inode, cache_inode);
574 duplicate_file(file, sfi->c_file);
579 static int fsfilt_smfs_post_setup(struct obd_device *obd, struct vfsmount *mnt)
581 struct super_block *sb = NULL;
586 S2SMI(sb)->smsi_exp = obd->obd_self_export;
587 if (SMFS_DO_REC(S2SMI(sb)))
588 rc = smfs_start_rec(sb, mnt);
592 obd->obd_llog_ctxt[LLOG_REINT_ORIG_CTXT] =
593 S2SMI(sb)->smsi_rec_log;
597 CERROR("can not do post setup in obd %p rc=%d", obd, rc);
602 static int fsfilt_smfs_post_cleanup(struct obd_device *obd,
603 struct vfsmount *mnt)
605 struct super_block *sb = NULL;
610 if (SMFS_DO_REC(S2SMI(sb)))
611 rc = smfs_stop_rec(sb);
616 static int fsfilt_smfs_set_kml_flags(struct inode *inode)
619 if (SMFS_DO_REC(S2SMI(inode->i_sb)))
620 SMFS_SET_INODE_REC(inode);
624 static int fsfilt_smfs_set_ost_flags(struct super_block *sb)
627 SET_REC_PACK_TYPE_INDEX(S2SMI(sb)->smsi_flags, PACK_OST);
631 static int fsfilt_smfs_set_mds_flags(struct super_block *sb)
634 SET_REC_PACK_TYPE_INDEX(S2SMI(sb)->smsi_flags, PACK_MDS);
638 static int fsfilt_smfs_get_reint_log_ctxt(struct super_block *sb,
639 struct llog_ctxt **ctxt)
641 struct smfs_super_info *smfs_info = S2SMI(sb);
644 *ctxt = smfs_info->smsi_rec_log;
648 static int fsfilt_smfs_setup(struct obd_device *obd, struct super_block *sb)
650 struct smfs_super_info *smfs_info = S2SMI(sb);
651 struct fsfilt_operations *cache_fsfilt;
652 struct super_block *csb;
655 /* It should be initialized olready by smfs_read_super(). */
656 if (!(cache_fsfilt = smfs_info->sm_cache_fsfilt))
657 cache_fsfilt = fsfilt_get_ops(smfs_info->smsi_cache_ftype);
663 if (cache_fsfilt->fs_setup)
664 rc = cache_fsfilt->fs_setup(obd, csb);
668 static int fsfilt_smfs_set_xattr(struct inode *inode, void *handle, char *name,
669 void *buffer, int buffer_size)
671 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
672 struct inode *cache_inode = NULL;
678 cache_inode = I2CI(inode);
682 pre_smfs_inode(inode, cache_inode);
684 if (cache_fsfilt->fs_set_xattr)
685 rc = cache_fsfilt->fs_set_xattr(cache_inode, handle, name,
686 buffer, buffer_size);
687 post_smfs_inode(inode, cache_inode);
692 static int fsfilt_smfs_get_xattr(struct inode *inode, char *name,
693 void *buffer, int buffer_size)
695 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
696 struct inode *cache_inode = NULL;
702 cache_inode = I2CI(inode);
706 pre_smfs_inode(inode, cache_inode);
708 if (cache_fsfilt->fs_get_xattr)
709 rc = cache_fsfilt->fs_get_xattr(cache_inode, name,
710 buffer, buffer_size);
711 post_smfs_inode(inode, cache_inode);
716 static int fsfilt_smfs_insert_extents_ea(struct inode *inode,
717 unsigned long from, unsigned long num)
719 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
720 struct inode *cache_inode = NULL;
726 cache_inode = I2CI(inode);
730 pre_smfs_inode(inode, cache_inode);
732 if (cache_fsfilt->fs_insert_extents_ea)
733 rc = cache_fsfilt->fs_insert_extents_ea(cache_inode, from, num);
735 post_smfs_inode(inode, cache_inode);
739 static int fsfilt_smfs_remove_extents_ea(struct inode *inode,
740 unsigned long from, unsigned long num)
742 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
743 struct inode *cache_inode = NULL;
749 cache_inode = I2CI(inode);
753 pre_smfs_inode(inode, cache_inode);
755 if (cache_fsfilt->fs_remove_extents_ea)
756 rc = cache_fsfilt->fs_remove_extents_ea(cache_inode, from, num);
758 post_smfs_inode(inode, cache_inode);
762 static int fsfilt_smfs_init_extents_ea(struct inode *inode)
764 struct fsfilt_operations *cache_fsfilt = I2FOPS(inode);
765 struct inode *cache_inode = NULL;
771 cache_inode = I2CI(inode);
775 pre_smfs_inode(inode, cache_inode);
777 if (cache_fsfilt->fs_init_extents_ea)
778 rc = cache_fsfilt->fs_init_extents_ea(cache_inode);
780 post_smfs_inode(inode, cache_inode);
784 static int fsfilt_smfs_free_extents(struct super_block *sb, ino_t ino,
785 char *pbuf, int size)
787 OBD_FREE(pbuf, size * (sizeof(struct ldlm_extent)));
790 static int fsfilt_smfs_write_extents(struct dentry *dentry,
791 unsigned long from, unsigned long num)
795 if (SMFS_DO_REC(S2SMI(dentry->d_inode->i_sb)))
796 rc = smfs_write_extents(dentry->d_inode, dentry, from, num);
801 static int fsfilt_smfs_get_ino_write_extents(struct super_block *sb, ino_t ino,
802 char **pbuf, int *size)
804 struct fs_extent *fs_extents;
805 struct ldlm_extent *extents;
807 struct inode *cache_inode;
808 struct fsfilt_operations *cache_fsfilt = NULL;
809 struct lvfs_run_ctxt saved;
810 int rc = 0, fs_ex_size, ex_num, flags;
811 char *buf = NULL, *ex_buf = NULL;
813 push_ctxt(&saved, S2SMI(sb)->smsi_ctxt, NULL);
815 inode = iget(sb, ino);
817 if (!inode || is_bad_inode(inode)) {
818 CWARN("Can not get inode %lu ino\n", ino);
821 cache_inode = I2CI(inode);
822 cache_fsfilt = I2FOPS(inode);
824 rc = cache_fsfilt->fs_get_xattr(cache_inode, REINT_EXTENTS_FLAGS,
825 &flags, sizeof(int));
826 if (!(flags & SMFS_OVER_WRITE) && !(flags & SMFS_DIRTY_WRITE)) {
828 } else if (flags & SMFS_OVER_WRITE) {
830 OBD_ALLOC(ex_buf, sizeof(struct ldlm_extent));
832 GOTO(out, rc=-ENOMEM);
833 extents = (struct ldlm_extent*)(ex_buf);
835 extents->end = 0xffffffff;
839 rc = cache_fsfilt->fs_get_write_extents_num(cache_inode, &fs_ex_size);
842 OBD_ALLOC(buf, fs_ex_size);
844 GOTO(out, rc=-ENOMEM);
846 rc = cache_fsfilt->fs_get_inode_write_extents(cache_inode, &buf,
851 ex_num = fs_ex_size / sizeof(struct fs_extent);
853 OBD_ALLOC(ex_buf, ex_num* sizeof(struct ldlm_extent));
855 GOTO(out, rc=-ENOMEM);
857 fs_extents = (struct fs_extent*)(buf);
858 extents = (struct ldlm_extent*)(ex_buf);
860 int blk_size = I2CI(inode)->i_blksize;
862 extents->start = fs_extents->e_block * blk_size;
863 extents->end = extents->start + fs_extents->e_num * blk_size;
872 OBD_FREE(buf, fs_ex_size);
874 OBD_FREE(ex_buf, (*size) * (sizeof(struct ldlm_extent)));
875 pop_ctxt(&saved, S2SMI(sb)->smsi_ctxt, NULL);
879 static struct fsfilt_operations fsfilt_smfs_ops = {
881 .fs_owner = THIS_MODULE,
882 .fs_start = fsfilt_smfs_start,
883 .fs_brw_start = fsfilt_smfs_brw_start,
884 .fs_commit = fsfilt_smfs_commit,
885 .fs_commit_async = fsfilt_smfs_commit_async,
886 .fs_commit_wait = fsfilt_smfs_commit_wait,
887 .fs_setattr = fsfilt_smfs_setattr,
888 .fs_iocontrol = fsfilt_smfs_iocontrol,
889 .fs_set_md = fsfilt_smfs_set_md,
890 .fs_get_md = fsfilt_smfs_get_md,
891 .fs_readpage = fsfilt_smfs_readpage,
892 .fs_getpage = fsfilt_smfs_getpage,
893 .fs_add_journal_cb = fsfilt_smfs_add_journal_cb,
894 .fs_statfs = fsfilt_smfs_statfs,
895 .fs_sync = fsfilt_smfs_sync,
896 .fs_map_inode_pages = fsfilt_smfs_map_inode_pages,
897 .fs_prep_san_write = fsfilt_smfs_prep_san_write,
898 .fs_write_record = fsfilt_smfs_write_record,
899 .fs_read_record = fsfilt_smfs_read_record,
900 .fs_setup = fsfilt_smfs_setup,
901 .fs_post_setup = fsfilt_smfs_post_setup,
902 .fs_post_cleanup = fsfilt_smfs_post_cleanup,
903 .fs_set_kml_flags = fsfilt_smfs_set_kml_flags,
904 .fs_set_ost_flags = fsfilt_smfs_set_ost_flags,
905 .fs_set_mds_flags = fsfilt_smfs_set_mds_flags,
906 .fs_get_reint_log_ctxt = fsfilt_smfs_get_reint_log_ctxt,
907 .fs_send_bio = fsfilt_smfs_send_bio,
908 .fs_set_xattr = fsfilt_smfs_set_xattr,
909 .fs_get_xattr = fsfilt_smfs_get_xattr,
910 .fs_init_extents_ea = fsfilt_smfs_init_extents_ea,
911 .fs_insert_extents_ea = fsfilt_smfs_insert_extents_ea,
912 .fs_remove_extents_ea = fsfilt_smfs_remove_extents_ea,
913 .fs_get_ino_write_extents = fsfilt_smfs_get_ino_write_extents,
914 .fs_free_write_extents = fsfilt_smfs_free_extents,
915 .fs_write_extents = fsfilt_smfs_write_extents,
916 /* FIXME-UMKA: probably fsfilt_smfs_get_op_len() should be
920 static int __init fsfilt_smfs_init(void)
924 rc = fsfilt_register_ops(&fsfilt_smfs_ops);
928 static void __exit fsfilt_smfs_exit(void)
930 fsfilt_unregister_ops(&fsfilt_smfs_ops);
933 module_init(fsfilt_smfs_init);
934 module_exit(fsfilt_smfs_exit);
936 MODULE_AUTHOR("Cluster File Systems, Inc. <info@clusterfs.com>");
937 MODULE_DESCRIPTION("Lustre SMFS Filesystem Helper v0.1");
938 MODULE_LICENSE("GPL");