lkml.org 
[lkml]   [2005]   [Jul]   [15]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[patch 05/12] dlm: rsb flag ops with inlined functions
    Replace test/set/clear_bit of rsb flags with new inline functions that use
    the less expense non-atomic bit ops.

    Signed-off-by: David Teigland <teigland@redhat.com>

    Index: linux-2.6.12-mm1/drivers/dlm/debug_fs.c
    ===================================================================
    --- linux-2.6.12-mm1.orig/drivers/dlm/debug_fs.c
    +++ linux-2.6.12-mm1/drivers/dlm/debug_fs.c
    @@ -114,7 +114,7 @@ static int print_resource(struct dlm_rsb
    seq_printf(s, "%02x ",
    (unsigned char) res->res_lvbptr[i]);
    }
    - if (test_bit(RESFL_VALNOTVALID, &res->res_flags))
    + if (rsb_flag(res, RSB_VALNOTVALID))
    seq_printf(s, " (INVALID)");
    seq_printf(s, "\n");
    }
    Index: linux-2.6.12-mm1/drivers/dlm/dlm_internal.h
    ===================================================================
    --- linux-2.6.12-mm1.orig/drivers/dlm/dlm_internal.h
    +++ linux-2.6.12-mm1/drivers/dlm/dlm_internal.h
    @@ -262,25 +262,11 @@ struct dlm_lkb {
    long lkb_astparam; /* caller's ast arg */
    };

    -
    -/* find_rsb() flags */
    -
    -#define R_MASTER 1 /* only return rsb if it's a master */
    -#define R_CREATE 2 /* create/add rsb if not found */
    -
    -#define RESFL_MASTER_WAIT 0
    -#define RESFL_MASTER_UNCERTAIN 1
    -#define RESFL_VALNOTVALID 2
    -#define RESFL_VALNOTVALID_PREV 3
    -#define RESFL_NEW_MASTER 4
    -#define RESFL_NEW_MASTER2 5
    -#define RESFL_RECOVER_CONVERT 6
    -
    struct dlm_rsb {
    struct dlm_ls *res_ls; /* the lockspace */
    struct kref res_ref;
    struct semaphore res_sem;
    - unsigned long res_flags; /* RESFL_ */
    + unsigned long res_flags;
    int res_length; /* length of rsb name */
    int res_nodeid;
    uint32_t res_lvbseq;
    @@ -301,6 +287,38 @@ struct dlm_rsb {
    char res_name[1];
    };

    +/* find_rsb() flags */
    +
    +#define R_MASTER 1 /* only return rsb if it's a master */
    +#define R_CREATE 2 /* create/add rsb if not found */
    +
    +/* rsb_flags */
    +
    +enum rsb_flags {
    + RSB_MASTER_WAIT,
    + RSB_MASTER_UNCERTAIN,
    + RSB_VALNOTVALID,
    + RSB_VALNOTVALID_PREV,
    + RSB_NEW_MASTER,
    + RSB_NEW_MASTER2,
    + RSB_RECOVER_CONVERT,
    +};
    +
    +static inline void rsb_set_flag(struct dlm_rsb *r, enum rsb_flags flag)
    +{
    + __set_bit(flag, &r->res_flags);
    +}
    +
    +static inline void rsb_clear_flag(struct dlm_rsb *r, enum rsb_flags flag)
    +{
    + __clear_bit(flag, &r->res_flags);
    +}
    +
    +static inline int rsb_flag(struct dlm_rsb *r, enum rsb_flags flag)
    +{
    + return test_bit(flag, &r->res_flags);
    +}
    +

    /* dlm_header is first element of all structs sent between nodes */

    Index: linux-2.6.12-mm1/drivers/dlm/lock.c
    ===================================================================
    --- linux-2.6.12-mm1.orig/drivers/dlm/lock.c
    +++ linux-2.6.12-mm1/drivers/dlm/lock.c
    @@ -317,18 +317,17 @@ static int _search_rsb(struct dlm_ls *ls
    list_move(&r->res_hashchain, &ls->ls_rsbtbl[b].list);

    if (r->res_nodeid == -1) {
    - clear_bit(RESFL_MASTER_WAIT, &r->res_flags);
    - clear_bit(RESFL_MASTER_UNCERTAIN, &r->res_flags);
    + rsb_clear_flag(r, RSB_MASTER_WAIT);
    + rsb_clear_flag(r, RSB_MASTER_UNCERTAIN);
    r->res_trial_lkid = 0;
    } else if (r->res_nodeid > 0) {
    - clear_bit(RESFL_MASTER_WAIT, &r->res_flags);
    - set_bit(RESFL_MASTER_UNCERTAIN, &r->res_flags);
    + rsb_clear_flag(r, RSB_MASTER_WAIT);
    + rsb_set_flag(r, RSB_MASTER_UNCERTAIN);
    r->res_trial_lkid = 0;
    } else {
    DLM_ASSERT(r->res_nodeid == 0, dlm_print_rsb(r););
    - DLM_ASSERT(!test_bit(RESFL_MASTER_WAIT, &r->res_flags),
    - dlm_print_rsb(r););
    - DLM_ASSERT(!test_bit(RESFL_MASTER_UNCERTAIN, &r->res_flags),);
    + DLM_ASSERT(!rsb_flag(r, RSB_MASTER_WAIT), dlm_print_rsb(r););
    + DLM_ASSERT(!rsb_flag(r, RSB_MASTER_UNCERTAIN),);
    }
    out:
    *r_ret = r;
    @@ -837,7 +836,7 @@ static void set_lvb_lock(struct dlm_rsb

    } else if (b == 0) {
    if (lkb->lkb_exflags & DLM_LKF_IVVALBLK) {
    - set_bit(RESFL_VALNOTVALID, &r->res_flags);
    + rsb_set_flag(r, RSB_VALNOTVALID);
    return;
    }

    @@ -856,10 +855,10 @@ static void set_lvb_lock(struct dlm_rsb
    memcpy(r->res_lvbptr, lkb->lkb_lvbptr, len);
    r->res_lvbseq++;
    lkb->lkb_lvbseq = r->res_lvbseq;
    - clear_bit(RESFL_VALNOTVALID, &r->res_flags);
    + rsb_clear_flag(r, RSB_VALNOTVALID);
    }

    - if (test_bit(RESFL_VALNOTVALID, &r->res_flags))
    + if (rsb_flag(r, RSB_VALNOTVALID))
    lkb->lkb_sbflags |= DLM_SBF_VALNOTVALID;
    }

    @@ -869,7 +868,7 @@ static void set_lvb_unlock(struct dlm_rs
    return;

    if (lkb->lkb_exflags & DLM_LKF_IVVALBLK) {
    - set_bit(RESFL_VALNOTVALID, &r->res_flags);
    + rsb_set_flag(r, RSB_VALNOTVALID);
    return;
    }

    @@ -887,7 +886,7 @@ static void set_lvb_unlock(struct dlm_rs

    memcpy(r->res_lvbptr, lkb->lkb_lvbptr, r->res_ls->ls_lvblen);
    r->res_lvbseq++;
    - clear_bit(RESFL_VALNOTVALID, &r->res_flags);
    + rsb_clear_flag(r, RSB_VALNOTVALID);
    }

    /* lkb is process copy (pc) */
    @@ -1419,8 +1418,9 @@ static int set_master(struct dlm_rsb *r,
    struct dlm_ls *ls = r->res_ls;
    int error, dir_nodeid, ret_nodeid, our_nodeid = dlm_our_nodeid();

    - if (test_and_clear_bit(RESFL_MASTER_UNCERTAIN, &r->res_flags)) {
    - set_bit(RESFL_MASTER_WAIT, &r->res_flags);
    + if (rsb_flag(r, RSB_MASTER_UNCERTAIN)) {
    + rsb_clear_flag(r, RSB_MASTER_UNCERTAIN);
    + rsb_set_flag(r, RSB_MASTER_WAIT);
    r->res_trial_lkid = lkb->lkb_id;
    lkb->lkb_nodeid = r->res_nodeid;
    return 0;
    @@ -1437,7 +1437,7 @@ static int set_master(struct dlm_rsb *r,
    return 0;
    }

    - if (test_bit(RESFL_MASTER_WAIT, &r->res_flags)) {
    + if (rsb_flag(r, RSB_MASTER_WAIT)) {
    list_add_tail(&lkb->lkb_rsb_lookup, &r->res_lookup);
    return 1;
    }
    @@ -1455,7 +1455,7 @@ static int set_master(struct dlm_rsb *r,
    dir_nodeid = dlm_dir_nodeid(r);

    if (dir_nodeid != our_nodeid) {
    - set_bit(RESFL_MASTER_WAIT, &r->res_flags);
    + rsb_set_flag(r, RSB_MASTER_WAIT);
    send_lookup(r, lkb);
    return 1;
    }
    @@ -1481,7 +1481,7 @@ static int set_master(struct dlm_rsb *r,
    return 0;
    }

    - set_bit(RESFL_MASTER_WAIT, &r->res_flags);
    + rsb_set_flag(r, RSB_MASTER_WAIT);
    r->res_trial_lkid = lkb->lkb_id;
    r->res_nodeid = ret_nodeid;
    lkb->lkb_nodeid = ret_nodeid;
    @@ -1503,7 +1503,7 @@ static void confirm_master(struct dlm_rs
    {
    struct dlm_lkb *lkb, *safe;

    - if (!test_bit(RESFL_MASTER_WAIT, &r->res_flags))
    + if (!rsb_flag(r, RSB_MASTER_WAIT))
    return;

    switch (error) {
    @@ -1512,7 +1512,7 @@ static void confirm_master(struct dlm_rs
    /* the remote master queued our request, or
    the remote dir node told us we're the master */

    - clear_bit(RESFL_MASTER_WAIT, &r->res_flags);
    + rsb_clear_flag(r, RSB_MASTER_WAIT);
    r->res_trial_lkid = 0;

    list_for_each_entry_safe(lkb, safe, &r->res_lookup,
    @@ -1544,7 +1544,7 @@ static void confirm_master(struct dlm_rs

    r->res_nodeid = -1;
    r->res_trial_lkid = 0;
    - clear_bit(RESFL_MASTER_WAIT, &r->res_flags);
    + rsb_clear_flag(r, RSB_MASTER_WAIT);
    break;

    default:
    @@ -2830,7 +2830,7 @@ static void receive_request_reply(struct
    case -ENOTBLK:
    /* find_rsb failed to find rsb or rsb wasn't master */

    - DLM_ASSERT(test_bit(RESFL_MASTER_WAIT, &r->res_flags),
    + DLM_ASSERT(rsb_flag(r, RSB_MASTER_WAIT),
    log_print("receive_request_reply error %d", error);
    dlm_print_lkb(lkb);
    dlm_print_rsb(r););
    @@ -3188,7 +3188,7 @@ static void recover_convert_waiter(struc

    /* Same special case as in receive_rcom_lock_args() */
    lkb->lkb_grmode = DLM_LOCK_IV;
    - set_bit(RESFL_RECOVER_CONVERT, &lkb->lkb_resource->res_flags);
    + rsb_set_flag(lkb->lkb_resource, RSB_RECOVER_CONVERT);
    unhold_lkb(lkb);

    } else if (lkb->lkb_rqmode >= lkb->lkb_grmode) {
    @@ -3482,7 +3482,7 @@ static int receive_rcom_lock_args(struct
    if (rl->rl_wait_type == DLM_MSG_CONVERT && middle_conversion(lkb)) {
    rl->rl_status = DLM_LKSTS_CONVERT;
    lkb->lkb_grmode = DLM_LOCK_IV;
    - set_bit(RESFL_RECOVER_CONVERT, &r->res_flags);
    + rsb_set_flag(r, RSB_RECOVER_CONVERT);
    }

    return 0;
    Index: linux-2.6.12-mm1/drivers/dlm/recover.c
    ===================================================================
    --- linux-2.6.12-mm1.orig/drivers/dlm/recover.c
    +++ linux-2.6.12-mm1/drivers/dlm/recover.c
    @@ -309,8 +309,8 @@ static void set_new_master(struct dlm_rs

    set_master_lkbs(r);

    - set_bit(RESFL_NEW_MASTER, &r->res_flags);
    - set_bit(RESFL_NEW_MASTER2, &r->res_flags);
    + rsb_set_flag(r, RSB_NEW_MASTER);
    + rsb_set_flag(r, RSB_NEW_MASTER2);
    unlock_rsb(r);
    }

    @@ -487,11 +487,11 @@ int dlm_recover_locks(struct dlm_ls *ls)
    down_read(&ls->ls_root_sem);
    list_for_each_entry(r, &ls->ls_root_list, res_root_list) {
    if (is_master(r)) {
    - clear_bit(RESFL_NEW_MASTER, &r->res_flags);
    + rsb_clear_flag(r, RSB_NEW_MASTER);
    continue;
    }

    - if (!test_bit(RESFL_NEW_MASTER, &r->res_flags))
    + if (!rsb_flag(r, RSB_NEW_MASTER))
    continue;

    error = dlm_recovery_stopped(ls);
    @@ -525,7 +525,7 @@ void dlm_recovered_lock(struct dlm_rsb *
    {
    r->res_recover_locks_count--;
    if (!r->res_recover_locks_count) {
    - clear_bit(RESFL_NEW_MASTER, &r->res_flags);
    + rsb_clear_flag(r, RSB_NEW_MASTER);
    recover_list_del(r);
    }

    @@ -538,7 +538,7 @@ void dlm_recovered_lock(struct dlm_rsb *
    * the VALNOTVALID flag if necessary, and determining the correct lvb contents
    * based on the lvb's of the locks held on the rsb.
    *
    - * RESFL_VALNOTVALID is set if there are only NL/CR locks on the rsb. If it
    + * RSB_VALNOTVALID is set if there are only NL/CR locks on the rsb. If it
    * was already set prior to recovery, it's not cleared, regardless of locks.
    *
    * The LVB contents are only considered for changing when this is a new master
    @@ -594,10 +594,10 @@ static void recover_lvb(struct dlm_rsb *
    goto out;

    if (!big_lock_exists)
    - set_bit(RESFL_VALNOTVALID, &r->res_flags);
    + rsb_set_flag(r, RSB_VALNOTVALID);

    /* don't mess with the lvb unless we're the new master */
    - if (!test_bit(RESFL_NEW_MASTER2, &r->res_flags))
    + if (!rsb_flag(r, RSB_NEW_MASTER2))
    goto out;

    if (!r->res_lvbptr) {
    @@ -657,12 +657,12 @@ void dlm_recover_rsbs(struct dlm_ls *ls)
    list_for_each_entry(r, &ls->ls_root_list, res_root_list) {
    lock_rsb(r);
    if (is_master(r)) {
    - if (test_bit(RESFL_RECOVER_CONVERT, &r->res_flags))
    + if (rsb_flag(r, RSB_RECOVER_CONVERT))
    recover_conversion(r);
    recover_lvb(r);
    count++;
    }
    - clear_bit(RESFL_RECOVER_CONVERT, &r->res_flags);
    + rsb_clear_flag(r, RSB_RECOVER_CONVERT);
    unlock_rsb(r);
    }
    up_read(&ls->ls_root_sem);
    --
    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

    \
     
     \ /
      Last update: 2005-07-15 13:19    [W:0.040 / U:1.872 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site