*/
/*
* This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
*
* lustre/ptlrpc/layout.c
*
#include <linux/module.h>
#include <llog_swab.h>
-#include <lustre_debug.h>
#include <lustre_swab.h>
#include <obd.h>
#include <obd_support.h>
#include <lustre_acl.h>
#include <lustre_nodemap.h>
+#include "ptlrpc_internal.h"
+
/*
* RQFs (see below) refer to two struct req_msg_field arrays describing the
* client request and server reply, respectively.
*/
/* empty set of fields... for suitable definition of emptiness. */
static const struct req_msg_field *empty[] = {
- &RMF_PTLRPC_BODY
+ &RMF_PTLRPC_BODY
};
static const struct req_msg_field *mgs_target_info_only[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MGS_TARGET_INFO
+ &RMF_PTLRPC_BODY,
+ &RMF_MGS_TARGET_INFO
};
-#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 13, 53, 0)
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 18, 53, 0)
static const struct req_msg_field *mgs_set_info[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MGS_SEND_PARAM
+ &RMF_PTLRPC_BODY,
+ &RMF_MGS_SEND_PARAM
};
#endif
static const struct req_msg_field *mgs_config_read_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MGS_CONFIG_BODY
+ &RMF_PTLRPC_BODY,
+ &RMF_MGS_CONFIG_BODY
};
static const struct req_msg_field *mgs_config_read_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MGS_CONFIG_RES
+ &RMF_PTLRPC_BODY,
+ &RMF_MGS_CONFIG_RES
};
static const struct req_msg_field *mdt_body_only[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MDT_BODY
+ &RMF_PTLRPC_BODY,
+ &RMF_MDT_BODY
};
static const struct req_msg_field *mdt_body_capa[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MDT_BODY,
- &RMF_CAPA1
+ &RMF_PTLRPC_BODY,
+ &RMF_MDT_BODY,
+ &RMF_CAPA1
};
static const struct req_msg_field *quotactl_only[] = {
- &RMF_PTLRPC_BODY,
- &RMF_OBD_QUOTACTL
+ &RMF_PTLRPC_BODY,
+ &RMF_OBD_QUOTACTL
+};
+
+static const struct req_msg_field *quotactl_server_only[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_OBD_QUOTACTL,
+ &RMF_OBD_QUOTA_ITER
};
static const struct req_msg_field *quota_body_only[] = {
};
static const struct req_msg_field *mdt_close_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MDT_EPOCH,
- &RMF_REC_REINT,
- &RMF_CAPA1
+ &RMF_PTLRPC_BODY,
+ &RMF_MDT_EPOCH,
+ &RMF_REC_REINT,
+ &RMF_CAPA1
};
static const struct req_msg_field *mdt_close_intent_client[] = {
};
static const struct req_msg_field *obd_statfs_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_OBD_STATFS
+ &RMF_PTLRPC_BODY,
+ &RMF_OBD_STATFS
};
static const struct req_msg_field *seq_query_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_SEQ_OPC,
- &RMF_SEQ_RANGE
+ &RMF_PTLRPC_BODY,
+ &RMF_SEQ_OPC,
+ &RMF_SEQ_RANGE
};
static const struct req_msg_field *seq_query_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_SEQ_RANGE
+ &RMF_PTLRPC_BODY,
+ &RMF_SEQ_RANGE
};
static const struct req_msg_field *fld_query_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_FLD_OPC,
- &RMF_FLD_MDFLD
+ &RMF_PTLRPC_BODY,
+ &RMF_FLD_OPC,
+ &RMF_FLD_MDFLD
};
static const struct req_msg_field *fld_query_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_FLD_MDFLD
+ &RMF_PTLRPC_BODY,
+ &RMF_FLD_MDFLD
};
static const struct req_msg_field *fld_read_client[] = {
};
static const struct req_msg_field *mds_getattr_name_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MDT_BODY,
- &RMF_CAPA1,
- &RMF_NAME
+ &RMF_PTLRPC_BODY,
+ &RMF_MDT_BODY,
+ &RMF_CAPA1,
+ &RMF_NAME
};
static const struct req_msg_field *mds_reint_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_REC_REINT
+ &RMF_PTLRPC_BODY,
+ &RMF_REC_REINT
};
static const struct req_msg_field *mds_reint_create_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_REC_REINT,
- &RMF_CAPA1,
- &RMF_NAME
+ &RMF_PTLRPC_BODY,
+ &RMF_REC_REINT,
+ &RMF_CAPA1,
+ &RMF_NAME
};
static const struct req_msg_field *mds_reint_create_slave_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_REC_REINT,
- &RMF_CAPA1,
- &RMF_NAME,
- &RMF_EADATA,
- &RMF_DLM_REQ
+ &RMF_PTLRPC_BODY,
+ &RMF_REC_REINT,
+ &RMF_CAPA1,
+ &RMF_NAME,
+ &RMF_EADATA,
+ &RMF_DLM_REQ
};
static const struct req_msg_field *mds_reint_create_acl_client[] = {
&RMF_DLM_REQ,
&RMF_FILE_SECCTX_NAME,
&RMF_FILE_SECCTX,
- &RMF_SELINUX_POL
+ &RMF_SELINUX_POL,
+ &RMF_FILE_ENCCTX,
};
static const struct req_msg_field *mds_reint_create_sym_client[] = {
&RMF_DLM_REQ,
&RMF_FILE_SECCTX_NAME,
&RMF_FILE_SECCTX,
- &RMF_SELINUX_POL
+ &RMF_SELINUX_POL,
+ &RMF_FILE_ENCCTX,
+};
+
+static const struct req_msg_field *mds_reint_create_acl_server[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_MDT_BODY,
+ &RMF_CAPA1,
+ &RMF_MDT_MD
};
static const struct req_msg_field *mds_reint_open_client[] = {
&RMF_EADATA,
&RMF_FILE_SECCTX_NAME,
&RMF_FILE_SECCTX,
- &RMF_SELINUX_POL
+ &RMF_SELINUX_POL,
+ &RMF_FILE_ENCCTX,
};
static const struct req_msg_field *mds_reint_open_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MDT_BODY,
- &RMF_MDT_MD,
- &RMF_ACL,
- &RMF_CAPA1,
- &RMF_CAPA2
+ &RMF_PTLRPC_BODY,
+ &RMF_MDT_BODY,
+ &RMF_MDT_MD,
+ &RMF_ACL,
+ &RMF_CAPA1,
+ &RMF_CAPA2
};
static const struct req_msg_field *mds_reint_unlink_client[] = {
};
static const struct req_msg_field *mds_last_unlink_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MDT_BODY,
- &RMF_MDT_MD,
- &RMF_LOGCOOKIES,
- &RMF_CAPA1,
- &RMF_CAPA2
+ &RMF_PTLRPC_BODY,
+ &RMF_MDT_BODY,
+ &RMF_MDT_MD,
+ &RMF_LOGCOOKIES,
+ &RMF_CAPA1,
+ &RMF_CAPA2
};
static const struct req_msg_field *mds_reint_setattr_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_REC_REINT,
- &RMF_CAPA1,
- &RMF_MDT_EPOCH,
- &RMF_EADATA,
- &RMF_LOGCOOKIES,
- &RMF_DLM_REQ
+ &RMF_PTLRPC_BODY,
+ &RMF_REC_REINT,
+ &RMF_CAPA1,
+ &RMF_MDT_EPOCH,
+ &RMF_EADATA,
+ &RMF_LOGCOOKIES,
+ &RMF_DLM_REQ
};
static const struct req_msg_field *mds_reint_setxattr_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_REC_REINT,
- &RMF_CAPA1,
- &RMF_NAME,
- &RMF_EADATA,
+ &RMF_PTLRPC_BODY,
+ &RMF_REC_REINT,
+ &RMF_CAPA1,
+ &RMF_NAME,
+ &RMF_EADATA,
&RMF_DLM_REQ,
&RMF_SELINUX_POL
};
};
static const struct req_msg_field *obd_connect_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_CONNECT_DATA
+ &RMF_PTLRPC_BODY,
+ &RMF_CONNECT_DATA
};
static const struct req_msg_field *obd_set_info_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_SETINFO_KEY,
- &RMF_SETINFO_VAL
+ &RMF_PTLRPC_BODY,
+ &RMF_SETINFO_KEY,
+ &RMF_SETINFO_VAL
+};
+
+static const struct req_msg_field *mdt_set_info_client[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_SETINFO_KEY,
+ &RMF_SETINFO_VAL,
+ &RMF_MDT_BODY
};
static const struct req_msg_field *ost_grant_shrink_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_SETINFO_KEY,
- &RMF_OST_BODY
+ &RMF_PTLRPC_BODY,
+ &RMF_SETINFO_KEY,
+ &RMF_OST_BODY
};
static const struct req_msg_field *mds_getinfo_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_GETINFO_KEY,
- &RMF_GETINFO_VALLEN
+ &RMF_PTLRPC_BODY,
+ &RMF_GETINFO_KEY,
+ &RMF_GETINFO_VALLEN
};
static const struct req_msg_field *mds_getinfo_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_GETINFO_VAL,
+ &RMF_PTLRPC_BODY,
+ &RMF_GETINFO_VAL,
};
static const struct req_msg_field *ldlm_enqueue_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_DLM_REQ
+ &RMF_PTLRPC_BODY,
+ &RMF_DLM_REQ
};
static const struct req_msg_field *ldlm_enqueue_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_DLM_REP
+ &RMF_PTLRPC_BODY,
+ &RMF_DLM_REP
};
static const struct req_msg_field *ldlm_enqueue_lvb_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_DLM_REP,
- &RMF_DLM_LVB
+ &RMF_PTLRPC_BODY,
+ &RMF_DLM_REP,
+ &RMF_DLM_LVB
};
static const struct req_msg_field *ldlm_cp_callback_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_DLM_REQ,
- &RMF_DLM_LVB
+ &RMF_PTLRPC_BODY,
+ &RMF_DLM_REQ,
+ &RMF_DLM_LVB
};
static const struct req_msg_field *ldlm_gl_callback_desc_client[] = {
};
static const struct req_msg_field *ldlm_gl_callback_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_DLM_LVB
+ &RMF_PTLRPC_BODY,
+ &RMF_DLM_LVB
};
static const struct req_msg_field *ldlm_intent_basic_client[] = {
};
static const struct req_msg_field *ldlm_intent_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_DLM_REQ,
- &RMF_LDLM_INTENT,
- &RMF_REC_REINT
+ &RMF_PTLRPC_BODY,
+ &RMF_DLM_REQ,
+ &RMF_LDLM_INTENT,
+ &RMF_REC_REINT
};
static const struct req_msg_field *ldlm_intent_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_DLM_REP,
- &RMF_MDT_BODY,
- &RMF_MDT_MD,
- &RMF_ACL
+ &RMF_PTLRPC_BODY,
+ &RMF_DLM_REP,
+ &RMF_MDT_BODY,
+ &RMF_MDT_MD,
+ &RMF_ACL
};
static const struct req_msg_field *ldlm_intent_layout_client[] = {
&RMF_CAPA1,
&RMF_CAPA2,
&RMF_NIOBUF_INLINE,
- &RMF_FILE_SECCTX
+ &RMF_FILE_SECCTX,
+ &RMF_FILE_ENCCTX,
+ &RMF_DEFAULT_MDT_MD,
};
static const struct req_msg_field *ldlm_intent_getattr_client[] = {
&RMF_ACL,
&RMF_CAPA1,
&RMF_FILE_SECCTX,
- &RMF_DEFAULT_MDT_MD
+ &RMF_DEFAULT_MDT_MD,
+ &RMF_FILE_ENCCTX,
};
static const struct req_msg_field *ldlm_intent_create_client[] = {
&RMF_EADATA,
&RMF_FILE_SECCTX_NAME,
&RMF_FILE_SECCTX,
- &RMF_SELINUX_POL
+ &RMF_SELINUX_POL,
+ &RMF_FILE_ENCCTX,
};
static const struct req_msg_field *ldlm_intent_open_client[] = {
&RMF_EADATA,
&RMF_FILE_SECCTX_NAME,
&RMF_FILE_SECCTX,
- &RMF_SELINUX_POL
+ &RMF_SELINUX_POL,
+ &RMF_FILE_ENCCTX,
};
static const struct req_msg_field *ldlm_intent_getxattr_client[] = {
};
static const struct req_msg_field *mds_getxattr_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MDT_BODY,
- &RMF_EADATA
+ &RMF_PTLRPC_BODY,
+ &RMF_MDT_BODY,
+ &RMF_EADATA
};
static const struct req_msg_field *mds_getattr_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MDT_BODY,
- &RMF_MDT_MD,
- &RMF_ACL,
- &RMF_CAPA1,
- &RMF_CAPA2
+ &RMF_PTLRPC_BODY,
+ &RMF_MDT_BODY,
+ &RMF_MDT_MD,
+ &RMF_ACL,
+ &RMF_CAPA1,
+ &RMF_CAPA2,
+ &RMF_FILE_ENCCTX,
};
static const struct req_msg_field *mds_setattr_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_MDT_BODY,
- &RMF_MDT_MD,
- &RMF_ACL,
- &RMF_CAPA1,
- &RMF_CAPA2
+ &RMF_PTLRPC_BODY,
+ &RMF_MDT_BODY,
+ &RMF_MDT_MD,
+ &RMF_ACL,
+ &RMF_CAPA1,
+ &RMF_CAPA2
};
-static const struct req_msg_field *mds_update_client[] = {
+static const struct req_msg_field *mds_batch_client[] = {
&RMF_PTLRPC_BODY,
- &RMF_OUT_UPDATE_HEADER,
- &RMF_OUT_UPDATE_BUF,
+ &RMF_BUT_HEADER,
+ &RMF_BUT_BUF,
};
-static const struct req_msg_field *mds_update_server[] = {
+static const struct req_msg_field *mds_batch_server[] = {
&RMF_PTLRPC_BODY,
- &RMF_OUT_UPDATE_REPLY,
+ &RMF_BUT_REPLY,
};
static const struct req_msg_field *llog_origin_handle_create_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_LLOGD_BODY,
- &RMF_NAME
+ &RMF_PTLRPC_BODY,
+ &RMF_LLOGD_BODY,
+ &RMF_NAME,
+ &RMF_MDT_BODY
};
static const struct req_msg_field *llogd_body_only[] = {
- &RMF_PTLRPC_BODY,
- &RMF_LLOGD_BODY
+ &RMF_PTLRPC_BODY,
+ &RMF_LLOGD_BODY
};
static const struct req_msg_field *llog_log_hdr_only[] = {
- &RMF_PTLRPC_BODY,
- &RMF_LLOG_LOG_HDR
+ &RMF_PTLRPC_BODY,
+ &RMF_LLOG_LOG_HDR
};
static const struct req_msg_field *llog_origin_handle_next_block_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_LLOGD_BODY,
- &RMF_EADATA
+ &RMF_PTLRPC_BODY,
+ &RMF_LLOGD_BODY,
+ &RMF_EADATA
};
static const struct req_msg_field *obd_idx_read_client[] = {
};
static const struct req_msg_field *ost_body_only[] = {
- &RMF_PTLRPC_BODY,
- &RMF_OST_BODY
+ &RMF_PTLRPC_BODY,
+ &RMF_OST_BODY
};
static const struct req_msg_field *ost_body_capa[] = {
- &RMF_PTLRPC_BODY,
- &RMF_OST_BODY,
- &RMF_CAPA1
+ &RMF_PTLRPC_BODY,
+ &RMF_OST_BODY,
+ &RMF_CAPA1
};
static const struct req_msg_field *ost_destroy_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_OST_BODY,
- &RMF_DLM_REQ,
- &RMF_CAPA1
+ &RMF_PTLRPC_BODY,
+ &RMF_OST_BODY,
+ &RMF_DLM_REQ,
+ &RMF_CAPA1
};
};
static const struct req_msg_field *ost_brw_write_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_OST_BODY,
- &RMF_RCS
+ &RMF_PTLRPC_BODY,
+ &RMF_OST_BODY,
+ &RMF_RCS
};
static const struct req_msg_field *ost_get_info_generic_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_GENERIC_DATA,
+ &RMF_PTLRPC_BODY,
+ &RMF_GENERIC_DATA,
};
static const struct req_msg_field *ost_get_info_generic_client[] = {
- &RMF_PTLRPC_BODY,
+ &RMF_PTLRPC_BODY,
&RMF_GETINFO_KEY
};
static const struct req_msg_field *ost_get_last_id_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_OBD_ID
+ &RMF_PTLRPC_BODY,
+ &RMF_OBD_ID
};
static const struct req_msg_field *ost_get_last_fid_client[] = {
};
static const struct req_msg_field *ost_get_fiemap_client[] = {
- &RMF_PTLRPC_BODY,
- &RMF_FIEMAP_KEY,
- &RMF_FIEMAP_VAL
+ &RMF_PTLRPC_BODY,
+ &RMF_FIEMAP_KEY,
+ &RMF_FIEMAP_VAL
};
static const struct req_msg_field *ost_ladvise[] = {
};
static const struct req_msg_field *ost_get_fiemap_server[] = {
- &RMF_PTLRPC_BODY,
- &RMF_FIEMAP_VAL
+ &RMF_PTLRPC_BODY,
+ &RMF_FIEMAP_VAL
};
static const struct req_msg_field *mdt_hsm_progress[] = {
&RMF_LFSCK_REPLY,
};
+static const struct req_msg_field *mds_batch_getattr_client[] = {
+ &RMF_DLM_REQ,
+ &RMF_LDLM_INTENT,
+ &RMF_MDT_BODY, /* coincides with mds_getattr_name_client[] */
+ &RMF_CAPA1,
+ &RMF_NAME,
+ &RMF_FILE_SECCTX_NAME
+};
+
+static const struct req_msg_field *mds_batch_getattr_server[] = {
+ &RMF_DLM_REP,
+ &RMF_MDT_BODY,
+ &RMF_MDT_MD,
+ &RMF_ACL,
+ &RMF_CAPA1,
+ &RMF_FILE_SECCTX,
+ &RMF_DEFAULT_MDT_MD,
+ &RMF_FILE_ENCCTX,
+};
+
static struct req_format *req_formats[] = {
&RQF_OBD_PING,
&RQF_OBD_SET_INFO,
+ &RQF_MDT_SET_INFO,
&RQF_OBD_IDX_READ,
&RQF_SEC_CTX,
&RQF_MGS_TARGET_REG,
-#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 13, 53, 0)
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 18, 53, 0)
&RQF_MGS_SET_INFO,
#endif
&RQF_MGS_CONFIG_READ,
&RQF_MDS_HSM_REQUEST,
&RQF_MDS_SWAP_LAYOUTS,
&RQF_MDS_RMFID,
+#ifdef HAVE_SERVER_SUPPORT
&RQF_OUT_UPDATE,
+#endif
&RQF_OST_CONNECT,
&RQF_OST_DISCONNECT,
&RQF_OST_QUOTACTL,
&RQF_OST_SETATTR,
&RQF_OST_CREATE,
&RQF_OST_PUNCH,
+ &RQF_OST_FALLOCATE,
&RQF_OST_SYNC,
&RQF_OST_DESTROY,
&RQF_OST_BRW_READ,
&RQF_OST_SET_INFO_LAST_FID,
&RQF_OST_GET_INFO_FIEMAP,
&RQF_OST_LADVISE,
+ &RQF_OST_SEEK,
&RQF_LDLM_ENQUEUE,
&RQF_LDLM_ENQUEUE_LVB,
&RQF_LDLM_CONVERT,
&RQF_CONNECT,
&RQF_LFSCK_NOTIFY,
&RQF_LFSCK_QUERY,
+ &RQF_BUT_GETATTR,
+ &RQF_MDS_BATCH,
};
struct req_msg_field {
- const __u32 rmf_flags;
- const char *rmf_name;
- /**
- * Field length. (-1) means "variable length". If the
- * \a RMF_F_STRUCT_ARRAY flag is set the field is also variable-length,
- * but the actual size must be a whole multiple of \a rmf_size.
- */
- const int rmf_size;
- void (*rmf_swabber)(void *);
- void (*rmf_dumper)(void *);
- int rmf_offset[ARRAY_SIZE(req_formats)][RCL_NR];
+ const __u32 rmf_flags;
+ const char *rmf_name;
+ /**
+ * Field length. (-1) means "variable length". If the
+ * \a RMF_F_STRUCT_ARRAY flag is set the field is also variable-length,
+ * but the actual size must be a whole multiple of \a rmf_size.
+ */
+ const int rmf_size;
+ void (*rmf_swabber)(void *);
+ /**
+ * Pass buffer size to swabbing function
+ * \retval > 0 the number of bytes swabbed
+ * -EOVERFLOW on error
+ */
+ int (*rmf_swab_len)(void *, __u32);
+ void (*rmf_dumper)(void *);
+ int rmf_offset[ARRAY_SIZE(req_formats)][RCL_NR];
};
enum rmf_flags {
- /**
- * The field is a string, must be NUL-terminated.
- */
- RMF_F_STRING = 1 << 0,
- /**
- * The field's buffer size need not match the declared \a rmf_size.
- */
- RMF_F_NO_SIZE_CHECK = 1 << 1,
- /**
- * The field's buffer size must be a whole multiple of the declared \a
- * rmf_size and the \a rmf_swabber function must work on the declared \a
- * rmf_size worth of bytes.
- */
- RMF_F_STRUCT_ARRAY = 1 << 2
+ /**
+ * The field is a string, must be NUL-terminated.
+ */
+ RMF_F_STRING = BIT(0),
+ /**
+ * The field's buffer size need not match the declared \a rmf_size.
+ */
+ RMF_F_NO_SIZE_CHECK = BIT(1),
+ /**
+ * The field's buffer size must be a whole multiple of the declared \a
+ * rmf_size and the \a rmf_swabber function must work on the declared \a
+ * rmf_size worth of bytes.
+ */
+ RMF_F_STRUCT_ARRAY = BIT(2),
};
struct req_capsule;
/*
* Request fields.
*/
-#define DEFINE_MSGF(name, flags, size, swabber, dumper) { \
- .rmf_name = (name), \
- .rmf_flags = (flags), \
- .rmf_size = (size), \
- .rmf_swabber = (void (*)(void*))(swabber), \
- .rmf_dumper = (void (*)(void*))(dumper) \
+#define DEFINE_MSGF(name, flags, size, swabber, dumper) { \
+ .rmf_name = (name), \
+ .rmf_flags = (flags), \
+ .rmf_size = (size), \
+ .rmf_swabber = (void (*)(void *))(swabber), \
+ .rmf_dumper = (void (*)(void *))(dumper) \
+}
+
+#define DEFINE_MSGFL(name, flags, size, swab_len, dumper) { \
+ .rmf_name = (name), \
+ .rmf_flags = (flags), \
+ .rmf_size = (size), \
+ .rmf_swab_len = (int (*)(void *, __u32))(swab_len), \
+ .rmf_dumper = (void (*)(void *))(dumper) \
}
struct req_msg_field RMF_GENERIC_DATA =
- DEFINE_MSGF("generic_data", 0,
- -1, NULL, NULL);
+ DEFINE_MSGF("generic_data", 0, -1, NULL, NULL);
EXPORT_SYMBOL(RMF_GENERIC_DATA);
struct req_msg_field RMF_MGS_TARGET_INFO =
- DEFINE_MSGF("mgs_target_info", 0,
- sizeof(struct mgs_target_info),
- lustre_swab_mgs_target_info, NULL);
+ DEFINE_MSGF("mgs_target_info", 0, sizeof(struct mgs_target_info),
+ lustre_swab_mgs_target_info, NULL);
EXPORT_SYMBOL(RMF_MGS_TARGET_INFO);
-#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 13, 53, 0)
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 18, 53, 0)
struct req_msg_field RMF_MGS_SEND_PARAM =
- DEFINE_MSGF("mgs_send_param", 0,
- sizeof(struct mgs_send_param),
- NULL, NULL);
+ DEFINE_MSGF("mgs_send_param", 0,
+ sizeof(struct mgs_send_param),
+ NULL, NULL);
EXPORT_SYMBOL(RMF_MGS_SEND_PARAM);
#endif
struct req_msg_field RMF_MGS_CONFIG_BODY =
- DEFINE_MSGF("mgs_config_read request", 0,
- sizeof(struct mgs_config_body),
- lustre_swab_mgs_config_body, NULL);
+ DEFINE_MSGF("mgs_config_read request", 0,
+ sizeof(struct mgs_config_body),
+ lustre_swab_mgs_config_body, NULL);
EXPORT_SYMBOL(RMF_MGS_CONFIG_BODY);
struct req_msg_field RMF_MGS_CONFIG_RES =
- DEFINE_MSGF("mgs_config_read reply ", 0,
- sizeof(struct mgs_config_res),
- lustre_swab_mgs_config_res, NULL);
+ DEFINE_MSGF("mgs_config_read reply ", 0, sizeof(struct mgs_config_res),
+ lustre_swab_mgs_config_res, NULL);
EXPORT_SYMBOL(RMF_MGS_CONFIG_RES);
struct req_msg_field RMF_U32 =
EXPORT_SYMBOL(RMF_U32);
struct req_msg_field RMF_SETINFO_VAL =
- DEFINE_MSGF("setinfo_val", 0, -1, NULL, NULL);
+ DEFINE_MSGF("setinfo_val", 0, -1, NULL, NULL);
EXPORT_SYMBOL(RMF_SETINFO_VAL);
struct req_msg_field RMF_GETINFO_KEY =
- DEFINE_MSGF("getinfo_key", 0, -1, NULL, NULL);
+ DEFINE_MSGF("getinfo_key", 0, -1, NULL, NULL);
EXPORT_SYMBOL(RMF_GETINFO_KEY);
struct req_msg_field RMF_GETINFO_VALLEN =
- DEFINE_MSGF("getinfo_vallen", 0,
- sizeof(__u32), lustre_swab_generic_32s, NULL);
+ DEFINE_MSGF("getinfo_vallen", 0, sizeof(__u32),
+ lustre_swab_generic_32s, NULL);
EXPORT_SYMBOL(RMF_GETINFO_VALLEN);
struct req_msg_field RMF_GETINFO_VAL =
- DEFINE_MSGF("getinfo_val", 0, -1, NULL, NULL);
+ DEFINE_MSGF("getinfo_val", 0, -1, NULL, NULL);
EXPORT_SYMBOL(RMF_GETINFO_VAL);
struct req_msg_field RMF_SEQ_OPC =
- DEFINE_MSGF("seq_query_opc", 0,
- sizeof(__u32), lustre_swab_generic_32s, NULL);
+ DEFINE_MSGF("seq_query_opc", 0, sizeof(__u32),
+ lustre_swab_generic_32s, NULL);
EXPORT_SYMBOL(RMF_SEQ_OPC);
struct req_msg_field RMF_SEQ_RANGE =
- DEFINE_MSGF("seq_query_range", 0,
- sizeof(struct lu_seq_range),
- lustre_swab_lu_seq_range, NULL);
+ DEFINE_MSGF("seq_query_range", 0, sizeof(struct lu_seq_range),
+ lustre_swab_lu_seq_range, NULL);
EXPORT_SYMBOL(RMF_SEQ_RANGE);
struct req_msg_field RMF_FLD_OPC =
- DEFINE_MSGF("fld_query_opc", 0,
- sizeof(__u32), lustre_swab_generic_32s, NULL);
+ DEFINE_MSGF("fld_query_opc", 0, sizeof(__u32),
+ lustre_swab_generic_32s, NULL);
EXPORT_SYMBOL(RMF_FLD_OPC);
struct req_msg_field RMF_FLD_MDFLD =
- DEFINE_MSGF("fld_query_mdfld", 0,
- sizeof(struct lu_seq_range),
- lustre_swab_lu_seq_range, NULL);
+ DEFINE_MSGF("fld_query_mdfld", 0, sizeof(struct lu_seq_range),
+ lustre_swab_lu_seq_range, NULL);
EXPORT_SYMBOL(RMF_FLD_MDFLD);
struct req_msg_field RMF_MDT_BODY =
- DEFINE_MSGF("mdt_body", 0,
- sizeof(struct mdt_body), lustre_swab_mdt_body, NULL);
+ DEFINE_MSGF("mdt_body", 0, sizeof(struct mdt_body),
+ lustre_swab_mdt_body, NULL);
EXPORT_SYMBOL(RMF_MDT_BODY);
struct req_msg_field RMF_OBD_QUOTACTL =
- DEFINE_MSGF("obd_quotactl", 0,
- sizeof(struct obd_quotactl),
- lustre_swab_obd_quotactl, NULL);
+ DEFINE_MSGFL("obd_quotactl", 0, sizeof(struct obd_quotactl),
+ lustre_swab_obd_quotactl, NULL);
EXPORT_SYMBOL(RMF_OBD_QUOTACTL);
+struct req_msg_field RMF_OBD_QUOTA_ITER =
+ DEFINE_MSGFL("quota_iter_key", 0, -1, NULL, NULL);
+EXPORT_SYMBOL(RMF_OBD_QUOTA_ITER);
+
struct req_msg_field RMF_QUOTA_BODY =
DEFINE_MSGF("quota_body", 0,
sizeof(struct quota_body), lustre_swab_quota_body, NULL);
EXPORT_SYMBOL(RMF_QUOTA_BODY);
struct req_msg_field RMF_MDT_EPOCH =
- DEFINE_MSGF("mdt_ioepoch", 0,
- sizeof(struct mdt_ioepoch), lustre_swab_mdt_ioepoch, NULL);
+ DEFINE_MSGF("mdt_ioepoch", 0, sizeof(struct mdt_ioepoch),
+ lustre_swab_mdt_ioepoch, NULL);
EXPORT_SYMBOL(RMF_MDT_EPOCH);
struct req_msg_field RMF_PTLRPC_BODY =
- DEFINE_MSGF("ptlrpc_body", 0,
- sizeof(struct ptlrpc_body), lustre_swab_ptlrpc_body, NULL);
+ DEFINE_MSGF("ptlrpc_body", 0,
+ sizeof(struct ptlrpc_body), lustre_swab_ptlrpc_body, NULL);
EXPORT_SYMBOL(RMF_PTLRPC_BODY);
struct req_msg_field RMF_CLOSE_DATA =
EXPORT_SYMBOL(RMF_CLOSE_DATA);
struct req_msg_field RMF_OBD_STATFS =
- DEFINE_MSGF("obd_statfs", 0,
- sizeof(struct obd_statfs), lustre_swab_obd_statfs, NULL);
+ DEFINE_MSGF("obd_statfs", 0,
+ sizeof(struct obd_statfs), lustre_swab_obd_statfs, NULL);
EXPORT_SYMBOL(RMF_OBD_STATFS);
struct req_msg_field RMF_SETINFO_KEY =
- DEFINE_MSGF("setinfo_key", 0, -1, NULL, NULL);
+ DEFINE_MSGF("setinfo_key", 0, -1, NULL, NULL);
EXPORT_SYMBOL(RMF_SETINFO_KEY);
struct req_msg_field RMF_NAME =
- DEFINE_MSGF("name", RMF_F_STRING, -1, NULL, NULL);
+ DEFINE_MSGF("name", RMF_F_STRING, -1, NULL, NULL);
EXPORT_SYMBOL(RMF_NAME);
struct req_msg_field RMF_FID_ARRAY =
EXPORT_SYMBOL(RMF_FID_ARRAY);
struct req_msg_field RMF_SYMTGT =
- DEFINE_MSGF("symtgt", RMF_F_STRING, -1, NULL, NULL);
+ DEFINE_MSGF("symtgt", 0, -1, NULL, NULL);
EXPORT_SYMBOL(RMF_SYMTGT);
struct req_msg_field RMF_TGTUUID =
- DEFINE_MSGF("tgtuuid", RMF_F_STRING, sizeof(struct obd_uuid) - 1, NULL,
- NULL);
+ DEFINE_MSGF("tgtuuid", RMF_F_STRING, sizeof(struct obd_uuid) - 1, NULL,
+ NULL);
EXPORT_SYMBOL(RMF_TGTUUID);
struct req_msg_field RMF_CLUUID =
- DEFINE_MSGF("cluuid", RMF_F_STRING, sizeof(struct obd_uuid) - 1, NULL,
- NULL);
+ DEFINE_MSGF("cluuid", RMF_F_STRING, sizeof(struct obd_uuid) - 1, NULL,
+ NULL);
EXPORT_SYMBOL(RMF_CLUUID);
struct req_msg_field RMF_STRING =
- DEFINE_MSGF("string", RMF_F_STRING, -1, NULL, NULL);
+ DEFINE_MSGF("string", RMF_F_STRING, -1, NULL, NULL);
EXPORT_SYMBOL(RMF_STRING);
struct req_msg_field RMF_FILE_SECCTX_NAME =
DEFINE_MSGF("file_secctx", RMF_F_NO_SIZE_CHECK, -1, NULL, NULL);
EXPORT_SYMBOL(RMF_FILE_SECCTX);
+struct req_msg_field RMF_FILE_ENCCTX =
+ DEFINE_MSGF("file_encctx", RMF_F_NO_SIZE_CHECK, -1, NULL, NULL);
+EXPORT_SYMBOL(RMF_FILE_ENCCTX);
+
struct req_msg_field RMF_LLOGD_BODY =
- DEFINE_MSGF("llogd_body", 0,
- sizeof(struct llogd_body), lustre_swab_llogd_body, NULL);
+ DEFINE_MSGF("llogd_body", 0, sizeof(struct llogd_body),
+ lustre_swab_llogd_body, NULL);
EXPORT_SYMBOL(RMF_LLOGD_BODY);
struct req_msg_field RMF_LLOG_LOG_HDR =
- DEFINE_MSGF("llog_log_hdr", 0,
- sizeof(struct llog_log_hdr), lustre_swab_llog_hdr, NULL);
+ DEFINE_MSGF("llog_log_hdr", 0, sizeof(struct llog_log_hdr),
+ lustre_swab_llog_hdr, NULL);
EXPORT_SYMBOL(RMF_LLOG_LOG_HDR);
struct req_msg_field RMF_LLOGD_CONN_BODY =
- DEFINE_MSGF("llogd_conn_body", 0,
- sizeof(struct llogd_conn_body),
- lustre_swab_llogd_conn_body, NULL);
+ DEFINE_MSGF("llogd_conn_body", 0, sizeof(struct llogd_conn_body),
+ lustre_swab_llogd_conn_body, NULL);
EXPORT_SYMBOL(RMF_LLOGD_CONN_BODY);
/*
* that the client does not interpret at all.
*/
struct req_msg_field RMF_CONN =
- DEFINE_MSGF("conn", 0, sizeof(struct lustre_handle), NULL, NULL);
+ DEFINE_MSGF("conn", 0, sizeof(struct lustre_handle), NULL, NULL);
EXPORT_SYMBOL(RMF_CONN);
struct req_msg_field RMF_CONNECT_DATA =
EXPORT_SYMBOL(RMF_CONNECT_DATA);
struct req_msg_field RMF_DLM_REQ =
- DEFINE_MSGF("dlm_req", RMF_F_NO_SIZE_CHECK /* ldlm_request_bufsize */,
- sizeof(struct ldlm_request),
- lustre_swab_ldlm_request, NULL);
+ DEFINE_MSGF("dlm_req", RMF_F_NO_SIZE_CHECK /* ldlm_request_bufsize */,
+ sizeof(struct ldlm_request),
+ lustre_swab_ldlm_request, NULL);
EXPORT_SYMBOL(RMF_DLM_REQ);
struct req_msg_field RMF_DLM_REP =
- DEFINE_MSGF("dlm_rep", 0,
- sizeof(struct ldlm_reply), lustre_swab_ldlm_reply, NULL);
+ DEFINE_MSGF("dlm_rep", 0,
+ sizeof(struct ldlm_reply), lustre_swab_ldlm_reply, NULL);
EXPORT_SYMBOL(RMF_DLM_REP);
struct req_msg_field RMF_LDLM_INTENT =
- DEFINE_MSGF("ldlm_intent", 0,
- sizeof(struct ldlm_intent), lustre_swab_ldlm_intent, NULL);
+ DEFINE_MSGF("ldlm_intent", 0,
+ sizeof(struct ldlm_intent), lustre_swab_ldlm_intent, NULL);
EXPORT_SYMBOL(RMF_LDLM_INTENT);
struct req_msg_field RMF_DLM_LVB =
EXPORT_SYMBOL(RMF_DLM_GL_DESC);
struct req_msg_field RMF_MDT_MD =
- DEFINE_MSGF("mdt_md", RMF_F_NO_SIZE_CHECK, MIN_MD_SIZE, NULL, NULL);
+ DEFINE_MSGF("mdt_md", RMF_F_NO_SIZE_CHECK, MIN_MD_SIZE, NULL, NULL);
EXPORT_SYMBOL(RMF_MDT_MD);
struct req_msg_field RMF_DEFAULT_MDT_MD =
EXPORT_SYMBOL(RMF_DEFAULT_MDT_MD);
struct req_msg_field RMF_REC_REINT =
- DEFINE_MSGF("rec_reint", 0, sizeof(struct mdt_rec_reint),
- lustre_swab_mdt_rec_reint, NULL);
+ DEFINE_MSGF("rec_reint", 0, sizeof(struct mdt_rec_reint),
+ lustre_swab_mdt_rec_reint, NULL);
EXPORT_SYMBOL(RMF_REC_REINT);
/* FIXME: this length should be defined as a macro */
-struct req_msg_field RMF_EADATA = DEFINE_MSGF("eadata", 0, -1,
- NULL, NULL);
+struct req_msg_field RMF_EADATA = DEFINE_MSGF("eadata", 0, -1, NULL, NULL);
EXPORT_SYMBOL(RMF_EADATA);
struct req_msg_field RMF_EAVALS = DEFINE_MSGF("eavals", 0, -1, NULL, NULL);
/* FIXME: this should be made to use RMF_F_STRUCT_ARRAY */
struct req_msg_field RMF_LOGCOOKIES =
- DEFINE_MSGF("logcookies", RMF_F_NO_SIZE_CHECK /* multiple cookies */,
- sizeof(struct llog_cookie), NULL, NULL);
+ DEFINE_MSGF("logcookies", RMF_F_NO_SIZE_CHECK /* multiple cookies */,
+ sizeof(struct llog_cookie), NULL, NULL);
EXPORT_SYMBOL(RMF_LOGCOOKIES);
-struct req_msg_field RMF_CAPA1 =
- DEFINE_MSGF("capa", 0, 0, NULL, NULL);
+struct req_msg_field RMF_CAPA1 = DEFINE_MSGF("capa", 0, 0, NULL, NULL);
EXPORT_SYMBOL(RMF_CAPA1);
-struct req_msg_field RMF_CAPA2 =
- DEFINE_MSGF("capa", 0, 0, NULL, NULL);
+struct req_msg_field RMF_CAPA2 = DEFINE_MSGF("capa", 0, 0, NULL, NULL);
EXPORT_SYMBOL(RMF_CAPA2);
struct req_msg_field RMF_LAYOUT_INTENT =
EXPORT_SYMBOL(RMF_OST_BODY);
struct req_msg_field RMF_OBD_IOOBJ =
- DEFINE_MSGF("obd_ioobj", RMF_F_STRUCT_ARRAY,
- sizeof(struct obd_ioobj), lustre_swab_obd_ioobj, dump_ioo);
+ DEFINE_MSGF("obd_ioobj", RMF_F_STRUCT_ARRAY,
+ sizeof(struct obd_ioobj), lustre_swab_obd_ioobj, dump_ioo);
EXPORT_SYMBOL(RMF_OBD_IOOBJ);
struct req_msg_field RMF_NIOBUF_REMOTE =
- DEFINE_MSGF("niobuf_remote", RMF_F_STRUCT_ARRAY,
- sizeof(struct niobuf_remote), lustre_swab_niobuf_remote,
- dump_rniobuf);
+ DEFINE_MSGF("niobuf_remote", RMF_F_STRUCT_ARRAY,
+ sizeof(struct niobuf_remote), lustre_swab_niobuf_remote,
+ dump_rniobuf);
EXPORT_SYMBOL(RMF_NIOBUF_REMOTE);
struct req_msg_field RMF_NIOBUF_INLINE =
struct req_msg_field RMF_EAVALS_LENS =
DEFINE_MSGF("eavals_lens", RMF_F_STRUCT_ARRAY, sizeof(__u32),
- lustre_swab_generic_32s, NULL);
+ lustre_swab_generic_32s, NULL);
EXPORT_SYMBOL(RMF_EAVALS_LENS);
struct req_msg_field RMF_OBD_ID =
EXPORT_SYMBOL(RMF_OST_ID);
struct req_msg_field RMF_FIEMAP_KEY =
- DEFINE_MSGF("fiemap", 0, sizeof(struct ll_fiemap_info_key),
- lustre_swab_fiemap, NULL);
+ DEFINE_MSGF("fiemap_key", 0, sizeof(struct ll_fiemap_info_key),
+ lustre_swab_fiemap_info_key, NULL);
EXPORT_SYMBOL(RMF_FIEMAP_KEY);
struct req_msg_field RMF_FIEMAP_VAL =
- DEFINE_MSGF("fiemap", 0, -1, lustre_swab_fiemap, NULL);
+ DEFINE_MSGFL("fiemap", 0, -1, lustre_swab_fiemap, NULL);
EXPORT_SYMBOL(RMF_FIEMAP_VAL);
struct req_msg_field RMF_IDX_INFO =
lustre_swab_hsm_request, NULL);
EXPORT_SYMBOL(RMF_MDS_HSM_REQUEST);
-struct req_msg_field RMF_OUT_UPDATE = DEFINE_MSGF("object_update", 0, -1,
- lustre_swab_object_update_request, NULL);
-EXPORT_SYMBOL(RMF_OUT_UPDATE);
-
-struct req_msg_field RMF_OUT_UPDATE_REPLY =
- DEFINE_MSGF("object_update_reply", 0, -1,
- lustre_swab_object_update_reply, NULL);
-EXPORT_SYMBOL(RMF_OUT_UPDATE_REPLY);
-
struct req_msg_field RMF_SWAP_LAYOUTS =
DEFINE_MSGF("swap_layouts", 0, sizeof(struct mdc_swap_layouts),
lustre_swab_swap_layouts, NULL);
lustre_swab_ladvise, NULL);
EXPORT_SYMBOL(RMF_OST_LADVISE);
-struct req_msg_field RMF_OUT_UPDATE_HEADER = DEFINE_MSGF("out_update_header", 0,
- -1, lustre_swab_out_update_header, NULL);
-EXPORT_SYMBOL(RMF_OUT_UPDATE_HEADER);
+struct req_msg_field RMF_BUT_REPLY =
+ DEFINE_MSGF("batch_update_reply", 0, -1,
+ lustre_swab_batch_update_reply, NULL);
+EXPORT_SYMBOL(RMF_BUT_REPLY);
-struct req_msg_field RMF_OUT_UPDATE_BUF = DEFINE_MSGF("update_buf",
- RMF_F_STRUCT_ARRAY, sizeof(struct out_update_buffer),
- lustre_swab_out_update_buffer, NULL);
-EXPORT_SYMBOL(RMF_OUT_UPDATE_BUF);
+struct req_msg_field RMF_BUT_HEADER = DEFINE_MSGF("but_update_header", 0,
+ -1, lustre_swab_but_update_header, NULL);
+EXPORT_SYMBOL(RMF_BUT_HEADER);
+
+struct req_msg_field RMF_BUT_BUF = DEFINE_MSGF("but_update_buf",
+ RMF_F_STRUCT_ARRAY, sizeof(struct but_update_buffer),
+ lustre_swab_but_update_buffer, NULL);
+EXPORT_SYMBOL(RMF_BUT_BUF);
/*
* Request formats.
struct req_format {
const char *rf_name;
- size_t rf_idx;
+ size_t rf_idx;
struct {
- size_t nr;
+ size_t nr;
const struct req_msg_field **d;
} rf_fields[RCL_NR];
};
-#define DEFINE_REQ_FMT(name, client, client_nr, server, server_nr) { \
- .rf_name = name, \
- .rf_fields = { \
- [RCL_CLIENT] = { \
- .nr = client_nr, \
- .d = client \
- }, \
- [RCL_SERVER] = { \
- .nr = server_nr, \
- .d = server \
- } \
- } \
+#define DEFINE_REQ_FMT(name, client, client_nr, server, server_nr) { \
+ .rf_name = name, \
+ .rf_fields = { \
+ [RCL_CLIENT] = { \
+ .nr = client_nr, \
+ .d = client \
+ }, \
+ [RCL_SERVER] = { \
+ .nr = server_nr, \
+ .d = server \
+ } \
+ } \
}
#define DEFINE_REQ_FMT0(name, client, server) \
DEFINE_REQ_FMT(name, client, ARRAY_SIZE(client), server, ARRAY_SIZE(server))
struct req_format RQF_OBD_PING =
- DEFINE_REQ_FMT0("OBD_PING", empty, empty);
+ DEFINE_REQ_FMT0("OBD_PING", empty, empty);
EXPORT_SYMBOL(RQF_OBD_PING);
struct req_format RQF_OBD_SET_INFO =
- DEFINE_REQ_FMT0("OBD_SET_INFO", obd_set_info_client, empty);
+ DEFINE_REQ_FMT0("OBD_SET_INFO", obd_set_info_client, empty);
EXPORT_SYMBOL(RQF_OBD_SET_INFO);
+struct req_format RQF_MDT_SET_INFO =
+ DEFINE_REQ_FMT0("MDT_SET_INFO", mdt_set_info_client, empty);
+EXPORT_SYMBOL(RQF_MDT_SET_INFO);
+
/* Read index file through the network */
struct req_format RQF_OBD_IDX_READ =
DEFINE_REQ_FMT0("OBD_IDX_READ",
EXPORT_SYMBOL(RQF_OBD_IDX_READ);
struct req_format RQF_SEC_CTX =
- DEFINE_REQ_FMT0("SEC_CTX", empty, empty);
+ DEFINE_REQ_FMT0("SEC_CTX", empty, empty);
EXPORT_SYMBOL(RQF_SEC_CTX);
struct req_format RQF_MGS_TARGET_REG =
- DEFINE_REQ_FMT0("MGS_TARGET_REG", mgs_target_info_only,
- mgs_target_info_only);
+ DEFINE_REQ_FMT0("MGS_TARGET_REG", mgs_target_info_only,
+ mgs_target_info_only);
EXPORT_SYMBOL(RQF_MGS_TARGET_REG);
-#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 13, 53, 0)
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 18, 53, 0)
struct req_format RQF_MGS_SET_INFO =
- DEFINE_REQ_FMT0("MGS_SET_INFO", mgs_set_info,
- mgs_set_info);
+ DEFINE_REQ_FMT0("MGS_SET_INFO", mgs_set_info,
+ mgs_set_info);
EXPORT_SYMBOL(RQF_MGS_SET_INFO);
#endif
struct req_format RQF_MGS_CONFIG_READ =
- DEFINE_REQ_FMT0("MGS_CONFIG_READ", mgs_config_read_client,
- mgs_config_read_server);
+ DEFINE_REQ_FMT0("MGS_CONFIG_READ", mgs_config_read_client,
+ mgs_config_read_server);
EXPORT_SYMBOL(RQF_MGS_CONFIG_READ);
struct req_format RQF_SEQ_QUERY =
- DEFINE_REQ_FMT0("SEQ_QUERY", seq_query_client, seq_query_server);
+ DEFINE_REQ_FMT0("SEQ_QUERY", seq_query_client, seq_query_server);
EXPORT_SYMBOL(RQF_SEQ_QUERY);
struct req_format RQF_FLD_QUERY =
- DEFINE_REQ_FMT0("FLD_QUERY", fld_query_client, fld_query_server);
+ DEFINE_REQ_FMT0("FLD_QUERY", fld_query_client, fld_query_server);
EXPORT_SYMBOL(RQF_FLD_QUERY);
/* The 'fld_read_server' uses 'RMF_GENERIC_DATA' to hold the 'FLD_QUERY'
EXPORT_SYMBOL(RQF_FLD_READ);
struct req_format RQF_MDS_QUOTACTL =
- DEFINE_REQ_FMT0("MDS_QUOTACTL", quotactl_only, quotactl_only);
+ DEFINE_REQ_FMT0("MDS_QUOTACTL", quotactl_only, quotactl_server_only);
EXPORT_SYMBOL(RQF_MDS_QUOTACTL);
struct req_format RQF_OST_QUOTACTL =
- DEFINE_REQ_FMT0("OST_QUOTACTL", quotactl_only, quotactl_only);
+ DEFINE_REQ_FMT0("OST_QUOTACTL", quotactl_only, quotactl_server_only);
EXPORT_SYMBOL(RQF_OST_QUOTACTL);
struct req_format RQF_QUOTA_DQACQ =
EXPORT_SYMBOL(RQF_MDS_STATFS_NEW);
struct req_format RQF_MDS_SYNC =
- DEFINE_REQ_FMT0("MDS_SYNC", mdt_body_capa, mdt_body_only);
+ DEFINE_REQ_FMT0("MDS_SYNC", mdt_body_capa, mdt_body_only);
EXPORT_SYMBOL(RQF_MDS_SYNC);
struct req_format RQF_MDS_GETATTR =
- DEFINE_REQ_FMT0("MDS_GETATTR", mdt_body_capa, mds_getattr_server);
+ DEFINE_REQ_FMT0("MDS_GETATTR", mdt_body_capa, mds_getattr_server);
EXPORT_SYMBOL(RQF_MDS_GETATTR);
struct req_format RQF_MDS_GETXATTR =
- DEFINE_REQ_FMT0("MDS_GETXATTR",
- mds_getxattr_client, mds_getxattr_server);
+ DEFINE_REQ_FMT0("MDS_GETXATTR",
+ mds_getxattr_client, mds_getxattr_server);
EXPORT_SYMBOL(RQF_MDS_GETXATTR);
struct req_format RQF_MDS_GETATTR_NAME =
- DEFINE_REQ_FMT0("MDS_GETATTR_NAME",
- mds_getattr_name_client, mds_getattr_server);
+ DEFINE_REQ_FMT0("MDS_GETATTR_NAME",
+ mds_getattr_name_client, mds_getattr_server);
EXPORT_SYMBOL(RQF_MDS_GETATTR_NAME);
struct req_format RQF_MDS_REINT =
- DEFINE_REQ_FMT0("MDS_REINT", mds_reint_client, mdt_body_only);
+ DEFINE_REQ_FMT0("MDS_REINT", mds_reint_client, mdt_body_only);
EXPORT_SYMBOL(RQF_MDS_REINT);
struct req_format RQF_MDS_REINT_CREATE =
- DEFINE_REQ_FMT0("MDS_REINT_CREATE",
- mds_reint_create_client, mdt_body_capa);
+ DEFINE_REQ_FMT0("MDS_REINT_CREATE",
+ mds_reint_create_client, mdt_body_capa);
EXPORT_SYMBOL(RQF_MDS_REINT_CREATE);
struct req_format RQF_MDS_REINT_CREATE_ACL =
DEFINE_REQ_FMT0("MDS_REINT_CREATE_ACL",
- mds_reint_create_acl_client, mdt_body_capa);
+ mds_reint_create_acl_client,
+ mds_reint_create_acl_server);
EXPORT_SYMBOL(RQF_MDS_REINT_CREATE_ACL);
struct req_format RQF_MDS_REINT_CREATE_SLAVE =
- DEFINE_REQ_FMT0("MDS_REINT_CREATE_EA",
- mds_reint_create_slave_client, mdt_body_capa);
+ DEFINE_REQ_FMT0("MDS_REINT_CREATE_EA",
+ mds_reint_create_slave_client, mdt_body_capa);
EXPORT_SYMBOL(RQF_MDS_REINT_CREATE_SLAVE);
struct req_format RQF_MDS_REINT_CREATE_SYM =
- DEFINE_REQ_FMT0("MDS_REINT_CREATE_SYM",
- mds_reint_create_sym_client, mdt_body_capa);
+ DEFINE_REQ_FMT0("MDS_REINT_CREATE_SYM",
+ mds_reint_create_sym_client, mdt_body_capa);
EXPORT_SYMBOL(RQF_MDS_REINT_CREATE_SYM);
struct req_format RQF_MDS_REINT_OPEN =
- DEFINE_REQ_FMT0("MDS_REINT_OPEN",
- mds_reint_open_client, mds_reint_open_server);
+ DEFINE_REQ_FMT0("MDS_REINT_OPEN",
+ mds_reint_open_client, mds_reint_open_server);
EXPORT_SYMBOL(RQF_MDS_REINT_OPEN);
struct req_format RQF_MDS_REINT_UNLINK =
- DEFINE_REQ_FMT0("MDS_REINT_UNLINK", mds_reint_unlink_client,
- mds_last_unlink_server);
+ DEFINE_REQ_FMT0("MDS_REINT_UNLINK", mds_reint_unlink_client,
+ mds_last_unlink_server);
EXPORT_SYMBOL(RQF_MDS_REINT_UNLINK);
struct req_format RQF_MDS_REINT_LINK =
- DEFINE_REQ_FMT0("MDS_REINT_LINK",
- mds_reint_link_client, mdt_body_only);
+ DEFINE_REQ_FMT0("MDS_REINT_LINK",
+ mds_reint_link_client, mdt_body_only);
EXPORT_SYMBOL(RQF_MDS_REINT_LINK);
struct req_format RQF_MDS_REINT_RENAME =
- DEFINE_REQ_FMT0("MDS_REINT_RENAME", mds_reint_rename_client,
- mds_last_unlink_server);
+ DEFINE_REQ_FMT0("MDS_REINT_RENAME", mds_reint_rename_client,
+ mds_last_unlink_server);
EXPORT_SYMBOL(RQF_MDS_REINT_RENAME);
struct req_format RQF_MDS_REINT_MIGRATE =
EXPORT_SYMBOL(RQF_MDS_REINT_MIGRATE);
struct req_format RQF_MDS_REINT_SETATTR =
- DEFINE_REQ_FMT0("MDS_REINT_SETATTR",
- mds_reint_setattr_client, mds_setattr_server);
+ DEFINE_REQ_FMT0("MDS_REINT_SETATTR",
+ mds_reint_setattr_client, mds_setattr_server);
EXPORT_SYMBOL(RQF_MDS_REINT_SETATTR);
struct req_format RQF_MDS_REINT_SETXATTR =
- DEFINE_REQ_FMT0("MDS_REINT_SETXATTR",
+ DEFINE_REQ_FMT0("MDS_REINT_SETXATTR",
mds_reint_setxattr_client, mdt_body_only);
EXPORT_SYMBOL(RQF_MDS_REINT_SETXATTR);
EXPORT_SYMBOL(RQF_MDS_REINT_RESYNC);
struct req_format RQF_MDS_CONNECT =
- DEFINE_REQ_FMT0("MDS_CONNECT",
- obd_connect_client, obd_connect_server);
+ DEFINE_REQ_FMT0("MDS_CONNECT",
+ obd_connect_client, obd_connect_server);
EXPORT_SYMBOL(RQF_MDS_CONNECT);
struct req_format RQF_MDS_DISCONNECT =
- DEFINE_REQ_FMT0("MDS_DISCONNECT", empty, empty);
+ DEFINE_REQ_FMT0("MDS_DISCONNECT", empty, empty);
EXPORT_SYMBOL(RQF_MDS_DISCONNECT);
struct req_format RQF_MDS_GET_INFO =
- DEFINE_REQ_FMT0("MDS_GET_INFO", mds_getinfo_client,
- mds_getinfo_server);
+ DEFINE_REQ_FMT0("MDS_GET_INFO", mds_getinfo_client,
+ mds_getinfo_server);
EXPORT_SYMBOL(RQF_MDS_GET_INFO);
-struct req_format RQF_OUT_UPDATE =
- DEFINE_REQ_FMT0("OUT_UPDATE", mds_update_client,
- mds_update_server);
-EXPORT_SYMBOL(RQF_OUT_UPDATE);
+struct req_format RQF_MDS_BATCH =
+ DEFINE_REQ_FMT0("MDS_BATCH", mds_batch_client,
+ mds_batch_server);
+EXPORT_SYMBOL(RQF_MDS_BATCH);
struct req_format RQF_LDLM_ENQUEUE =
- DEFINE_REQ_FMT0("LDLM_ENQUEUE",
- ldlm_enqueue_client, ldlm_enqueue_lvb_server);
+ DEFINE_REQ_FMT0("LDLM_ENQUEUE",
+ ldlm_enqueue_client, ldlm_enqueue_lvb_server);
EXPORT_SYMBOL(RQF_LDLM_ENQUEUE);
struct req_format RQF_LDLM_ENQUEUE_LVB =
- DEFINE_REQ_FMT0("LDLM_ENQUEUE_LVB",
- ldlm_enqueue_client, ldlm_enqueue_lvb_server);
+ DEFINE_REQ_FMT0("LDLM_ENQUEUE_LVB",
+ ldlm_enqueue_client, ldlm_enqueue_lvb_server);
EXPORT_SYMBOL(RQF_LDLM_ENQUEUE_LVB);
struct req_format RQF_LDLM_CONVERT =
- DEFINE_REQ_FMT0("LDLM_CONVERT",
- ldlm_enqueue_client, ldlm_enqueue_server);
+ DEFINE_REQ_FMT0("LDLM_CONVERT",
+ ldlm_enqueue_client, ldlm_enqueue_server);
EXPORT_SYMBOL(RQF_LDLM_CONVERT);
struct req_format RQF_LDLM_CANCEL =
- DEFINE_REQ_FMT0("LDLM_CANCEL", ldlm_enqueue_client, empty);
+ DEFINE_REQ_FMT0("LDLM_CANCEL", ldlm_enqueue_client, empty);
EXPORT_SYMBOL(RQF_LDLM_CANCEL);
struct req_format RQF_LDLM_CALLBACK =
- DEFINE_REQ_FMT0("LDLM_CALLBACK", ldlm_enqueue_client, empty);
+ DEFINE_REQ_FMT0("LDLM_CALLBACK", ldlm_enqueue_client, empty);
EXPORT_SYMBOL(RQF_LDLM_CALLBACK);
struct req_format RQF_LDLM_CP_CALLBACK =
- DEFINE_REQ_FMT0("LDLM_CP_CALLBACK", ldlm_cp_callback_client, empty);
+ DEFINE_REQ_FMT0("LDLM_CP_CALLBACK", ldlm_cp_callback_client, empty);
EXPORT_SYMBOL(RQF_LDLM_CP_CALLBACK);
struct req_format RQF_LDLM_BL_CALLBACK =
- DEFINE_REQ_FMT0("LDLM_BL_CALLBACK", ldlm_enqueue_client, empty);
+ DEFINE_REQ_FMT0("LDLM_BL_CALLBACK", ldlm_enqueue_client, empty);
EXPORT_SYMBOL(RQF_LDLM_BL_CALLBACK);
struct req_format RQF_LDLM_GL_CALLBACK =
- DEFINE_REQ_FMT0("LDLM_GL_CALLBACK", ldlm_enqueue_client,
- ldlm_gl_callback_server);
+ DEFINE_REQ_FMT0("LDLM_GL_CALLBACK", ldlm_enqueue_client,
+ ldlm_gl_callback_server);
EXPORT_SYMBOL(RQF_LDLM_GL_CALLBACK);
struct req_format RQF_LDLM_GL_CALLBACK_DESC =
EXPORT_SYMBOL(RQF_LDLM_INTENT_BASIC);
struct req_format RQF_LDLM_INTENT =
- DEFINE_REQ_FMT0("LDLM_INTENT",
- ldlm_intent_client, ldlm_intent_server);
+ DEFINE_REQ_FMT0("LDLM_INTENT",
+ ldlm_intent_client, ldlm_intent_server);
EXPORT_SYMBOL(RQF_LDLM_INTENT);
struct req_format RQF_LDLM_INTENT_LAYOUT =
EXPORT_SYMBOL(RQF_LDLM_INTENT_LAYOUT);
struct req_format RQF_LDLM_INTENT_GETATTR =
- DEFINE_REQ_FMT0("LDLM_INTENT_GETATTR",
- ldlm_intent_getattr_client, ldlm_intent_getattr_server);
+ DEFINE_REQ_FMT0("LDLM_INTENT_GETATTR",
+ ldlm_intent_getattr_client, ldlm_intent_getattr_server);
EXPORT_SYMBOL(RQF_LDLM_INTENT_GETATTR);
struct req_format RQF_LDLM_INTENT_OPEN =
- DEFINE_REQ_FMT0("LDLM_INTENT_OPEN",
- ldlm_intent_open_client, ldlm_intent_open_server);
+ DEFINE_REQ_FMT0("LDLM_INTENT_OPEN",
+ ldlm_intent_open_client, ldlm_intent_open_server);
EXPORT_SYMBOL(RQF_LDLM_INTENT_OPEN);
struct req_format RQF_LDLM_INTENT_CREATE =
- DEFINE_REQ_FMT0("LDLM_INTENT_CREATE",
- ldlm_intent_create_client, ldlm_intent_getattr_server);
+ DEFINE_REQ_FMT0("LDLM_INTENT_CREATE",
+ ldlm_intent_create_client, ldlm_intent_getattr_server);
EXPORT_SYMBOL(RQF_LDLM_INTENT_CREATE);
struct req_format RQF_LDLM_INTENT_GETXATTR =
EXPORT_SYMBOL(RQF_LDLM_INTENT_GETXATTR);
struct req_format RQF_MDS_CLOSE =
- DEFINE_REQ_FMT0("MDS_CLOSE",
- mdt_close_client, mds_last_unlink_server);
+ DEFINE_REQ_FMT0("MDS_CLOSE",
+ mdt_close_client, mds_last_unlink_server);
EXPORT_SYMBOL(RQF_MDS_CLOSE);
struct req_format RQF_MDS_CLOSE_INTENT =
EXPORT_SYMBOL(RQF_MDS_CLOSE_INTENT);
struct req_format RQF_MDS_READPAGE =
- DEFINE_REQ_FMT0("MDS_READPAGE",
- mdt_body_capa, mdt_body_only);
+ DEFINE_REQ_FMT0("MDS_READPAGE",
+ mdt_body_capa, mdt_body_only);
EXPORT_SYMBOL(RQF_MDS_READPAGE);
struct req_format RQF_MDS_HSM_ACTION =
EXPORT_SYMBOL(RQF_MDS_RMFID);
struct req_format RQF_LLOG_ORIGIN_HANDLE_CREATE =
- DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_CREATE",
- llog_origin_handle_create_client, llogd_body_only);
+ DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_CREATE",
+ llog_origin_handle_create_client, llogd_body_only);
EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_CREATE);
struct req_format RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK =
- DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_NEXT_BLOCK",
- llogd_body_only, llog_origin_handle_next_block_server);
+ DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_NEXT_BLOCK",
+ llogd_body_only, llog_origin_handle_next_block_server);
EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK);
struct req_format RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK =
- DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_PREV_BLOCK",
- llogd_body_only, llog_origin_handle_next_block_server);
+ DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_PREV_BLOCK",
+ llogd_body_only, llog_origin_handle_next_block_server);
EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK);
struct req_format RQF_LLOG_ORIGIN_HANDLE_READ_HEADER =
- DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_READ_HEADER",
- llogd_body_only, llog_log_hdr_only);
+ DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_READ_HEADER",
+ llogd_body_only, llog_log_hdr_only);
EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_READ_HEADER);
struct req_format RQF_CONNECT =
EXPORT_SYMBOL(RQF_CONNECT);
struct req_format RQF_OST_CONNECT =
- DEFINE_REQ_FMT0("OST_CONNECT",
- obd_connect_client, obd_connect_server);
+ DEFINE_REQ_FMT0("OST_CONNECT",
+ obd_connect_client, obd_connect_server);
EXPORT_SYMBOL(RQF_OST_CONNECT);
struct req_format RQF_OST_DISCONNECT =
- DEFINE_REQ_FMT0("OST_DISCONNECT", empty, empty);
+ DEFINE_REQ_FMT0("OST_DISCONNECT", empty, empty);
EXPORT_SYMBOL(RQF_OST_DISCONNECT);
struct req_format RQF_OST_GETATTR =
- DEFINE_REQ_FMT0("OST_GETATTR", ost_body_capa, ost_body_only);
+ DEFINE_REQ_FMT0("OST_GETATTR", ost_body_capa, ost_body_only);
EXPORT_SYMBOL(RQF_OST_GETATTR);
struct req_format RQF_OST_SETATTR =
- DEFINE_REQ_FMT0("OST_SETATTR", ost_body_capa, ost_body_only);
+ DEFINE_REQ_FMT0("OST_SETATTR", ost_body_capa, ost_body_only);
EXPORT_SYMBOL(RQF_OST_SETATTR);
struct req_format RQF_OST_CREATE =
- DEFINE_REQ_FMT0("OST_CREATE", ost_body_only, ost_body_only);
+ DEFINE_REQ_FMT0("OST_CREATE", ost_body_only, ost_body_only);
EXPORT_SYMBOL(RQF_OST_CREATE);
struct req_format RQF_OST_PUNCH =
- DEFINE_REQ_FMT0("OST_PUNCH", ost_body_capa, ost_body_only);
+ DEFINE_REQ_FMT0("OST_PUNCH", ost_body_capa, ost_body_only);
EXPORT_SYMBOL(RQF_OST_PUNCH);
+struct req_format RQF_OST_FALLOCATE =
+ DEFINE_REQ_FMT0("OST_FALLOCATE", ost_body_capa, ost_body_only);
+EXPORT_SYMBOL(RQF_OST_FALLOCATE);
+
+struct req_format RQF_OST_SEEK =
+ DEFINE_REQ_FMT0("OST_SEEK", ost_body_only, ost_body_only);
+EXPORT_SYMBOL(RQF_OST_SEEK);
+
struct req_format RQF_OST_SYNC =
- DEFINE_REQ_FMT0("OST_SYNC", ost_body_capa, ost_body_only);
+ DEFINE_REQ_FMT0("OST_SYNC", ost_body_capa, ost_body_only);
EXPORT_SYMBOL(RQF_OST_SYNC);
struct req_format RQF_OST_DESTROY =
- DEFINE_REQ_FMT0("OST_DESTROY", ost_destroy_client, ost_body_only);
+ DEFINE_REQ_FMT0("OST_DESTROY", ost_destroy_client, ost_body_only);
EXPORT_SYMBOL(RQF_OST_DESTROY);
struct req_format RQF_OST_BRW_READ =
- DEFINE_REQ_FMT0("OST_BRW_READ", ost_brw_client, ost_brw_read_server);
+ DEFINE_REQ_FMT0("OST_BRW_READ", ost_brw_client, ost_brw_read_server);
EXPORT_SYMBOL(RQF_OST_BRW_READ);
struct req_format RQF_OST_BRW_WRITE =
- DEFINE_REQ_FMT0("OST_BRW_WRITE", ost_brw_client, ost_brw_write_server);
+ DEFINE_REQ_FMT0("OST_BRW_WRITE", ost_brw_client, ost_brw_write_server);
EXPORT_SYMBOL(RQF_OST_BRW_WRITE);
struct req_format RQF_OST_STATFS =
- DEFINE_REQ_FMT0("OST_STATFS", empty, obd_statfs_server);
+ DEFINE_REQ_FMT0("OST_STATFS", empty, obd_statfs_server);
EXPORT_SYMBOL(RQF_OST_STATFS);
struct req_format RQF_OST_SET_GRANT_INFO =
- DEFINE_REQ_FMT0("OST_SET_GRANT_INFO", ost_grant_shrink_client,
- ost_body_only);
+ DEFINE_REQ_FMT0("OST_SET_GRANT_INFO", ost_grant_shrink_client,
+ ost_body_only);
EXPORT_SYMBOL(RQF_OST_SET_GRANT_INFO);
struct req_format RQF_OST_GET_INFO =
- DEFINE_REQ_FMT0("OST_GET_INFO", ost_get_info_generic_client,
- ost_get_info_generic_server);
+ DEFINE_REQ_FMT0("OST_GET_INFO", ost_get_info_generic_client,
+ ost_get_info_generic_server);
EXPORT_SYMBOL(RQF_OST_GET_INFO);
struct req_format RQF_OST_GET_INFO_LAST_ID =
- DEFINE_REQ_FMT0("OST_GET_INFO_LAST_ID", ost_get_info_generic_client,
- ost_get_last_id_server);
+ DEFINE_REQ_FMT0("OST_GET_INFO_LAST_ID", ost_get_info_generic_client,
+ ost_get_last_id_server);
EXPORT_SYMBOL(RQF_OST_GET_INFO_LAST_ID);
struct req_format RQF_OST_GET_INFO_LAST_FID =
struct req_format RQF_OST_SET_INFO_LAST_FID =
DEFINE_REQ_FMT0("OST_SET_INFO_LAST_FID", obd_set_info_client,
- empty);
+ empty);
EXPORT_SYMBOL(RQF_OST_SET_INFO_LAST_FID);
struct req_format RQF_OST_GET_INFO_FIEMAP =
- DEFINE_REQ_FMT0("OST_GET_INFO_FIEMAP", ost_get_fiemap_client,
- ost_get_fiemap_server);
+ DEFINE_REQ_FMT0("OST_GET_INFO_FIEMAP", ost_get_fiemap_client,
+ ost_get_fiemap_server);
EXPORT_SYMBOL(RQF_OST_GET_INFO_FIEMAP);
struct req_format RQF_LFSCK_NOTIFY =
DEFINE_REQ_FMT0("OST_LADVISE", ost_ladvise, ost_body_only);
EXPORT_SYMBOL(RQF_OST_LADVISE);
+struct req_format RQF_BUT_GETATTR =
+ DEFINE_REQ_FMT0("MDS_BATCH_GETATTR", mds_batch_getattr_client,
+ mds_batch_getattr_server);
+EXPORT_SYMBOL(RQF_BUT_GETATTR);
+
/* Convenience macro */
#define FMT_FIELD(fmt, i, j) (fmt)->rf_fields[(i)].d[(j)]
size_t i;
size_t j;
size_t k;
- struct req_format *rf = NULL;
-
- for (i = 0; i < ARRAY_SIZE(req_formats); ++i) {
- rf = req_formats[i];
- rf->rf_idx = i;
- for (j = 0; j < RCL_NR; ++j) {
- LASSERT(rf->rf_fields[j].nr <= REQ_MAX_FIELD_NR);
- for (k = 0; k < rf->rf_fields[j].nr; ++k) {
- struct req_msg_field *field;
-
- field = (typeof(field))rf->rf_fields[j].d[k];
- LASSERT(!(field->rmf_flags & RMF_F_STRUCT_ARRAY)
- || field->rmf_size > 0);
- LASSERT(field->rmf_offset[i][j] == 0);
- /*
- * k + 1 to detect unused format/field
- * combinations.
- */
- field->rmf_offset[i][j] = k + 1;
- }
- }
- }
- return 0;
+ struct req_format *rf = NULL;
+
+ for (i = 0; i < ARRAY_SIZE(req_formats); ++i) {
+ rf = req_formats[i];
+ rf->rf_idx = i;
+ for (j = 0; j < RCL_NR; ++j) {
+ LASSERT(rf->rf_fields[j].nr <= REQ_MAX_FIELD_NR);
+ for (k = 0; k < rf->rf_fields[j].nr; ++k) {
+ struct req_msg_field *field;
+
+ field = (typeof(field))rf->rf_fields[j].d[k];
+ LASSERT(!(field->rmf_flags & RMF_F_STRUCT_ARRAY)
+ || field->rmf_size > 0);
+ LASSERT(field->rmf_offset[i][j] == 0);
+ /*
+ * k + 1 to detect unused format/field
+ * combinations.
+ */
+ field->rmf_offset[i][j] = k + 1;
+ }
+ }
+ }
+ return 0;
}
EXPORT_SYMBOL(req_layout_init);
{
size_t i;
- for (i = 0; i < ARRAY_SIZE(pill->rc_area[RCL_CLIENT]); i++) {
- pill->rc_area[RCL_CLIENT][i] = -1;
- pill->rc_area[RCL_SERVER][i] = -1;
- }
+ for (i = 0; i < ARRAY_SIZE(pill->rc_area[RCL_CLIENT]); i++) {
+ pill->rc_area[RCL_CLIENT][i] = -1;
+ pill->rc_area[RCL_SERVER][i] = -1;
+ }
}
EXPORT_SYMBOL(req_capsule_init_area);
* The \a location indicates whether the caller is executing on the client side
* (RCL_CLIENT) or server side (RCL_SERVER)..
*/
-void req_capsule_init(struct req_capsule *pill,
- struct ptlrpc_request *req,
- enum req_location location)
+void req_capsule_init(struct req_capsule *pill, struct ptlrpc_request *req,
+ enum req_location location)
{
- LASSERT(location == RCL_SERVER || location == RCL_CLIENT);
-
- /*
- * Today all capsules are embedded in ptlrpc_request structs,
- * but just in case that ever isn't the case, we don't reach
- * into req unless req != NULL and pill is the one embedded in
- * the req.
- *
- * The req->rq_pill_init flag makes it safe to initialize a pill
- * twice, which might happen in the OST paths as a result of the
- * high-priority RPC queue getting peeked at before ost_handle()
- * handles an OST RPC.
- */
- if (req != NULL && pill == &req->rq_pill && req->rq_pill_init)
- return;
-
- memset(pill, 0, sizeof *pill);
- pill->rc_req = req;
- pill->rc_loc = location;
- req_capsule_init_area(pill);
-
- if (req != NULL && pill == &req->rq_pill)
- req->rq_pill_init = 1;
+ LASSERT(location == RCL_SERVER || location == RCL_CLIENT);
+
+ /*
+ * Today all capsules are embedded in ptlrpc_request structs,
+ * but just in case that ever isn't the case, we don't reach
+ * into req unless req != NULL and pill is the one embedded in
+ * the req.
+ *
+ * The req->rq_pill_init flag makes it safe to initialize a pill
+ * twice, which might happen in the OST paths as a result of the
+ * high-priority RPC queue getting peeked at before ost_handle()
+ * handles an OST RPC.
+ */
+ if (req != NULL && pill == &req->rq_pill && req->rq_pill_init)
+ return;
+
+ pill->rc_fmt = NULL;
+ pill->rc_req = req;
+ pill->rc_loc = location;
+ req_capsule_init_area(pill);
+
+ if (req != NULL && pill == &req->rq_pill)
+ req->rq_pill_init = 1;
}
EXPORT_SYMBOL(req_capsule_init);
}
static struct lustre_msg *__req_msg(const struct req_capsule *pill,
- enum req_location loc)
+ enum req_location loc)
{
- struct ptlrpc_request *req;
-
- req = pill->rc_req;
- return loc == RCL_CLIENT ? req->rq_reqmsg : req->rq_repmsg;
+ return loc == RCL_CLIENT ? pill->rc_reqmsg : pill->rc_repmsg;
}
/**
*/
void req_capsule_set(struct req_capsule *pill, const struct req_format *fmt)
{
- LASSERT(pill->rc_fmt == NULL || pill->rc_fmt == fmt);
- LASSERT(__req_format_is_sane(fmt));
+ LASSERT(pill->rc_fmt == NULL || pill->rc_fmt == fmt);
+ LASSERT(__req_format_is_sane(fmt));
- pill->rc_fmt = fmt;
+ pill->rc_fmt = fmt;
}
EXPORT_SYMBOL(req_capsule_set);
enum req_location loc)
{
const struct req_format *fmt = pill->rc_fmt;
- size_t i;
-
- LASSERT(fmt != NULL);
-
- for (i = 0; i < fmt->rf_fields[loc].nr; ++i) {
- if (pill->rc_area[loc][i] == -1) {
- pill->rc_area[loc][i] =
- fmt->rf_fields[loc].d[i]->rmf_size;
- if (pill->rc_area[loc][i] == -1) {
- /*
- * Skip the following fields.
- *
- * If this LASSERT() trips then you're missing a
- * call to req_capsule_set_size().
- */
- LASSERT(loc != RCL_SERVER);
- break;
- }
- }
- }
- return i;
+ size_t i;
+
+ LASSERT(fmt != NULL);
+
+ for (i = 0; i < fmt->rf_fields[loc].nr; ++i) {
+ if (pill->rc_area[loc][i] == -1) {
+ pill->rc_area[loc][i] =
+ fmt->rf_fields[loc].d[i]->rmf_size;
+ if (pill->rc_area[loc][i] == -1) {
+ /*
+ * Skip the following fields.
+ *
+ * If this LASSERT() trips then you're missing a
+ * call to req_capsule_set_size().
+ */
+ LASSERT(loc != RCL_SERVER);
+ break;
+ }
+ }
+ }
+ return i;
}
EXPORT_SYMBOL(req_capsule_filled_sizes);
LASSERT(fmt != NULL);
count = req_capsule_filled_sizes(pill, RCL_SERVER);
- rc = lustre_pack_reply(pill->rc_req, count,
- pill->rc_area[RCL_SERVER], NULL);
- if (rc != 0) {
- DEBUG_REQ(D_ERROR, pill->rc_req,
- "Cannot pack %d fields in format '%s'",
- count, fmt->rf_name);
+ if (req_capsule_ptlreq(pill)) {
+ rc = lustre_pack_reply(pill->rc_req, count,
+ pill->rc_area[RCL_SERVER], NULL);
+ if (rc != 0) {
+ DEBUG_REQ(D_ERROR, pill->rc_req,
+ "Cannot pack %d fields in format '%s'",
+ count, fmt->rf_name);
+ }
+ } else { /* SUB request */
+ struct ptlrpc_request *req = pill->rc_req;
+ __u32 used_len;
+ __u32 msg_len;
+
+ msg_len = lustre_msg_size_v2(count, pill->rc_area[RCL_SERVER]);
+ used_len = (char *)pill->rc_repmsg - (char *)req->rq_repmsg;
+ /* Overflow the reply buffer */
+ if (used_len + msg_len > req->rq_replen) {
+ __u32 len;
+ __u32 max;
+
+ if (!req_capsule_has_field(&req->rq_pill,
+ &RMF_BUT_REPLY, RCL_SERVER))
+ return -EINVAL;
+
+ if (!req_capsule_field_present(&req->rq_pill,
+ &RMF_BUT_REPLY,
+ RCL_SERVER))
+ return -EINVAL;
+
+ if (used_len + msg_len > BUT_MAXREPSIZE)
+ return -EOVERFLOW;
+
+ len = req_capsule_get_size(&req->rq_pill,
+ &RMF_BUT_REPLY, RCL_SERVER);
+ /*
+ * Currently just increase the batch reply buffer
+ * by 2.
+ */
+ max = BUT_MAXREPSIZE - req->rq_replen;
+ if (used_len + msg_len > len)
+ len = used_len + msg_len;
+
+ if (len > max)
+ len += max;
+ else
+ len += len;
+
+ rc = req_capsule_server_grow(&req->rq_pill,
+ &RMF_BUT_REPLY, len);
+ if (rc)
+ return rc;
+
+ pill->rc_repmsg =
+ (struct lustre_msg *)((char *)req->rq_repmsg +
+ used_len);
+ }
+ if (msg_len > pill->rc_reqmsg->lm_repsize)
+ /* TODO: Check whether there is enough buffer size */
+ CDEBUG(D_INFO,
+ "Overflow pack %d fields in format '%s' for the SUB request with message len %u:%u\n",
+ count, fmt->rf_name, msg_len,
+ pill->rc_reqmsg->lm_repsize);
+
+ rc = 0;
+ lustre_init_msg_v2(pill->rc_repmsg, count,
+ pill->rc_area[RCL_SERVER], NULL);
}
+
return rc;
}
EXPORT_SYMBOL(req_capsule_server_pack);
+int req_capsule_client_pack(struct req_capsule *pill)
+{
+ const struct req_format *fmt;
+ int count;
+ int rc = 0;
+
+ LASSERT(pill->rc_loc == RCL_CLIENT);
+ fmt = pill->rc_fmt;
+ LASSERT(fmt != NULL);
+
+ count = req_capsule_filled_sizes(pill, RCL_CLIENT);
+ if (req_capsule_ptlreq(pill)) {
+ struct ptlrpc_request *req = pill->rc_req;
+
+ rc = lustre_pack_request(req, req->rq_import->imp_msg_magic,
+ count, pill->rc_area[RCL_CLIENT],
+ NULL);
+ } else {
+ /* Sub request in a batch PTLRPC request */
+ lustre_init_msg_v2(pill->rc_reqmsg, count,
+ pill->rc_area[RCL_CLIENT], NULL);
+ }
+ return rc;
+}
+EXPORT_SYMBOL(req_capsule_client_pack);
+
/**
* Returns the PTLRPC request or reply (\a loc) buffer offset of a \a pill
* corresponding to the given RMF (\a field).
offset--;
LASSERT(offset < REQ_MAX_FIELD_NR);
- return offset;
+ return offset;
+}
+
+void req_capsule_set_swabbed(struct req_capsule *pill, enum req_location loc,
+ __u32 index)
+{
+ if (loc == RCL_CLIENT)
+ req_capsule_set_req_swabbed(pill, index);
+ else
+ req_capsule_set_rep_swabbed(pill, index);
+}
+
+bool req_capsule_need_swab(struct req_capsule *pill, enum req_location loc,
+ __u32 index)
+{
+ if (loc == RCL_CLIENT)
+ return (req_capsule_req_need_swab(pill) &&
+ !req_capsule_req_swabbed(pill, index));
+
+ return (req_capsule_rep_need_swab(pill) &&
+ !req_capsule_rep_swabbed(pill, index));
}
/**
* Helper for __req_capsule_get(); swabs value / array of values and/or dumps
* them if desired.
*/
-static
-void
+static int
swabber_dumper_helper(struct req_capsule *pill,
- const struct req_msg_field *field,
- enum req_location loc,
- int offset,
- void *value, int len, int dump, void (*swabber)( void *))
+ const struct req_msg_field *field,
+ enum req_location loc,
+ int offset,
+ void *value, int len, bool dump, void (*swabber)(void *))
{
- void *p;
- int i;
- int n;
- int do_swab;
- int inout = loc == RCL_CLIENT;
+ void *p;
+ int i;
+ int n;
+ int size;
+ int rc = 0;
+ bool do_swab;
+ bool array = field->rmf_flags & RMF_F_STRUCT_ARRAY;
- swabber = swabber ?: field->rmf_swabber;
+ swabber = swabber ?: field->rmf_swabber;
- if (ptlrpc_buf_need_swab(pill->rc_req, inout, offset) &&
- swabber != NULL && value != NULL)
- do_swab = 1;
- else
- do_swab = 0;
+ if (req_capsule_need_swab(pill, loc, offset) &&
+ (swabber != NULL || field->rmf_swab_len != NULL) && value != NULL)
+ do_swab = true;
+ else
+ do_swab = false;
if (!field->rmf_dumper)
- dump = 0;
-
- if (!(field->rmf_flags & RMF_F_STRUCT_ARRAY)) {
- if (dump) {
- CDEBUG(D_RPCTRACE, "Dump of %sfield %s follows\n",
- do_swab ? "unswabbed " : "", field->rmf_name);
- field->rmf_dumper(value);
- }
- if (!do_swab)
- return;
- swabber(value);
- ptlrpc_buf_set_swabbed(pill->rc_req, inout, offset);
+ dump = false;
+
+ /*
+ * We're swabbing an array; swabber() swabs a single array element, so
+ * swab every element.
+ */
+ if (array && (len % field->rmf_size)) {
+ static const struct req_msg_field *last_field;
+
+ if (field != last_field) {
+ CERROR("%s: array buffer size %u is not a multiple of element size %u\n",
+ field->rmf_name, len, field->rmf_size);
+ last_field = field;
+ }
+ }
+ /* For the non-array cases, the process of swab/dump/swab only
+ * needs to be done once. (n = 1)
+ */
+ if (!array)
+ len = field->rmf_size;
+ for (p = value, i = 0, n = len / field->rmf_size;
+ i < n;
+ i++, p += field->rmf_size) {
+ if (dump) {
+ CDEBUG(D_RPCTRACE, "Dump of %s%sfield %s element %d follows\n",
+ do_swab ? "unswabbed " : "",
+ array ? "array " : "",
+ field->rmf_name, i);
+ field->rmf_dumper(p);
+ }
+ if (!do_swab) {
+ if (array)
+ continue;
+ else
+ break;
+ }
+ if (!field->rmf_swab_len) {
+ swabber(p);
+ } else {
+ size = field->rmf_swab_len(p, len);
+ if (size > 0) {
+ len -= size;
+ } else {
+ rc = size;
+ break;
+ }
+ }
if (dump) {
- CDEBUG(D_RPCTRACE, "Dump of swabbed field %s "
- "follows\n", field->rmf_name);
- field->rmf_dumper(value);
- }
-
- return;
- }
-
- /*
- * We're swabbing an array; swabber() swabs a single array element, so
- * swab every element.
- */
- LASSERT((len % field->rmf_size) == 0);
- for (p = value, i = 0, n = len / field->rmf_size;
- i < n;
- i++, p += field->rmf_size) {
- if (dump) {
- CDEBUG(D_RPCTRACE, "Dump of %sarray field %s, "
- "element %d follows\n",
- do_swab ? "unswabbed " : "", field->rmf_name, i);
- field->rmf_dumper(p);
- }
- if (!do_swab)
- continue;
- swabber(p);
- if (dump) {
- CDEBUG(D_RPCTRACE, "Dump of swabbed array field %s, "
- "element %d follows\n", field->rmf_name, i);
- field->rmf_dumper(value);
- }
- }
- if (do_swab)
- ptlrpc_buf_set_swabbed(pill->rc_req, inout, offset);
+ CDEBUG(D_RPCTRACE,
+ "Dump of swabbed %sfield %s, element %d follows\n",
+ array ? "array " : "", field->rmf_name, i);
+ field->rmf_dumper(value);
+ }
+ }
+ if (do_swab)
+ req_capsule_set_swabbed(pill, loc, offset);
+
+ return rc;
}
/**
* element of the array swabbed.
*/
static void *__req_capsule_get(struct req_capsule *pill,
- const struct req_msg_field *field,
- enum req_location loc,
- void (*swabber)( void *),
- int dump)
+ const struct req_msg_field *field,
+ enum req_location loc,
+ void (*swabber)(void *),
+ bool dump)
{
- const struct req_format *fmt;
- struct lustre_msg *msg;
- void *value;
+ const struct req_format *fmt;
+ struct lustre_msg *msg;
+ void *value;
__u32 len;
__u32 offset;
void *(*getter)(struct lustre_msg *m, __u32 n, __u32 minlen);
- static const char *rcl_names[RCL_NR] = {
- [RCL_CLIENT] = "client",
- [RCL_SERVER] = "server"
- };
+ static const char *rcl_names[RCL_NR] = {
+ [RCL_CLIENT] = "client",
+ [RCL_SERVER] = "server"
+ };
- LASSERT(pill != NULL);
- LASSERT(pill != LP_POISON);
- fmt = pill->rc_fmt;
- LASSERT(fmt != NULL);
- LASSERT(fmt != LP_POISON);
- LASSERT(__req_format_is_sane(fmt));
+ LASSERT(pill != NULL);
+ LASSERT(pill != LP_POISON);
+ fmt = pill->rc_fmt;
+ LASSERT(fmt != NULL);
+ LASSERT(fmt != LP_POISON);
+ LASSERT(__req_format_is_sane(fmt));
- offset = __req_capsule_offset(pill, field, loc);
+ offset = __req_capsule_offset(pill, field, loc);
- msg = __req_msg(pill, loc);
- LASSERT(msg != NULL);
+ msg = __req_msg(pill, loc);
+ LASSERT(msg != NULL);
- getter = (field->rmf_flags & RMF_F_STRING) ?
- (typeof(getter))lustre_msg_string : lustre_msg_buf;
+ getter = (field->rmf_flags & RMF_F_STRING) ?
+ (typeof(getter))lustre_msg_string : lustre_msg_buf;
if (field->rmf_flags & (RMF_F_STRUCT_ARRAY|RMF_F_NO_SIZE_CHECK)) {
/*
len = lustre_msg_buflen(msg, offset);
if (!(field->rmf_flags & RMF_F_NO_SIZE_CHECK) &&
(len % field->rmf_size) != 0) {
- CERROR("%s: array field size mismatch "
- "%d modulo %u != 0 (%d)\n",
+ CERROR("%s: array field size mismatch %d modulo %u != 0 (%d)\n",
field->rmf_name, len, field->rmf_size, loc);
return NULL;
}
- } else if (pill->rc_area[loc][offset] != -1) {
- len = pill->rc_area[loc][offset];
- } else {
+ } else if (pill->rc_area[loc][offset] != -1) {
+ len = pill->rc_area[loc][offset];
+ } else {
len = max_t(typeof(field->rmf_size), field->rmf_size, 0);
- }
- value = getter(msg, offset, len);
-
- if (value == NULL) {
- DEBUG_REQ(D_ERROR, pill->rc_req,
- "Wrong buffer for field '%s' (%u of %u) in format '%s', %u vs. %u (%s)",
- field->rmf_name, offset, lustre_msg_bufcount(msg),
- fmt->rf_name, lustre_msg_buflen(msg, offset), len,
- rcl_names[loc]);
- } else {
- swabber_dumper_helper(pill, field, loc, offset, value, len,
- dump, swabber);
- }
-
- return value;
+ }
+ value = getter(msg, offset, len);
+
+ if (value == NULL) {
+ LASSERT(pill->rc_req != NULL);
+ DEBUG_REQ(D_ERROR, pill->rc_req,
+ "Wrong buffer for field '%s' (%u of %u) in format '%s', %u vs. %u (%s)",
+ field->rmf_name, offset, lustre_msg_bufcount(msg),
+ fmt->rf_name, lustre_msg_buflen(msg, offset), len,
+ rcl_names[loc]);
+ } else {
+ swabber_dumper_helper(pill, field, loc, offset, value, len,
+ dump, swabber);
+ }
+
+ return value;
}
/**
* Dump a request and/or reply
*/
-void __req_capsule_dump(struct req_capsule *pill, enum req_location loc)
+static void __req_capsule_dump(struct req_capsule *pill, enum req_location loc)
{
const struct req_format *fmt;
const struct req_msg_field *field;
* have a specific dumper
*/
len = req_capsule_get_size(pill, field, loc);
- CDEBUG(D_RPCTRACE, "Field %s has no dumper function;"
- "field size is %u\n", field->rmf_name, len);
+ CDEBUG(D_RPCTRACE,
+ "Field %s has no dumper function; field size is %u\n",
+ field->rmf_name, len);
} else {
/* It's dumping side-effect that we're interested in */
- (void) __req_capsule_get(pill, field, loc, NULL, 1);
+ (void) __req_capsule_get(pill, field, loc, NULL, true);
}
}
CDEBUG(D_RPCTRACE, "END REQ CAPSULE DUMP\n");
*/
void req_capsule_client_dump(struct req_capsule *pill)
{
- __req_capsule_dump(pill, RCL_CLIENT);
+ __req_capsule_dump(pill, RCL_CLIENT);
}
EXPORT_SYMBOL(req_capsule_client_dump);
*/
void req_capsule_server_dump(struct req_capsule *pill)
{
- __req_capsule_dump(pill, RCL_SERVER);
+ __req_capsule_dump(pill, RCL_SERVER);
}
EXPORT_SYMBOL(req_capsule_server_dump);
* buffer corresponding to the given RMF (\a field) of a \a pill.
*/
void *req_capsule_client_get(struct req_capsule *pill,
- const struct req_msg_field *field)
+ const struct req_msg_field *field)
{
- return __req_capsule_get(pill, field, RCL_CLIENT, NULL, 0);
+ return __req_capsule_get(pill, field, RCL_CLIENT, NULL, false);
}
EXPORT_SYMBOL(req_capsule_client_get);
const struct req_msg_field *field,
void *swabber)
{
- return __req_capsule_get(pill, field, RCL_CLIENT, swabber, 0);
+ return __req_capsule_get(pill, field, RCL_CLIENT, swabber, false);
}
EXPORT_SYMBOL(req_capsule_client_swab_get);
const struct req_msg_field *field,
__u32 len)
{
- req_capsule_set_size(pill, field, RCL_CLIENT, len);
- return __req_capsule_get(pill, field, RCL_CLIENT, NULL, 0);
+ req_capsule_set_size(pill, field, RCL_CLIENT, len);
+ return __req_capsule_get(pill, field, RCL_CLIENT, NULL, false);
}
EXPORT_SYMBOL(req_capsule_client_sized_get);
* buffer corresponding to the given RMF (\a field) of a \a pill.
*/
void *req_capsule_server_get(struct req_capsule *pill,
- const struct req_msg_field *field)
+ const struct req_msg_field *field)
{
- return __req_capsule_get(pill, field, RCL_SERVER, NULL, 0);
+ return __req_capsule_get(pill, field, RCL_SERVER, NULL, false);
}
EXPORT_SYMBOL(req_capsule_server_get);
* swabbing done outside this capsule abstraction.
*/
void *req_capsule_server_swab_get(struct req_capsule *pill,
- const struct req_msg_field *field,
- void *swabber)
+ const struct req_msg_field *field,
+ void *swabber)
{
- return __req_capsule_get(pill, field, RCL_SERVER, swabber, 0);
+ return __req_capsule_get(pill, field, RCL_SERVER, swabber, false);
}
EXPORT_SYMBOL(req_capsule_server_swab_get);
const struct req_msg_field *field,
__u32 len)
{
- req_capsule_set_size(pill, field, RCL_SERVER, len);
- return __req_capsule_get(pill, field, RCL_SERVER, NULL, 0);
+ req_capsule_set_size(pill, field, RCL_SERVER, len);
+ return __req_capsule_get(pill, field, RCL_SERVER, NULL, false);
}
EXPORT_SYMBOL(req_capsule_server_sized_get);
__u32 len, void *swabber)
{
req_capsule_set_size(pill, field, RCL_SERVER, len);
- return __req_capsule_get(pill, field, RCL_SERVER, swabber, 0);
+ return __req_capsule_get(pill, field, RCL_SERVER, swabber, false);
}
EXPORT_SYMBOL(req_capsule_server_sized_swab_get);
* client and server alike.
*/
const void *req_capsule_other_get(struct req_capsule *pill,
- const struct req_msg_field *field)
+ const struct req_msg_field *field)
{
- return __req_capsule_get(pill, field, pill->rc_loc ^ 1, NULL, 0);
+ return __req_capsule_get(pill, field, pill->rc_loc ^ 1, NULL, false);
}
EXPORT_SYMBOL(req_capsule_other_get);
!(field->rmf_flags & RMF_F_NO_SIZE_CHECK) &&
(size > 0)) {
__u32 rmf_size = (__u32)field->rmf_size;
+
if ((field->rmf_flags & RMF_F_STRUCT_ARRAY) &&
(size % rmf_size != 0)) {
- CERROR("%s: array field size mismatch "
- "%u %% %u != 0 (%d)\n",
+ CERROR("%s: array field size mismatch %u %% %u != 0 (%d)\n",
field->rmf_name, size, rmf_size, loc);
LBUG();
} else if (!(field->rmf_flags & RMF_F_STRUCT_ARRAY) &&
* returns the message buflen[offset], maybe we should use another name.
*/
__u32 req_capsule_get_size(const struct req_capsule *pill,
- const struct req_msg_field *field,
- enum req_location loc)
+ const struct req_msg_field *field,
+ enum req_location loc)
{
- LASSERT(loc == RCL_SERVER || loc == RCL_CLIENT);
+ LASSERT(loc == RCL_SERVER || loc == RCL_CLIENT);
- return lustre_msg_buflen(__req_msg(pill, loc),
- __req_capsule_offset(pill, field, loc));
+ return lustre_msg_buflen(__req_msg(pill, loc),
+ __req_capsule_offset(pill, field, loc));
}
EXPORT_SYMBOL(req_capsule_get_size);
*/
__u32 req_capsule_msg_size(struct req_capsule *pill, enum req_location loc)
{
- return lustre_msg_size(pill->rc_req->rq_import->imp_msg_magic,
- pill->rc_fmt->rf_fields[loc].nr,
- pill->rc_area[loc]);
+ if (req_capsule_ptlreq(pill)) {
+ return lustre_msg_size(pill->rc_req->rq_import->imp_msg_magic,
+ pill->rc_fmt->rf_fields[loc].nr,
+ pill->rc_area[loc]);
+ } else { /* SUB request in a batch request */
+ int count;
+
+ count = req_capsule_filled_sizes(pill, loc);
+ return lustre_msg_size_v2(count, pill->rc_area[loc]);
+ }
}
+EXPORT_SYMBOL(req_capsule_msg_size);
/**
* While req_capsule_msg_size() computes the size of a PTLRPC request or reply
* fields.
*/
__u32 req_capsule_fmt_size(__u32 magic, const struct req_format *fmt,
- enum req_location loc)
+ enum req_location loc)
{
__u32 size;
size_t i = 0;
- /*
- * This function should probably LASSERT() that fmt has no fields with
- * RMF_F_STRUCT_ARRAY in rmf_flags, since we can't know here how many
- * elements in the array there will ultimately be, but then, we could
- * assume that there will be at least one element, and that's just what
- * we do.
- */
- size = lustre_msg_hdr_size(magic, fmt->rf_fields[loc].nr);
+ /*
+ * This function should probably LASSERT() that fmt has no fields with
+ * RMF_F_STRUCT_ARRAY in rmf_flags, since we can't know here how many
+ * elements in the array there will ultimately be, but then, we could
+ * assume that there will be at least one element, and that's just what
+ * we do.
+ */
+ size = lustre_msg_hdr_size(magic, fmt->rf_fields[loc].nr);
if (size == 0)
return size;
- for (; i < fmt->rf_fields[loc].nr; ++i)
- if (fmt->rf_fields[loc].d[i]->rmf_size != -1)
- size += cfs_size_round(fmt->rf_fields[loc].d[i]->
- rmf_size);
+ for (; i < fmt->rf_fields[loc].nr; ++i) {
+ if (fmt->rf_fields[loc].d[i]->rmf_size == -1)
+ continue;
+ size += round_up(fmt->rf_fields[loc].d[i]->rmf_size, 8);
+ }
return size;
}
EXPORT_SYMBOL(req_capsule_fmt_size);
{
int i;
size_t j;
+ const struct req_format *old;
- const struct req_format *old;
-
- LASSERT(pill->rc_fmt != NULL);
- LASSERT(__req_format_is_sane(fmt));
-
- old = pill->rc_fmt;
- /*
- * Sanity checking...
- */
- for (i = 0; i < RCL_NR; ++i) {
- LASSERT(fmt->rf_fields[i].nr >= old->rf_fields[i].nr);
- for (j = 0; j < old->rf_fields[i].nr - 1; ++j) {
- const struct req_msg_field *ofield = FMT_FIELD(old, i, j);
-
- /* "opaque" fields can be transmogrified */
- if (ofield->rmf_swabber == NULL &&
- (ofield->rmf_flags & ~RMF_F_NO_SIZE_CHECK) == 0 &&
- (ofield->rmf_size == -1 ||
- ofield->rmf_flags == RMF_F_NO_SIZE_CHECK))
- continue;
- LASSERT(FMT_FIELD(fmt, i, j) == FMT_FIELD(old, i, j));
- }
- /*
- * Last field in old format can be shorter than in new.
- */
- LASSERT(FMT_FIELD(fmt, i, j)->rmf_size >=
- FMT_FIELD(old, i, j)->rmf_size);
- }
-
- pill->rc_fmt = fmt;
+ LASSERT(pill->rc_fmt != NULL);
+ LASSERT(__req_format_is_sane(fmt));
+
+ old = pill->rc_fmt;
+ /*
+ * Sanity checking...
+ */
+ for (i = 0; i < RCL_NR; ++i) {
+ LASSERT(fmt->rf_fields[i].nr >= old->rf_fields[i].nr);
+ for (j = 0; j < old->rf_fields[i].nr - 1; ++j) {
+ const struct req_msg_field *ofield = FMT_FIELD(old, i,
+ j);
+
+ /* "opaque" fields can be transmogrified */
+ if (ofield->rmf_swabber == NULL &&
+ (ofield->rmf_flags & ~RMF_F_NO_SIZE_CHECK) == 0 &&
+ (ofield->rmf_size == -1 ||
+ ofield->rmf_flags == RMF_F_NO_SIZE_CHECK))
+ continue;
+ LASSERT(FMT_FIELD(fmt, i, j) == FMT_FIELD(old, i, j));
+ }
+ /*
+ * Last field in old format can be shorter than in new.
+ */
+ LASSERT(FMT_FIELD(fmt, i, j)->rmf_size >=
+ FMT_FIELD(old, i, j)->rmf_size);
+ }
+
+ pill->rc_fmt = fmt;
}
EXPORT_SYMBOL(req_capsule_extend);
* returns 0.
*/
int req_capsule_has_field(const struct req_capsule *pill,
- const struct req_msg_field *field,
- enum req_location loc)
+ const struct req_msg_field *field,
+ enum req_location loc)
{
- LASSERT(loc == RCL_SERVER || loc == RCL_CLIENT);
+ LASSERT(loc == RCL_SERVER || loc == RCL_CLIENT);
- return field->rmf_offset[pill->rc_fmt->rf_idx][loc];
+ return field->rmf_offset[pill->rc_fmt->rf_idx][loc];
}
EXPORT_SYMBOL(req_capsule_has_field);
* pill's PTLRPC request or reply (\a loc), else it returns 0.
*/
int req_capsule_field_present(const struct req_capsule *pill,
- const struct req_msg_field *field,
- enum req_location loc)
+ const struct req_msg_field *field,
+ enum req_location loc)
{
__u32 offset;
- LASSERT(loc == RCL_SERVER || loc == RCL_CLIENT);
- LASSERT(req_capsule_has_field(pill, field, loc));
+ LASSERT(loc == RCL_SERVER || loc == RCL_CLIENT);
+ LASSERT(req_capsule_has_field(pill, field, loc));
- offset = __req_capsule_offset(pill, field, loc);
- return lustre_msg_bufcount(__req_msg(pill, loc)) > offset;
+ offset = __req_capsule_offset(pill, field, loc);
+ return lustre_msg_bufcount(__req_msg(pill, loc)) > offset;
}
EXPORT_SYMBOL(req_capsule_field_present);
* This is not the opposite of req_capsule_extend().
*/
void req_capsule_shrink(struct req_capsule *pill,
- const struct req_msg_field *field,
- __u32 newlen,
+ const struct req_msg_field *field, __u32 newlen,
enum req_location loc)
{
- const struct req_format *fmt;
- struct lustre_msg *msg;
- __u32 len;
- int offset;
+ const struct req_format *fmt;
+ struct lustre_msg *msg;
+ __u32 len;
+ int offset;
- fmt = pill->rc_fmt;
- LASSERT(fmt != NULL);
- LASSERT(__req_format_is_sane(fmt));
- LASSERT(req_capsule_has_field(pill, field, loc));
- LASSERT(req_capsule_field_present(pill, field, loc));
+ fmt = pill->rc_fmt;
+ LASSERT(fmt != NULL);
+ LASSERT(__req_format_is_sane(fmt));
+ LASSERT(req_capsule_has_field(pill, field, loc));
+ LASSERT(req_capsule_field_present(pill, field, loc));
- offset = __req_capsule_offset(pill, field, loc);
+ offset = __req_capsule_offset(pill, field, loc);
msg = __req_msg(pill, loc);
len = lustre_msg_buflen(msg, offset);
LASSERTF(newlen <= len, "%s:%s, oldlen=%u, newlen=%u\n",
fmt->rf_name, field->rmf_name, len, newlen);
+ len = lustre_shrink_msg(msg, offset, newlen, 1);
if (loc == RCL_CLIENT) {
- pill->rc_req->rq_reqlen = lustre_shrink_msg(msg, offset, newlen,
- 1);
+ if (req_capsule_ptlreq(pill))
+ pill->rc_req->rq_reqlen = len;
} else {
- pill->rc_req->rq_replen = lustre_shrink_msg(msg, offset, newlen,
- 1);
/* update also field size in reply lenghts arrays for possible
* reply re-pack due to req_capsule_server_grow() call.
*/
req_capsule_set_size(pill, field, loc, newlen);
+ if (req_capsule_ptlreq(pill))
+ pill->rc_req->rq_replen = len;
}
}
EXPORT_SYMBOL(req_capsule_shrink);
const struct req_msg_field *field,
__u32 newlen)
{
- struct ptlrpc_reply_state *rs = pill->rc_req->rq_reply_state, *nrs;
- char *from, *to;
+ struct ptlrpc_request *req = pill->rc_req;
+ struct ptlrpc_reply_state *rs = req->rq_reply_state, *nrs;
+ char *from, *to, *sptr = NULL;
+ __u32 slen = 0, snewlen = 0;
+ __u32 offset, len, max, diff;
int rc;
- __u32 offset, len;
LASSERT(pill->rc_fmt != NULL);
LASSERT(__req_format_is_sane(pill->rc_fmt));
LASSERT(req_capsule_has_field(pill, field, RCL_SERVER));
LASSERT(req_capsule_field_present(pill, field, RCL_SERVER));
- len = req_capsule_get_size(pill, field, RCL_SERVER);
- offset = __req_capsule_offset(pill, field, RCL_SERVER);
+ if (req_capsule_subreq(pill)) {
+ if (!req_capsule_has_field(&req->rq_pill, &RMF_BUT_REPLY,
+ RCL_SERVER))
+ return -EINVAL;
+
+ if (!req_capsule_field_present(&req->rq_pill, &RMF_BUT_REPLY,
+ RCL_SERVER))
+ return -EINVAL;
+
+ len = req_capsule_get_size(&req->rq_pill, &RMF_BUT_REPLY,
+ RCL_SERVER);
+ sptr = req_capsule_server_get(&req->rq_pill, &RMF_BUT_REPLY);
+ slen = req_capsule_get_size(pill, field, RCL_SERVER);
+
+ LASSERT(len >= (char *)pill->rc_repmsg - sptr +
+ lustre_packed_msg_size(pill->rc_repmsg));
+ if (len >= (char *)pill->rc_repmsg - sptr +
+ lustre_packed_msg_size(pill->rc_repmsg) - slen +
+ newlen) {
+ req_capsule_set_size(pill, field, RCL_SERVER, newlen);
+ offset = __req_capsule_offset(pill, field, RCL_SERVER);
+ lustre_grow_msg(pill->rc_repmsg, offset, newlen);
+ return 0;
+ }
+
+ /*
+ * Currently first try to increase the reply buffer by
+ * 2 * newlen with reply buffer limit of BUT_MAXREPSIZE.
+ * TODO: Enlarge the reply buffer properly according to the
+ * left SUB requests in the batch PTLRPC request.
+ */
+ snewlen = newlen;
+ diff = snewlen - slen;
+ max = BUT_MAXREPSIZE - req->rq_replen;
+ if (diff > max)
+ return -EOVERFLOW;
+
+ if (diff * 2 + len < max)
+ newlen = (len + diff) * 2;
+ else
+ newlen = len + max;
+
+ req_capsule_set_size(pill, field, RCL_SERVER, snewlen);
+ req_capsule_set_size(&req->rq_pill, &RMF_BUT_REPLY, RCL_SERVER,
+ newlen);
+ offset = __req_capsule_offset(&req->rq_pill, &RMF_BUT_REPLY,
+ RCL_SERVER);
+ } else {
+ len = req_capsule_get_size(pill, field, RCL_SERVER);
+ offset = __req_capsule_offset(pill, field, RCL_SERVER);
+ req_capsule_set_size(pill, field, RCL_SERVER, newlen);
+ }
CDEBUG(D_INFO, "Reply packed: %d, allocated: %d, field len %d -> %d\n",
lustre_packed_msg_size(rs->rs_msg), rs->rs_repbuf_len,
len, newlen);
- req_capsule_set_size(pill, field, RCL_SERVER, newlen);
- /* there can be enough space in current reply buffer */
- if (rs->rs_repbuf_len >=
+ /**
+ * There can be enough space in current reply buffer, make sure
+ * that rs_repbuf is not a wrapper but real reply msg, otherwise
+ * re-packing is still needed.
+ */
+ if (rs->rs_msg == rs->rs_repbuf &&
+ rs->rs_repbuf_len >=
lustre_packed_msg_size(rs->rs_msg) - len + newlen) {
- pill->rc_req->rq_replen = lustre_grow_msg(rs->rs_msg, offset,
- newlen);
+ req->rq_replen = lustre_grow_msg(rs->rs_msg, offset, newlen);
return 0;
}
/* Re-allocate replay state */
- pill->rc_req->rq_reply_state = NULL;
- rc = req_capsule_server_pack(pill);
+ req->rq_reply_state = NULL;
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc) {
/* put old values back, the caller should decide what to do */
- req_capsule_set_size(pill, field, RCL_SERVER, len);
+ if (req_capsule_subreq(pill)) {
+ req_capsule_set_size(&req->rq_pill, &RMF_BUT_REPLY,
+ RCL_SERVER, len);
+ req_capsule_set_size(pill, field, RCL_SERVER, slen);
+ } else {
+ req_capsule_set_size(pill, field, RCL_SERVER, len);
+ }
pill->rc_req->rq_reply_state = rs;
return rc;
}
- nrs = pill->rc_req->rq_reply_state;
+ nrs = req->rq_reply_state;
LASSERT(lustre_packed_msg_size(nrs->rs_msg) >
lustre_packed_msg_size(rs->rs_msg));
/* Now we need only buffers, copy them and grow the needed one */
to = lustre_msg_buf(nrs->rs_msg, 0, 0);
from = lustre_msg_buf(rs->rs_msg, 0, 0);
- len = (char *)rs->rs_msg + lustre_packed_msg_size(rs->rs_msg) - from;
- memcpy(to, from, len);
- pill->rc_req->rq_replen = lustre_grow_msg(nrs->rs_msg, offset, newlen);
-
- if (rs->rs_difficult) {
- /* copy rs data */
- int i;
-
- nrs->rs_difficult = 1;
- nrs->rs_no_ack = rs->rs_no_ack;
- nrs->rs_convert_lock = rs->rs_convert_lock;
- for (i = 0; i < rs->rs_nlocks; i++) {
- nrs->rs_locks[i] = rs->rs_locks[i];
- nrs->rs_modes[i] = rs->rs_modes[i];
- nrs->rs_nlocks++;
- }
- rs->rs_nlocks = 0;
- rs->rs_difficult = 0;
- rs->rs_no_ack = 0;
- }
- ptlrpc_rs_decref(rs);
- return 0;
+ memcpy(to, from,
+ (char *)rs->rs_msg + lustre_packed_msg_size(rs->rs_msg) - from);
+ lustre_msg_set_buflen(nrs->rs_msg, offset, len);
+ req->rq_replen = lustre_grow_msg(nrs->rs_msg, offset, newlen);
+
+ if (req_capsule_subreq(pill)) {
+ char *ptr;
+
+ ptr = req_capsule_server_get(&req->rq_pill, &RMF_BUT_REPLY);
+ pill->rc_repmsg = (struct lustre_msg *)(ptr +
+ ((char *)pill->rc_repmsg - sptr));
+ offset = __req_capsule_offset(pill, field, RCL_SERVER);
+ lustre_grow_msg(pill->rc_repmsg, offset, snewlen);
+ }
+
+ if (rs->rs_difficult) {
+ /* copy rs data */
+ int i;
+
+ nrs->rs_difficult = 1;
+ nrs->rs_no_ack = rs->rs_no_ack;
+ for (i = 0; i < rs->rs_nlocks; i++) {
+ nrs->rs_locks[i] = rs->rs_locks[i];
+ nrs->rs_nlocks++;
+ }
+ rs->rs_nlocks = 0;
+ rs->rs_difficult = 0;
+ rs->rs_no_ack = 0;
+ }
+ ptlrpc_rs_decref(rs);
+ return 0;
}
EXPORT_SYMBOL(req_capsule_server_grow);
+#ifdef HAVE_SERVER_SUPPORT
+static const struct req_msg_field *mds_update_client[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_OUT_UPDATE_HEADER,
+ &RMF_OUT_UPDATE_BUF,
+};
+
+static const struct req_msg_field *mds_update_server[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_OUT_UPDATE_REPLY,
+};
+
+struct req_msg_field RMF_OUT_UPDATE = DEFINE_MSGFL("object_update", 0, -1,
+ lustre_swab_object_update_request, NULL);
+EXPORT_SYMBOL(RMF_OUT_UPDATE);
+
+struct req_msg_field RMF_OUT_UPDATE_REPLY =
+ DEFINE_MSGFL("object_update_reply", 0, -1,
+ lustre_swab_object_update_reply, NULL);
+EXPORT_SYMBOL(RMF_OUT_UPDATE_REPLY);
+
+struct req_msg_field RMF_OUT_UPDATE_HEADER = DEFINE_MSGF("out_update_header", 0,
+ -1, lustre_swab_out_update_header, NULL);
+EXPORT_SYMBOL(RMF_OUT_UPDATE_HEADER);
+
+struct req_msg_field RMF_OUT_UPDATE_BUF = DEFINE_MSGF("update_buf",
+ RMF_F_STRUCT_ARRAY, sizeof(struct out_update_buffer),
+ lustre_swab_out_update_buffer, NULL);
+EXPORT_SYMBOL(RMF_OUT_UPDATE_BUF);
+
+struct req_format RQF_OUT_UPDATE =
+ DEFINE_REQ_FMT0("OUT_UPDATE", mds_update_client,
+ mds_update_server);
+EXPORT_SYMBOL(RQF_OUT_UPDATE);
+
int req_check_sepol(struct req_capsule *pill)
{
int rc = 0;
-#ifdef HAVE_SERVER_SUPPORT
struct obd_export *export;
struct lu_nodemap *nm = NULL;
const char *sepol = NULL;
const char *nm_sepol = NULL;
+ if (req_capsule_subreq(pill))
+ return 0;
+
if (!pill->rc_req)
return -EPROTO;
if (!IS_ERR_OR_NULL(nm))
nodemap_putref(nm);
-#endif
return rc;
}
EXPORT_SYMBOL(req_check_sepol);
+#endif
+
+void req_capsule_subreq_init(struct req_capsule *pill,
+ const struct req_format *fmt,
+ struct ptlrpc_request *req,
+ struct lustre_msg *reqmsg,
+ struct lustre_msg *repmsg,
+ enum req_location loc)
+{
+ req_capsule_init(pill, req, loc);
+ req_capsule_set(pill, fmt);
+ pill->rc_reqmsg = reqmsg;
+ pill->rc_repmsg = repmsg;
+}
+EXPORT_SYMBOL(req_capsule_subreq_init);
+
+void req_capsule_set_replen(struct req_capsule *pill)
+{
+ if (req_capsule_ptlreq(pill)) {
+ ptlrpc_request_set_replen(pill->rc_req);
+ } else { /* SUB request in a batch request */
+ int count;
+
+ count = req_capsule_filled_sizes(pill, RCL_SERVER);
+ pill->rc_reqmsg->lm_repsize =
+ lustre_msg_size_v2(count,
+ pill->rc_area[RCL_SERVER]);
+ }
+}
+EXPORT_SYMBOL(req_capsule_set_replen);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff