| xj | b04a402 | 2021-11-25 15:01:52 +0800 | [diff] [blame] | 1 | /* SPDX-License-Identifier: GPL-2.0 */ | 
 | 2 | /* | 
 | 3 |  * fs/nfs/nfs4session.h | 
 | 4 |  * | 
 | 5 |  * Copyright (c) 2012 Trond Myklebust <Trond.Myklebust@netapp.com> | 
 | 6 |  * | 
 | 7 |  */ | 
 | 8 | #ifndef __LINUX_FS_NFS_NFS4SESSION_H | 
 | 9 | #define __LINUX_FS_NFS_NFS4SESSION_H | 
 | 10 |  | 
 | 11 | /* maximum number of slots to use */ | 
 | 12 | #define NFS4_DEF_SLOT_TABLE_SIZE (64U) | 
 | 13 | #define NFS4_DEF_CB_SLOT_TABLE_SIZE (1U) | 
 | 14 | #define NFS4_MAX_SLOT_TABLE (1024U) | 
 | 15 | #define NFS4_NO_SLOT ((u32)-1) | 
 | 16 |  | 
 | 17 | #if IS_ENABLED(CONFIG_NFS_V4) | 
 | 18 |  | 
 | 19 | /* Sessions slot seqid */ | 
 | 20 | struct nfs4_slot { | 
 | 21 | 	struct nfs4_slot_table	*table; | 
 | 22 | 	struct nfs4_slot	*next; | 
 | 23 | 	unsigned long		generation; | 
 | 24 | 	u32			slot_nr; | 
 | 25 | 	u32		 	seq_nr; | 
 | 26 | 	unsigned int		interrupted : 1, | 
 | 27 | 				privileged : 1, | 
 | 28 | 				seq_done : 1; | 
 | 29 | }; | 
 | 30 |  | 
 | 31 | /* Sessions */ | 
 | 32 | enum nfs4_slot_tbl_state { | 
 | 33 | 	NFS4_SLOT_TBL_DRAINING, | 
 | 34 | }; | 
 | 35 |  | 
 | 36 | #define SLOT_TABLE_SZ DIV_ROUND_UP(NFS4_MAX_SLOT_TABLE, 8*sizeof(long)) | 
 | 37 | struct nfs4_slot_table { | 
 | 38 | 	struct nfs4_session *session;		/* Parent session */ | 
 | 39 | 	struct nfs4_slot *slots;		/* seqid per slot */ | 
 | 40 | 	unsigned long   used_slots[SLOT_TABLE_SZ]; /* used/unused bitmap */ | 
 | 41 | 	spinlock_t	slot_tbl_lock; | 
 | 42 | 	struct rpc_wait_queue	slot_tbl_waitq;	/* allocators may wait here */ | 
 | 43 | 	wait_queue_head_t	slot_waitq;	/* Completion wait on slot */ | 
 | 44 | 	u32		max_slots;		/* # slots in table */ | 
 | 45 | 	u32		max_slotid;		/* Max allowed slotid value */ | 
 | 46 | 	u32		highest_used_slotid;	/* sent to server on each SEQ. | 
 | 47 | 						 * op for dynamic resizing */ | 
 | 48 | 	u32		target_highest_slotid;	/* Server max_slot target */ | 
 | 49 | 	u32		server_highest_slotid;	/* Server highest slotid */ | 
 | 50 | 	s32		d_target_highest_slotid; /* Derivative */ | 
 | 51 | 	s32		d2_target_highest_slotid; /* 2nd derivative */ | 
 | 52 | 	unsigned long	generation;		/* Generation counter for | 
 | 53 | 						   target_highest_slotid */ | 
 | 54 | 	struct completion complete; | 
 | 55 | 	unsigned long	slot_tbl_state; | 
 | 56 | }; | 
 | 57 |  | 
 | 58 | /* | 
 | 59 |  * Session related parameters | 
 | 60 |  */ | 
 | 61 | struct nfs4_session { | 
 | 62 | 	struct nfs4_sessionid		sess_id; | 
 | 63 | 	u32				flags; | 
 | 64 | 	unsigned long			session_state; | 
 | 65 | 	u32				hash_alg; | 
 | 66 | 	u32				ssv_len; | 
 | 67 |  | 
 | 68 | 	/* The fore and back channel */ | 
 | 69 | 	struct nfs4_channel_attrs	fc_attrs; | 
 | 70 | 	struct nfs4_slot_table		fc_slot_table; | 
 | 71 | 	struct nfs4_channel_attrs	bc_attrs; | 
 | 72 | 	struct nfs4_slot_table		bc_slot_table; | 
 | 73 | 	struct nfs_client		*clp; | 
 | 74 | }; | 
 | 75 |  | 
 | 76 | enum nfs4_session_state { | 
 | 77 | 	NFS4_SESSION_INITING, | 
 | 78 | 	NFS4_SESSION_ESTABLISHED, | 
 | 79 | }; | 
 | 80 |  | 
 | 81 | extern int nfs4_setup_slot_table(struct nfs4_slot_table *tbl, | 
 | 82 | 		unsigned int max_reqs, const char *queue); | 
 | 83 | extern void nfs4_shutdown_slot_table(struct nfs4_slot_table *tbl); | 
 | 84 | extern struct nfs4_slot *nfs4_alloc_slot(struct nfs4_slot_table *tbl); | 
 | 85 | extern struct nfs4_slot *nfs4_lookup_slot(struct nfs4_slot_table *tbl, u32 slotid); | 
 | 86 | extern int nfs4_slot_wait_on_seqid(struct nfs4_slot_table *tbl, | 
 | 87 | 		u32 slotid, u32 seq_nr, | 
 | 88 | 		unsigned long timeout); | 
 | 89 | extern bool nfs4_try_to_lock_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *slot); | 
 | 90 | extern void nfs4_free_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *slot); | 
 | 91 | extern void nfs4_slot_tbl_drain_complete(struct nfs4_slot_table *tbl); | 
 | 92 | bool nfs41_wake_and_assign_slot(struct nfs4_slot_table *tbl, | 
 | 93 | 		struct nfs4_slot *slot); | 
 | 94 | void nfs41_wake_slot_table(struct nfs4_slot_table *tbl); | 
 | 95 |  | 
 | 96 | static inline bool nfs4_slot_tbl_draining(struct nfs4_slot_table *tbl) | 
 | 97 | { | 
 | 98 | 	return !!test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state); | 
 | 99 | } | 
 | 100 |  | 
 | 101 | static inline bool nfs4_test_locked_slot(const struct nfs4_slot_table *tbl, | 
 | 102 | 		u32 slotid) | 
 | 103 | { | 
 | 104 | 	return !!test_bit(slotid, tbl->used_slots); | 
 | 105 | } | 
 | 106 |  | 
 | 107 | static inline struct nfs4_session *nfs4_get_session(const struct nfs_client *clp) | 
 | 108 | { | 
 | 109 | 	return clp->cl_session; | 
 | 110 | } | 
 | 111 |  | 
 | 112 | #if defined(CONFIG_NFS_V4_1) | 
 | 113 | extern void nfs41_set_target_slotid(struct nfs4_slot_table *tbl, | 
 | 114 | 		u32 target_highest_slotid); | 
 | 115 | extern void nfs41_update_target_slotid(struct nfs4_slot_table *tbl, | 
 | 116 | 		struct nfs4_slot *slot, | 
 | 117 | 		struct nfs4_sequence_res *res); | 
 | 118 |  | 
 | 119 | extern int nfs4_setup_session_slot_tables(struct nfs4_session *ses); | 
 | 120 |  | 
 | 121 | extern struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp); | 
 | 122 | extern void nfs4_destroy_session(struct nfs4_session *session); | 
 | 123 | extern int nfs4_init_session(struct nfs_client *clp); | 
 | 124 | extern int nfs4_init_ds_session(struct nfs_client *, unsigned long); | 
 | 125 |  | 
 | 126 | /* | 
 | 127 |  * Determine if sessions are in use. | 
 | 128 |  */ | 
 | 129 | static inline int nfs4_has_session(const struct nfs_client *clp) | 
 | 130 | { | 
 | 131 | 	if (clp->cl_session) | 
 | 132 | 		return 1; | 
 | 133 | 	return 0; | 
 | 134 | } | 
 | 135 |  | 
 | 136 | static inline int nfs4_has_persistent_session(const struct nfs_client *clp) | 
 | 137 | { | 
 | 138 | 	if (nfs4_has_session(clp)) | 
 | 139 | 		return (clp->cl_session->flags & SESSION4_PERSIST); | 
 | 140 | 	return 0; | 
 | 141 | } | 
 | 142 |  | 
 | 143 | static inline void nfs4_copy_sessionid(struct nfs4_sessionid *dst, | 
 | 144 | 		const struct nfs4_sessionid *src) | 
 | 145 | { | 
 | 146 | 	memcpy(dst->data, src->data, NFS4_MAX_SESSIONID_LEN); | 
 | 147 | } | 
 | 148 |  | 
 | 149 | #ifdef CONFIG_CRC32 | 
 | 150 | /* | 
 | 151 |  * nfs_session_id_hash - calculate the crc32 hash for the session id | 
 | 152 |  * @session - pointer to session | 
 | 153 |  */ | 
 | 154 | #define nfs_session_id_hash(sess_id) \ | 
 | 155 | 	(~crc32_le(0xFFFFFFFF, &(sess_id)->data[0], sizeof((sess_id)->data))) | 
 | 156 | #else | 
 | 157 | #define nfs_session_id_hash(session) (0) | 
 | 158 | #endif | 
 | 159 | #else /* defined(CONFIG_NFS_V4_1) */ | 
 | 160 |  | 
 | 161 | static inline int nfs4_init_session(struct nfs_client *clp) | 
 | 162 | { | 
 | 163 | 	return 0; | 
 | 164 | } | 
 | 165 |  | 
 | 166 | /* | 
 | 167 |  * Determine if sessions are in use. | 
 | 168 |  */ | 
 | 169 | static inline int nfs4_has_session(const struct nfs_client *clp) | 
 | 170 | { | 
 | 171 | 	return 0; | 
 | 172 | } | 
 | 173 |  | 
 | 174 | static inline int nfs4_has_persistent_session(const struct nfs_client *clp) | 
 | 175 | { | 
 | 176 | 	return 0; | 
 | 177 | } | 
 | 178 |  | 
 | 179 | #define nfs_session_id_hash(session) (0) | 
 | 180 |  | 
 | 181 | #endif /* defined(CONFIG_NFS_V4_1) */ | 
 | 182 | #endif /* IS_ENABLED(CONFIG_NFS_V4) */ | 
 | 183 | #endif /* __LINUX_FS_NFS_NFS4SESSION_H */ |