LU-2693 tests: check Lustre version in conf-sanity test 66

[fs/lustre-release.git] / lustre / osd-ldiskfs / osd_scrub.c

diff --git a/lustre/osd-ldiskfs/osd_scrub.c b/lustre/osd-ldiskfs/osd_scrub.c
index 7e58c20..fbfdecf 100644 (file)
--- a/lustre/osd-ldiskfs/osd_scrub.c
+++ b/lustre/osd-ldiskfs/osd_scrub.c
@@ -20,7 +20,7 @@
  * GPL HEADER END
  */
 /*
- * Copyright (c) 2012 Whamcloud, Inc.
+ * Copyright (c) 2012, Intel Corporation.
  */
 /*
  * lustre/osd-ldiskfs/osd_scrub.c
@@ -238,7 +238,7 @@ static int osd_scrub_prep(struct osd_device *dev)
        int                   rc;
        ENTRY;
 
-       cfs_down_write(&scrub->os_rwsem);
+       down_write(&scrub->os_rwsem);
        if (flags & SS_SET_FAILOUT)
                sf->sf_param |= SP_FAILOUT;
 
@@ -273,12 +273,12 @@ static int osd_scrub_prep(struct osd_device *dev)
        sf->sf_time_last_checkpoint = sf->sf_time_latest_start;
        rc = osd_scrub_file_store(scrub);
        if (rc == 0) {
-               cfs_spin_lock(&scrub->os_lock);
+               spin_lock(&scrub->os_lock);
                thread_set_flags(thread, SVC_RUNNING);
-               cfs_spin_unlock(&scrub->os_lock);
+               spin_unlock(&scrub->os_lock);
                cfs_waitq_broadcast(&thread->t_ctl_waitq);
        }
-       cfs_up_write(&scrub->os_rwsem);
+       up_write(&scrub->os_rwsem);
 
        RETURN(rc);
 }
@@ -289,13 +289,13 @@ osd_scrub_error(struct osd_device *dev, struct osd_inode_id *lid, int rc)
        struct osd_scrub  *scrub = &dev->od_scrub;
        struct scrub_file *sf    = &scrub->os_file;
 
-       cfs_down_write(&scrub->os_rwsem);
+       down_write(&scrub->os_rwsem);
        scrub->os_new_checked++;
        sf->sf_items_failed++;
        if (sf->sf_pos_first_inconsistent == 0 ||
            sf->sf_pos_first_inconsistent > lid->oii_ino)
                sf->sf_pos_first_inconsistent = lid->oii_ino;
-       cfs_up_write(&scrub->os_rwsem);
+       up_write(&scrub->os_rwsem);
        return sf->sf_param & SP_FAILOUT ? rc : 0;
 }
 
@@ -324,7 +324,7 @@ osd_scrub_check_update(struct osd_thread_info *info, struct osd_device *dev,
                oii = cfs_list_entry(oic, struct osd_inconsistent_item,
                                     oii_cache);
 
-       cfs_down_write(&scrub->os_rwsem);
+       down_write(&scrub->os_rwsem);
        scrub->os_new_checked++;
        if (lid->oii_ino < sf->sf_pos_latest_start && oii == NULL)
                GOTO(out, rc = 0);
@@ -348,9 +348,9 @@ iget:
                }
 
                /* Prevent the inode to be unlinked during OI scrub. */
-               cfs_mutex_lock(&inode->i_mutex);
+               mutex_lock(&inode->i_mutex);
                if (unlikely(inode->i_nlink == 0)) {
-                       cfs_mutex_unlock(&inode->i_mutex);
+                       mutex_unlock(&inode->i_mutex);
                        iput(inode);
                        GOTO(out, rc = 0);
                }
@@ -385,12 +385,15 @@ iget:
                GOTO(out, rc = -ENOMEM);
        }
 
