LU-6068 misc: update Intel copyright messages 2014

[fs/lustre-release.git] / lustre / lfsck / lfsck_lib.c

diff --git a/lustre/lfsck/lfsck_lib.c b/lustre/lfsck/lfsck_lib.c
index e864119..8e31130 100644 (file)
--- a/lustre/lfsck/lfsck_lib.c
+++ b/lustre/lfsck/lfsck_lib.c
@@ -20,7 +20,7 @@
  * GPL HEADER END
  */
 /*
- * Copyright (c) 2012, 2013, Intel Corporation.
+ * Copyright (c) 2013, 2014, Intel Corporation.
  */
 /*
  * lustre/lfsck/lfsck_lib.c
@@ -53,6 +53,7 @@ static void lfsck_key_fini(const struct lu_context *ctx,
        struct lfsck_thread_info *info = data;
 
        lu_buf_free(&info->lti_linkea_buf);
+       lu_buf_free(&info->lti_linkea_buf2);
        lu_buf_free(&info->lti_big_buf);
        OBD_FREE_PTR(info);
 }
@@ -97,6 +98,7 @@ const char *lfsck_param_names[] = {
        "broadcast",
        "orphan",
        "create_ostobj",
+       "create_mdtobj",
        NULL
 };
 
@@ -390,10 +392,25 @@ int lfsck_ibits_lock(const struct lu_env *env, struct lfsck_instance *lfsck,
        memset(policy, 0, sizeof(*policy));
        policy->l_inodebits.bits = bits;
        fid_build_reg_res_name(lfsck_dto2fid(obj), resid);
-       rc = ldlm_cli_enqueue_local(lfsck->li_namespace, resid, LDLM_IBITS,
-                                   policy, mode, &flags, ldlm_blocking_ast,
-                                   ldlm_completion_ast, NULL, NULL, 0,
-                                   LVB_T_NONE, NULL, lh);
+       if (dt_object_remote(obj)) {
+               struct ldlm_enqueue_info *einfo = &info->lti_einfo;
+
+               memset(einfo, 0, sizeof(*einfo));
+               einfo->ei_type = LDLM_IBITS;
+               einfo->ei_mode = mode;
+               einfo->ei_cb_bl = ldlm_blocking_ast;
+               einfo->ei_cb_cp = ldlm_completion_ast;
+               einfo->ei_res_id = resid;
+
+               rc = dt_object_lock(env, obj, lh, einfo, policy);
+       } else {
+               rc = ldlm_cli_enqueue_local(lfsck->li_namespace, resid,
+                                           LDLM_IBITS, policy, mode,
+                                           &flags, ldlm_blocking_ast,
+                                           ldlm_completion_ast, NULL, NULL,
+                                           0, LVB_T_NONE, NULL, lh);
+       }
+
        if (rc == ELDLM_OK) {
                rc = 0;
        } else {
@@ -421,8 +438,25 @@ void lfsck_ibits_unlock(struct lustre_handle *lh, ldlm_mode_t mode)
        }
 }
 
-static const char dot[] = ".";
-static const char dotdot[] = "..";
+int lfsck_find_mdt_idx_by_fid(const struct lu_env *env,
+                             struct lfsck_instance *lfsck,
+                             const struct lu_fid *fid)
+{
+       struct seq_server_site  *ss     =
+                       lu_site2seq(lfsck->li_bottom->dd_lu_dev.ld_site);
+       struct lu_seq_range     *range  = &lfsck_env_info(env)->lti_range;
+       int                      rc;
+
+       fld_range_set_mdt(range);
+       rc = fld_server_lookup(env, ss->ss_server_fld, fid_seq(fid), range);
+       if (rc == 0)
+               rc = range->lsr_index;
+
+       return rc;
+}
+
+const char dot[] = ".";
+const char dotdot[] = "..";
 static const char dotlustre[] = ".lustre";
 static const char lostfound[] = "lost+found";
 
@@ -449,7 +483,7 @@ static int lfsck_create_lpf_local(const struct lu_env *env,
        ENTRY;
 
        rc = linkea_data_new(&ldata,
-                            &lfsck_env_info(env)->lti_linkea_buf);
+                            &lfsck_env_info(env)->lti_linkea_buf2);
        if (rc != 0)
                RETURN(rc);
 
@@ -593,7 +627,7 @@ static int lfsck_create_lpf_remote(const struct lu_env *env,
        ENTRY;
 
        rc = linkea_data_new(&ldata,
-                            &lfsck_env_info(env)->lti_linkea_buf);
+                            &lfsck_env_info(env)->lti_linkea_buf2);
        if (rc != 0)
                RETURN(rc);
 
@@ -917,13 +951,8 @@ static int lfsck_scan_lpf_bad_entries(const struct lu_env *env,
                        break;
 
                ent->lde_namelen = le16_to_cpu(ent->lde_namelen);
-               if (ent->lde_name[0] == '.') {
-                       if (ent->lde_namelen == 1)
-                               goto next;
-
-                       if (ent->lde_namelen == 2 && ent->lde_name[1] == '.')
-                               goto next;
-               }
+               if (name_is_dot_or_dotdot(ent->lde_name, ent->lde_namelen))
+                       goto next;
 
                /* name length must be strlen("MDTxxxx") */
                if (ent->lde_namelen != 7)
