~ubuntu-branches/ubuntu/trusty/drbd8/trusty

#define UUID_NEW_BM_OFFSET ((u64)0x0001000000000000ULL)

 * Trigger is definition of dev_to_disk macro, introduced with the

 * macro, so it is easy do have independent rate limits at different locations

 

#ifdef DRBD_ENABLE_FAULTS

        return 0;

}

        P_OUT_OF_SYNC         = 0x28, /* Mark as out of sync (Outrunning), data socket */

        P_RS_CANCEL           = 0x29, /* meta: Used to cancel RS_DATA_REQUEST packet by SyncSource */

        P_MAX_CMD             = 0x2A,

                [P_OUT_OF_SYNC]         = "OutOfSync",

#define DP_HARDBARRIER        1 /* no longer used */

         * for now, feature_flags and the reserved array shall be zero.

        u64 reserved[7];

        u32         max_bio_size;  /* Maximal size of a BIO */

struct p_block_desc {

        struct p_header80 head;

        u64 sector;

        u32 blksize;

        u32 pad;        /* to multiple of 8 Byte */

} __packed;

 

 * should fit within one _architecture independent_ page.

 * most architectures have used for a long time.

        struct p_block_desc      block_desc;

        struct hlist_node collision;

        struct hlist_node collision;

         * On successful completion, the epoch is released,

        CREATE_BARRIER,         /* next P_DATA is preceded by a P_BARRIER */

                                 * reconfiguring (nl_disk_conf, nl_net_conf) is disallowed,

        AHEAD_TO_SYNC_SOURCE,   /* Ahead -> SyncSource queued */

/* definition of bits in bm_flags to be used in drbd_bm_lock

 * and drbd_bitmap_io and friends. */

enum bm_flag {

        /* do we need to kfree, or vfree bm_pages? */

        BM_P_VMALLOCED = 0x10000, /* internal use only, will be masked out */

 

        /* currently locked for bulk operation */

        BM_LOCKED_MASK = 0x7,

 

        /* in detail, that is: */

        BM_DONT_CLEAR = 0x1,

        BM_DONT_SET   = 0x2,

        BM_DONT_TEST  = 0x4,

 

        /* (test bit, count bit) allowed (common case) */

        BM_LOCKED_TEST_ALLOWED = 0x3,

 

        /* testing bits, as well as setting new bits allowed, but clearing bits

         * would be unexpected.  Used during bitmap receive.  Setting new bits

         * requires sending of "out-of-sync" information, though. */

        BM_LOCKED_SET_ALLOWED = 0x1,

 

        /* clear is not expected while bitmap is locked for bulk operation */

};

 

 

        enum bm_flag flags;

                          md_sync_work,

                          start_resync_work;

        struct timer_list start_resync_timer;

        struct timer_list request_timer;

        atomic_t unacked_cnt;    /* Need to send replies for */

        /* blocks to resync in this run [unit BM_BLOCK_SIZE] */

        /* number of resync blocks that failed in this run */

        struct hlist_head *ee_hash; /* is protected by req_lock! */

        struct hlist_head *app_reads_hash; /* is protected by req_lock */

        int rs_planed;    /* resync sectors already planned */

        atomic_t ap_in_flight; /* App sectors in flight (waiting for ack) */

        int peer_max_bio_size;

        int local_max_bio_size;

/* returns 1 if it was successful,

extern enum drbd_state_rv drbd_change_state(struct drbd_conf *mdev,

                                            enum chg_state_flags f,

                                            union drbd_state mask,

                                            union drbd_state val);

extern enum drbd_state_rv _drbd_request_state(struct drbd_conf *,

                                              union drbd_state,

                                              union drbd_state,

                                              enum chg_state_flags);

extern enum drbd_state_rv __drbd_set_state(struct drbd_conf *, union drbd_state,

                                           enum chg_state_flags,

                                           struct completion *done);

extern int drbd_gen_and_send_sync_uuid(struct drbd_conf *mdev);

extern int drbd_send_oos(struct drbd_conf *mdev, struct drbd_request *req);

extern int drbd_send_sr_reply(struct drbd_conf *mdev, enum drbd_state_rv retcode);

void drbd_print_uuids(struct drbd_conf *mdev, const char *text);

                                 char *why, enum bm_flag flags);

extern int drbd_bitmap_io(struct drbd_conf *mdev,

                int (*io_fn)(struct drbd_conf *),

                char *why, enum bm_flag flags);

/* Since the smallest IO unit is usually 512 byte */

#define BME_PRIORITY   2  /* finish resync IO on this extent ASAP! App IO waiting! */

/* we allow up to 1 PiB now on 64bit architecture with "flexible" meta data */

#define DRBD_MAX_SECTORS_FLEX (1UL << 51)

/* corresponds to (1UL << 38) bits right now. */

#define DRBD_MAX_BIO_SIZE (1U<<(9+HT_SHIFT))

#define DRBD_MAX_BIO_SIZE_SAFE (1 << 12)       /* Works always = 4k */

/* set/clear/test only a few bits at a time */

