Branch b1_4 merge from b_cray.

Rename lvfs_run_ctxt lvfs_ucred ->ouc to ->luc
       ll_sbdev -> lvfs_sbdev and move from obdclass to lvfs_linux
       ll_sbdev_type -> lvfs_sb_type
       ll_sbdev_sync -> lvfs_sbdev_sync
       ll_set_rdonly -> lvfs_set_rdonly
       ll_check_rdonly -> lvfs_check_rdonly
       ll_clear_rdonly -> lvfs_clear_rdonly
b=6510

diff --git a/lustre/include/linux/lvfs.h b/lustre/include/linux/lvfs.h
index f5e0fef..2862b8d 100644 (file)
--- a/lustre/include/linux/lvfs.h
+++ b/lustre/include/linux/lvfs.h
@@ -56,7 +56,7 @@ struct lvfs_run_ctxt {
         struct vfsmount *pwdmnt;
         struct dentry   *pwd;
         mm_segment_t     fs;
-        struct lvfs_ucred ouc;
+        struct lvfs_ucred luc;
         int              ngroups;
         struct lvfs_callback_ops cb_ops;
 #ifdef OBD_CTXT_DEBUG

diff --git a/lustre/include/linux/lvfs_linux.h b/lustre/include/linux/lvfs_linux.h
index fdcaa31..26a8a08 100644 (file)
--- a/lustre/include/linux/lvfs_linux.h
+++ b/lustre/include/linux/lvfs_linux.h
@@ -32,4 +32,25 @@ struct l_readdir_callback {
         struct list_head      *lrc_list;
 };
 
+# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
+#  define BDEVNAME_DECLARE_STORAGE(foo) char foo[BDEVNAME_SIZE]
+#  define ll_bdevname(SB, STORAGE) __bdevname(kdev_t_to_nr(SB->s_dev), STORAGE)
+#  define lvfs_sbdev(SB)       ((SB)->s_bdev)
+#  define lvfs_sbdev_type      struct block_device *
+   int fsync_bdev(struct block_device *);
+#  define lvfs_sbdev_sync      fsync_bdev
+#  define lvfs_lock_kernel     lock_kernel()
+# else
+#  define BDEVNAME_DECLARE_STORAGE(foo) char __unused_##foo
+#  define ll_bdevname(SB,STORAGE) ((void)__unused_##STORAGE,bdevname(lvfs_sbdev(SB)))
+#  define lvfs_sbdev(SB)       (kdev_t_to_nr((SB)->s_dev))
+#  define lvfs_sbdev_type      kdev_t
+#  define lvfs_sbdev_sync      fsync_dev
+#  define lvfs_lock_kernel
+# endif
+
+void lvfs_set_rdonly(lvfs_sbdev_type dev);
+int lvfs_check_rdonly(lvfs_sbdev_type dev);
+void lvfs_clear_rdonly(lvfs_sbdev_type dev);
+
 #endif

diff --git a/lustre/include/linux/obd_support.h b/lustre/include/linux/obd_support.h
index 98294db..757dba2 100644 (file)
--- a/lustre/include/linux/obd_support.h
+++ b/lustre/include/linux/obd_support.h
@@ -196,7 +196,7 @@ do {                                                                         \
 
 #define OBD_FAIL_TIMEOUT(id, secs)                                           \
 do {                                                                         \
-        if  (OBD_FAIL_CHECK_ONCE(id)) {                                      \
+        if (OBD_FAIL_CHECK_ONCE(id)) {                                      \
                 CERROR("obd_fail_timeout id %x sleeping for %d secs\n",      \
                        (id), (secs));                                        \
                 set_current_state(TASK_UNINTERRUPTIBLE);                     \
@@ -264,37 +264,7 @@ do {                                                            \
 #ifdef __KERNEL__
 # include <linux/types.h>
 # include <linux/blkdev.h>
-
-
-# if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
-#  define BDEVNAME_DECLARE_STORAGE(foo) char foo[BDEVNAME_SIZE]
-#  define ll_bdevname(SB, STORAGE) __bdevname(kdev_t_to_nr(SB->s_dev), STORAGE)
-#  define ll_sbdev(SB)       ((SB)->s_bdev)
-#  define ll_sbdev_type      struct block_device *
-   int fsync_bdev(struct block_device *);
-#  define ll_sbdev_sync      fsync_bdev
-#  define ll_lock_kernel     lock_kernel()
-# else
-#  define BDEVNAME_DECLARE_STORAGE(foo) char __unused_##foo
-#  define ll_bdevname(SB,STORAGE) ((void)__unused_##STORAGE,bdevname(ll_sbdev(SB)))
-#  define ll_sbdev(SB)       (kdev_t_to_nr((SB)->s_dev))
-#  define ll_sbdev_type      kdev_t
-#  define ll_sbdev_sync      fsync_dev
-#  define ll_lock_kernel
-# endif
-
-#ifdef HAVE_OLD_DEV_SET_RDONLY
-  void dev_set_rdonly(ll_sbdev_type dev, int no_write);
-  void dev_clear_rdonly(int no_write);
-#else
-  void dev_set_rdonly(ll_sbdev_type dev);
-  void dev_clear_rdonly(ll_sbdev_type dev);
-#endif
-int dev_check_rdonly(ll_sbdev_type dev);
-#define ll_check_rdonly(dev) dev_check_rdonly(dev)
-
-void ll_set_rdonly(ll_sbdev_type dev);
-void ll_clear_rdonly(ll_sbdev_type dev);
+# include <linux/lvfs.h>
 
 static inline void OBD_FAIL_WRITE(int id, struct super_block *sb)
 {
@@ -302,7 +272,7 @@ static inline void OBD_FAIL_WRITE(int id, struct super_block *sb)
                 BDEVNAME_DECLARE_STORAGE(tmp);
                 CERROR("obd_fail_loc=%x, fail write operation on %s\n",
                        id, ll_bdevname(sb, tmp));
-                ll_set_rdonly(ll_sbdev(sb));
+                lvfs_set_rdonly(lvfs_sbdev(sb));
                 /* We set FAIL_ONCE because we never "un-fail" a device */
                 obd_fail_loc |= OBD_FAILED | OBD_FAIL_ONCE;
         }

diff --git a/lustre/lvfs/lvfs_linux.c b/lustre/lvfs/lvfs_linux.c
index 58dd545..19268e6 100644 (file)
--- a/lustre/lvfs/lvfs_linux.c
+++ b/lustre/lvfs/lvfs_linux.c
@@ -56,8 +56,9 @@ int obd_memmax;
 /* Debugging check only needed during development */
 #ifdef OBD_CTXT_DEBUG
 # define ASSERT_CTXT_MAGIC(magic) LASSERT((magic) == OBD_RUN_CTXT_MAGIC)
-# define ASSERT_NOT_KERNEL_CTXT(msg) LASSERT(!segment_eq(get_fs(), get_ds()))
-# define ASSERT_KERNEL_CTXT(msg) LASSERT(segment_eq(get_fs(), get_ds()))
+# define ASSERT_NOT_KERNEL_CTXT(msg) LASSERTF(!segment_eq(get_fs(), get_ds()),\
+                                              msg)
+# define ASSERT_KERNEL_CTXT(msg) LASSERTF(segment_eq(get_fs(), get_ds()), msg)
 #else
 # define ASSERT_CTXT_MAGIC(magic) do {} while(0)
 # define ASSERT_NOT_KERNEL_CTXT(msg) do {} while(0)
@@ -97,7 +98,7 @@ void push_ctxt(struct lvfs_run_ctxt *save, struct lvfs_run_ctxt *new_ctx,
         save->pwd = dget(current->fs->pwd);
         save->pwdmnt = mntget(current->fs->pwdmnt);
         save->ngroups = current_ngroups;
-        save->ouc.luc_umask = current->fs->umask;
+        save->luc.luc_umask = current->fs->umask;
 
         LASSERT(save->pwd);
         LASSERT(save->pwdmnt);
@@ -105,11 +106,11 @@ void push_ctxt(struct lvfs_run_ctxt *save, struct lvfs_run_ctxt *new_ctx,
         LASSERT(new_ctx->pwdmnt);
 
         if (uc) {
-                save->ouc.luc_fsuid = current->fsuid;
-                save->ouc.luc_fsgid = current->fsgid;
-                save->ouc.luc_cap = current->cap_effective;
-                save->ouc.luc_suppgid1 = current_groups[0];
-                save->ouc.luc_suppgid2 = current_groups[1];
+                save->luc.luc_fsuid = current->fsuid;
+                save->luc.luc_fsgid = current->fsgid;
+                save->luc.luc_cap = current->cap_effective;
+                save->luc.luc_suppgid1 = current_groups[0];
+                save->luc.luc_suppgid2 = current_groups[1];
 
                 current->fsuid = uc->luc_fsuid;
                 current->fsgid = uc->luc_fsgid;
@@ -172,14 +173,14 @@ void pop_ctxt(struct lvfs_run_ctxt *saved, struct lvfs_run_ctxt *new_ctx,
 
         dput(saved->pwd);
         mntput(saved->pwdmnt);
-        current->fs->umask = saved->ouc.luc_umask;
+        current->fs->umask = saved->luc.luc_umask;
         if (uc) {
-                current->fsuid = saved->ouc.luc_fsuid;
-                current->fsgid = saved->ouc.luc_fsgid;
-                current->cap_effective = saved->ouc.luc_cap;
+                current->fsuid = saved->luc.luc_fsuid;
+                current->fsgid = saved->luc.luc_fsgid;
+                current->cap_effective = saved->luc.luc_cap;
                 current_ngroups = saved->ngroups;
-                current_groups[0] = saved->ouc.luc_suppgid1;
-                current_groups[1] = saved->ouc.luc_suppgid2;
+                current_groups[0] = saved->luc.luc_suppgid1;
+                current_groups[1] = saved->luc.luc_suppgid2;
         }
 
         /*
@@ -391,6 +392,43 @@ EXPORT_SYMBOL(l_readdir);
 EXPORT_SYMBOL(obd_memory);
 EXPORT_SYMBOL(obd_memmax);
 
+void lvfs_set_rdonly(lvfs_sbdev_type dev)
+{
+        CDEBUG(D_IOCTL | D_HA, "set dev %lx rdonly\n", (long)dev);
+        lvfs_sbdev_sync(dev);
+#ifdef HAVE_OLD_DEV_SET_RDONLY
+        dev_set_rdonly(dev, 2);
+#else
+        dev_set_rdonly(dev);
+#endif
+}
+
+int lvfs_check_rdonly(lvfs_sbdev_type dev)
+{
+        return dev_check_rdonly(dev);
+}
+
+void lvfs_clear_rdonly(lvfs_sbdev_type dev)
+{
+#ifndef HAVE_CLEAR_RDONLY_ON_PUT
+        CDEBUG(D_IOCTL | D_HA, "unset dev %lx rdonly\n", (long)dev);
+        if (lvfs_check_rdonly(dev)) {
+                lvfs_sbdev_sync(dev);
+#ifdef HAVE_OLD_DEV_SET_RDONLY
+                dev_clear_rdonly(2);
+#else
+                dev_clear_rdonly(dev);
+#endif
+        }
+#else
+        CDEBUG(D_IOCTL | D_HA, "(will unset dev %lx rdonly on put)\n",
+               (long)dev);
+#endif
+}
+EXPORT_SYMBOL(lvfs_set_rdonly);
+EXPORT_SYMBOL(lvfs_check_rdonly);
+EXPORT_SYMBOL(lvfs_clear_rdonly);
+
 static int __init lvfs_linux_init(void)
 {
         RETURN(0);

diff --git a/lustre/mds/handler.c b/lustre/mds/handler.c
index 7496d54..bf19fdf 100644 (file)
--- a/lustre/mds/handler.c
+++ b/lustre/mds/handler.c
@@ -1682,7 +1682,7 @@ static int mds_setup(struct obd_device *obd, obd_count len, void *buf)
 
         CDEBUG(D_SUPER, "%s: mnt = %p\n", lustre_cfg_string(lcfg, 1), mnt);
 
-        LASSERT(!ll_check_rdonly(ll_sbdev(mnt->mnt_sb)));
+        LASSERT(!lvfs_check_rdonly(lvfs_sbdev(mnt->mnt_sb)));
 
         sema_init(&mds->mds_quota_info.qi_sem, 1);
         sema_init(&mds->mds_orphan_recovery_sem, 1);
@@ -1957,7 +1957,7 @@ static int mds_precleanup(struct obd_device *obd, int stage)
 static int mds_cleanup(struct obd_device *obd)
 {
         struct mds_obd *mds = &obd->u.mds;
-        ll_sbdev_type save_dev;
+        lvfs_sbdev_type save_dev;
         int must_relock = 0;
         ENTRY;
 
@@ -1965,8 +1965,8 @@ static int mds_cleanup(struct obd_device *obd)
 
         if (mds->mds_sb == NULL)
                 RETURN(0);
-        save_dev = ll_sbdev(mds->mds_sb);
-        
+        save_dev = lvfs_sbdev(mds->mds_sb);
+
         if (mds->mds_osc_exp)
                 /* lov export was disconnected by mds_lov_clean;
                    we just need to drop our ref */
@@ -2008,8 +2008,8 @@ static int mds_cleanup(struct obd_device *obd)
         }
         spin_unlock_bh(&obd->obd_processing_task_lock);
 
-        ll_clear_rdonly(save_dev);
-        
+        lvfs_clear_rdonly(save_dev);
+
         if (must_relock)
                 lock_kernel();
 

diff --git a/lustre/mds/mds_lov.c b/lustre/mds/mds_lov.c
index c815962..06b9d1c 100644 (file)
--- a/lustre/mds/mds_lov.c
+++ b/lustre/mds/mds_lov.c
@@ -430,7 +430,7 @@ int mds_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
                 CDEBUG(D_HA, "syncing mds %s\n", obd->obd_name);
                 rc = fsfilt_sync(obd, obd->u.mds.mds_sb);
 
-                ll_set_rdonly(ll_sbdev(obd->u.mds.mds_sb));
+                lvfs_set_rdonly(lvfs_sbdev(obd->u.mds.mds_sb));
                 RETURN(0);
         }
 

diff --git a/lustre/obdclass/class_obd.c b/lustre/obdclass/class_obd.c
index ffd7f80..9e473b4 100644 (file)
--- a/lustre/obdclass/class_obd.c
+++ b/lustre/obdclass/class_obd.c
@@ -102,35 +102,6 @@ unsigned int obd_print_fail_loc(void)
         return obd_fail_loc;
 }
 
-void ll_set_rdonly(ll_sbdev_type dev)
-{
-        CDEBUG(D_IOCTL | D_HA, "set dev %ld rdonly\n", (long)dev);
-        ll_sbdev_sync(dev);
-#ifdef HAVE_OLD_DEV_SET_RDONLY
-        dev_set_rdonly(dev, 2);
-#else
-        dev_set_rdonly(dev);
-#endif
-}
-
-void ll_clear_rdonly(ll_sbdev_type dev)
-{
-#ifndef HAVE_CLEAR_RDONLY_ON_PUT
-        CDEBUG(D_IOCTL | D_HA, "unset dev %ld rdonly\n", (long)dev);
-        if (ll_check_rdonly(dev)) {
-                ll_sbdev_sync(dev);
-#ifdef HAVE_OLD_DEV_SET_RDONLY
-                dev_clear_rdonly(2);
-#else
-                dev_clear_rdonly(dev);
-#endif
-        }
-#else 
-        CDEBUG(D_IOCTL | D_HA, "(will unset dev %ld rdonly on put)\n",
-               (long)dev);
-#endif
-}
-
 /*  opening /dev/obd */
 static int obd_class_open(struct inode * inode, struct file * file)
 {
@@ -399,8 +370,6 @@ void *obd_psdev = NULL;
 
 EXPORT_SYMBOL(obd_dev);
 EXPORT_SYMBOL(obd_fail_loc);
-EXPORT_SYMBOL(ll_set_rdonly);
-EXPORT_SYMBOL(ll_clear_rdonly);
 EXPORT_SYMBOL(obd_print_fail_loc);
 EXPORT_SYMBOL(obd_race_waitq);
 EXPORT_SYMBOL(obd_dump_on_timeout);

diff --git a/lustre/obdfilter/filter.c b/lustre/obdfilter/filter.c
index 4499f86..e1a1a0c 100644 (file)
--- a/lustre/obdfilter/filter.c
+++ b/lustre/obdfilter/filter.c
@@ -1223,7 +1223,7 @@ int filter_common_setup(struct obd_device *obd, obd_count len, void *buf,
         if (IS_ERR(mnt))
                 GOTO(err_ops, rc);
 
-        LASSERT(!ll_check_rdonly(ll_sbdev(mnt->mnt_sb)));
+        LASSERT(!lvfs_check_rdonly(lvfs_sbdev(mnt->mnt_sb)));
 
         if (lcfg->lcfg_bufcount > 3 && LUSTRE_CFG_BUFLEN(lcfg, 3) > 0) {
                 str = lustre_cfg_string(lcfg, 3);
@@ -1440,7 +1440,7 @@ static int filter_precleanup(struct obd_device *obd, int stage)
 static int filter_cleanup(struct obd_device *obd)
 {
         struct filter_obd *filter = &obd->u.filter;
-        ll_sbdev_type save_dev;
+        lvfs_sbdev_type save_dev;
         int must_relock = 0;
         ENTRY;
 
@@ -1465,7 +1465,7 @@ static int filter_cleanup(struct obd_device *obd)
 
         if (filter->fo_sb == NULL)
                 RETURN(0);
-        save_dev = ll_sbdev(filter->fo_sb);
+        save_dev = lvfs_sbdev(filter->fo_sb);
 
         lprocfs_free_obd_stats(obd);
         lprocfs_obd_cleanup(obd);
@@ -1492,7 +1492,7 @@ static int filter_cleanup(struct obd_device *obd)
         //destroy_buffers(filter->fo_sb->s_dev);
         filter->fo_sb = NULL;
 
-        ll_clear_rdonly(save_dev);
+        lvfs_clear_rdonly(save_dev);
 
         if (must_relock)
                 lock_kernel();
@@ -2580,7 +2580,7 @@ int filter_iocontrol(unsigned int cmd, struct obd_export *exp,
                 CDEBUG(D_HA, "syncing ost %s\n", obd->obd_name);
                 rc = fsfilt_sync(obd, obd->u.filter.fo_sb);
 
-                ll_set_rdonly(ll_sbdev(obd->u.filter.fo_sb));
+                lvfs_set_rdonly(lvfs_sbdev(obd->u.filter.fo_sb));
                 RETURN(0);
         }