dm kcopyd: avoid useless atomic operations

[linux-2.6-microblaze.git] / drivers / md / dm-kcopyd.c

diff --git a/drivers/md/dm-kcopyd.c b/drivers/md/dm-kcopyd.c
index 1bbe4a3..d85a65a 100644 (file)
--- a/drivers/md/dm-kcopyd.c
+++ b/drivers/md/dm-kcopyd.c
@@ -341,7 +341,7 @@ static void client_free_pages(struct dm_kcopyd_client *kc)
 struct kcopyd_job {
        struct dm_kcopyd_client *kc;
        struct list_head list;
-       unsigned long flags;
+       unsigned flags;
 
        /*
         * Error state of the job.
@@ -418,7 +418,7 @@ static struct kcopyd_job *pop_io_job(struct list_head *jobs,
         * constraint and sequential writes that are at the right position.
         */
        list_for_each_entry(job, jobs, list) {
-               if (job->rw == READ || !test_bit(DM_KCOPYD_WRITE_SEQ, &job->flags)) {
+               if (job->rw == READ || !(job->flags & BIT(DM_KCOPYD_WRITE_SEQ))) {
                        list_del(&job->list);
                        return job;
                }
@@ -525,7 +525,7 @@ static void complete_io(unsigned long error, void *context)
                else
                        job->read_err = 1;
 
-               if (!test_bit(DM_KCOPYD_IGNORE_ERROR, &job->flags)) {
+               if (!(job->flags & BIT(DM_KCOPYD_IGNORE_ERROR))) {
                        push(&kc->complete_jobs, job);
                        wake(kc);
                        return;
@@ -565,7 +565,7 @@ static int run_io_job(struct kcopyd_job *job)
         * If we need to write sequentially and some reads or writes failed,
         * no point in continuing.
         */
-       if (test_bit(DM_KCOPYD_WRITE_SEQ, &job->flags) &&
+       if (job->flags & BIT(DM_KCOPYD_WRITE_SEQ) &&
            job->master_job->write_err) {
                job->write_err = job->master_job->write_err;
                return -EIO;
@@ -709,7 +709,7 @@ static void segment_complete(int read_err, unsigned long write_err,
         * Only dispatch more work if there hasn't been an error.
         */
        if ((!job->read_err && !job->write_err) ||
-           test_bit(DM_KCOPYD_IGNORE_ERROR, &job->flags)) {
+           job->flags & BIT(DM_KCOPYD_IGNORE_ERROR)) {
                /* get the next chunk of work */
                progress = job->progress;
                count = job->source.count - progress;
@@ -801,10 +801,10 @@ void dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
         * we need to write sequentially. If one of the destination is a
         * host-aware device, then leave it to the caller to choose what to do.
         */
-       if (!test_bit(DM_KCOPYD_WRITE_SEQ, &job->flags)) {
+       if (!(job->flags & BIT(DM_KCOPYD_WRITE_SEQ))) {
                for (i = 0; i < job->num_dests; i++) {
                        if (bdev_zoned_model(dests[i].bdev) == BLK_ZONED_HM) {
-                               set_bit(DM_KCOPYD_WRITE_SEQ, &job->flags);
+                               job->flags |= BIT(DM_KCOPYD_WRITE_SEQ);
                                break;
                        }
                }
@@ -813,9 +813,9 @@ void dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
        /*
         * If we need to write sequentially, errors cannot be ignored.
         */
-       if (test_bit(DM_KCOPYD_WRITE_SEQ, &job->flags) &&
-           test_bit(DM_KCOPYD_IGNORE_ERROR, &job->flags))
-               clear_bit(DM_KCOPYD_IGNORE_ERROR, &job->flags);
+       if (job->flags & BIT(DM_KCOPYD_WRITE_SEQ) &&
+           job->flags & BIT(DM_KCOPYD_IGNORE_ERROR))
+               job->flags &= ~BIT(DM_KCOPYD_IGNORE_ERROR);
 
        if (from) {
                job->source = *from;