-       if (ops == DTO_INDEX_UPDATE)
+       if (ops == DTO_INDEX_UPDATE) {
                rc = iam_update(jh, bag, (const struct iam_key *)oi_fid,
                                (struct iam_rec *)oi_id, ipd);
-       else
+       } else {
                rc = iam_insert(jh, bag, (const struct iam_key *)oi_fid,
                                (struct iam_rec *)oi_id, ipd);
+               if (rc == -EEXIST)
+                       rc = 1;
+       }
        osd_ipd_put(info->oti_env, bag, ipd);
        ldiskfs_journal_stop(jh);
        if (rc == 0) {
@@ -403,25 +406,27 @@ iget:
        GOTO(out, rc);
 
 out:
-       if (rc != 0) {
+       if (rc < 0) {
                sf->sf_items_failed++;
                if (sf->sf_pos_first_inconsistent == 0 ||
                    sf->sf_pos_first_inconsistent > lid->oii_ino)
                        sf->sf_pos_first_inconsistent = lid->oii_ino;
+       } else {
+               rc = 0;
        }
 
        if (ops == DTO_INDEX_INSERT) {
-               cfs_mutex_unlock(&inode->i_mutex);
+               mutex_unlock(&inode->i_mutex);
                iput(inode);
        }
-       cfs_up_write(&scrub->os_rwsem);
+       up_write(&scrub->os_rwsem);
 
        if (oii != NULL) {
                LASSERT(!cfs_list_empty(&oii->oii_list));
 
-               cfs_spin_lock(&scrub->os_lock);
+               spin_lock(&scrub->os_lock);
                cfs_list_del_init(&oii->oii_list);
-               cfs_spin_unlock(&scrub->os_lock);
+               spin_unlock(&scrub->os_lock);
                OBD_FREE_PTR(oii);
        }
        RETURN(sf->sf_param & SP_FAILOUT ? rc : 0);
@@ -433,7 +438,7 @@ static int do_osd_scrub_checkpoint(struct osd_scrub *scrub)
        int                rc;
        ENTRY;
 
-       cfs_down_write(&scrub->os_rwsem);
+       down_write(&scrub->os_rwsem);
        sf->sf_items_checked += scrub->os_new_checked;
        scrub->os_new_checked = 0;
        sf->sf_pos_last_checkpoint = scrub->os_pos_current;
@@ -441,7 +446,7 @@ static int do_osd_scrub_checkpoint(struct osd_scrub *scrub)
        sf->sf_run_time += cfs_duration_sec(cfs_time_current() + HALF_SEC -
                                            scrub->os_time_last_checkpoint);
        rc = osd_scrub_file_store(scrub);
-       cfs_up_write(&scrub->os_rwsem);
+       up_write(&scrub->os_rwsem);
 
        RETURN(rc);
 }
@@ -460,10 +465,10 @@ static void osd_scrub_post(struct osd_scrub *scrub, int result)
        struct scrub_file *sf = &scrub->os_file;
        ENTRY;
 
-       cfs_down_write(&scrub->os_rwsem);
-       cfs_spin_lock(&scrub->os_lock);
+       down_write(&scrub->os_rwsem);
+       spin_lock(&scrub->os_lock);
        thread_set_flags(&scrub->os_thread, SVC_STOPPING);
-       cfs_spin_unlock(&scrub->os_lock);
+       spin_unlock(&scrub->os_lock);
        if (scrub->os_new_checked > 0) {
                sf->sf_items_checked += scrub->os_new_checked;
                scrub->os_new_checked = 0;
@@ -491,7 +496,7 @@ static void osd_scrub_post(struct osd_scrub *scrub, int result)
                CERROR("%.16s: fail to osd_scrub_post, rc = %d\n",
                       LDISKFS_SB(osd_scrub2sb(scrub))->s_es->s_volume_name,
                       result);
-       cfs_up_write(&scrub->os_rwsem);
+       up_write(&scrub->os_rwsem);
 
        EXIT;
 }
@@ -591,9 +596,9 @@ static int osd_scrub_next(struct osd_thread_info *info, struct osd_device *dev,
        }
 
        if (OBD_FAIL_CHECK(OBD_FAIL_OSD_SCRUB_CRASH)) {
-               cfs_spin_lock(&scrub->os_lock);
+               spin_lock(&scrub->os_lock);
                thread_set_flags(thread, SVC_STOPPING);
-               cfs_spin_unlock(&scrub->os_lock);
+               spin_unlock(&scrub->os_lock);
                return SCRUB_NEXT_CRASH;
        }
 
@@ -698,10 +703,10 @@ static int osd_scrub_exec(struct osd_thread_info *info, struct osd_device *dev,
        }
 
        if (items != NULL) {
-               cfs_down_write(&scrub->os_rwsem);
+               down_write(&scrub->os_rwsem);
                scrub->os_new_checked++;
                (*items)++;
-               cfs_up_write(&scrub->os_rwsem);
+               up_write(&scrub->os_rwsem);
                goto next;
        }
 
@@ -920,10 +925,10 @@ out:
        lu_env_fini(&env);
 
 noenv:
-       cfs_spin_lock(&scrub->os_lock);
+       spin_lock(&scrub->os_lock);
        thread_set_flags(thread, SVC_STOPPED);
        cfs_waitq_broadcast(&thread->t_ctl_waitq);
-       cfs_spin_unlock(&scrub->os_lock);
+       spin_unlock(&scrub->os_lock);
        return rc;
 }
 
