[mirror_ubuntu-focal-kernel.git] / drivers / block / drbd / drbd_state.h

#ifndef DRBD_STATE_H
#define DRBD_STATE_H

struct drbd_device;
struct drbd_connection;

/**
 * DOC: DRBD State macros
 *
 * These macros are used to express state changes in easily readable form.
 *
 * The NS macros expand to a mask and a value, that can be bit ored onto the
 * current state as soon as the spinlock (req_lock) was taken.
 *
 * The _NS macros are used for state functions that get called with the
 * spinlock. These macros expand directly to the new state value.
 *
 * Besides the basic forms NS() and _NS() additional _?NS[23] are defined
 * to express state changes that affect more than one aspect of the state.
 *
 * E.g. NS2(conn, C_CONNECTED, peer, R_SECONDARY)
 * Means that the network connection was established and that the peer
 * is in secondary role.
 */
#define role_MASK R_MASK
#define peer_MASK R_MASK
#define disk_MASK D_MASK
#define pdsk_MASK D_MASK
#define conn_MASK C_MASK
#define susp_MASK 1
#define user_isp_MASK 1
#define aftr_isp_MASK 1
#define susp_nod_MASK 1
#define susp_fen_MASK 1

#define NS(T, S) \
	({ union drbd_state mask; mask.i = 0; mask.T = T##_MASK; mask; }), \
	({ union drbd_state val; val.i = 0; val.T = (S); val; })
#define NS2(T1, S1, T2, S2) \
	({ union drbd_state mask; mask.i = 0; mask.T1 = T1##_MASK; \
	  mask.T2 = T2##_MASK; mask; }), \
	({ union drbd_state val; val.i = 0; val.T1 = (S1); \
	  val.T2 = (S2); val; })
#define NS3(T1, S1, T2, S2, T3, S3) \
	({ union drbd_state mask; mask.i = 0; mask.T1 = T1##_MASK; \
	  mask.T2 = T2##_MASK; mask.T3 = T3##_MASK; mask; }), \
	({ union drbd_state val;  val.i = 0; val.T1 = (S1); \
	  val.T2 = (S2); val.T3 = (S3); val; })

#define _NS(D, T, S) \
	D, ({ union drbd_state __ns; __ns = drbd_read_state(D); __ns.T = (S); __ns; })
#define _NS2(D, T1, S1, T2, S2) \
	D, ({ union drbd_state __ns; __ns = drbd_read_state(D); __ns.T1 = (S1); \
	__ns.T2 = (S2); __ns; })
#define _NS3(D, T1, S1, T2, S2, T3, S3) \
	D, ({ union drbd_state __ns; __ns = drbd_read_state(D); __ns.T1 = (S1); \
	__ns.T2 = (S2); __ns.T3 = (S3); __ns; })

enum chg_state_flags {
	CS_HARD	         = 1 << 0,
	CS_VERBOSE       = 1 << 1,
	CS_WAIT_COMPLETE = 1 << 2,
	CS_SERIALIZE     = 1 << 3,
	CS_ORDERED       = CS_WAIT_COMPLETE + CS_SERIALIZE,
	CS_LOCAL_ONLY    = 1 << 4, /* Do not consider a device pair wide state change */
	CS_DC_ROLE       = 1 << 5, /* DC = display as connection state change */
	CS_DC_PEER       = 1 << 6,
	CS_DC_CONN       = 1 << 7,
	CS_DC_DISK       = 1 << 8,
	CS_DC_PDSK       = 1 << 9,
	CS_DC_SUSP       = 1 << 10,
	CS_DC_MASK       = CS_DC_ROLE + CS_DC_PEER + CS_DC_CONN + CS_DC_DISK + CS_DC_PDSK,
	CS_IGN_OUTD_FAIL = 1 << 11,

	/* Make sure no meta data IO is in flight, by calling
	 * drbd_md_get_buffer().  Used for graceful detach. */
	CS_INHIBIT_MD_IO = 1 << 12,
};

/* drbd_dev_state and drbd_state are different types. This is to stress the
   small difference. There is no suspended flag (.susp), and no suspended
   while fence handler runs flas (susp_fen). */
union drbd_dev_state {
	struct {
#if defined(__LITTLE_ENDIAN_BITFIELD)
		unsigned role:2 ;   /* 3/4	 primary/secondary/unknown */
		unsigned peer:2 ;   /* 3/4	 primary/secondary/unknown */
		unsigned conn:5 ;   /* 17/32	 cstates */
		unsigned disk:4 ;   /* 8/16	 from D_DISKLESS to D_UP_TO_DATE */
		unsigned pdsk:4 ;   /* 8/16	 from D_DISKLESS to D_UP_TO_DATE */
		unsigned _unused:1 ;
		unsigned aftr_isp:1 ; /* isp .. imposed sync pause */
		unsigned peer_isp:1 ;
		unsigned user_isp:1 ;
		unsigned _pad:11;   /* 0	 unused */
#elif defined(__BIG_ENDIAN_BITFIELD)
		unsigned _pad:11;
		unsigned user_isp:1 ;
		unsigned peer_isp:1 ;
		unsigned aftr_isp:1 ; /* isp .. imposed sync pause */
		unsigned _unused:1 ;
		unsigned pdsk:4 ;   /* 8/16	 from D_DISKLESS to D_UP_TO_DATE */
		unsigned disk:4 ;   /* 8/16	 from D_DISKLESS to D_UP_TO_DATE */
		unsigned conn:5 ;   /* 17/32	 cstates */
		unsigned peer:2 ;   /* 3/4	 primary/secondary/unknown */
		unsigned role:2 ;   /* 3/4	 primary/secondary/unknown */
#else
# error "this endianess is not supported"
#endif
	};
	unsigned int i;
};

extern enum drbd_state_rv drbd_change_state(struct drbd_device *device,
					    enum chg_state_flags f,
					    union drbd_state mask,
					    union drbd_state val);
extern void drbd_force_state(struct drbd_device *, union drbd_state,
			union drbd_state);
extern enum drbd_state_rv _drbd_request_state(struct drbd_device *,
					      union drbd_state,
					      union drbd_state,
					      enum chg_state_flags);

extern enum drbd_state_rv
_drbd_request_state_holding_state_mutex(struct drbd_device *, union drbd_state,
					union drbd_state, enum chg_state_flags);

extern enum drbd_state_rv _drbd_set_state(struct drbd_device *, union drbd_state,
					  enum chg_state_flags,
					  struct completion *done);
extern void print_st_err(struct drbd_device *, union drbd_state,
			union drbd_state, int);

enum drbd_state_rv
_conn_request_state(struct drbd_connection *connection, union drbd_state mask, union drbd_state val,
		    enum chg_state_flags flags);

enum drbd_state_rv
conn_request_state(struct drbd_connection *connection, union drbd_state mask, union drbd_state val,
		   enum chg_state_flags flags);

extern void drbd_resume_al(struct drbd_device *device);
extern bool conn_all_vols_unconf(struct drbd_connection *connection);

/**
 * drbd_request_state() - Request a state change
 * @device:	DRBD device.
 * @mask:	mask of state bits to change.
 * @val:	value of new state bits.
 *
 * This is the most graceful way of requesting a state change. It is verbose
 * quite verbose in case the state change is not possible, and all those
 * state changes are globally serialized.
 */
static inline int drbd_request_state(struct drbd_device *device,
				     union drbd_state mask,
				     union drbd_state val)
{
	return _drbd_request_state(device, mask, val, CS_VERBOSE + CS_ORDERED);
}

/* for use in adm_detach() (drbd_adm_detach(), drbd_adm_down()) */
enum drbd_state_rv
drbd_request_detach_interruptible(struct drbd_device *device);

enum drbd_role conn_highest_role(struct drbd_connection *connection);
enum drbd_role conn_highest_peer(struct drbd_connection *connection);
enum drbd_disk_state conn_highest_disk(struct drbd_connection *connection);
enum drbd_disk_state conn_lowest_disk(struct drbd_connection *connection);
enum drbd_disk_state conn_highest_pdsk(struct drbd_connection *connection);
enum drbd_conns conn_lowest_conn(struct drbd_connection *connection);

#endif
Commit	Line	Data
b8907339 PR	1	#ifndef DRBD_STATE_H
	2	#define DRBD_STATE_H
	3
54761697	4	struct drbd_device;
bde89a9e	5	struct drbd_connection;
b8907339 PR	6
	7	/**
	8	* DOC: DRBD State macros
	9	*
	10	* These macros are used to express state changes in easily readable form.
	11	*
	12	* The NS macros expand to a mask and a value, that can be bit ored onto the
	13	* current state as soon as the spinlock (req_lock) was taken.
	14	*
	15	* The _NS macros are used for state functions that get called with the
	16	* spinlock. These macros expand directly to the new state value.
	17	*
	18	* Besides the basic forms NS() and _NS() additional _?NS[23] are defined
	19	* to express state changes that affect more than one aspect of the state.
	20	*
	21	* E.g. NS2(conn, C_CONNECTED, peer, R_SECONDARY)
	22	* Means that the network connection was established and that the peer
	23	* is in secondary role.
	24	*/
	25	#define role_MASK R_MASK
	26	#define peer_MASK R_MASK
	27	#define disk_MASK D_MASK
	28	#define pdsk_MASK D_MASK
	29	#define conn_MASK C_MASK
	30	#define susp_MASK 1
	31	#define user_isp_MASK 1
	32	#define aftr_isp_MASK 1
	33	#define susp_nod_MASK 1
	34	#define susp_fen_MASK 1
	35
	36	#define NS(T, S) \
	37	({ union drbd_state mask; mask.i = 0; mask.T = T##_MASK; mask; }), \
	38	({ union drbd_state val; val.i = 0; val.T = (S); val; })
	39	#define NS2(T1, S1, T2, S2) \
	40	({ union drbd_state mask; mask.i = 0; mask.T1 = T1##_MASK; \
	41	mask.T2 = T2##_MASK; mask; }), \
	42	({ union drbd_state val; val.i = 0; val.T1 = (S1); \
	43	val.T2 = (S2); val; })
	44	#define NS3(T1, S1, T2, S2, T3, S3) \
	45	({ union drbd_state mask; mask.i = 0; mask.T1 = T1##_MASK; \
	46	mask.T2 = T2##_MASK; mask.T3 = T3##_MASK; mask; }), \
	47	({ union drbd_state val; val.i = 0; val.T1 = (S1); \
	48	val.T2 = (S2); val.T3 = (S3); val; })
	49
	50	#define _NS(D, T, S) \
78bae59b	51	D, ({ union drbd_state __ns; __ns = drbd_read_state(D); __ns.T = (S); __ns; })
b8907339	52	#define _NS2(D, T1, S1, T2, S2) \
78bae59b	53	D, ({ union drbd_state __ns; __ns = drbd_read_state(D); __ns.T1 = (S1); \
b8907339 PR	54	__ns.T2 = (S2); __ns; })
b8907339 PR	55	#define _NS3(D, T1, S1, T2, S2, T3, S3) \
78bae59b	56	D, ({ union drbd_state __ns; __ns = drbd_read_state(D); __ns.T1 = (S1); \
b8907339 PR	57	__ns.T2 = (S2); __ns.T3 = (S3); __ns; })
	58
	59	enum chg_state_flags {
435693e8 PR	60	CS_HARD = 1 << 0,
	61	CS_VERBOSE = 1 << 1,
	62	CS_WAIT_COMPLETE = 1 << 2,
	63	CS_SERIALIZE = 1 << 3,
	64	CS_ORDERED = CS_WAIT_COMPLETE + CS_SERIALIZE,
	65	CS_LOCAL_ONLY = 1 << 4, /* Do not consider a device pair wide state change */
	66	CS_DC_ROLE = 1 << 5, /* DC = display as connection state change */
	67	CS_DC_PEER = 1 << 6,
	68	CS_DC_CONN = 1 << 7,
	69	CS_DC_DISK = 1 << 8,
	70	CS_DC_PDSK = 1 << 9,
706cb24c	71	CS_DC_SUSP = 1 << 10,
435693e8	72	CS_DC_MASK = CS_DC_ROLE + CS_DC_PEER + CS_DC_CONN + CS_DC_DISK + CS_DC_PDSK,
706cb24c	73	CS_IGN_OUTD_FAIL = 1 << 11,
33d32fa7 LE	74
	75	/* Make sure no meta data IO is in flight, by calling
	76	* drbd_md_get_buffer(). Used for graceful detach. */
	77	CS_INHIBIT_MD_IO = 1 << 12,
b8907339 PR	78	};
b8907339 PR	79
da9fbc27 PR	80	/* drbd_dev_state and drbd_state are different types. This is to stress the
	81	small difference. There is no suspended flag (.susp), and no suspended
	82	while fence handler runs flas (susp_fen). */
	83	union drbd_dev_state {
	84	struct {
	85	#if defined(__LITTLE_ENDIAN_BITFIELD)
	86	unsigned role:2 ; /* 3/4 primary/secondary/unknown */
	87	unsigned peer:2 ; /* 3/4 primary/secondary/unknown */
	88	unsigned conn:5 ; /* 17/32 cstates */
	89	unsigned disk:4 ; /* 8/16 from D_DISKLESS to D_UP_TO_DATE */
	90	unsigned pdsk:4 ; /* 8/16 from D_DISKLESS to D_UP_TO_DATE */
	91	unsigned _unused:1 ;
	92	unsigned aftr_isp:1 ; /* isp .. imposed sync pause */
	93	unsigned peer_isp:1 ;
	94	unsigned user_isp:1 ;
	95	unsigned _pad:11; /* 0 unused */
	96	#elif defined(__BIG_ENDIAN_BITFIELD)
	97	unsigned _pad:11;
	98	unsigned user_isp:1 ;
	99	unsigned peer_isp:1 ;
	100	unsigned aftr_isp:1 ; /* isp .. imposed sync pause */
	101	unsigned _unused:1 ;
	102	unsigned pdsk:4 ; /* 8/16 from D_DISKLESS to D_UP_TO_DATE */
	103	unsigned disk:4 ; /* 8/16 from D_DISKLESS to D_UP_TO_DATE */
	104	unsigned conn:5 ; /* 17/32 cstates */
	105	unsigned peer:2 ; /* 3/4 primary/secondary/unknown */
	106	unsigned role:2 ; /* 3/4 primary/secondary/unknown */
	107	#else
	108	# error "this endianess is not supported"
	109	#endif
	110	};
	111	unsigned int i;
	112	};
	113
b30ab791	114	extern enum drbd_state_rv drbd_change_state(struct drbd_device *device,
b8907339 PR	115	enum chg_state_flags f,
	116	union drbd_state mask,
	117	union drbd_state val);
54761697	118	extern void drbd_force_state(struct drbd_device *, union drbd_state,
b8907339	119	union drbd_state);
54761697	120	extern enum drbd_state_rv _drbd_request_state(struct drbd_device *,
b8907339 PR	121	union drbd_state,
	122	union drbd_state,
	123	enum chg_state_flags);
a8821531 PR	124
	125	extern enum drbd_state_rv
	126	_drbd_request_state_holding_state_mutex(struct drbd_device *, union drbd_state,
	127	union drbd_state, enum chg_state_flags);
	128
28bc3b8c AG	129	extern enum drbd_state_rv _drbd_set_state(struct drbd_device *, union drbd_state,
	130	enum chg_state_flags,
	131	struct completion *done);
54761697	132	extern void print_st_err(struct drbd_device *, union drbd_state,
b8907339 PR	133	union drbd_state, int);
b8907339 PR	134
bbeb641c	135	enum drbd_state_rv
bde89a9e	136	_conn_request_state(struct drbd_connection *connection, union drbd_state mask, union drbd_state val,
bbeb641c PR	137	enum chg_state_flags flags);
	138
	139	enum drbd_state_rv
bde89a9e	140	conn_request_state(struct drbd_connection *connection, union drbd_state mask, union drbd_state val,
bbeb641c PR	141	enum chg_state_flags flags);
bbeb641c PR	142
b30ab791	143	extern void drbd_resume_al(struct drbd_device *device);
bde89a9e	144	extern bool conn_all_vols_unconf(struct drbd_connection *connection);
b8907339 PR	145
b8907339 PR	146	/**
7e5fec31	147	* drbd_request_state() - Request a state change
b30ab791	148	* @device: DRBD device.
b8907339 PR	149	* @mask: mask of state bits to change.
	150	* @val: value of new state bits.
	151	*
	152	* This is the most graceful way of requesting a state change. It is verbose
	153	* quite verbose in case the state change is not possible, and all those
	154	* state changes are globally serialized.
	155	*/
b30ab791	156	static inline int drbd_request_state(struct drbd_device *device,
b8907339 PR	157	union drbd_state mask,
	158	union drbd_state val)
	159	{
b30ab791	160	return _drbd_request_state(device, mask, val, CS_VERBOSE + CS_ORDERED);
b8907339 PR	161	}
b8907339 PR	162
33d32fa7 LE	163	/* for use in adm_detach() (drbd_adm_detach(), drbd_adm_down()) */
	164	enum drbd_state_rv
	165	drbd_request_detach_interruptible(struct drbd_device *device);
	166
bde89a9e AG	167	enum drbd_role conn_highest_role(struct drbd_connection *connection);
	168	enum drbd_role conn_highest_peer(struct drbd_connection *connection);
	169	enum drbd_disk_state conn_highest_disk(struct drbd_connection *connection);
	170	enum drbd_disk_state conn_lowest_disk(struct drbd_connection *connection);
	171	enum drbd_disk_state conn_highest_pdsk(struct drbd_connection *connection);
	172	enum drbd_conns conn_lowest_conn(struct drbd_connection *connection);
cb703454	173
b8907339	174	#endif