4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License version 2 for more details. A copy is
14 * included in the COPYING file that accompanied this code.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 * Copyright (c) 2017, Intel Corporation.
25 * lustre/mgs/mgs_barrier.c
27 * Author: Fan, Yong <fan.yong@intel.com>
30 #define DEBUG_SUBSYSTEM S_MGS
31 #define D_MGS D_CONFIG
33 #include <uapi/linux/lustre/lustre_ioctl.h>
34 #include <lustre_swab.h>
35 #include <uapi/linux/lustre/lustre_barrier_user.h>
37 #include "mgs_internal.h"
40 * Handle the barrier lock glimpse reply.
42 * The barrier lock glimpse reply contains the target MDT's index and
43 * the barrier operation status on such MDT. With such infomation. If
44 * the MDT given barrier status is the expected one, then set related
45 * 'fsdb''s barrier bitmap; otherwise record the failure or status.
47 * \param[in] env pointer to the thread context
48 * \param[in] req pointer to the glimpse callback RPC request
49 * \param[in] data pointer the async glimpse callback data
50 * \param[in] rc the glimpse callback RPC return value
52 * \retval 0 for success
53 * \retval negative error number on failure
55 static int mgs_barrier_gl_interpret_reply(const struct lu_env *env,
56 struct ptlrpc_request *req,
59 struct ldlm_cb_async_args *ca = data;
60 struct fs_db *fsdb = ca->ca_set_arg->gl_interpret_data;
61 struct barrier_lvb *lvb;
65 if (rc == -ENODEV || rc == -EINVAL) {
66 /* The lock is useless, cancel it. */
67 ldlm_lock_cancel(ca->ca_lock);
74 lvb = req_capsule_server_swab_get(&req->rq_pill, &RMF_DLM_LVB,
75 lustre_swab_barrier_lvb);
77 GOTO(out, rc = -EPROTO);
79 if (lvb->lvb_status == fsdb->fsdb_barrier_expected) {
80 if (unlikely(lvb->lvb_index > INDEX_MAP_SIZE))
83 set_bit(lvb->lvb_index, fsdb->fsdb_barrier_map);
84 } else if (likely(!test_bit(lvb->lvb_index, fsdb->fsdb_barrier_map))) {
85 fsdb->fsdb_barrier_result = lvb->lvb_status;
92 fsdb->fsdb_barrier_result = rc;
98 * Send glimpse callback to the barrier locks holders.
100 * The glimpse callback takes the current barrier status. The barrier locks
101 * holders (on the MDTs) will take related barrier actions according to the
102 * given barrier status, then return their local barrier status.
104 * \param[in] env pointer to the thread context
105 * \param[in] mgs pointer to the MGS device
106 * \param[in] fsdb pointer the barrier 'fsdb'
107 * \param[in] timeout indicate when the barrier will be expired
108 * \param[in] expected the expected barrier status on remote servers (MDTs)
110 * \retval positive number for unexpected barrier status
111 * \retval 0 for success
112 * \retval negative error number on failure
114 static int mgs_barrier_glimpse_lock(const struct lu_env *env,
115 struct mgs_device *mgs,
117 __u32 timeout, __u32 expected)
119 union ldlm_gl_desc *desc = &mgs_env_info(env)->mgi_gl_desc;
120 struct ldlm_res_id res_id;
121 struct ldlm_resource *res;
122 struct ldlm_glimpse_work *work;
123 struct ldlm_glimpse_work *tmp;
125 struct list_head *pos;
130 LASSERT(fsdb->fsdb_mdt_count > 0);
132 rc = mgc_logname2resid(fsdb->fsdb_name, &res_id, MGS_CFG_T_BARRIER);
136 res = ldlm_resource_get(mgs->mgs_obd->obd_namespace, &res_id,
139 RETURN(PTR_ERR(res));
141 fsdb->fsdb_barrier_result = 0;
142 fsdb->fsdb_barrier_expected = expected;
143 desc->barrier_desc.lgbd_status = fsdb->fsdb_barrier_status;
144 desc->barrier_desc.lgbd_timeout = timeout;
147 list_for_each_entry(work, &gl_list, gl_list) {
151 LDLM_LOCK_RELEASE(work->gl_lock);
152 work->gl_lock = NULL;
155 /* It is not big issue to alloc more work item than needed. */
156 for (i = 0; i < fsdb->fsdb_mdt_count; i++) {
159 GOTO(out, rc = -ENOMEM);
161 list_add_tail(&work->gl_list, &gl_list);
164 work = list_first_entry(&gl_list, struct ldlm_glimpse_work, gl_list);
167 list_for_each(pos, &res->lr_granted) {
168 struct ldlm_lock *lock = list_entry(pos, struct ldlm_lock,
171 work->gl_lock = LDLM_LOCK_GET(lock);
173 work->gl_desc = desc;
174 work->gl_interpret_reply = mgs_barrier_gl_interpret_reply;
175 work->gl_interpret_data = fsdb;
177 if (unlikely(work->gl_list.next == &gl_list)) {
178 if (likely(pos->next == &res->lr_granted))
182 /* The granted locks are more than the MDTs count. */
186 work = list_entry(work->gl_list.next, struct ldlm_glimpse_work,
191 /* The MDTs count may be more than the granted locks. */
192 list_for_each_entry_safe_reverse(work, tmp, &gl_list, gl_list) {
196 list_del(&work->gl_list);
200 if (!list_empty(&gl_list))
201 rc = ldlm_glimpse_locks(res, &gl_list);
208 list_for_each_entry_safe(work, tmp, &gl_list, gl_list) {
209 list_del(&work->gl_list);
211 LDLM_LOCK_RELEASE(work->gl_lock);
215 ldlm_resource_putref(res);
217 rc = fsdb->fsdb_barrier_result;
222 static void mgs_barrier_bitmap_setup(struct mgs_device *mgs,
223 struct fs_db *b_fsdb,
226 struct fs_db *c_fsdb;
228 c_fsdb = mgs_find_fsdb(mgs, name);
229 if (likely(c_fsdb)) {
230 memcpy(b_fsdb->fsdb_mdt_index_map,
231 c_fsdb->fsdb_mdt_index_map, INDEX_MAP_SIZE);
232 b_fsdb->fsdb_mdt_count = c_fsdb->fsdb_mdt_count;
233 mgs_put_fsdb(mgs, c_fsdb);
237 static bool mgs_barrier_done(struct fs_db *fsdb)
241 for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
242 if (test_bit(i, fsdb->fsdb_mdt_index_map) &&
243 !test_bit(i, fsdb->fsdb_barrier_map))
250 static bool mgs_barrier_expired(struct fs_db *fsdb, time64_t timeout)
252 time64_t expired = fsdb->fsdb_barrier_latest_create_time + timeout;
254 return expired > ktime_get_real_seconds();
257 static inline bool mgs_barrier_tests_disabled(struct barrier_ctl *bc,
258 struct obd_export *exp,
261 __u64 flags = exp_connect_flags(exp);
263 if ((flags & OBD_CONNECT_MDS_MDS) && !(flags & OBD_CONNECT_BARRIER)) {
264 fsdb->fsdb_barrier_disabled = 1;
265 LCONSOLE_WARN("%s: Barrier incompatible connection %s\n",
267 obd_uuid2str(&exp->exp_client_uuid));
274 * Create the barrier for the given instance.
276 * We use two-phases barrier to guarantee that after the barrier setup:
277 * 1) All the server side pending async modification RPCs have been flushed.
278 * 2) Any subsequent modification will be blocked.
279 * 3) All async transactions on the MDTs have been committed.
281 * For phase1, we do the following:
283 * Firstly, it sets barrier flag on the instance that will block subsequent
284 * modifications from clients. (Note: server sponsored modification will be
285 * allowed for flush pending modifications)
287 * Secondly, it will flush all pending modification via dt_sync(), such as
288 * async OST-object destroy, async OST-object owner changes, and so on.
290 * If there are some on-handling clients sponsored modifications during the
291 * barrier creating, then related modifications may cause pending requests
292 * after the first dt_sync(), so call dt_sync() again after all on-handling
293 * modifications done.
295 * With the phase1 barrier set, all pending cross-servers modification RPCs
296 * have been flushed to remote servers, and any new modification will be
297 * blocked. But it does not guarantees that all the updates have been
298 * committed to storage on remote servers. So when all the instances have
299 * done phase1 barrier successfully, the MGS will notify all instances to
300 * do the phase2 barrier as following:
302 * Every barrier instance will call dt_sync() to make all async transactions
303 * to be committed locally.
305 * \param[in] env pointer to the thread context
306 * \param[in] mgs pointer to the MGS device
307 * \param[in] bc pointer the barrier control structure
309 * \retval 0 for success
310 * \retval negative error number on failure
312 static int mgs_barrier_freeze(const struct lu_env *env,
313 struct mgs_device *mgs,
314 struct barrier_ctl *bc)
316 char *name = mgs_env_info(env)->mgi_fsname;
324 snprintf(name, sizeof(mgs_env_info(env)->mgi_fsname) - 1, "%s-%s",
325 bc->bc_name, BARRIER_FILENAME);
327 down_write(&mgs->mgs_barrier_rwsem);
328 mutex_lock(&mgs->mgs_mutex);
330 rc = mgs_find_or_make_fsdb_nolock(env, mgs, name, &fsdb);
332 mutex_unlock(&mgs->mgs_mutex);
333 up_write(&mgs->mgs_barrier_rwsem);
337 if (unlikely(fsdb->fsdb_mdt_count == 0)) {
338 mgs_barrier_bitmap_setup(mgs, fsdb, bc->bc_name);
340 /* fsdb was just created, ensure that fsdb_barrier_disabled is
342 if (fsdb->fsdb_mdt_count > 0) {
343 struct obd_export *exp;
344 struct obd_device *mgs_obd = mgs->mgs_obd;
346 spin_lock(&mgs_obd->obd_dev_lock);
347 list_for_each_entry(exp, &mgs_obd->obd_exports,
349 if (mgs_barrier_tests_disabled(bc, exp, fsdb))
352 spin_unlock(&mgs_obd->obd_dev_lock);
356 mutex_lock(&fsdb->fsdb_mutex);
357 mutex_unlock(&mgs->mgs_mutex);
359 switch (fsdb->fsdb_barrier_status) {
369 if (mgs_barrier_expired(fsdb, fsdb->fsdb_barrier_timeout)) {
378 if (fsdb->fsdb_barrier_disabled) {
380 } else if (unlikely(fsdb->fsdb_mdt_count == 0)) {
383 fsdb->fsdb_barrier_latest_create_time =
384 ktime_get_real_seconds();
385 fsdb->fsdb_barrier_status = BS_FREEZING_P1;
386 if (bc->bc_timeout != 0)
387 fsdb->fsdb_barrier_timeout = bc->bc_timeout;
389 fsdb->fsdb_barrier_timeout =
390 BARRIER_TIMEOUT_DEFAULT;
391 memset(fsdb->fsdb_barrier_map, 0, INDEX_MAP_SIZE);
395 LCONSOLE_WARN("%s: found unexpected barrier status %u\n",
396 bc->bc_name, fsdb->fsdb_barrier_status);
404 left = fsdb->fsdb_barrier_timeout;
407 mutex_unlock(&fsdb->fsdb_mutex);
408 up_write(&mgs->mgs_barrier_rwsem);
410 CFS_FAIL_TIMEOUT(OBD_FAIL_BARRIER_DELAY, cfs_fail_val);
412 rc = mgs_barrier_glimpse_lock(env, mgs, fsdb, left,
413 phase1 ? BS_FREEZING_P1 : BS_FROZEN);
414 down_write(&mgs->mgs_barrier_rwsem);
415 mutex_lock(&fsdb->fsdb_mutex);
418 left = fsdb->fsdb_barrier_latest_create_time +
419 fsdb->fsdb_barrier_timeout - ktime_get_real_seconds();
421 fsdb->fsdb_barrier_status = BS_EXPIRED;
423 GOTO(out, rc = -ETIME);
426 LASSERTF(fsdb->fsdb_barrier_status ==
427 (phase1 ? BS_FREEZING_P1 : BS_FREEZING_P2),
428 "unexpected barrier status %u\n",
429 fsdb->fsdb_barrier_status);
431 if (rc == -ETIMEDOUT) {
432 fsdb->fsdb_barrier_status = BS_EXPIRED;
435 fsdb->fsdb_barrier_status = rc;
438 fsdb->fsdb_barrier_status = BS_FAILED;
439 } else if (mgs_barrier_done(fsdb)) {
441 fsdb->fsdb_barrier_status = BS_FREEZING_P2;
442 memset(fsdb->fsdb_barrier_map, 0,
448 fsdb->fsdb_barrier_status = BS_FROZEN;
451 fsdb->fsdb_barrier_status = BS_FAILED;
458 mutex_unlock(&fsdb->fsdb_mutex);
459 up_write(&mgs->mgs_barrier_rwsem);
461 memset(fsdb->fsdb_barrier_map, 0, INDEX_MAP_SIZE);
462 mgs_barrier_glimpse_lock(env, mgs, fsdb, 0, BS_THAWED);
465 mgs_put_fsdb(mgs, fsdb);
470 static int mgs_barrier_thaw(const struct lu_env *env,
471 struct mgs_device *mgs,
472 struct barrier_ctl *bc)
474 char *name = mgs_env_info(env)->mgi_fsname;
479 snprintf(name, sizeof(mgs_env_info(env)->mgi_fsname) - 1, "%s-%s",
480 bc->bc_name, BARRIER_FILENAME);
482 down_write(&mgs->mgs_barrier_rwsem);
483 mutex_lock(&mgs->mgs_mutex);
485 rc = mgs_find_or_make_fsdb_nolock(env, mgs, name, &fsdb);
487 mutex_unlock(&mgs->mgs_mutex);
488 up_write(&mgs->mgs_barrier_rwsem);
492 if (unlikely(fsdb->fsdb_mdt_count == 0)) {
493 mgs_barrier_bitmap_setup(mgs, fsdb, bc->bc_name);
495 /* fsdb was just created, ensure that fsdb_barrier_disabled is
497 if (fsdb->fsdb_mdt_count > 0) {
498 struct obd_export *exp;
499 struct obd_device *mgs_obd = mgs->mgs_obd;
501 spin_lock(&mgs_obd->obd_dev_lock);
502 list_for_each_entry(exp, &mgs_obd->obd_exports,
504 if (mgs_barrier_tests_disabled(bc, exp, fsdb))
507 spin_unlock(&mgs_obd->obd_dev_lock);
511 mutex_lock(&fsdb->fsdb_mutex);
512 mutex_unlock(&mgs->mgs_mutex);
514 switch (fsdb->fsdb_barrier_status) {
528 case BS_EXPIRED: /* The barrier on some MDT(s) may be expired,
529 * but may be not on others. Destory anyway. */
531 if (unlikely(fsdb->fsdb_mdt_count == 0)) {
534 fsdb->fsdb_barrier_status = BS_THAWING;
535 memset(fsdb->fsdb_barrier_map, 0, INDEX_MAP_SIZE);
539 LCONSOLE_WARN("%s: found unexpected barrier status %u\n",
540 bc->bc_name, fsdb->fsdb_barrier_status);
548 mutex_unlock(&fsdb->fsdb_mutex);
549 up_write(&mgs->mgs_barrier_rwsem);
551 CFS_FAIL_TIMEOUT(OBD_FAIL_BARRIER_DELAY, cfs_fail_val);
553 rc = mgs_barrier_glimpse_lock(env, mgs, fsdb, 0, BS_THAWED);
554 down_write(&mgs->mgs_barrier_rwsem);
555 mutex_lock(&fsdb->fsdb_mutex);
557 LASSERTF(fsdb->fsdb_barrier_status == BS_THAWING,
558 "unexpected barrier status %u\n",
559 fsdb->fsdb_barrier_status);
562 fsdb->fsdb_barrier_status = rc;
565 fsdb->fsdb_barrier_status = BS_FAILED;
566 } else if (mgs_barrier_done(fsdb)) {
567 fsdb->fsdb_barrier_status = BS_THAWED;
569 fsdb->fsdb_barrier_status = BS_FAILED;
576 mutex_unlock(&fsdb->fsdb_mutex);
577 up_write(&mgs->mgs_barrier_rwsem);
578 mgs_put_fsdb(mgs, fsdb);
583 static int mgs_barrier_stat(const struct lu_env *env,
584 struct mgs_device *mgs,
585 struct barrier_ctl *bc)
587 char *name = mgs_env_info(env)->mgi_fsname;
591 snprintf(name, sizeof(mgs_env_info(env)->mgi_fsname) - 1, "%s-%s",
592 bc->bc_name, BARRIER_FILENAME);
594 mutex_lock(&mgs->mgs_mutex);
596 fsdb = mgs_find_fsdb(mgs, name);
598 mutex_lock(&fsdb->fsdb_mutex);
599 mutex_unlock(&mgs->mgs_mutex);
601 bc->bc_status = fsdb->fsdb_barrier_status;
602 if (bc->bc_status == BS_FREEZING_P1 ||
603 bc->bc_status == BS_FREEZING_P2 ||
604 bc->bc_status == BS_FROZEN) {
605 if (mgs_barrier_expired(fsdb, fsdb->fsdb_barrier_timeout))
607 fsdb->fsdb_barrier_latest_create_time +
608 fsdb->fsdb_barrier_timeout -
609 ktime_get_real_seconds();
611 bc->bc_status = fsdb->fsdb_barrier_status =
615 mutex_unlock(&fsdb->fsdb_mutex);
616 mgs_put_fsdb(mgs, fsdb);
618 mutex_unlock(&mgs->mgs_mutex);
620 bc->bc_status = BS_INIT;
626 static int mgs_barrier_rescan(const struct lu_env *env,
627 struct mgs_device *mgs,
628 struct barrier_ctl *bc)
630 char *name = mgs_env_info(env)->mgi_fsname;
631 struct fs_db *b_fsdb;
632 struct fs_db *c_fsdb;
636 down_write(&mgs->mgs_barrier_rwsem);
637 mutex_lock(&mgs->mgs_mutex);
639 c_fsdb = mgs_find_fsdb(mgs, bc->bc_name);
640 if (!c_fsdb || unlikely(c_fsdb->fsdb_mdt_count == 0)) {
641 mutex_unlock(&mgs->mgs_mutex);
642 up_write(&mgs->mgs_barrier_rwsem);
647 snprintf(name, sizeof(mgs_env_info(env)->mgi_fsname) - 1, "%s-%s",
648 bc->bc_name, BARRIER_FILENAME);
649 rc = mgs_find_or_make_fsdb_nolock(env, mgs, name, &b_fsdb);
651 mutex_unlock(&mgs->mgs_mutex);
652 up_write(&mgs->mgs_barrier_rwsem);
653 mgs_put_fsdb(mgs, c_fsdb);
657 if (unlikely(b_fsdb->fsdb_mdt_count == 0 &&
658 c_fsdb->fsdb_mdt_count > 0)) {
659 /* fsdb was just created, ensure that fsdb_barrier_disabled is
661 struct obd_export *exp;
662 struct obd_device *mgs_obd = mgs->mgs_obd;
664 spin_lock(&mgs_obd->obd_dev_lock);
665 list_for_each_entry(exp, &mgs_obd->obd_exports,
667 if (mgs_barrier_tests_disabled(bc, exp, b_fsdb))
670 spin_unlock(&mgs_obd->obd_dev_lock);
673 mutex_lock(&b_fsdb->fsdb_mutex);
674 mutex_lock(&c_fsdb->fsdb_mutex);
675 mutex_unlock(&mgs->mgs_mutex);
677 switch (b_fsdb->fsdb_barrier_status) {
687 if (mgs_barrier_expired(b_fsdb, b_fsdb->fsdb_barrier_timeout)) {
696 b_fsdb->fsdb_barrier_latest_create_time = ktime_get_real_seconds();
697 b_fsdb->fsdb_barrier_status = BS_RESCAN;
698 memcpy(b_fsdb->fsdb_mdt_index_map, c_fsdb->fsdb_mdt_index_map,
700 memset(b_fsdb->fsdb_barrier_map, 0, INDEX_MAP_SIZE);
701 b_fsdb->fsdb_mdt_count = c_fsdb->fsdb_mdt_count;
704 LCONSOLE_WARN("%s: found unexpected barrier status %u\n",
705 bc->bc_name, b_fsdb->fsdb_barrier_status);
710 mutex_unlock(&c_fsdb->fsdb_mutex);
711 mgs_put_fsdb(mgs, c_fsdb);
717 mutex_unlock(&b_fsdb->fsdb_mutex);
718 up_write(&mgs->mgs_barrier_rwsem);
719 rc = mgs_barrier_glimpse_lock(env, mgs, b_fsdb, 0, BS_INIT);
720 down_write(&mgs->mgs_barrier_rwsem);
721 mutex_lock(&b_fsdb->fsdb_mutex);
723 LASSERTF(b_fsdb->fsdb_barrier_status == BS_RESCAN,
724 "unexpected barrier status %u\n",
725 b_fsdb->fsdb_barrier_status);
728 b_fsdb->fsdb_barrier_status = rc;
730 } else if (rc == -ETIMEDOUT &&
731 mgs_barrier_expired(b_fsdb, bc->bc_timeout)) {
732 memset(b_fsdb->fsdb_barrier_map, 0, INDEX_MAP_SIZE);
735 } else if (rc < 0 && rc != -ETIMEDOUT && rc != -ENODEV) {
736 b_fsdb->fsdb_barrier_status = BS_FAILED;
740 b_fsdb->fsdb_mdt_count = 0;
744 for (i = 0; i < INDEX_MAP_SIZE * 8; i++) {
745 if (test_bit(i, b_fsdb->fsdb_barrier_map)) {
746 b_fsdb->fsdb_mdt_count++;
747 } else if (test_bit(i, b_fsdb->fsdb_mdt_index_map)) {
748 b_fsdb->fsdb_mdt_count++;
753 bc->bc_total = b_fsdb->fsdb_mdt_count;
754 memcpy(b_fsdb->fsdb_mdt_index_map,
755 b_fsdb->fsdb_barrier_map, INDEX_MAP_SIZE);
756 b_fsdb->fsdb_barrier_status = BS_INIT;
762 mutex_unlock(&b_fsdb->fsdb_mutex);
763 up_write(&mgs->mgs_barrier_rwsem);
764 mgs_put_fsdb(mgs, b_fsdb);
769 int mgs_iocontrol_barrier(const struct lu_env *env,
770 struct mgs_device *mgs,
771 struct obd_ioctl_data *data)
773 struct barrier_ctl *bc = (struct barrier_ctl *)(data->ioc_inlbuf1);
777 if (unlikely(bc->bc_version != BARRIER_VERSION_V1))
780 if (unlikely(bc->bc_name[0] == '\0' ||
781 strnlen(bc->bc_name, sizeof(bc->bc_name)) > 8))
784 /* NOT allow barrier operations during recovery. */
785 if (unlikely(mgs->mgs_obd->obd_recovering))
788 switch (bc->bc_cmd) {
790 rc = mgs_barrier_freeze(env, mgs, bc);
793 rc = mgs_barrier_thaw(env, mgs, bc);
796 rc = mgs_barrier_stat(env, mgs, bc);
799 rc = mgs_barrier_rescan(env, mgs, bc);