@@ -937,18 +942,21 @@ static int do_osd_scrub_start(struct osd_device *dev, __u32 flags)
 
 again:
        /* os_lock: sync status between stop and scrub thread */
-       cfs_spin_lock(&scrub->os_lock);
+       spin_lock(&scrub->os_lock);
        if (thread_is_running(thread)) {
-               cfs_spin_unlock(&scrub->os_lock);
+               spin_unlock(&scrub->os_lock);
                RETURN(-EALREADY);
        } else if (unlikely(thread_is_stopping(thread))) {
-               cfs_spin_unlock(&scrub->os_lock);
+               spin_unlock(&scrub->os_lock);
                l_wait_event(thread->t_ctl_waitq,
                             thread_is_stopped(thread),
                             &lwi);
                goto again;
        }
-       cfs_spin_unlock(&scrub->os_lock);
+       spin_unlock(&scrub->os_lock);
+
+       if (scrub->os_file.sf_status == SS_COMPLETED)
+               flags |= SS_RESET;
 
        scrub->os_start_flags = flags;
        thread_set_flags(thread, 0);
@@ -968,17 +976,13 @@ again:
 
 int osd_scrub_start(struct osd_device *dev)
 {
-       __u32 flags = SS_AUTO;
-       int   rc;
+       int rc;
        ENTRY;
 
-       if (dev->od_scrub.os_file.sf_status == SS_COMPLETED)
-               flags |= SS_RESET;
-
        /* od_otable_mutex: prevent curcurrent start/stop */
-       cfs_mutex_lock(&dev->od_otable_mutex);
-       rc = do_osd_scrub_start(dev, flags);
-       cfs_mutex_unlock(&dev->od_otable_mutex);
+       mutex_lock(&dev->od_otable_mutex);
+       rc = do_osd_scrub_start(dev, SS_AUTO);
+       mutex_unlock(&dev->od_otable_mutex);
 
        RETURN(rc == -EALREADY ? 0 : rc);
 }
@@ -989,28 +993,28 @@ static void do_osd_scrub_stop(struct osd_scrub *scrub)
        struct l_wait_info    lwi    = { 0 };
 
        /* os_lock: sync status between stop and scrub thread */
-       cfs_spin_lock(&scrub->os_lock);
+       spin_lock(&scrub->os_lock);
        if (!thread_is_init(thread) && !thread_is_stopped(thread)) {
                thread_set_flags(thread, SVC_STOPPING);
-               cfs_spin_unlock(&scrub->os_lock);
+               spin_unlock(&scrub->os_lock);
                cfs_waitq_broadcast(&thread->t_ctl_waitq);
                l_wait_event(thread->t_ctl_waitq,
                             thread_is_stopped(thread),
                             &lwi);
                /* Do not skip the last lock/unlock, which can guarantee that
                 * the caller cannot return until the OI scrub thread exit. */
-               cfs_spin_lock(&scrub->os_lock);
+               spin_lock(&scrub->os_lock);
        }
-       cfs_spin_unlock(&scrub->os_lock);
+       spin_unlock(&scrub->os_lock);
 }
 
 static void osd_scrub_stop(struct osd_device *dev)
 {
        /* od_otable_mutex: prevent curcurrent start/stop */
-       cfs_mutex_lock(&dev->od_otable_mutex);
+       mutex_lock(&dev->od_otable_mutex);
        dev->od_scrub.os_paused = 1;
        do_osd_scrub_stop(&dev->od_scrub);
-       cfs_mutex_unlock(&dev->od_otable_mutex);
+       mutex_unlock(&dev->od_otable_mutex);
 }
 
 static const char osd_scrub_name[] = "OI_scrub";
@@ -1039,8 +1043,8 @@ int osd_scrub_setup(const struct lu_env *env, struct osd_device *dev)
        ctxt->fs = get_ds();
 
        cfs_waitq_init(&scrub->os_thread.t_ctl_waitq);
-       cfs_init_rwsem(&scrub->os_rwsem);
-       cfs_spin_lock_init(&scrub->os_lock);
+       init_rwsem(&scrub->os_rwsem);
+       spin_lock_init(&scrub->os_lock);
        CFS_INIT_LIST_HEAD(&scrub->os_inconsistent_items);
 
        push_ctxt(&saved, ctxt, NULL);