extern int drbd_bm_count_bits(

        struct drbd_conf *mdev, const unsigned long s, const unsigned long e);

/* bm_set_bits variant for use while holding drbd_bm_lock,

 * may process the whole bitmap in one go */

extern int  drbd_bm_write_page(struct drbd_conf *mdev, unsigned int idx) __must_hold(local);

 

#define DRBD_END_OF_BITMAP      (~(unsigned long)0)

/* for _drbd_send_bitmap */

extern void drbd_bm_lock(struct drbd_conf *mdev, char *why, enum bm_flag flags);

extern int drbd_make_request(struct request_queue *q, struct bio *bio);

extern enum determine_dev_size drbd_determine_dev_size(struct drbd_conf *, enum dds_flags) __must_hold(local);

extern void drbd_reconsider_max_bio_size(struct drbd_conf *mdev);

extern enum drbd_state_rv drbd_set_role(struct drbd_conf *mdev,

                                        enum drbd_role new_role,

                                        int force);

extern void drbd_rs_controller_reset(struct drbd_conf *mdev);

extern int w_resync_timer(struct drbd_conf *, struct drbd_work *, int);

extern int w_send_oos(struct drbd_conf *, struct drbd_work *, int);

extern int w_start_resync(struct drbd_conf *, struct drbd_work *, int);

extern void start_resync_timer_fn(unsigned long data);

extern int drbd_rs_should_slow_down(struct drbd_conf *mdev, sector_t sector);

extern void drbd_advance_rs_marks(struct drbd_conf *mdev, unsigned long still_to_go);

extern int __drbd_set_out_of_sync(struct drbd_conf *mdev, sector_t sector,

static inline enum drbd_state_rv

_drbd_set_state(struct drbd_conf *mdev, union drbd_state ns,

                enum chg_state_flags flags, struct completion *done)

        enum drbd_state_rv rv;

                        if (mdev->state.disk > D_INCONSISTENT)

                                _drbd_set_state(_NS(mdev, disk, D_INCONSISTENT), CS_HARD, NULL);

        _drbd_thread_stop(thi, false, true);

        _drbd_thread_stop(thi, false, false);

        _drbd_thread_stop(thi, true, false);

 * C_SYNC_SOURCE sends P_RS_DATA_REPLY   (and expects P_WRITE_ACK with ID_SYNCER)

 

        /* This may be called from some endio handler,

         * so we must not sleep here. */

 

        /* this is to break it at compile time when we change that, in case we

         * want to support more than (1<<32) bits on a 32bit arch. */

        if (mdev->state.conn == C_VERIFY_S || mdev->state.conn == C_VERIFY_T)

                *bits_left = mdev->ov_left;

        else

                *bits_left = drbd_bm_total_weight(mdev) - mdev->rs_failed;

                /* Make sure the division happens in long context.

                 * We allow up to one petabyte storage right now,

                 * at a granularity of 4k per bit that is 2**38 bits.

                 * After shift right and multiplication by 1000,

                 * this should still fit easily into a 32bit long,

                 * so we don't need a 64bit division on 32bit arch.

                 * Note: currently we don't support such large bitmaps on 32bit

                 * arch anyways, but no harm done to be prepared for it here.

                 */

                unsigned int shift = mdev->rs_total > UINT_MAX ? 16 : 10;

                unsigned long left = *bits_left >> shift;

                unsigned long total = 1UL + (mdev->rs_total >> shift);

                unsigned long tmp = 1000UL - left * 1000UL/total;

static inline int drbd_state_is_stable(struct drbd_conf *mdev)

        union drbd_state s = mdev->state;

        case C_AHEAD:

        case C_BEHIND:

                /* transitional states, IO allowed */

                break;

 

                /* Allow IO in BM exchange states with new protocols */

                if (mdev->agreed_pro_version < 96)

                        return 0;

                break;

 

                /* no new io accepted in these states */

        /* no new io accepted during transitional states */

static inline bool may_inc_ap_bio(struct drbd_conf *mdev)

                return false;

                return false;

        if (!drbd_state_is_stable(mdev))

                return false;

                return false;

                return false;

        return true;

}

 

static inline bool inc_ap_bio_cond(struct drbd_conf *mdev, int count)

{

        bool rv = false;

 

        spin_lock_irq(&mdev->req_lock);

        rv = may_inc_ap_bio(mdev);

        if (rv)

                atomic_add(count, &mdev->ap_bio_cnt);

        spin_unlock_irq(&mdev->req_lock);

 

        return rv;

}

 

         *    handshake as long as we would exceed the max_buffer limit.

        wait_event(mdev->misc_wait, inc_ap_bio_cond(mdev, count));

static inline int drbd_set_ed_uuid(struct drbd_conf *mdev, u64 val)

        int changed = mdev->ed_uuid != val;

        return changed;

#ifdef blk_queue_plugged

#else

static inline void drbd_blk_run_queue(struct request_queue *q)

{

}

static inline void drbd_kick_lo(struct drbd_conf *mdev)

{

}

#endif

        r = blkdev_issue_flush(mdev->ldev->md_bdev, GFP_KERNEL, NULL);