X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;ds=sidebyside;f=lustre%2Fquota%2Fqsd_lib.c;h=1e4236c4635d2a795d003371a2be676f8eb64b34;hb=7a814e94e065551ab79e2ba75df9626e4940efc5;hp=d1ef839320a199d8c10e429e975aecb7ba1a1fbe;hpb=8b5814bbbb95efe440ff921506d9214ae3261b6e;p=fs%2Flustre-release.git

diff --git a/lustre/quota/qsd_lib.c b/lustre/quota/qsd_lib.c
index d1ef8393..1e4236c 100644
--- a/lustre/quota/qsd_lib.c
+++ b/lustre/quota/qsd_lib.c
@@ -21,7 +21,7 @@
  * GPL HEADER END
  */
 /*
- * Copyright (c) 2012, 2013, Intel Corporation.
+ * Copyright (c) 2012, 2014, Intel Corporation.
  * Use is subject to license terms.
  *
  * Author: Johann Lombardi <johann.lombardi@intel.com>
@@ -77,7 +77,6 @@ static int qsd_state_seq_show(struct seq_file *m, void *data)
 {
 	struct qsd_instance	*qsd = m->private;
 	char			 enabled[5];
-	int			 rc;
 
 	LASSERT(qsd != NULL);
 
@@ -89,14 +88,14 @@ static int qsd_state_seq_show(struct seq_file *m, void *data)
 	if (strlen(enabled) == 0)
 		strcat(enabled, "none");
 
-	rc = seq_printf(m, "target name:    %s\n"
-			"pool ID:        %d\n"
-			"type:           %s\n"
-			"quota enabled:  %s\n"
-			"conn to master: %s\n",
-			qsd->qsd_svname, qsd->qsd_pool_id,
-			qsd->qsd_is_md ? "md" : "dt", enabled,
-			qsd->qsd_exp_valid ? "setup" : "not setup yet");
+	seq_printf(m, "target name:    %s\n"
+		   "pool ID:        %d\n"
+		   "type:           %s\n"
+		   "quota enabled:  %s\n"
+		   "conn to master: %s\n",
+		   qsd->qsd_svname, qsd->qsd_pool_id,
+		   qsd->qsd_is_md ? "md" : "dt", enabled,
+		   qsd->qsd_exp_valid ? "setup" : "not setup yet");
 
 	if (qsd->qsd_prepared) {
 		memset(enabled, 0, sizeof(enabled));
@@ -106,18 +105,18 @@ static int qsd_state_seq_show(struct seq_file *m, void *data)
 			strcat(enabled, "g");
 		if (strlen(enabled) == 0)
 			strcat(enabled, "none");
-		rc += seq_printf(m, "space acct:     %s\n"
-				"user uptodate:  glb[%d],slv[%d],reint[%d]\n"
-				"group uptodate: glb[%d],slv[%d],reint[%d]\n",
-				enabled,
-				qsd->qsd_type_array[USRQUOTA]->qqi_glb_uptodate,
-				qsd->qsd_type_array[USRQUOTA]->qqi_slv_uptodate,
-				qsd->qsd_type_array[USRQUOTA]->qqi_reint,
-				qsd->qsd_type_array[GRPQUOTA]->qqi_glb_uptodate,
-				qsd->qsd_type_array[GRPQUOTA]->qqi_slv_uptodate,
-				qsd->qsd_type_array[GRPQUOTA]->qqi_reint);
+		seq_printf(m, "space acct:     %s\n"
+			   "user uptodate:  glb[%d],slv[%d],reint[%d]\n"
+			   "group uptodate: glb[%d],slv[%d],reint[%d]\n",
+			   enabled,
+			   qsd->qsd_type_array[USRQUOTA]->qqi_glb_uptodate,
+			   qsd->qsd_type_array[USRQUOTA]->qqi_slv_uptodate,
+			   qsd->qsd_type_array[USRQUOTA]->qqi_reint,
+			   qsd->qsd_type_array[GRPQUOTA]->qqi_glb_uptodate,
+			   qsd->qsd_type_array[GRPQUOTA]->qqi_slv_uptodate,
+			   qsd->qsd_type_array[GRPQUOTA]->qqi_reint);
 	}
-	return rc;
+	return 0;
 }
 LPROC_SEQ_FOPS_RO(qsd_state);
 
@@ -136,14 +135,15 @@ static int qsd_enabled_seq_show(struct seq_file *m, void *data)
 	if (strlen(enabled) == 0)
 		strcat(enabled, "none");
 
-	return seq_printf(m, "%s\n", enabled);
+	seq_printf(m, "%s\n", enabled);
+	return 0;
 }
 LPROC_SEQ_FOPS_RO(qsd_enabled);
 
 /* force reintegration procedure to be executed.
  * Used for test/debugging purpose */
 static ssize_t