@@ -1410,6 +1439,9 @@ void lfsck_instance_cleanup(const struct lu_env *env,
        struct ptlrpc_thread    *thread = &lfsck->li_thread;
        struct lfsck_component  *com;
        struct lfsck_component  *next;
+       struct lfsck_lmv_unit   *llu;
+       struct lfsck_lmv_unit   *llu_next;
+       struct lfsck_lmv        *llmv;
        ENTRY;
 
        LASSERT(list_empty(&lfsck->li_link));
@@ -1421,6 +1453,17 @@ void lfsck_instance_cleanup(const struct lu_env *env,
        }
 
        LASSERT(lfsck->li_obj_dir == NULL);
+       LASSERT(lfsck->li_lmv == NULL);
+
+       list_for_each_entry_safe(llu, llu_next, &lfsck->li_list_lmv, llu_link) {
+               llmv = &llu->llu_lmv;
+
+               LASSERTF(atomic_read(&llmv->ll_ref) == 1,
+                        "still in using: %u\n",
+                        atomic_read(&llmv->ll_ref));
+
+               lfsck_lmv_put(env, llmv);
+       }
 
        list_for_each_entry_safe(com, next, &lfsck->li_list_scan, lc_link) {
                lfsck_component_cleanup(env, com);
@@ -1602,12 +1645,14 @@ bool __lfsck_set_speed(struct lfsck_instance *lfsck, __u32 limit)
        bool dirty = false;
 
        if (limit != LFSCK_SPEED_NO_LIMIT) {
-               if (limit > HZ) {
-                       lfsck->li_sleep_rate = limit / HZ;
+               if (limit > msecs_to_jiffies(MSEC_PER_SEC)) {
+                       lfsck->li_sleep_rate = limit /
+                                              msecs_to_jiffies(MSEC_PER_SEC);
                        lfsck->li_sleep_jif = 1;
                } else {
                        lfsck->li_sleep_rate = 1;
-                       lfsck->li_sleep_jif = HZ / limit;
+                       lfsck->li_sleep_jif = msecs_to_jiffies(MSEC_PER_SEC) /
+                                             limit;
                }
        } else {
                lfsck->li_sleep_jif = 0;
@@ -2496,7 +2541,8 @@ static int lfsck_start_all(const struct lu_env *env,
        lr->lr_param = start->ls_flags;
        lr->lr_async_windows = bk->lb_async_windows;
        lr->lr_valid = LSV_SPEED_LIMIT | LSV_ERROR_HANDLE | LSV_DRYRUN |
-                      LSV_ASYNC_WINDOWS;
+                      LSV_ASYNC_WINDOWS | LSV_CREATE_OSTOBJ |
+                      LSV_CREATE_MDTOBJ;
 
        laia->laia_com = NULL;
        laia->laia_ltds = ltds;
@@ -2857,7 +2903,7 @@ out:
 EXPORT_SYMBOL(lfsck_stop);
 
 int lfsck_in_notify(const struct lu_env *env, struct dt_device *key,
-                   struct lfsck_request *lr)
+                   struct lfsck_request *lr, struct thandle *th)
 {
        int rc = -EOPNOTSUPP;
        ENTRY;
@@ -2895,6 +2941,11 @@ int lfsck_in_notify(const struct lu_env *env, struct dt_device *key,
        case LE_FID_ACCESSED:
        case LE_PEER_EXIT:
        case LE_CONDITIONAL_DESTROY:
+       case LE_CREATE_ORPHAN:
+       case LE_SKIP_NLINK_DECLARE:
+       case LE_SKIP_NLINK:
+       case LE_SET_LMV_MASTER:
+       case LE_SET_LMV_SLAVE:
        case LE_PAIRS_VERIFY: {
                struct lfsck_instance  *lfsck;
                struct lfsck_component *com;
@@ -2905,7 +2956,7 @@ int lfsck_in_notify(const struct lu_env *env, struct dt_device *key,
 
                com = lfsck_component_find(lfsck, lr->lr_active);
                if (likely(com != NULL)) {
-                       rc = com->lc_ops->lfsck_in_notify(env, com, lr);
+                       rc = com->lc_ops->lfsck_in_notify(env, com, lr, th);
                        lfsck_component_put(env, com);
                }
 
@@ -2989,6 +3040,7 @@ int lfsck_register(const struct lu_env *env, struct dt_device *key,
        INIT_LIST_HEAD(&lfsck->li_list_dir);
        INIT_LIST_HEAD(&lfsck->li_list_double_scan);
        INIT_LIST_HEAD(&lfsck->li_list_idle);
+       INIT_LIST_HEAD(&lfsck->li_list_lmv);
        atomic_set(&lfsck->li_ref, 1);
        atomic_set(&lfsck->li_double_scan_count, 0);
        init_waitqueue_head(&lfsck->li_thread.t_ctl_waitq);