LU-9183 llite: handle xattr with the xattr_handler infrastructure

[fs/lustre-release.git] / lustre / obdclass / obd_mount_server.c

diff --git a/lustre/obdclass/obd_mount_server.c b/lustre/obdclass/obd_mount_server.c
index d6a7fe4..8a4883a 100644 (file)
--- a/lustre/obdclass/obd_mount_server.c
+++ b/lustre/obdclass/obd_mount_server.c
@@ -55,17 +55,16 @@
 
 #include <llog_swab.h>
 #include <lustre_disk.h>
-#include <lustre_ioctl.h>
+#include <uapi/linux/lustre_ioctl.h>
 #include <lustre_log.h>
-#include <lustre_param.h>
+#include <uapi/linux/lustre_param.h>
 #include <obd.h>
 #include <obd_class.h>
 
 /*********** mount lookup *********/
 
 static DEFINE_MUTEX(lustre_mount_info_lock);
-static struct list_head server_mount_info_list =
-       LIST_HEAD_INIT(server_mount_info_list);
+static LIST_HEAD(server_mount_info_list);
 
 static struct lustre_mount_info *server_find_mount(const char *name)
 {
@@ -383,8 +382,7 @@ cleanup:
 }
 EXPORT_SYMBOL(tgt_name2lwp_name);
 
-static struct list_head lwp_register_list =
-       LIST_HEAD_INIT(lwp_register_list);
+static LIST_HEAD(lwp_register_list);
 static DEFINE_SPINLOCK(lwp_register_list_lock);
 
 static void lustre_put_lwp_item(struct lwp_register_item *lri)
@@ -457,18 +455,34 @@ EXPORT_SYMBOL(lustre_register_lwp_item);
 void lustre_deregister_lwp_item(struct obd_export **exp)
 {
        struct lwp_register_item *lri;
+       bool removed = false;
+       int repeat = 0;
 
        spin_lock(&lwp_register_list_lock);
        list_for_each_entry(lri, &lwp_register_list, lri_list) {
                if (exp == lri->lri_exp) {
                        list_del_init(&lri->lri_list);
-                       spin_unlock(&lwp_register_list_lock);
-
-                       lustre_put_lwp_item(lri);
-                       return;
+                       removed = true;
+                       break;
                }
        }
        spin_unlock(&lwp_register_list_lock);
+
+       if (!removed)
+               return;
+
+       /* See lustre_notify_lwp_list(), in some extreme race conditions,
+        * the notify callback could be still on the fly, we need to wait
+        * for the callback done before moving on to free the data used
+        * by callback. */
+       while (atomic_read(&lri->lri_ref) > 1) {
+               CDEBUG(D_MOUNT, "lri reference count %u, repeat: %d\n",
+                      atomic_read(&lri->lri_ref), repeat);
+               repeat++;
+               set_current_state(TASK_INTERRUPTIBLE);
+               schedule_timeout(cfs_time_seconds(1));
+       }
+       lustre_put_lwp_item(lri);
 }
 EXPORT_SYMBOL(lustre_deregister_lwp_item);
 
@@ -741,15 +755,18 @@ static int lustre_lwp_add_conn(struct lustre_cfg *cfg,
        lustre_cfg_bufs_set_string(bufs, 1,
                                   lustre_cfg_string(cfg, 1));
 
-       lcfg = lustre_cfg_new(LCFG_ADD_CONN, bufs);
-       if (lcfg == NULL)
+       OBD_ALLOC(lcfg, lustre_cfg_len(bufs->lcfg_bufcount, bufs->lcfg_buflen));
+       if (!lcfg)
                GOTO(out_cfg, rc = -ENOMEM);
+       lustre_cfg_init(lcfg, LCFG_ADD_CONN, bufs);
+
        rc = class_add_conn(lwp, lcfg);
        if (rc)
                CERROR("%s: can't add conn: rc = %d\n", lwpname, rc);
 
-       if (lcfg != NULL)
-               lustre_cfg_free(lcfg);
+       if (lcfg)
+               OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount,
+                                             lcfg->lcfg_buflens));
 out_cfg:
        if (bufs != NULL)
                OBD_FREE_PTR(bufs);
@@ -939,15 +956,18 @@ static int lustre_disconnect_lwp(struct super_block *sb)
 
                lustre_cfg_bufs_reset(bufs, lwp->obd_name);
                lustre_cfg_bufs_set_string(bufs, 1, NULL);
-               lcfg = lustre_cfg_new(LCFG_CLEANUP, bufs);
-               if (lcfg == NULL)
+               OBD_ALLOC(lcfg, lustre_cfg_len(bufs->lcfg_bufcount,
+                                              bufs->lcfg_buflen));
+               if (!lcfg)
                        GOTO(out, rc = -ENOMEM);
+               lustre_cfg_init(lcfg, LCFG_CLEANUP, bufs);
 
                /* Disconnect import first. NULL is passed for the '@env',
                 * since it will not be used. */
                rc = lwp->obd_lu_dev->ld_ops->ldo_process_config(NULL,
                                                        lwp->obd_lu_dev, lcfg);
-               lustre_cfg_free(lcfg);
+               OBD_FREE(lcfg, lustre_cfg_len(lcfg->lcfg_bufcount,
+                                             lcfg->lcfg_buflens));
                if (rc != 0 && rc != -ETIMEDOUT) {
                        CERROR("%s: fail to disconnect LWP: rc = %d\n",
                               lwp->obd_name, rc);
@@ -1377,9 +1397,6 @@ static int server_start_targets(struct super_block *sb)
        /* calculate recovery timeout, do it after lustre_process_log */
        server_calc_timeout(lsi, obd);
 
-       /* log has been fully processed */
-       obd_notify(obd, NULL, OBD_NOTIFY_CONFIG, (void *)CONFIG_LOG);
-
        /* log has been fully processed, let clients connect */
        dev = obd->obd_lu_dev;
        if (dev && dev->ld_ops->ldo_prepare) {
@@ -1659,6 +1676,7 @@ static struct super_operations server_ops = {
 /*
  * Xattr support for Lustre servers
  */
+#ifdef HAVE_IOP_XATTR
 static ssize_t lustre_getxattr(struct dentry *dentry, const char *name,
                                void *buffer, size_t size)
 {
@@ -1672,6 +1690,7 @@ static int lustre_setxattr(struct dentry *dentry, const char *name,
 {
        return -EOPNOTSUPP;
 }
+#endif
 
 static ssize_t lustre_listxattr(struct dentry *d_entry, char *name,
                                size_t size)
@@ -1680,8 +1699,10 @@ static ssize_t lustre_listxattr(struct dentry *d_entry, char *name,
 }
 
 static const struct inode_operations server_inode_operations = {
+#ifdef HAVE_IOP_XATTR
        .setxattr       = lustre_setxattr,
        .getxattr       = lustre_getxattr,
+#endif
        .listxattr      = lustre_listxattr,
 };
 
@@ -1922,7 +1943,8 @@ void server_calc_timeout(struct lustre_sb_info *lsi, struct obd_device *obd)
        }
 
        /* we're done */
-       obd->obd_recovery_timeout   = max(obd->obd_recovery_timeout, soft);
+       obd->obd_recovery_timeout = max_t(time64_t, obd->obd_recovery_timeout,
+                                         soft);
        obd->obd_recovery_time_hard = hard;
        obd->obd_recovery_ir_factor = factor;
 }