@@ -1145,7 +1149,7 @@ static struct dt_it *osd_otable_it_init(const struct lu_env *env,
        ENTRY;
 
        /* od_otable_mutex: prevent curcurrent init/fini */
-       cfs_mutex_lock(&dev->od_otable_mutex);
+       mutex_lock(&dev->od_otable_mutex);
        if (dev->od_otable_it != NULL)
                GOTO(out, it = ERR_PTR(-EALREADY));
 
@@ -1183,7 +1187,7 @@ static struct dt_it *osd_otable_it_init(const struct lu_env *env,
        GOTO(out, it);
 
 out:
-       cfs_mutex_unlock(&dev->od_otable_mutex);
+       mutex_unlock(&dev->od_otable_mutex);
        return (struct dt_it *)it;
 }
 
@@ -1193,12 +1197,12 @@ static void osd_otable_it_fini(const struct lu_env *env, struct dt_it *di)
        struct osd_device    *dev = it->ooi_dev;
 
        /* od_otable_mutex: prevent curcurrent init/fini */
-       cfs_mutex_lock(&dev->od_otable_mutex);
+       mutex_lock(&dev->od_otable_mutex);
        do_osd_scrub_stop(&dev->od_scrub);
        LASSERT(dev->od_otable_it == it);
 
        dev->od_otable_it = NULL;
-       cfs_mutex_unlock(&dev->od_otable_mutex);
+       mutex_unlock(&dev->od_otable_mutex);
        OBD_FREE_PTR(it);
 }
 
@@ -1210,9 +1214,9 @@ static void osd_otable_it_put(const struct lu_env *env, struct dt_it *di)
        struct osd_device *dev = ((struct osd_otable_it *)di)->ooi_dev;
 
        /* od_otable_mutex: prevent curcurrent init/fini */
-       cfs_mutex_lock(&dev->od_otable_mutex);
+       mutex_lock(&dev->od_otable_mutex);
        dev->od_scrub.os_paused = 1;
-       cfs_mutex_unlock(&dev->od_otable_mutex);
+       mutex_unlock(&dev->od_otable_mutex);
 }
 
 /**
@@ -1401,9 +1405,9 @@ int osd_oii_insert(struct osd_device *dev, struct osd_idmap_cache *oic,
        oii->oii_cache = *oic;
        oii->oii_insert = insert;
 
-       cfs_spin_lock(&scrub->os_lock);
+       spin_lock(&scrub->os_lock);
        if (unlikely(!thread_is_running(thread))) {
-               cfs_spin_unlock(&scrub->os_lock);
+               spin_unlock(&scrub->os_lock);
                OBD_FREE_PTR(oii);
                RETURN(-EAGAIN);
        }
@@ -1411,7 +1415,7 @@ int osd_oii_insert(struct osd_device *dev, struct osd_idmap_cache *oic,
        if (cfs_list_empty(&scrub->os_inconsistent_items))
                wakeup = 1;
        cfs_list_add_tail(&oii->oii_list, &scrub->os_inconsistent_items);
-       cfs_spin_unlock(&scrub->os_lock);
+       spin_unlock(&scrub->os_lock);
 
        if (wakeup != 0)
                cfs_waitq_broadcast(&thread->t_ctl_waitq);
@@ -1426,15 +1430,15 @@ int osd_oii_lookup(struct osd_device *dev, const struct lu_fid *fid,
        struct osd_inconsistent_item *oii;
        ENTRY;
 
-       cfs_spin_lock(&scrub->os_lock);
+       spin_lock(&scrub->os_lock);
        cfs_list_for_each_entry(oii, &scrub->os_inconsistent_items, oii_list) {
                if (lu_fid_eq(fid, &oii->oii_cache.oic_fid)) {
                        *id = oii->oii_cache.oic_lid;
-                       cfs_spin_unlock(&scrub->os_lock);
+                       spin_unlock(&scrub->os_lock);
                        RETURN(0);
                }
        }
-       cfs_spin_unlock(&scrub->os_lock);
+       spin_unlock(&scrub->os_lock);
 
        RETURN(-ENOENT);
 }
@@ -1534,7 +1538,7 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
        int                ret     = -ENOSPC;
        int                rc;
 
-       cfs_down_read(&scrub->os_rwsem);
+       down_read(&scrub->os_rwsem);
        rc = snprintf(buf, len,
                      "name: OI scrub\n"
                      "magic: 0x%x\n"
@@ -1640,6 +1644,6 @@ int osd_scrub_dump(struct osd_device *dev, char *buf, int len)
        ret = save - len;
 
 out:
-       cfs_up_read(&scrub->os_rwsem);
+       up_read(&scrub->os_rwsem);
        return ret;
 }