/* SPDX-License-Identifier: GPL-2.0-only */ /* drbd_int.h This file is part of DRBD by Philipp Reisner and Lars Ellenberg. Copyright (C) 2001-2008, LINBIT Information Technologies GmbH. Copyright (C) 1999-2008, Philipp Reisner <[email protected]>. Copyright (C) 2002-2008, Lars Ellenberg <[email protected]>. */ #ifndef _DRBD_INT_H #define _DRBD_INT_H #include <crypto/hash.h> #include <linux/compiler.h> #include <linux/types.h> #include <linux/list.h> #include <linux/sched/signal.h> #include <linux/bitops.h> #include <linux/slab.h> #include <linux/ratelimit.h> #include <linux/tcp.h> #include <linux/mutex.h> #include <linux/major.h> #include <linux/blkdev.h> #include <linux/backing-dev.h> #include <linux/idr.h> #include <linux/dynamic_debug.h> #include <net/tcp.h> #include <linux/lru_cache.h> #include <linux/prefetch.h> #include <linux/drbd_genl_api.h> #include <linux/drbd.h> #include <linux/drbd_config.h> #include "drbd_strings.h" #include "drbd_state.h" #include "drbd_protocol.h" #include "drbd_polymorph_printk.h" /* shared module parameters, defined in drbd_main.c */ #ifdef CONFIG_DRBD_FAULT_INJECTION extern int drbd_enable_faults; extern int drbd_fault_rate; #endif extern unsigned int drbd_minor_count; extern char drbd_usermode_helper[]; extern int drbd_proc_details; /* This is used to stop/restart our threads. * Cannot use SIGTERM nor SIGKILL, since these * are sent out by init on runlevel changes * I choose SIGHUP for now. */ #define DRBD_SIGKILL … #define ID_IN_SYNC … #define ID_OUT_OF_SYNC … #define ID_SYNCER … #define UUID_NEW_BM_OFFSET … struct drbd_device; struct drbd_connection; struct drbd_peer_device; /* Defines to control fault insertion */ enum { … }; extern unsigned int _drbd_insert_fault(struct drbd_device *device, unsigned int type); static inline int drbd_insert_fault(struct drbd_device *device, unsigned int type) { … } /* integer division, round _UP_ to the next integer */ #define div_ceil(A, B) … /* usual integer division */ #define div_floor(A, B) … extern struct ratelimit_state drbd_ratelimit_state; extern struct idr drbd_devices; /* RCU, updates: genl_lock() */ extern struct list_head drbd_resources; /* RCU, updates: genl_lock() */ extern const char *cmdname(enum drbd_packet cmd); /* for sending/receiving the bitmap, * possibly in some encoding scheme */ struct bm_xfer_ctx { … }; extern void INFO_bm_xfer_stats(struct drbd_peer_device *peer_device, const char *direction, struct bm_xfer_ctx *c); static inline void bm_xfer_ctx_bit_to_word_offset(struct bm_xfer_ctx *c) { … } extern unsigned int drbd_header_size(struct drbd_connection *connection); /**********************************************************************/ enum drbd_thread_state { … }; struct drbd_thread { … }; static inline enum drbd_thread_state get_t_state(struct drbd_thread *thi) { … } struct drbd_work { … }; struct drbd_device_work { … }; #include "drbd_interval.h" extern int drbd_wait_misc(struct drbd_device *, struct drbd_interval *); extern void lock_all_resources(void); extern void unlock_all_resources(void); struct drbd_request { … }; struct drbd_epoch { … }; /* drbd_epoch flag bits */ enum { … }; enum epoch_event { … }; struct digest_info { … }; struct drbd_peer_request { … }; /* Equivalent to bio_op and req_op. */ #define peer_req_op(peer_req) … /* ee flag bits. * While corresponding bios are in flight, the only modification will be * set_bit WAS_ERROR, which has to be atomic. * If no bios are in flight yet, or all have been completed, * non-atomic modification to ee->flags is ok. */ enum { … }; #define EE_CALL_AL_COMPLETE_IO … #define EE_MAY_SET_IN_SYNC … #define EE_TRIM … #define EE_ZEROOUT … #define EE_RESUBMITTED … #define EE_WAS_ERROR … #define EE_HAS_DIGEST … #define EE_RESTART_REQUESTS … #define EE_SEND_WRITE_ACK … #define EE_IN_INTERVAL_TREE … #define EE_SUBMITTED … #define EE_WRITE … #define EE_WRITE_SAME … #define EE_APPLICATION … #define EE_RS_THIN_REQ … /* flag bits per device */ enum { … }; struct drbd_bitmap; /* opaque for drbd_device */ /* definition of bits in bm_flags to be used in drbd_bm_lock * and drbd_bitmap_io and friends. */ enum bm_flag { … }; struct drbd_work_queue { … }; struct drbd_socket { … }; struct drbd_md { … }; struct drbd_backing_dev { … }; struct drbd_md_io { … }; struct bm_io_work { … }; struct fifo_buffer { … }; extern struct fifo_buffer *fifo_alloc(unsigned int fifo_size); /* flag bits per connection */ enum { … }; enum which_state { … }; struct drbd_resource { … }; struct drbd_thread_timing_details { … }; struct drbd_connection { … }; static inline bool has_net_conf(struct drbd_connection *connection) { … } void __update_timing_details( struct drbd_thread_timing_details *tdp, unsigned int *cb_nr, void *cb, const char *fn, const unsigned int line); #define update_worker_timing_details(c, cb) … #define update_receiver_timing_details(c, cb) … struct submit_worker { … }; struct drbd_peer_device { … }; struct drbd_device { … }; struct drbd_bm_aio_ctx { … }; struct drbd_config_context { … }; static inline struct drbd_device *minor_to_device(unsigned int minor) { … } static inline struct drbd_peer_device *first_peer_device(struct drbd_device *device) { … } static inline struct drbd_peer_device * conn_peer_device(struct drbd_connection *connection, int volume_number) { … } #define for_each_resource(resource, _resources) … #define for_each_resource_rcu(resource, _resources) … #define for_each_resource_safe(resource, tmp, _resources) … #define for_each_connection(connection, resource) … #define for_each_connection_rcu(connection, resource) … #define for_each_connection_safe(connection, tmp, resource) … #define for_each_peer_device(peer_device, device) … #define for_each_peer_device_rcu(peer_device, device) … #define for_each_peer_device_safe(peer_device, tmp, device) … static inline unsigned int device_to_minor(struct drbd_device *device) { … } /* * function declarations *************************/ /* drbd_main.c */ enum dds_flags { … }; extern void drbd_init_set_defaults(struct drbd_device *device); extern int drbd_thread_start(struct drbd_thread *thi); extern void _drbd_thread_stop(struct drbd_thread *thi, int restart, int wait); #ifdef CONFIG_SMP extern void drbd_thread_current_set_cpu(struct drbd_thread *thi); #else #define drbd_thread_current_set_cpu … #endif extern void tl_release(struct drbd_connection *, unsigned int barrier_nr, unsigned int set_size); extern void tl_clear(struct drbd_connection *); extern void drbd_free_sock(struct drbd_connection *connection); extern int drbd_send(struct drbd_connection *connection, struct socket *sock, void *buf, size_t size, unsigned msg_flags); extern int drbd_send_all(struct drbd_connection *, struct socket *, void *, size_t, unsigned); extern int __drbd_send_protocol(struct drbd_connection *connection, enum drbd_packet cmd); extern int drbd_send_protocol(struct drbd_connection *connection); extern int drbd_send_uuids(struct drbd_peer_device *); extern int drbd_send_uuids_skip_initial_sync(struct drbd_peer_device *); extern void drbd_gen_and_send_sync_uuid(struct drbd_peer_device *); extern int drbd_send_sizes(struct drbd_peer_device *, int trigger_reply, enum dds_flags flags); extern int drbd_send_state(struct drbd_peer_device *, union drbd_state s); extern int drbd_send_current_state(struct drbd_peer_device *); extern int drbd_send_sync_param(struct drbd_peer_device *); extern void drbd_send_b_ack(struct drbd_connection *connection, u32 barrier_nr, u32 set_size); extern int drbd_send_ack(struct drbd_peer_device *, enum drbd_packet, struct drbd_peer_request *); extern void drbd_send_ack_rp(struct drbd_peer_device *, enum drbd_packet, struct p_block_req *rp); extern void drbd_send_ack_dp(struct drbd_peer_device *, enum drbd_packet, struct p_data *dp, int data_size); extern int drbd_send_ack_ex(struct drbd_peer_device *, enum drbd_packet, sector_t sector, int blksize, u64 block_id); extern int drbd_send_out_of_sync(struct drbd_peer_device *, struct drbd_request *); extern int drbd_send_block(struct drbd_peer_device *, enum drbd_packet, struct drbd_peer_request *); extern int drbd_send_dblock(struct drbd_peer_device *, struct drbd_request *req); extern int drbd_send_drequest(struct drbd_peer_device *, int cmd, sector_t sector, int size, u64 block_id); extern int drbd_send_drequest_csum(struct drbd_peer_device *, sector_t sector, int size, void *digest, int digest_size, enum drbd_packet cmd); extern int drbd_send_ov_request(struct drbd_peer_device *, sector_t sector, int size); extern int drbd_send_bitmap(struct drbd_device *device, struct drbd_peer_device *peer_device); extern void drbd_send_sr_reply(struct drbd_peer_device *, enum drbd_state_rv retcode); extern void conn_send_sr_reply(struct drbd_connection *connection, enum drbd_state_rv retcode); extern int drbd_send_rs_deallocated(struct drbd_peer_device *, struct drbd_peer_request *); extern void drbd_backing_dev_free(struct drbd_device *device, struct drbd_backing_dev *ldev); extern void drbd_device_cleanup(struct drbd_device *device); extern void drbd_print_uuids(struct drbd_device *device, const char *text); extern void drbd_queue_unplug(struct drbd_device *device); extern void conn_md_sync(struct drbd_connection *connection); extern void drbd_md_write(struct drbd_device *device, void *buffer); extern void drbd_md_sync(struct drbd_device *device); extern int drbd_md_read(struct drbd_device *device, struct drbd_backing_dev *bdev); extern void drbd_uuid_set(struct drbd_device *device, int idx, u64 val) __must_hold(…); extern void _drbd_uuid_set(struct drbd_device *device, int idx, u64 val) __must_hold(…); extern void drbd_uuid_new_current(struct drbd_device *device) __must_hold(…); extern void drbd_uuid_set_bm(struct drbd_device *device, u64 val) __must_hold(…); extern void drbd_uuid_move_history(struct drbd_device *device) __must_hold(…); extern void __drbd_uuid_set(struct drbd_device *device, int idx, u64 val) __must_hold(…); extern void drbd_md_set_flag(struct drbd_device *device, int flags) __must_hold(…); extern void drbd_md_clear_flag(struct drbd_device *device, int flags)__must_hold(…); extern int drbd_md_test_flag(struct drbd_backing_dev *, int); extern void drbd_md_mark_dirty(struct drbd_device *device); extern void drbd_queue_bitmap_io(struct drbd_device *device, int (*io_fn)(struct drbd_device *, struct drbd_peer_device *), void (*done)(struct drbd_device *, int), char *why, enum bm_flag flags, struct drbd_peer_device *peer_device); extern int drbd_bitmap_io(struct drbd_device *device, int (*io_fn)(struct drbd_device *, struct drbd_peer_device *), char *why, enum bm_flag flags, struct drbd_peer_device *peer_device); extern int drbd_bitmap_io_from_worker(struct drbd_device *device, int (*io_fn)(struct drbd_device *, struct drbd_peer_device *), char *why, enum bm_flag flags, struct drbd_peer_device *peer_device); extern int drbd_bmio_set_n_write(struct drbd_device *device, struct drbd_peer_device *peer_device) __must_hold(…); extern int drbd_bmio_clear_n_write(struct drbd_device *device, struct drbd_peer_device *peer_device) __must_hold(…); /* Meta data layout * * We currently have two possible layouts. * Offsets in (512 byte) sectors. * external: * |----------- md_size_sect ------------------| * [ 4k superblock ][ activity log ][ Bitmap ] * | al_offset == 8 | * | bm_offset = al_offset + X | * ==> bitmap sectors = md_size_sect - bm_offset * * Variants: * old, indexed fixed size meta data: * * internal: * |----------- md_size_sect ------------------| * [data.....][ Bitmap ][ activity log ][ 4k superblock ][padding*] * | al_offset < 0 | * | bm_offset = al_offset - Y | * ==> bitmap sectors = Y = al_offset - bm_offset * * [padding*] are zero or up to 7 unused 512 Byte sectors to the * end of the device, so that the [4k superblock] will be 4k aligned. * * The activity log consists of 4k transaction blocks, * which are written in a ring-buffer, or striped ring-buffer like fashion, * which are writtensize used to be fixed 32kB, * but is about to become configurable. */ /* Our old fixed size meta data layout * allows up to about 3.8TB, so if you want more, * you need to use the "flexible" meta data format. */ #define MD_128MB_SECT … #define MD_4kB_SECT … #define MD_32kB_SECT … /* One activity log extent represents 4M of storage */ #define AL_EXTENT_SHIFT … #define AL_EXTENT_SIZE … /* We could make these currently hardcoded constants configurable * variables at create-md time (or even re-configurable at runtime?). * Which will require some more changes to the DRBD "super block" * and attach code. * * updates per transaction: * This many changes to the active set can be logged with one transaction. * This number is arbitrary. * context per transaction: * This many context extent numbers are logged with each transaction. * This number is resulting from the transaction block size (4k), the layout * of the transaction header, and the number of updates per transaction. * See drbd_actlog.c:struct al_transaction_on_disk * */ #define AL_UPDATES_PER_TRANSACTION … #define AL_CONTEXT_PER_TRANSACTION … #if BITS_PER_LONG == 32 #define LN2_BPL … #define cpu_to_lel … #define lel_to_cpu … #elif BITS_PER_LONG == 64 #define LN2_BPL … #define cpu_to_lel(A) … #define lel_to_cpu(A) … #else #error "LN2 of BITS_PER_LONG unknown!" #endif /* resync bitmap */ /* 16MB sized 'bitmap extent' to track syncer usage */ struct bm_extent { … }; #define BME_NO_WRITES … #define BME_LOCKED … #define BME_PRIORITY … /* drbd_bitmap.c */ /* * We need to store one bit for a block. * Example: 1GB disk @ 4096 byte blocks ==> we need 32 KB bitmap. * Bit 0 ==> local node thinks this block is binary identical on both nodes * Bit 1 ==> local node thinks this block needs to be synced. */ #define SLEEP_TIME … /* We do bitmap IO in units of 4k blocks. * We also still have a hardcoded 4k per bit relation. */ #define BM_BLOCK_SHIFT … #define BM_BLOCK_SIZE … /* mostly arbitrarily set the represented size of one bitmap extent, * aka resync extent, to 16 MiB (which is also 512 Byte worth of bitmap * at 4k per bit resolution) */ #define BM_EXT_SHIFT … #define BM_EXT_SIZE … #if (BM_EXT_SHIFT != 24) || (BM_BLOCK_SHIFT != 12) #error "HAVE YOU FIXED drbdmeta AS WELL??" #endif /* thus many _storage_ sectors are described by one bit */ #define BM_SECT_TO_BIT(x) … #define BM_BIT_TO_SECT(x) … #define BM_SECT_PER_BIT … /* bit to represented kilo byte conversion */ #define Bit2KB(bits) … /* in which _bitmap_ extent (resp. sector) the bit for a certain * _storage_ sector is located in */ #define BM_SECT_TO_EXT(x) … #define BM_BIT_TO_EXT(x) … /* first storage sector a bitmap extent corresponds to */ #define BM_EXT_TO_SECT(x) … /* how much _storage_ sectors we have per bitmap extent */ #define BM_SECT_PER_EXT … /* how many bits are covered by one bitmap extent (resync extent) */ #define BM_BITS_PER_EXT … #define BM_BLOCKS_PER_BM_EXT_MASK … /* in one sector of the bitmap, we have this many activity_log extents. */ #define AL_EXT_PER_BM_SECT … /* the extent in "PER_EXTENT" below is an activity log extent * we need that many (long words/bytes) to store the bitmap * of one AL_EXTENT_SIZE chunk of storage. * we can store the bitmap for that many AL_EXTENTS within * one sector of the _on_disk_ bitmap: * bit 0 bit 37 bit 38 bit (512*8)-1 * ...|........|........|.. // ..|........| * sect. 0 `296 `304 ^(512*8*8)-1 * #define BM_WORDS_PER_EXT ( (AL_EXT_SIZE/BM_BLOCK_SIZE) / BITS_PER_LONG ) #define BM_BYTES_PER_EXT ( (AL_EXT_SIZE/BM_BLOCK_SIZE) / 8 ) // 128 #define BM_EXT_PER_SECT ( 512 / BM_BYTES_PER_EXTENT ) // 4 */ #define DRBD_MAX_SECTORS_32 … /* we have a certain meta data variant that has a fixed on-disk size of 128 * MiB, of which 4k are our "superblock", and 32k are the fixed size activity * log, leaving this many sectors for the bitmap. */ #define DRBD_MAX_SECTORS_FIXED_BM … #define DRBD_MAX_SECTORS … /* 16 TB in units of sectors */ #if BITS_PER_LONG == 32 /* adjust by one page worth of bitmap, * so we won't wrap around in drbd_bm_find_next_bit. * you should use 64bit OS for that much storage, anyways. */ #define DRBD_MAX_SECTORS_FLEX … #else /* we allow up to 1 PiB now on 64bit architecture with "flexible" meta data */ #define DRBD_MAX_SECTORS_FLEX … /* corresponds to (1UL << 38) bits right now. */ #endif /* Estimate max bio size as 256 * PAGE_SIZE, * so for typical PAGE_SIZE of 4k, that is (1<<20) Byte. * Since we may live in a mixed-platform cluster, * we limit us to a platform agnostic constant here for now. * A followup commit may allow even bigger BIO sizes, * once we thought that through. */ #define DRBD_MAX_BIO_SIZE … #if DRBD_MAX_BIO_SIZE > (BIO_MAX_VECS << PAGE_SHIFT) #error Architecture not supported: DRBD_MAX_BIO_SIZE > BIO_MAX_SIZE #endif #define DRBD_MAX_BIO_SIZE_SAFE … #define DRBD_MAX_SIZE_H80_PACKET … #define DRBD_MAX_BIO_SIZE_P95 … /* For now, don't allow more than half of what we can "activate" in one * activity log transaction to be discarded in one go. We may need to rework * drbd_al_begin_io() to allow for even larger discard ranges */ #define DRBD_MAX_BATCH_BIO_SIZE … #define DRBD_MAX_BBIO_SECTORS … extern int drbd_bm_init(struct drbd_device *device); extern int drbd_bm_resize(struct drbd_device *device, sector_t sectors, int set_new_bits); extern void drbd_bm_cleanup(struct drbd_device *device); extern void drbd_bm_set_all(struct drbd_device *device); extern void drbd_bm_clear_all(struct drbd_device *device); /* set/clear/test only a few bits at a time */ extern int drbd_bm_set_bits( struct drbd_device *device, unsigned long s, unsigned long e); extern int drbd_bm_clear_bits( struct drbd_device *device, unsigned long s, unsigned long e); extern int drbd_bm_count_bits( struct drbd_device *device, 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 void _drbd_bm_set_bits(struct drbd_device *device, const unsigned long s, const unsigned long e); extern int drbd_bm_test_bit(struct drbd_device *device, unsigned long bitnr); extern int drbd_bm_e_weight(struct drbd_device *device, unsigned long enr); extern int drbd_bm_read(struct drbd_device *device, struct drbd_peer_device *peer_device) __must_hold(…); extern void drbd_bm_mark_for_writeout(struct drbd_device *device, int page_nr); extern int drbd_bm_write(struct drbd_device *device, struct drbd_peer_device *peer_device) __must_hold(…); extern void drbd_bm_reset_al_hints(struct drbd_device *device) __must_hold(…); extern int drbd_bm_write_hinted(struct drbd_device *device) __must_hold(…); extern int drbd_bm_write_lazy(struct drbd_device *device, unsigned upper_idx) __must_hold(…); extern int drbd_bm_write_all(struct drbd_device *device, struct drbd_peer_device *peer_device) __must_hold(…); extern int drbd_bm_write_copy_pages(struct drbd_device *device, struct drbd_peer_device *peer_device) __must_hold(…); extern size_t drbd_bm_words(struct drbd_device *device); extern unsigned long drbd_bm_bits(struct drbd_device *device); extern sector_t drbd_bm_capacity(struct drbd_device *device); #define DRBD_END_OF_BITMAP … extern unsigned long drbd_bm_find_next(struct drbd_device *device, unsigned long bm_fo); /* bm_find_next variants for use while you hold drbd_bm_lock() */ extern unsigned long _drbd_bm_find_next(struct drbd_device *device, unsigned long bm_fo); extern unsigned long _drbd_bm_find_next_zero(struct drbd_device *device, unsigned long bm_fo); extern unsigned long _drbd_bm_total_weight(struct drbd_device *device); extern unsigned long drbd_bm_total_weight(struct drbd_device *device); /* for receive_bitmap */ extern void drbd_bm_merge_lel(struct drbd_device *device, size_t offset, size_t number, unsigned long *buffer); /* for _drbd_send_bitmap */ extern void drbd_bm_get_lel(struct drbd_device *device, size_t offset, size_t number, unsigned long *buffer); extern void drbd_bm_lock(struct drbd_device *device, char *why, enum bm_flag flags); extern void drbd_bm_unlock(struct drbd_device *device); /* drbd_main.c */ extern struct kmem_cache *drbd_request_cache; extern struct kmem_cache *drbd_ee_cache; /* peer requests */ extern struct kmem_cache *drbd_bm_ext_cache; /* bitmap extents */ extern struct kmem_cache *drbd_al_ext_cache; /* activity log extents */ extern mempool_t drbd_request_mempool; extern mempool_t drbd_ee_mempool; /* drbd's page pool, used to buffer data received from the peer, * or data requested by the peer. * * This does not have an emergency reserve. * * When allocating from this pool, it first takes pages from the pool. * Only if the pool is depleted will try to allocate from the system. * * The assumption is that pages taken from this pool will be processed, * and given back, "quickly", and then can be recycled, so we can avoid * frequent calls to alloc_page(), and still will be able to make progress even * under memory pressure. */ extern struct page *drbd_pp_pool; extern spinlock_t drbd_pp_lock; extern int drbd_pp_vacant; extern wait_queue_head_t drbd_pp_wait; /* We also need a standard (emergency-reserve backed) page pool * for meta data IO (activity log, bitmap). * We can keep it global, as long as it is used as "N pages at a time". * 128 should be plenty, currently we probably can get away with as few as 1. */ #define DRBD_MIN_POOL_PAGES … extern mempool_t drbd_md_io_page_pool; /* We also need to make sure we get a bio * when we need it for housekeeping purposes */ extern struct bio_set drbd_md_io_bio_set; /* And a bio_set for cloning */ extern struct bio_set drbd_io_bio_set; extern struct mutex resources_mutex; extern enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsigned int minor); extern void drbd_destroy_device(struct kref *kref); extern void drbd_delete_device(struct drbd_device *device); extern struct drbd_resource *drbd_create_resource(const char *name); extern void drbd_free_resource(struct drbd_resource *resource); extern int set_resource_options(struct drbd_resource *resource, struct res_opts *res_opts); extern struct drbd_connection *conn_create(const char *name, struct res_opts *res_opts); extern void drbd_destroy_connection(struct kref *kref); extern struct drbd_connection *conn_get_by_addrs(void *my_addr, int my_addr_len, void *peer_addr, int peer_addr_len); extern struct drbd_resource *drbd_find_resource(const char *name); extern void drbd_destroy_resource(struct kref *kref); extern void conn_free_crypto(struct drbd_connection *connection); /* drbd_req */ extern void do_submit(struct work_struct *ws); extern void __drbd_make_request(struct drbd_device *, struct bio *); void drbd_submit_bio(struct bio *bio); /* drbd_nl.c */ extern struct mutex notification_mutex; extern void drbd_suspend_io(struct drbd_device *device); extern void drbd_resume_io(struct drbd_device *device); extern char *ppsize(char *buf, unsigned long long size); extern sector_t drbd_new_dev_size(struct drbd_device *, struct drbd_backing_dev *, sector_t, int); enum determine_dev_size { … }; extern enum determine_dev_size drbd_determine_dev_size(struct drbd_device *, enum dds_flags, struct resize_parms *) __must_hold(…); extern void resync_after_online_grow(struct drbd_device *); extern void drbd_reconsider_queue_parameters(struct drbd_device *device, struct drbd_backing_dev *bdev, struct o_qlim *o); extern enum drbd_state_rv drbd_set_role(struct drbd_device *device, enum drbd_role new_role, int force); extern bool conn_try_outdate_peer(struct drbd_connection *connection); extern void conn_try_outdate_peer_async(struct drbd_connection *connection); extern enum drbd_peer_state conn_khelper(struct drbd_connection *connection, char *cmd); extern int drbd_khelper(struct drbd_device *device, char *cmd); /* drbd_worker.c */ /* bi_end_io handlers */ extern void drbd_md_endio(struct bio *bio); extern void drbd_peer_request_endio(struct bio *bio); extern void drbd_request_endio(struct bio *bio); extern int drbd_worker(struct drbd_thread *thi); enum drbd_ret_code drbd_resync_after_valid(struct drbd_device *device, int o_minor); void drbd_resync_after_changed(struct drbd_device *device); extern void drbd_start_resync(struct drbd_device *device, enum drbd_conns side); extern void resume_next_sg(struct drbd_device *device); extern void suspend_other_sg(struct drbd_device *device); extern int drbd_resync_finished(struct drbd_peer_device *peer_device); /* maybe rather drbd_main.c ? */ extern void *drbd_md_get_buffer(struct drbd_device *device, const char *intent); extern void drbd_md_put_buffer(struct drbd_device *device); extern int drbd_md_sync_page_io(struct drbd_device *device, struct drbd_backing_dev *bdev, sector_t sector, enum req_op op); extern void drbd_ov_out_of_sync_found(struct drbd_peer_device *peer_device, sector_t sector, int size); extern void wait_until_done_or_force_detached(struct drbd_device *device, struct drbd_backing_dev *bdev, unsigned int *done); extern void drbd_rs_controller_reset(struct drbd_peer_device *peer_device); static inline void ov_out_of_sync_print(struct drbd_peer_device *peer_device) { … } extern void drbd_csum_bio(struct crypto_shash *, struct bio *, void *); extern void drbd_csum_ee(struct crypto_shash *, struct drbd_peer_request *, void *); /* worker callbacks */ extern int w_e_end_data_req(struct drbd_work *, int); extern int w_e_end_rsdata_req(struct drbd_work *, int); extern int w_e_end_csum_rs_req(struct drbd_work *, int); extern int w_e_end_ov_reply(struct drbd_work *, int); extern int w_e_end_ov_req(struct drbd_work *, int); extern int w_ov_finished(struct drbd_work *, int); extern int w_resync_timer(struct drbd_work *, int); extern int w_send_write_hint(struct drbd_work *, int); extern int w_send_dblock(struct drbd_work *, int); extern int w_send_read_req(struct drbd_work *, int); extern int w_restart_disk_io(struct drbd_work *, int); extern int w_send_out_of_sync(struct drbd_work *, int); extern void resync_timer_fn(struct timer_list *t); extern void start_resync_timer_fn(struct timer_list *t); extern void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req); /* drbd_receiver.c */ extern int drbd_issue_discard_or_zero_out(struct drbd_device *device, sector_t start, unsigned int nr_sectors, int flags); extern int drbd_receiver(struct drbd_thread *thi); extern int drbd_ack_receiver(struct drbd_thread *thi); extern void drbd_send_acks_wf(struct work_struct *ws); extern bool drbd_rs_c_min_rate_throttle(struct drbd_device *device); extern bool drbd_rs_should_slow_down(struct drbd_peer_device *peer_device, sector_t sector, bool throttle_if_app_is_waiting); extern int drbd_submit_peer_request(struct drbd_peer_request *peer_req); extern int drbd_free_peer_reqs(struct drbd_device *, struct list_head *); extern struct drbd_peer_request *drbd_alloc_peer_req(struct drbd_peer_device *, u64, sector_t, unsigned int, unsigned int, gfp_t) __must_hold(…); extern void __drbd_free_peer_req(struct drbd_device *, struct drbd_peer_request *, int); #define drbd_free_peer_req(m,e) … #define drbd_free_net_peer_req(m,e) … extern struct page *drbd_alloc_pages(struct drbd_peer_device *, unsigned int, bool); extern void _drbd_clear_done_ee(struct drbd_device *device, struct list_head *to_be_freed); extern int drbd_connected(struct drbd_peer_device *); /* sets the number of 512 byte sectors of our virtual device */ void drbd_set_my_capacity(struct drbd_device *device, sector_t size); /* * used to submit our private bio */ static inline void drbd_submit_bio_noacct(struct drbd_device *device, int fault_type, struct bio *bio) { … } void drbd_bump_write_ordering(struct drbd_resource *resource, struct drbd_backing_dev *bdev, enum write_ordering_e wo); /* drbd_proc.c */ extern struct proc_dir_entry *drbd_proc; int drbd_seq_show(struct seq_file *seq, void *v); /* drbd_actlog.c */ extern bool drbd_al_begin_io_prepare(struct drbd_device *device, struct drbd_interval *i); extern int drbd_al_begin_io_nonblock(struct drbd_device *device, struct drbd_interval *i); extern void drbd_al_begin_io_commit(struct drbd_device *device); extern bool drbd_al_begin_io_fastpath(struct drbd_device *device, struct drbd_interval *i); extern void drbd_al_begin_io(struct drbd_device *device, struct drbd_interval *i); extern void drbd_al_complete_io(struct drbd_device *device, struct drbd_interval *i); extern void drbd_rs_complete_io(struct drbd_device *device, sector_t sector); extern int drbd_rs_begin_io(struct drbd_device *device, sector_t sector); extern int drbd_try_rs_begin_io(struct drbd_peer_device *peer_device, sector_t sector); extern void drbd_rs_cancel_all(struct drbd_device *device); extern int drbd_rs_del_all(struct drbd_device *device); extern void drbd_rs_failed_io(struct drbd_peer_device *peer_device, sector_t sector, int size); extern void drbd_advance_rs_marks(struct drbd_peer_device *peer_device, unsigned long still_to_go); enum update_sync_bits_mode { … }; extern int __drbd_change_sync(struct drbd_peer_device *peer_device, sector_t sector, int size, enum update_sync_bits_mode mode); #define drbd_set_in_sync(peer_device, sector, size) … #define drbd_set_out_of_sync(peer_device, sector, size) … #define drbd_rs_failed_io(peer_device, sector, size) … extern void drbd_al_shrink(struct drbd_device *device); extern int drbd_al_initialize(struct drbd_device *, void *); /* drbd_nl.c */ /* state info broadcast */ struct sib_info { … }; void drbd_bcast_event(struct drbd_device *device, const struct sib_info *sib); extern int notify_resource_state(struct sk_buff *, unsigned int, struct drbd_resource *, struct resource_info *, enum drbd_notification_type); extern int notify_device_state(struct sk_buff *, unsigned int, struct drbd_device *, struct device_info *, enum drbd_notification_type); extern int notify_connection_state(struct sk_buff *, unsigned int, struct drbd_connection *, struct connection_info *, enum drbd_notification_type); extern int notify_peer_device_state(struct sk_buff *, unsigned int, struct drbd_peer_device *, struct peer_device_info *, enum drbd_notification_type); extern void notify_helper(enum drbd_notification_type, struct drbd_device *, struct drbd_connection *, const char *, int); /* * inline helper functions *************************/ /* see also page_chain_add and friends in drbd_receiver.c */ static inline struct page *page_chain_next(struct page *page) { … } #define page_chain_for_each(page) … #define page_chain_for_each_safe(page, n) … static inline int drbd_peer_req_has_active_page(struct drbd_peer_request *peer_req) { … } static inline union drbd_state drbd_read_state(struct drbd_device *device) { … } enum drbd_force_detach_flags { … }; #define __drbd_chk_io_error(m,f) … static inline void __drbd_chk_io_error_(struct drbd_device *device, enum drbd_force_detach_flags df, const char *where) { … } /** * drbd_chk_io_error: Handle the on_io_error setting, should be called from all io completion handlers * @device: DRBD device. * @error: Error code passed to the IO completion callback * @forcedetach: Force detach. I.e. the error happened while accessing the meta data * * See also drbd_main.c:after_state_ch() if (os.disk > D_FAILED && ns.disk == D_FAILED) */ #define drbd_chk_io_error(m,e,f) … static inline void drbd_chk_io_error_(struct drbd_device *device, int error, enum drbd_force_detach_flags forcedetach, const char *where) { … } /** * drbd_md_first_sector() - Returns the first sector number of the meta data area * @bdev: Meta data block device. * * BTW, for internal meta data, this happens to be the maximum capacity * we could agree upon with our peer node. */ static inline sector_t drbd_md_first_sector(struct drbd_backing_dev *bdev) { … } /** * drbd_md_last_sector() - Return the last sector number of the meta data area * @bdev: Meta data block device. */ static inline sector_t drbd_md_last_sector(struct drbd_backing_dev *bdev) { … } /* Returns the number of 512 byte sectors of the device */ static inline sector_t drbd_get_capacity(struct block_device *bdev) { … } /** * drbd_get_max_capacity() - Returns the capacity we announce to out peer * @bdev: Meta data block device. * * returns the capacity we announce to out peer. we clip ourselves at the * various MAX_SECTORS, because if we don't, current implementation will * oops sooner or later */ static inline sector_t drbd_get_max_capacity(struct drbd_backing_dev *bdev) { … } /** * drbd_md_ss() - Return the sector number of our meta data super block * @bdev: Meta data block device. */ static inline sector_t drbd_md_ss(struct drbd_backing_dev *bdev) { … } static inline void drbd_queue_work(struct drbd_work_queue *q, struct drbd_work *w) { … } static inline void drbd_queue_work_if_unqueued(struct drbd_work_queue *q, struct drbd_work *w) { … } static inline void drbd_device_post_work(struct drbd_device *device, int work_bit) { … } extern void drbd_flush_workqueue(struct drbd_work_queue *work_queue); /* To get the ack_receiver out of the blocking network stack, * so it can change its sk_rcvtimeo from idle- to ping-timeout, * and send a ping, we need to send a signal. * Which signal we send is irrelevant. */ static inline void wake_ack_receiver(struct drbd_connection *connection) { … } static inline void request_ping(struct drbd_connection *connection) { … } extern void *conn_prepare_command(struct drbd_connection *, struct drbd_socket *); extern void *drbd_prepare_command(struct drbd_peer_device *, struct drbd_socket *); extern int conn_send_command(struct drbd_connection *, struct drbd_socket *, enum drbd_packet, unsigned int, void *, unsigned int); extern int drbd_send_command(struct drbd_peer_device *, struct drbd_socket *, enum drbd_packet, unsigned int, void *, unsigned int); extern int drbd_send_ping(struct drbd_connection *connection); extern int drbd_send_ping_ack(struct drbd_connection *connection); extern int drbd_send_state_req(struct drbd_peer_device *, union drbd_state, union drbd_state); extern int conn_send_state_req(struct drbd_connection *, union drbd_state, union drbd_state); static inline void drbd_thread_stop(struct drbd_thread *thi) { … } static inline void drbd_thread_stop_nowait(struct drbd_thread *thi) { … } static inline void drbd_thread_restart_nowait(struct drbd_thread *thi) { … } /* counts how many answer packets packets we expect from our peer, * for either explicit application requests, * or implicit barrier packets as necessary. * increased: * w_send_barrier * _req_mod(req, QUEUE_FOR_NET_WRITE or QUEUE_FOR_NET_READ); * it is much easier and equally valid to count what we queue for the * worker, even before it actually was queued or send. * (drbd_make_request_common; recovery path on read io-error) * decreased: * got_BarrierAck (respective tl_clear, tl_clear_barrier) * _req_mod(req, DATA_RECEIVED) * [from receive_DataReply] * _req_mod(req, WRITE_ACKED_BY_PEER or RECV_ACKED_BY_PEER or NEG_ACKED) * [from got_BlockAck (P_WRITE_ACK, P_RECV_ACK)] * for some reason it is NOT decreased in got_NegAck, * but in the resulting cleanup code from report_params. * we should try to remember the reason for that... * _req_mod(req, SEND_FAILED or SEND_CANCELED) * _req_mod(req, CONNECTION_LOST_WHILE_PENDING) * [from tl_clear_barrier] */ static inline void inc_ap_pending(struct drbd_device *device) { … } #define dec_ap_pending(device) … static inline int __dec_ap_pending(struct drbd_device *device) { … } /* counts how many resync-related answers we still expect from the peer * increase decrease * C_SYNC_TARGET sends P_RS_DATA_REQUEST (and expects P_RS_DATA_REPLY) * C_SYNC_SOURCE sends P_RS_DATA_REPLY (and expects P_WRITE_ACK with ID_SYNCER) * (or P_NEG_ACK with ID_SYNCER) */ static inline void inc_rs_pending(struct drbd_peer_device *peer_device) { … } #define dec_rs_pending(peer_device) … static inline int __dec_rs_pending(struct drbd_peer_device *peer_device) { … } /* counts how many answers we still need to send to the peer. * increased on * receive_Data unless protocol A; * we need to send a P_RECV_ACK (proto B) * or P_WRITE_ACK (proto C) * receive_RSDataReply (recv_resync_read) we need to send a P_WRITE_ACK * receive_DataRequest (receive_RSDataRequest) we need to send back P_DATA * receive_Barrier_* we need to send a P_BARRIER_ACK */ static inline void inc_unacked(struct drbd_device *device) { … } #define dec_unacked(device) … static inline int __dec_unacked(struct drbd_device *device) { … } #define sub_unacked(device, n) … static inline int __sub_unacked(struct drbd_device *device, int n) { … } static inline bool is_sync_target_state(enum drbd_conns connection_state) { … } static inline bool is_sync_source_state(enum drbd_conns connection_state) { … } static inline bool is_sync_state(enum drbd_conns connection_state) { … } /** * get_ldev() - Increase the ref count on device->ldev. Returns 0 if there is no ldev * @_device: DRBD device. * @_min_state: Minimum device state required for success. * * You have to call put_ldev() when finished working with device->ldev. */ #define get_ldev_if_state(_device, _min_state) … #define get_ldev(_device) … static inline void put_ldev(struct drbd_device *device) { … } #ifndef __CHECKER__ static inline int _get_ldev_if_state(struct drbd_device *device, enum drbd_disk_state mins) { … } #else extern int _get_ldev_if_state(struct drbd_device *device, enum drbd_disk_state mins); #endif /* this throttles on-the-fly application requests * according to max_buffers settings; * maybe re-implement using semaphores? */ static inline int drbd_get_max_buffers(struct drbd_device *device) { … } static inline int drbd_state_is_stable(struct drbd_device *device) { … } static inline int drbd_suspended(struct drbd_device *device) { … } static inline bool may_inc_ap_bio(struct drbd_device *device) { … } static inline bool inc_ap_bio_cond(struct drbd_device *device) { … } static inline void inc_ap_bio(struct drbd_device *device) { … } static inline void dec_ap_bio(struct drbd_device *device) { … } static inline bool verify_can_do_stop_sector(struct drbd_device *device) { … } static inline int drbd_set_ed_uuid(struct drbd_device *device, u64 val) { … } static inline int drbd_queue_order_type(struct drbd_device *device) { … } static inline struct drbd_connection *first_connection(struct drbd_resource *resource) { … } #endif
Codebase Browser
linux