-lprocfs_force_reint_seq_write(struct file *file, const char *buffer,
+lprocfs_force_reint_seq_write(struct file *file, const char __user *buffer,
 				size_t count, loff_t *off)
 {
 	struct qsd_instance *qsd = ((struct seq_file *)file->private_data)->private;
@@ -160,7 +160,7 @@ lprocfs_force_reint_seq_write(struct file *file, const char *buffer,
 		rc = -EAGAIN;
 	} else {
 		/* mark all indexes as stale */
-		for (qtype = USRQUOTA; qtype < MAXQUOTAS; qtype++) {
+		for (qtype = USRQUOTA; qtype < LL_MAXQUOTAS; qtype++) {
 			qsd->qsd_type_array[qtype]->qqi_glb_uptodate = false;
 			qsd->qsd_type_array[qtype]->qqi_slv_uptodate = false;
 		}
@@ -171,7 +171,7 @@ lprocfs_force_reint_seq_write(struct file *file, const char *buffer,
 		return rc;
 
 	/* kick off reintegration */
-	for (qtype = USRQUOTA; qtype < MAXQUOTAS; qtype++) {
+	for (qtype = USRQUOTA; qtype < LL_MAXQUOTAS; qtype++) {
 		rc = qsd_start_reint_thread(qsd->qsd_type_array[qtype]);
 		if (rc)
 			break;
@@ -185,21 +185,23 @@ static int qsd_timeout_seq_show(struct seq_file *m, void *data)
 	struct qsd_instance *qsd = m->private;
 	LASSERT(qsd != NULL);
 
-	return seq_printf(m, "%d\n", qsd_wait_timeout(qsd));
+	seq_printf(m, "%d\n", qsd_wait_timeout(qsd));
+	return 0;
 }
 
 static ssize_t
-qsd_timeout_seq_write(struct file *file, const char *buffer,
+qsd_timeout_seq_write(struct file *file, const char __user *buffer,
 			size_t count, loff_t *off)
 {
 	struct qsd_instance *qsd = ((struct seq_file *)file->private_data)->private;
-	int		     timeout, rc;
+	int rc;
+	__s64 timeout;
 	LASSERT(qsd != NULL);
 
-	rc = lprocfs_write_helper(buffer, count, &timeout);
+	rc = lprocfs_str_to_s64(buffer, count, &timeout);
 	if (rc)
 		return rc;
-	if (timeout < 0)
+	if (timeout < 0 || timeout > INT_MAX)
 		return -EINVAL;
 
 	qsd->qsd_timeout = timeout;
@@ -207,11 +209,15 @@ qsd_timeout_seq_write(struct file *file, const char *buffer,
 }
 LPROC_SEQ_FOPS(qsd_timeout);
 
-static struct lprocfs_seq_vars lprocfs_quota_qsd_vars[] = {
-	{ "info",		&qsd_state_fops		},
-	{ "enabled",		&qsd_enabled_fops	},
-	{ "force_reint",	&qsd_force_reint_fops	},
-	{ "timeout",		&qsd_timeout_fops	},
+static struct lprocfs_vars lprocfs_quota_qsd_vars[] = {
+	{ .name	=	"info",
+	  .fops	=	&qsd_state_fops		},
+	{ .name	=	"enabled",
+	  .fops	=	&qsd_enabled_fops	},
+	{ .name	=	"force_reint",
+	  .fops	=	&qsd_force_reint_fops	},
+	{ .name	=	"timeout",
+	  .fops	=	&qsd_timeout_fops	},
 	{ NULL }
 };
 
@@ -246,7 +252,7 @@ static int qsd_conn_callback(void *data)
 	 * reintegration procedure (i.e. global lock enqueue and slave
 	 * index transfer) since the space usage reconciliation (i.e.
 	 * step 3) will have to wait for qsd_start() to be called */
-	for (type = USRQUOTA; type < MAXQUOTAS; type++) {
+	for (type = USRQUOTA; type < LL_MAXQUOTAS; type++) {
 		struct qsd_qtype_info *qqi = qsd->qsd_type_array[type];
 		wake_up(&qqi->qqi_reint_thread.t_ctl_waitq);
 	}
@@ -268,6 +274,7 @@ static void qsd_qtype_fini(const struct lu_env *env, struct qsd_instance *qsd,
 			   int qtype)
 {
 	struct qsd_qtype_info	*qqi;
+	int repeat = 0;
 	ENTRY;
 
 	if (qsd->qsd_type_array[qtype] == NULL)
@@ -276,8 +283,8 @@ static void qsd_qtype_fini(const struct lu_env *env, struct qsd_instance *qsd,
 	qsd->qsd_type_array[qtype] = NULL;
 
 	/* all deferred work lists should be empty */
-	LASSERT(cfs_list_empty(&qqi->qqi_deferred_glb));
-	LASSERT(cfs_list_empty(&qqi->qqi_deferred_slv));
+	LASSERT(list_empty(&qqi->qqi_deferred_glb));
+	LASSERT(list_empty(&qqi->qqi_deferred_slv));
 
 	/* shutdown lquota site */
 	if (qqi->qqi_site != NULL && !IS_ERR(qqi->qqi_site)) {
@@ -285,8 +292,31 @@ static void qsd_qtype_fini(const struct lu_env *env, struct qsd_instance *qsd,
 		qqi->qqi_site = NULL;
 	}
 
+	/* The qqi may still be holding by global locks which are being
+	 * canceled asynchronously (LU-4365), see the following steps:
+	 *
+	 * - On server umount, we try to clear all quota locks first by
+	 *   disconnecting LWP (which will invalidate import and cleanup
+	 *   all locks on it), however, if quota reint process is holding
+	 *   the global lock for reintegration at that time, global lock
+	 *   will fail to be cleared on LWP disconnection.
+	 *
+	 * - Umount process goes on and stops reint process, the global
+	 *   lock will be dropped on reint process exit, however, the lock
+	 *   cancel in done in asynchronous way, so the
+	 *   qsd_glb_blocking_ast() might haven't been called yet when we
+	 *   get here.
+	 */
+	while (atomic_read(&qqi->qqi_ref) > 1) {
+		CDEBUG(D_QUOTA, "qqi reference count %u, repeat: %d\n",
+		       atomic_read(&qqi->qqi_ref), repeat);
+		repeat++;
+		set_current_state(TASK_INTERRUPTIBLE);
+		schedule_timeout(cfs_time_seconds(1));
+	}
+
 	/* by now, all qqi users should have gone away */
-	LASSERT(cfs_atomic_read(&qqi->qqi_ref) == 1);
+	LASSERT(atomic_read(&qqi->qqi_ref) == 1);
 	lu_ref_fini(&qqi->qqi_reference);
 
 	/* release accounting object */
@@ -342,7 +372,7 @@ static int qsd_qtype_init(const struct lu_env *env, struct qsd_instance *qsd,
 	if (qqi == NULL)
 		RETURN(-ENOMEM);
 	qsd->qsd_type_array[qtype] = qqi;
-	cfs_atomic_set(&qqi->qqi_ref, 1); /* referenced from qsd */
+	atomic_set(&qqi->qqi_ref, 1); /* referenced from qsd */
 
 	/* set backpointer and other parameters */
 	qqi->qqi_qsd   = qsd;
@@ -355,8 +385,8 @@ static int qsd_qtype_init(const struct lu_env *env, struct qsd_instance *qsd,
 	qqi->qqi_reint        = false;
 	init_waitqueue_head(&qqi->qqi_reint_thread.t_ctl_waitq);
 	thread_set_flags(&qqi->qqi_reint_thread, SVC_STOPPED);
-	CFS_INIT_LIST_HEAD(&qqi->qqi_deferred_glb);
-	CFS_INIT_LIST_HEAD(&qqi->qqi_deferred_slv);
+	INIT_LIST_HEAD(&qqi->qqi_deferred_glb);
+	INIT_LIST_HEAD(&qqi->qqi_deferred_slv);
 
 	/* open accounting object */
 	LASSERT(qqi->qqi_acct_obj == NULL);
@@ -464,7 +494,7 @@ void qsd_fini(const struct lu_env *env, struct qsd_instance *qsd)
 	qsd_stop_upd_thread(qsd);
 
 	/* shutdown the reintegration threads */
-	for (qtype = USRQUOTA; qtype < MAXQUOTAS; qtype++) {
+	for (qtype = USRQUOTA; qtype < LL_MAXQUOTAS; qtype++) {
 		if (qsd->qsd_type_array[qtype] == NULL)
 			continue;
 		qsd_stop_reint_thread(qsd->qsd_type_array[qtype]);
@@ -475,7 +505,7 @@ void qsd_fini(const struct lu_env *env, struct qsd_instance *qsd)
 	}
 
 	/* free per-quota type data */
-	for (qtype = USRQUOTA; qtype < MAXQUOTAS; qtype++)
+	for (qtype = USRQUOTA; qtype < LL_MAXQUOTAS; qtype++)
 		qsd_qtype_fini(env, qsd, qtype);
 
 	/* deregister connection to the quota master */
@@ -484,10 +514,10 @@ void qsd_fini(const struct lu_env *env, struct qsd_instance *qsd)
 
 	/* release per-filesystem information */
 	if (qsd->qsd_fsinfo != NULL) {
-		down(&qsd->qsd_fsinfo->qfs_sem);
+		mutex_lock(&qsd->qsd_fsinfo->qfs_mutex);
 		/* remove from the list of fsinfo */
-		cfs_list_del_init(&qsd->qsd_link);
-		up(&qsd->qsd_fsinfo->qfs_sem);
+		list_del_init(&qsd->qsd_link);
+		mutex_unlock(&qsd->qsd_fsinfo->qfs_mutex);
 		qsd_put_fsinfo(qsd->qsd_fsinfo);
 		qsd->qsd_fsinfo = NULL;
 	}
@@ -526,7 +556,7 @@ EXPORT_SYMBOL(qsd_fini);
  */
 struct qsd_instance *qsd_init(const struct lu_env *env, char *svname,
 			      struct dt_device *dev,
-			      cfs_proc_dir_entry_t *osd_proc)
+			      struct proc_dir_entry *osd_proc)
 {
 	struct qsd_thread_info	*qti = qsd_info(env);
 	struct qsd_instance	*qsd;
@@ -545,12 +575,12 @@ struct qsd_instance *qsd_init(const struct lu_env *env, char *svname,
 
 	/* generic initializations */
 	rwlock_init(&qsd->qsd_lock);
-	CFS_INIT_LIST_HEAD(&qsd->qsd_link);
+	INIT_LIST_HEAD(&qsd->qsd_link);
 	thread_set_flags(&qsd->qsd_upd_thread, SVC_STOPPED);
 	init_waitqueue_head(&qsd->qsd_upd_thread.t_ctl_waitq);
-	CFS_INIT_LIST_HEAD(&qsd->qsd_upd_list);
+	INIT_LIST_HEAD(&qsd->qsd_upd_list);
 	spin_lock_init(&qsd->qsd_adjust_lock);
-	CFS_INIT_LIST_HEAD(&qsd->qsd_adjust_list);
+	INIT_LIST_HEAD(&qsd->qsd_adjust_list);
 	qsd->qsd_prepared = false;
 	qsd->qsd_started = false;
 
@@ -584,13 +614,13 @@ struct qsd_instance *qsd_init(const struct lu_env *env, char *svname,
 	}
 
 	/* add in the list of lquota_fsinfo */
-	down(&qsd->qsd_fsinfo->qfs_sem);
+	mutex_lock(&qsd->qsd_fsinfo->qfs_mutex);
 	list_add_tail(&qsd->qsd_link, &qsd->qsd_fsinfo->qfs_qsd_list);
-	up(&qsd->qsd_fsinfo->qfs_sem);
+	mutex_unlock(&qsd->qsd_fsinfo->qfs_mutex);
 
 	/* register procfs directory */
-	qsd->qsd_proc = lprocfs_seq_register(QSD_DIR, osd_proc,
-						lprocfs_quota_qsd_vars, qsd);
+	qsd->qsd_proc = lprocfs_register(QSD_DIR, osd_proc,
+					 lprocfs_quota_qsd_vars, qsd);
 	if (IS_ERR(qsd->qsd_proc)) {
 		rc = PTR_ERR(qsd->qsd_proc);
 		qsd->qsd_proc = NULL;
@@ -662,7 +692,7 @@ int qsd_prepare(const struct lu_env *env, struct qsd_instance *qsd)
 	}
 
 	/* initialize per-quota type data */
-	for (qtype = USRQUOTA; qtype < MAXQUOTAS; qtype++) {
+	for (qtype = USRQUOTA; qtype < LL_MAXQUOTAS; qtype++) {
 		rc = qsd_qtype_init(env, qsd, qtype);
 		if (rc)
 			RETURN(rc);
@@ -674,7 +704,7 @@ int qsd_prepare(const struct lu_env *env, struct qsd_instance *qsd)
 	write_unlock(&qsd->qsd_lock);
 
 	/* start reintegration thread for each type, if required */
-	for (qtype = USRQUOTA; qtype < MAXQUOTAS; qtype++) {
+	for (qtype = USRQUOTA; qtype < LL_MAXQUOTAS; qtype++) {
 		struct qsd_qtype_info	*qqi = qsd->qsd_type_array[qtype];
 
 		if (qsd_type_enabled(qsd, qtype) && qsd->qsd_acct_failed) {
@@ -704,7 +734,8 @@ int qsd_prepare(const struct lu_env *env, struct qsd_instance *qsd)
 	}
 
 	/* generate osp name */
-	rc = tgt_name2lwpname((char *)qsd->qsd_svname, qti->qti_buf);
+	rc = tgt_name2lwp_name(qsd->qsd_svname, qti->qti_buf,
+			       MTI_NAME_MAXLEN, 0);
 	if (rc) {
 		CERROR("%s: failed to generate ospname (%d)\n",
 		       qsd->qsd_svname, rc);
@@ -761,7 +792,7 @@ int qsd_start(const struct lu_env *env, struct qsd_instance *qsd)
 
 	/* Trigger the 3rd step of reintegration: If usage > granted, acquire
 	 * up to usage; If usage < granted, release down to usage.  */
-	for (type = USRQUOTA; type < MAXQUOTAS; type++) {
+	for (type = USRQUOTA; type < LL_MAXQUOTAS; type++) {
 		struct qsd_qtype_info	*qqi = qsd->qsd_type_array[type];
 		wake_up(&qqi->qqi_reint_thread.t_ctl_waitq);
 	}