static ssize_t
ldiskfs_osd_index_in_idif_seq_write(struct file *file,
const char __user *buffer,
size_t count, loff_t *off)
{
struct lu_env env;
struct seq_file *m = file->private_data;
struct dt_device *dt = m->private;
struct osd_device *dev = osd_dt_dev(dt);
struct lu_target *tgt;
__s64 val;
int rc;
LASSERT(dev != NULL);
if (unlikely(dev->od_mnt == NULL))
return -EINPROGRESS;
rc = lprocfs_str_to_s64(buffer, count, &val);
if (rc != 0)
return rc;
if (dev->od_index_in_idif) {
if (val != 0)
return count;
LCONSOLE_WARN("%s: OST-index in IDIF has been enabled, "
"it cannot be reverted back.\n", osd_name(dev));
return -EPERM;
}
if (val == 0)
return count;
rc = lu_env_init(&env, LCT_DT_THREAD);
if (rc != 0)
return rc;
tgt = dev->od_dt_dev.dd_lu_dev.ld_site->ls_tgt;
tgt->lut_lsd.lsd_feature_rocompat |= OBD_ROCOMPAT_IDX_IN_IDIF;
rc = tgt_server_data_update(&env, tgt, 1);
lu_env_fini(&env);
if (rc < 0)
return rc;
LCONSOLE_INFO("%s: enable OST-index in IDIF successfully, "
"it cannot be reverted back.\n", osd_name(dev));
dev->od_index_in_idif = 1;
return count;
}
/**
* Match client and OST server connection feature flags.
*
* Compute the compatibility flags for a connection request based on
* features mutually supported by client and server.
*
* The obd_export::exp_connect_data.ocd_connect_flags field in \a exp
* must not be updated here, otherwise a partially initialized value may
* be exposed. After the connection request is successfully processed,
* the top-level tgt_connect() request handler atomically updates the export
* connect flags from the obd_connect_data::ocd_connect_flags field of the
* reply. \see tgt_connect().
*
* \param[in] env execution environment
* \param[in] exp the obd_export associated with this
* client/target pair
* \param[in] data stores data for this connect request
* \param[in] new_connection is this connection new or not
*
* \retval 0 if success
* \retval -EPROTO client and server feature requirements are
* incompatible
* \retval -EBADF OST index in connect request doesn't match
* real OST index
*/
static int ofd_parse_connect_data(const struct lu_env *env,
struct obd_export *exp,
struct obd_connect_data *data,
bool new_connection)
{
struct ofd_device *ofd = ofd_exp(exp);
struct filter_export_data *fed = &exp->exp_filter_data;
if (!data)
RETURN(0);
CDEBUG(D_RPCTRACE, "%s: cli %s/%p ocd_connect_flags: "LPX64
" ocd_version: %x ocd_grant: %d ocd_index: %u"
" ocd_group %u\n",
exp->exp_obd->obd_name, exp->exp_client_uuid.uuid, exp,
data->ocd_connect_flags, data->ocd_version,
data->ocd_grant, data->ocd_index, data->ocd_group);
if (fed->fed_group != 0 && fed->fed_group != data->ocd_group) {
CWARN("!!! This export (nid %s) used object group %d "
"earlier; now it's trying to use group %d! This could "
"be a bug in the MDS. Please report to "
"https://jira.hpdd.intel.com/\n",
obd_export_nid2str(exp), fed->fed_group,
data->ocd_group);
RETURN(-EPROTO);
}
fed->fed_group = data->ocd_group;
data->ocd_connect_flags &= OST_CONNECT_SUPPORTED;
data->ocd_version = LUSTRE_VERSION_CODE;
/* Kindly make sure the SKIP_ORPHAN flag is from MDS. */
if (data->ocd_connect_flags & OBD_CONNECT_MDS)
CDEBUG(D_HA, "%s: Received MDS connection for group %u\n",
exp->exp_obd->obd_name, data->ocd_group);
else if (data->ocd_connect_flags & OBD_CONNECT_SKIP_ORPHAN)
RETURN(-EPROTO);
if (ofd_grant_param_supp(exp)) {
exp->exp_filter_data.fed_pagesize = data->ocd_blocksize;
/* ocd_{blocksize,inodespace} are log2 values */
data->ocd_blocksize = ofd->ofd_blockbits;
data->ocd_inodespace = ofd->ofd_dt_conf.ddp_inodespace;
/* ocd_grant_extent is in 1K blocks */
data->ocd_grant_extent = ofd->ofd_dt_conf.ddp_grant_frag >> 10;
}
if (data->ocd_connect_flags & OBD_CONNECT_GRANT)
data->ocd_grant = ofd_grant_connect(env, exp, data->ocd_grant,
new_connection);
if (data->ocd_connect_flags & OBD_CONNECT_INDEX) {
struct lr_server_data *lsd = &ofd->ofd_lut.lut_lsd;
int index = lsd->lsd_osd_index;
if (index != data->ocd_index) {
LCONSOLE_ERROR_MSG(0x136, "Connection from %s to index"
" %u doesn't match actual OST index"
" %u in last_rcvd file, bad "
"configuration?\n",
obd_export_nid2str(exp), index,
data->ocd_index);
RETURN(-EBADF);
}
if (!(lsd->lsd_feature_compat & OBD_COMPAT_OST)) {
/* this will only happen on the first connect */
lsd->lsd_feature_compat |= OBD_COMPAT_OST;
/* sync is not needed here as lut_client_add will
* set exp_need_sync flag */
tgt_server_data_update(env, &ofd->ofd_lut, 0);
}
}
if (OBD_FAIL_CHECK(OBD_FAIL_OST_BRW_SIZE)) {
data->ocd_brw_size = 65536;
} else if (data->ocd_connect_flags & OBD_CONNECT_BRW_SIZE) {
data->ocd_brw_size = min(data->ocd_brw_size,
(__u32)DT_MAX_BRW_SIZE);
if (data->ocd_brw_size == 0) {
CERROR("%s: cli %s/%p ocd_connect_flags: "LPX64
" ocd_version: %x ocd_grant: %d ocd_index: %u "
"ocd_brw_size is unexpectedly zero, "
"network data corruption?"
"Refusing connection of this client\n",
exp->exp_obd->obd_name,
exp->exp_client_uuid.uuid,
exp, data->ocd_connect_flags, data->ocd_version,
data->ocd_grant, data->ocd_index);
RETURN(-EPROTO);
}
}
if (data->ocd_connect_flags & OBD_CONNECT_CKSUM) {
__u32 cksum_types = data->ocd_cksum_types;
/* The client set in ocd_cksum_types the checksum types it
* supports. We have to mask off the algorithms that we don't
* support */
data->ocd_cksum_types &= cksum_types_supported_server();
if (unlikely(data->ocd_cksum_types == 0)) {
CERROR("%s: Connect with checksum support but no "
"ocd_cksum_types is set\n",
exp->exp_obd->obd_name);
RETURN(-EPROTO);
}
CDEBUG(D_RPCTRACE, "%s: cli %s supports cksum type %x, return "
"%x\n", exp->exp_obd->obd_name, obd_export_nid2str(exp),
cksum_types, data->ocd_cksum_types);
} else {
/* This client does not support OBD_CONNECT_CKSUM
* fall back to CRC32 */
CDEBUG(D_RPCTRACE, "%s: cli %s does not support "
"OBD_CONNECT_CKSUM, CRC32 will be used\n",
exp->exp_obd->obd_name, obd_export_nid2str(exp));
}
if (data->ocd_connect_flags & OBD_CONNECT_MAXBYTES)
data->ocd_maxbytes = ofd->ofd_dt_conf.ddp_maxbytes;
if (OCD_HAS_FLAG(data, PINGLESS)) {
if (ptlrpc_pinger_suppress_pings()) {
spin_lock(&exp->exp_obd->obd_dev_lock);
list_del_init(&exp->exp_obd_chain_timed);
spin_unlock(&exp->exp_obd->obd_dev_lock);
} else {
data->ocd_connect_flags &= ~OBD_CONNECT_PINGLESS;
}
}
RETURN(0);
}
