#include <linux/string.h>
#else
#include <liblustre.h>
+#include <string.h>
#include <obd_class.h>
#include <obd.h>
#endif
-#include <lustre_log.h>
-#include <lprocfs_status.h>
-#include <libcfs/list.h>
#include <lustre_param.h>
+#include "llog_internal.h"
+
static cfs_hash_ops_t uuid_hash_ops;
static cfs_hash_ops_t nid_hash_ops;
static cfs_hash_ops_t nid_stat_hash_ops;
return 0;
}
+EXPORT_SYMBOL(class_find_param);
+
+/**
+ * Check whether the proc parameter \a param is an old parameter or not from
+ * the array \a ptr which contains the mapping from old parameters to new ones.
+ * If it's an old one, then return the pointer to the cfg_interop_param struc-
+ * ture which contains both the old and new parameters.
+ *
+ * \param param proc parameter
+ * \param ptr an array which contains the mapping from
+ * old parameters to new ones
+ *
+ * \retval valid-pointer pointer to the cfg_interop_param structure
+ * which contains the old and new parameters
+ * \retval NULL \a param or \a ptr is NULL,
+ * or \a param is not an old parameter
+ */
+struct cfg_interop_param *class_find_old_param(const char *param,
+ struct cfg_interop_param *ptr)
+{
+ char *value = NULL;
+ int name_len = 0;
+
+ if (param == NULL || ptr == NULL)
+ RETURN(NULL);
+
+ value = strchr(param, '=');
+ if (value == NULL)
+ name_len = strlen(param);
+ else
+ name_len = value - param;
+
+ while (ptr->old_param != NULL) {
+ if (strncmp(param, ptr->old_param, name_len) == 0 &&
+ name_len == strlen(ptr->old_param))
+ RETURN(ptr);
+ ptr++;
+ }
+
+ RETURN(NULL);
+}
+EXPORT_SYMBOL(class_find_old_param);
/**
* Finds a parameter in \a params and copies it to \a copy.
}
return 1;
}
+EXPORT_SYMBOL(class_get_next_param);
/* returns 0 if this is the first key in the buffer, else 1.
valp points to first char after key. */
return 0;
}
+EXPORT_SYMBOL(class_match_param);
static int parse_nid(char *buf, void *value)
{
{
return class_parse_value(buf, CLASS_PARSE_NID, (void *)nid, endh);
}
+EXPORT_SYMBOL(class_parse_nid);
int class_parse_net(char *buf, __u32 *net, char **endh)
{
return class_parse_value(buf, CLASS_PARSE_NET, (void *)net, endh);
}
+EXPORT_SYMBOL(class_parse_net);
/* 1 param contains key and match
* 0 param contains key and not match
}
return rc;
}
+EXPORT_SYMBOL(class_match_nid);
int class_match_net(char *buf, char *key, __u32 net)
{
}
return rc;
}
-
-EXPORT_SYMBOL(class_find_param);
-EXPORT_SYMBOL(class_get_next_param);
-EXPORT_SYMBOL(class_match_param);
-EXPORT_SYMBOL(class_parse_nid);
-EXPORT_SYMBOL(class_parse_net);
-EXPORT_SYMBOL(class_match_nid);
EXPORT_SYMBOL(class_match_net);
/********************** class fns **********************/
}
return rc;
}
+EXPORT_SYMBOL(class_attach);
/** Create hashes, self-export, and call type-specific setup.
* Setup is effectively the "start this obd" call.
CERROR("setup %s failed (%d)\n", obd->obd_name, err);
return err;
}
+EXPORT_SYMBOL(class_setup);
/** We have finished using this obd and are ready to destroy it.
* There can be no more references to this obd.
class_decref(obd, "attach", obd);
RETURN(0);
}
+EXPORT_SYMBOL(class_detach);
/** Start shutting down the obd. There may be in-progess ops when
* this is called. We tell them to start shutting down with a call
RETURN(0);
}
+EXPORT_SYMBOL(class_cleanup);
struct obd_device *class_incref(struct obd_device *obd,
const char *scope, const void *source)
return obd;
}
+EXPORT_SYMBOL(class_incref);
void class_decref(struct obd_device *obd, const char *scope, const void *source)
{
class_release_dev(obd);
}
}
+EXPORT_SYMBOL(class_decref);
/** Add a failover nid location.
* Client obd types contact server obd types using this nid list.
}
RETURN(NULL);
}
+EXPORT_SYMBOL(class_get_profile);
/** Create a named "profile".
* This defines the mdc and osc names to use for a client.
}
EXIT;
}
+EXPORT_SYMBOL(class_del_profile);
/* COMPAT_146 */
void class_del_profiles(void)
}
EXIT;
}
+EXPORT_SYMBOL(class_del_profiles);
static int class_set_global(char *ptr, int val, struct lustre_cfg *lcfg)
{
at_early_margin = val;
else if (class_match_param(ptr, PARAM_AT_HISTORY, NULL) == 0)
at_history = val;
- else if (class_match_param(ptr, PARAM_JOBID_VAR, NULL) == 0) {
- memset(obd_jobid_var, 0, JOBSTATS_JOBID_VAR_MAX_LEN + 1);
- memcpy(obd_jobid_var, lustre_cfg_string(lcfg, 2),
- JOBSTATS_JOBID_VAR_MAX_LEN + 1);
- } else
+ else if (class_match_param(ptr, PARAM_JOBID_VAR, NULL) == 0)
+ strlcpy(obd_jobid_var, lustre_cfg_string(lcfg, 2),
+ JOBSTATS_JOBID_VAR_MAX_LEN + 1);
+ else
RETURN(-EINVAL);
CDEBUG(D_IOCTL, "global %s = %d\n", ptr, val);
}
-/* We can't call ll_process_config directly because it lives in a module that
- must be loaded after this one. */
+/* We can't call ll_process_config or lquota_process_config directly because
+ * it lives in a module that must be loaded after this one. */
static int (*client_process_config)(struct lustre_cfg *lcfg) = NULL;
+static int (*quota_process_config)(struct lustre_cfg *lcfg) = NULL;
void lustre_register_client_process_config(int (*cpc)(struct lustre_cfg *lcfg))
{
}
EXPORT_SYMBOL(lustre_cfg_rename);
+void lustre_register_quota_process_config(int (*qpc)(struct lustre_cfg *lcfg))
+{
+ quota_process_config = qpc;
+}
+EXPORT_SYMBOL(lustre_register_quota_process_config);
+
/** Process configuration commands given in lustre_cfg form.
* These may come from direct calls (e.g. class_manual_cleanup)
* or processing the config llog, or ioctl from lctl.
CDEBUG(D_IOCTL, "changing lustre timeout from %d to %d\n",
obd_timeout, lcfg->lcfg_num);
obd_timeout = max(lcfg->lcfg_num, 1U);
+ obd_timeout_set = 1;
GOTO(out, err = 0);
}
case LCFG_SET_LDLM_TIMEOUT: {
ldlm_timeout = max(lcfg->lcfg_num, 1U);
if (ldlm_timeout >= obd_timeout)
ldlm_timeout = max(obd_timeout / 3, 1U);
-
+ ldlm_timeout_set = 1;
GOTO(out, err = 0);
}
case LCFG_SET_UPCALL: {
if (err)
CWARN("Ignoring unknown param %s\n", tmp);
GOTO(out, 0);
- }
-
+ } else if ((class_match_param(lustre_cfg_string(lcfg, 1),
+ PARAM_QUOTA, &tmp) == 0) &&
+ quota_process_config) {
+ err = (*quota_process_config)(lcfg);
+ GOTO(out, err);
+ }
/* Fall through */
break;
}
}
return err;
}
+EXPORT_SYMBOL(class_process_config);
int class_process_proc_param(char *prefix, struct lprocfs_vars *lvars,
struct lustre_cfg *lcfg, void *data)
RETURN(0);
#endif
}
-
-int class_config_dump_handler(struct llog_handle * handle,
- struct llog_rec_hdr *rec, void *data);
+EXPORT_SYMBOL(class_process_proc_param);
#ifdef __KERNEL__
extern int lustre_check_exclusion(struct super_block *sb, char *svname);
* records, change uuids, etc), then class_process_config() resulting
* net records.
*/
-static int class_config_llog_handler(struct llog_handle * handle,
- struct llog_rec_hdr *rec, void *data)
+static int class_config_llog_handler(const struct lu_env *env,
+ struct llog_handle *handle,
+ struct llog_rec_hdr *rec, void *data)
{
struct config_llog_instance *clli = data;
int cfg_len = rec->lrh_len;
out:
if (rc) {
CERROR("Err %d on cfg command:\n", rc);
- class_config_dump_handler(handle, rec, data);
+ class_config_dump_handler(NULL, handle, rec, data);
}
RETURN(rc);
}
ENTRY;
CDEBUG(D_INFO, "looking up llog %s\n", name);
- rc = llog_create(ctxt, &llh, NULL, name);
+ rc = llog_create(NULL, ctxt, &llh, NULL, name);
if (rc)
RETURN(rc);
- rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_init_handle(NULL, llh, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(parse_out, rc);
cd.lpcd_first_idx = cfg->cfg_last_idx;
cd.lpcd_last_idx = 0;
- rc = llog_process(llh, class_config_llog_handler, cfg, &cd);
+ rc = llog_process(NULL, llh, class_config_llog_handler, cfg, &cd);
CDEBUG(D_CONFIG, "Processed log %s gen %d-%d (rc=%d)\n", name,
cd.lpcd_first_idx + 1, cd.lpcd_last_idx, rc);
cfg->cfg_last_idx = cd.lpcd_last_idx;
parse_out:
- rc2 = llog_close(llh);
+ rc2 = llog_close(NULL, llh);
if (rc == 0)
rc = rc2;
RETURN(rc);
}
+EXPORT_SYMBOL(class_config_parse_llog);
-int class_config_dump_handler(struct llog_handle * handle,
- struct llog_rec_hdr *rec, void *data)
+int class_config_dump_handler(const struct lu_env *env,
+ struct llog_handle *handle,
+ struct llog_rec_hdr *rec, void *data)
{
int cfg_len = rec->lrh_len;
char *cfg_buf = (char*) (rec + 1);
LCONSOLE_INFO("Dumping config log %s\n", name);
- rc = llog_create(ctxt, &llh, NULL, name);
+ rc = llog_create(NULL, ctxt, &llh, NULL, name);
if (rc)
RETURN(rc);
- rc = llog_init_handle(llh, LLOG_F_IS_PLAIN, NULL);
+ rc = llog_init_handle(NULL, llh, LLOG_F_IS_PLAIN, NULL);
if (rc)
GOTO(parse_out, rc);
- rc = llog_process(llh, class_config_dump_handler, cfg, NULL);
+ rc = llog_process(NULL, llh, class_config_dump_handler, cfg, NULL);
parse_out:
- rc2 = llog_close(llh);
+ rc2 = llog_close(NULL, llh);
if (rc == 0)
rc = rc2;
RETURN(rc);
}
+EXPORT_SYMBOL(class_config_dump_llog);
/** Call class_cleanup and class_detach.
* "Manual" only in the sense that we're faking lcfg commands.
lustre_cfg_free(lcfg);
RETURN(rc);
}
+EXPORT_SYMBOL(class_manual_cleanup);
/*
* uuid<->export lustre hash operations
git://git.whamcloud.com / fs / lustre-release.git / blobdiff