#include <linux/init.h>
#include <linux/list.h>
#include <asm/io.h>
+#include <asm/ioctls.h>
#include <asm/system.h>
#include <asm/poll.h>
#include <asm/uaccess.h>
#include <linux/obd_class.h>
#include <linux/lustre_debug.h>
#include <linux/smp_lock.h>
-#include <linux/lprocfs.h>
+#include <linux/lprocfs_status.h>
struct semaphore obd_conf_sem; /* serialize configuration commands */
struct obd_device obd_dev[MAX_OBD_DEVICES];
char obd_recovery_upcall[128] = "/usr/lib/lustre/ha_assist";
extern struct obd_type *class_nm_to_type(char *nm);
-/*
- * LProcFS specific data structures. These define the namespace for
- * the various device classes. We will need to distribute these
- * later, to individual modules (e.g. MDS, MDC etc)
- */
-
-#ifdef LPROCFS_EXISTS
-
-/*
- * Common OBD namespace for lprocFS (these are used very often)
- */
-
-char* obd_dir_nm_1[]= {
- "mgmt%",
- "mgmt/setup",
- "mgmt/cleanup",
- "mgmt/connect",
- "mgmt/disconnect",
- 0
-};
-
-lprocfs_vars_t obd_var_nm_1[]= {
- {"num_ops", lprocfs_ll_rd, lprocfs_ll_wr},
- {"min_time", lprocfs_ll_rd, lprocfs_ll_wr},
- {"max_time", lprocfs_ll_rd, lprocfs_ll_wr},
- {"sum_time", lprocfs_ll_rd, lprocfs_ll_wr},
- {"0", 0, 0}
-};
-
-
-/*
- * MDC Spcific namespace for lprocFS
- */
-
-char *mdc_dir_nm_1[]= {
- "reint",
- "getstatus",
- "getattr",
- "setattr",
- "open",
- "readpage",
- "create",
- "unlink",
- "link",
- "rename",
- 0
-};
-
-/*
- * Create the MDC groupings
- */
-lprocfs_group_t lprocfs_mdc_nm[]= {
-
- {obd_dir_nm_1, obd_var_nm_1, e_generic},
- {mdc_dir_nm_1, obd_var_nm_1, e_generic},
- {0, 0, 0}
-};
-
-/*
- * MDS Device Groupings
- */
-char *mds_dir_nm_1[]={
- "getstatus",
- "connect",
- "disconnect_callback",
- "getattr",
- "readpage",
- "open",
- "close",
- "create",
- "unlink",
- "link",
- "rename",
- "reint%",
- "reint/summary",
- "reint/setattr",
- "reint/create",
- "reint/unlink",
- "reint/link",
- "reint/rename",
- "reint/recreate",
- 0
-};
-
-char *mds_dir_nm_2[]={
- "mstatfs",
- 0
-};
-
-
-lprocfs_vars_t mds_var_nm_2[]={
- {"f_type", rd_other, wr_other},
- {"f_bsize",rd_other, wr_other},
- {"f_blocks",rd_other, wr_other},
- {"f_bfree",rd_other, wr_other},
- {"f_bavail",rd_other, wr_other},
- {"uuid",rd_string, wr_string},
- {"0", 0, 0}
-};
-
-
-lprocfs_group_t lprocfs_mds_nm[]={
- {obd_dir_nm_1, obd_var_nm_1, e_generic},
- {mds_dir_nm_1, obd_var_nm_1, e_generic},
- {mds_dir_nm_2, mds_var_nm_2, e_specific},
- {0, 0, 0}
-};
-
-/*
- * OSC Namespace
- */
-
-char* osc_dir_nm_1[]={
- "create",
- "destroy",
- "getattr",
- "setattr",
- "open",
- "close",
- "brw",
- "punch",
- "summary",
- "cancel",
- 0
-};
-
-lprocfs_group_t lprocfs_osc_nm[]={
- {obd_dir_nm_1, obd_var_nm_1, e_generic},
- {osc_dir_nm_1, obd_var_nm_1, e_generic},
- {0, 0, 0}
-};
-
-
-/*
- * OST, LOV, OBD_FILTER namespace
- * Note: These namespaces are exactly similar to the osc_dir_namespace
- * Hence, I use the osc namespace as the base class and add only
- * those attributes that are missing in osc_dir_namespace.
- */
-
-char *ost_lov_obdfilter_dir_nm_1[]={
- "getinfo",
- 0
-
-};
-
-char *ost_lov_obdfilter_dir_nm_2[]={
- "ostatfs",
- 0
-};
-
-lprocfs_vars_t ost_lov_obdfilter_var_nm_2[]={
- {"f_type", rd_other, wr_other},
- {"f_bsize",rd_other, wr_other},
- {"f_blocks",rd_other, wr_other},
- {"f_bfree",rd_other, wr_other},
- {"f_bavail",rd_other, wr_other},
- {"f_objects", rd_other, wr_other},
- {"f_ofree", rd_other, wr_other},
- {"f_objectgroups", rd_other, wr_other},
- {"f_uuid", rd_string, wr_string},
- {"0", 0, 0}
-};
-
-
-lprocfs_group_t lprocfs_ost_lov_obdf_nm[]={
- {obd_dir_nm_1, obd_var_nm_1, e_generic},
- {osc_dir_nm_1, obd_var_nm_1, e_generic},
- {ost_lov_obdfilter_dir_nm_1, obd_var_nm_1, e_generic},
- {ost_lov_obdfilter_dir_nm_2, ost_lov_obdfilter_var_nm_2, e_specific},
- {0, 0, 0}
-};
-
-/*
- * LDLM Device namespace
- */
-
-
-char* ldlm_dir_nm_1[]={
- "locks%",
- "locks/enqueus",
- "locks/cancels",
- "locks/converts",
- "locks/matches",
- 0
-};
-
-lprocfs_vars_t ldlm_var_nm_1[]= {
- {"num_total", lprocfs_ll_rd, lprocfs_ll_wr},
- {"num_zerolatency", lprocfs_ll_rd, lprocfs_ll_wr},
- {"num_zerolatency_inflight", lprocfs_ll_rd, lprocfs_ll_wr},
- {"num_zerolatency_done", lprocfs_ll_rd, lprocfs_ll_wr},
- {"nonzero_mintime", lprocfs_ll_rd, lprocfs_ll_wr},
- {"nonzero_maxtime", lprocfs_ll_rd, lprocfs_ll_wr},
- {"nonzero_sumtime", lprocfs_ll_rd, lprocfs_ll_wr},
- {"0", 0, 0}
-
-};
-
-lprocfs_group_t lprocfs_ldlm_nm[]={
- {obd_dir_nm_1, obd_var_nm_1, e_generic},
- {ldlm_dir_nm_1, ldlm_var_nm_1, e_generic},
- {0, 0, 0}
-};
-
-/*
- * Note: Need to add namespace for breaking out locks by device class
- */
-
-/*
- * PTLRPC Namespace
- */
-char* ptlrpc_dir_nm_1[]={
- "counters",
- 0
-};
-
-lprocfs_vars_t ptlrpc_var_nm_1[]={
- {"msgs_alloc", lprocfs_ll_rd, lprocfs_ll_wr},
- {"msgs_max", lprocfs_ll_rd, lprocfs_ll_wr},
- {"recv_count", lprocfs_ll_rd, lprocfs_ll_wr},
- {"recv_length", lprocfs_ll_rd, lprocfs_ll_wr},
- {"send_count", lprocfs_ll_rd, lprocfs_ll_wr},
- {"send_length", lprocfs_ll_rd, lprocfs_ll_wr},
- {"portal_kmemory", lprocfs_ll_rd, lprocfs_ll_wr},
- {"0", 0, 0}
-};
-
-char* ptlrpc_dir_nm_2[] = {
- "network",
- 0
-};
-
-lprocfs_vars_t ptlrpc_var_nm_2[] = {
- {"type", rd_string, wr_string},
- {"mtu", lprocfs_ll_rd, lprocfs_ll_wr},
- {"rxpackets", lprocfs_ll_rd, lprocfs_ll_wr},
- {"txpackets", lprocfs_ll_rd, lprocfs_ll_wr},
- {"txbytes", lprocfs_ll_rd, lprocfs_ll_wr},
- {"0", 0, 0}
-};
-
-lprocfs_group_t lprocfs_ptlrpc_nm[]={
- {obd_dir_nm_1, obd_var_nm_1, e_generic},
- {ptlrpc_dir_nm_1, ptlrpc_var_nm_1, e_generic},
- {ptlrpc_dir_nm_2, ptlrpc_var_nm_2, e_specific},
- {0, 0, 0}
-};
-
-
-/*
- * Building the entire device namespace. This will be used during attach and
- * detach to associate the namespace with the class of the device
- */
-
-lprocfs_obd_nm_t obd_nm[]={
- {"mdc", lprocfs_mdc_nm, sizeof(struct lprofiler_gen)},
- {"mds", lprocfs_mds_nm, sizeof(struct lprofiler_gen)},
- {"osc", lprocfs_osc_nm, sizeof(struct lprofiler_gen)},
- {"ost", lprocfs_ost_lov_obdf_nm, sizeof(struct lprofiler_gen)},
- {"lov", lprocfs_ost_lov_obdf_nm, sizeof(struct lprofiler_gen)},
- {"obdfilter", lprocfs_ost_lov_obdf_nm, sizeof(struct lprofiler_gen)},
- {"obdecho", lprocfs_ost_lov_obdf_nm, sizeof(struct lprofiler_gen)},
- {"ldlm", lprocfs_ldlm_nm, sizeof(struct lprofiler_ldlm)},
- {"ptlrpc", lprocfs_ptlrpc_nm, sizeof(struct lprofiler_ptlrpc)},
- {"0", 0, 0}
-};
-
-#else
-
-lprocfs_obd_nm_t* obd_nm=0;
-
-#endif
/* opening /dev/obd */
static int obd_class_open(struct inode * inode, struct file * file)
ENTRY;
file->private_data = NULL;
+ CDEBUG(D_IOCTL, "MOD_INC_USE for open: count = %d\n",
+ atomic_read(&(THIS_MODULE)->uc.usecount));
MOD_INC_USE_COUNT;
RETURN(0);
}
{
ENTRY;
+ // XXX drop lsm, connections here
if (file->private_data)
file->private_data = NULL;
+ CDEBUG(D_IOCTL, "MOD_DEC_USE for close: count = %d\n",
+ atomic_read(&(THIS_MODULE)->uc.usecount) - 1);
MOD_DEC_USE_COUNT;
RETURN(0);
}
data->ioc_cookie = conn->cookie;
}
+static void forcibly_detach_exports(struct obd_device *obd)
+{
+ int rc;
+ struct list_head *tmp, *n;
+ struct lustre_handle fake_conn;
+
+ CDEBUG(D_IOCTL, "OBD device %d (%p) has exports, "
+ "disconnecting them", obd->obd_minor, obd);
+ list_for_each_safe(tmp, n, &obd->obd_exports) {
+ struct obd_export *exp = list_entry(tmp, struct obd_export,
+ exp_obd_chain);
+ fake_conn.addr = (__u64)(unsigned long)exp;
+ fake_conn.cookie = exp->exp_cookie;
+ rc = obd_disconnect(&fake_conn);
+ if (rc) {
+ CDEBUG(D_IOCTL, "disconnecting export %p failed: %d\n",
+ exp, rc);
+ } else {
+ CDEBUG(D_IOCTL, "export %p disconnected\n", exp);
+ }
+ }
+}
/* to control /dev/obd */
static int obd_class_ioctl (struct inode * inode, struct file * filp,
int rw = OBD_BRW_READ;
int err = 0;
int serialised = 0;
- int l_idx = 0;
+
ENTRY;
switch (cmd)
}
}
- err = copy_to_user((int *)arg, data, len);
+ err = copy_to_user((void *)arg, data, len);
GOTO(out, err);
}
CDEBUG(D_IOCTL, "device name %s, dev %d\n", data->ioc_inlbuf1,
dev);
- err = copy_to_user((int *)arg, data, sizeof(*data));
+ err = copy_to_user((void *)arg, data, sizeof(*data));
GOTO(out, err);
}
CDEBUG(D_IOCTL, "device name %s, dev %d\n", data->ioc_inlbuf1,
dev);
- err = copy_to_user((int *)arg, data, sizeof(*data));
+ err = copy_to_user((void *)arg, data, sizeof(*data));
GOTO(out, err);
}
if (dev == -1)
GOTO(out, err=-EINVAL);
- err = copy_to_user((int *)arg, data, sizeof(*data));
+ err = copy_to_user((void *)arg, data, sizeof(*data));
GOTO(out, err);
}
INIT_LIST_HEAD(&obd->obd_imports);
spin_lock_init(&obd->obd_dev_lock);
- /* do the attach */
- if (OBP(obd, attach))
- err = OBP(obd,attach)(obd, sizeof(*data), data);
- if (err) {
- obd->obd_type = NULL;
- } else {
- obd->obd_flags |= OBD_ATTACHED;
-
- type->typ_refcnt++;
- CDEBUG(D_IOCTL, "OBD: dev %d attached type %s\n",
- obd->obd_minor, data->ioc_inlbuf1);
if (data->ioc_inlbuf2) {
int len = strlen(data->ioc_inlbuf2) + 1;
OBD_ALLOC(obd->obd_name, len);
LBUG();
}
memcpy(obd->obd_name, data->ioc_inlbuf2, len);
- /* obd->obd_proc_entry =
- proc_lustre_register_obd_device(obd);
- */
} else {
CERROR("WARNING: unnamed obd device\n");
- obd->obd_proc_entry = NULL;
}
-
if (data->ioc_inlbuf3) {
int len = strlen(data->ioc_inlbuf3);
if (len >= sizeof(obd->obd_uuid)) {
}
memcpy(obd->obd_uuid, data->ioc_inlbuf3, len);
}
- /* Get the LprocFS namespace for this device class */
- /*
- l_idx = lprocfs_get_nm(data->ioc_inlbuf1, obd_nm);
- if (l_idx < 0) {
- CERROR("Non-existent device class"
- "or proc/lustre not compiled \n");
+ /* do the attach */
+ if (OBP(obd, attach))
+ err = OBP(obd,attach)(obd, sizeof(*data), data);
+ if (err) {
+ if(data->ioc_inlbuf2)
+ OBD_FREE(obd->obd_name, strlen(obd->obd_name)+1);
+ obd->obd_type = NULL;
+
} else {
- lprocfs_reg_dev(obd, obd_nm[l_idx].obd_names,
- obd_nm[l_idx].cntr_blk_sz);
- }
- */
+ obd->obd_flags |= OBD_ATTACHED;
+
+ type->typ_refcnt++;
+ CDEBUG(D_IOCTL, "OBD: dev %d attached type %s\n",
+ obd->obd_minor, data->ioc_inlbuf1);
+
+ CDEBUG(D_IOCTL, "MOD_INC_USE for attach: count = %d\n",
+ atomic_read(&(THIS_MODULE)->uc.usecount));
MOD_INC_USE_COUNT;
}
CERROR("OBD device %d not attached\n", obd->obd_minor);
GOTO(out, err=-ENODEV);
}
-#warning FIXME: Mike, we probably need some sort of "force detach" here
- if (!list_empty(&obd->obd_exports) ) {
- CERROR("OBD device %d (%p) has exports\n",
- obd->obd_minor, obd);
- GOTO(out, err=-EBUSY);
+ if (!list_empty(&obd->obd_exports)) {
+ if (!data->ioc_inlbuf1 || data->ioc_inlbuf1[0] != 'F') {
+ CERROR("OBD device %d (%p) has exports\n",
+ obd->obd_minor, obd);
+ GOTO(out, err=-EBUSY);
+ }
+ forcibly_detach_exports(obd);
}
+ if (OBP(obd, detach))
+ err=OBP(obd,detach)(obd);
- /*
- if (lprocfs_dereg_dev(obd) != LPROCFS_SUCCESS) {
- CERROR("Could not remove /proc entry\n");
- }
- */
if (obd->obd_name) {
OBD_FREE(obd->obd_name, strlen(obd->obd_name)+1);
obd->obd_name = NULL;
}
- /*
- if (obd->obd_proc_entry)
- proc_lustre_release_obd_device(obd);
- */
obd->obd_flags &= ~OBD_ATTACHED;
obd->obd_type->typ_refcnt--;
obd->obd_type = NULL;
+ CDEBUG(D_IOCTL, "MOD_DEC_USE for detach: count = %d\n",
+ atomic_read(&(THIS_MODULE)->uc.usecount) - 1);
MOD_DEC_USE_COUNT;
- GOTO(out, err=0);
+ GOTO(out, err = 0);
}
case OBD_IOC_SETUP: {
char * cluuid = "OBD_CLASS_UUID";
obd_data2conn(&conn, data);
- err = obd_connect(&conn, obd, cluuid);
+ err = obd_connect(&conn, obd, cluuid, NULL, NULL);
CDEBUG(D_IOCTL, "assigned export "LPX64"\n", conn.addr);
obd_conn2data(data, &conn);
if (err)
GOTO(out, err);
- err = copy_to_user((int *)arg, data, sizeof(*data));
+ err = copy_to_user((void *)arg, data, sizeof(*data));
+ // XXX save connection data into file handle
GOTO(out, err);
}
}
case OBD_IOC_DEC_USE_COUNT: {
+ CDEBUG(D_IOCTL, "MOD_DEC_USE for force dec: count = %d\n",
+ atomic_read(&(THIS_MODULE)->uc.usecount) - 1);
MOD_DEC_USE_COUNT;
GOTO(out, err=0);
}
case OBD_IOC_CREATE: {
- struct lov_stripe_md *ea = NULL;
+ struct lov_stripe_md *lsm = NULL;
obd_data2conn(&conn, data);
- err = obd_create(&conn, &data->ioc_obdo1, &ea);
- if (err)
- GOTO(out, err);
-
- err = copy_to_user((int *)arg, data, sizeof(*data));
+#warning FIXME: save lsm into file handle for other ops, release on close
+ err = obd_create(&conn, &data->ioc_obdo1, &lsm);
+ if (!err)
+ err = copy_to_user((void *)arg, data, sizeof(*data));
GOTO(out, err);
}
obd_data2conn(&conn, data);
err = obd_getattr(&conn, &data->ioc_obdo1, NULL);
- if (err)
- GOTO(out, err);
-
- err = copy_to_user((int *)arg, data, sizeof(*data));
+ if (!err)
+ err = copy_to_user((void *)arg, data, sizeof(*data));
GOTO(out, err);
}
case OBD_IOC_SETATTR: {
obd_data2conn(&conn, data);
err = obd_setattr(&conn, &data->ioc_obdo1, NULL);
- if (err)
- GOTO(out, err);
-
- err = copy_to_user((int *)arg, data, sizeof(*data));
+ if (!err)
+ err = copy_to_user((void *)arg, data, sizeof(*data));
GOTO(out, err);
}
obd_data2conn(&conn, data);
err = obd_destroy(&conn, &data->ioc_obdo1, NULL);
- if (err)
- GOTO(out, err);
-
- err = copy_to_user((int *)arg, data, sizeof(*data));
+ if (!err)
+ err = copy_to_user((void *)arg, data, sizeof(*data));
GOTO(out, err);
}
case OBD_IOC_OPEN: {
- struct lov_stripe_md *md; // XXX fill in md from create
+ struct lov_stripe_md *lsm = NULL; // XXX fill in from create
obd_data2conn(&conn, data);
- err = obd_open(&conn, &data->ioc_obdo1, NULL);
+ err = obd_open(&conn, &data->ioc_obdo1, lsm);
+ if (!err)
+ err = copy_to_user((void *)arg, data, sizeof(*data));
GOTO(out, err);
}
case OBD_IOC_CLOSE: {
- struct lov_stripe_md *md; // XXX fill in md from create
+ struct lov_stripe_md *lsm = NULL; // XXX fill in from create
obd_data2conn(&conn, data);
- obd_data2conn(&conn, data);
- err = obd_close(&conn, &data->ioc_obdo1, NULL);
+ err = obd_close(&conn, &data->ioc_obdo1, lsm);
GOTO(out, err);
}
case OBD_IOC_BRW_WRITE:
rw = OBD_BRW_WRITE;
case OBD_IOC_BRW_READ: {
- struct lov_stripe_md smd;
+ struct lov_stripe_md tmp_lsm; // XXX fill in from create
+ struct lov_stripe_md *lsm = &tmp_lsm; // XXX fill in from create
struct io_cb_data *cbd = ll_init_cb();
obd_count pages = 0;
struct brw_page *pga, *pgp;
GOTO(brw_free, err = -ENOMEM);
}
- memset(&smd, 0, sizeof(smd));
- smd.lmd_object_id = id;
+ memset(lsm, 0, sizeof(*lsm)); // XXX don't do this later
+ lsm->lsm_object_id = id; // ensure id == lsm->lsm_object_id
for (j = 0, pgp = pga; j < pages; j++, off += PAGE_SIZE, pgp++){
pgp->pg = alloc_pages(gfp_mask, 0);
}
}
- err = obd_brw(rw, &conn, &smd, j, pga, ll_sync_io_cb, cbd);
+ err = obd_brw(rw, &conn, lsm, j, pga, ll_sync_io_cb, cbd);
if (err)
CERROR("test_brw: error from obd_brw: err = %d\n", err);
EXIT;
if (err)
GOTO(out, err);
- err = copy_to_user((int *)arg, data, len);
+ err = copy_to_user((void *)arg, data, len);
GOTO(out, err);
}
};
void (*class_signal_connection_failure)(struct ptlrpc_connection *);
-int (*mds_destroy_export)(struct obd_export *exp);
-int (*ldlm_destroy_export)(struct obd_export *exp);
EXPORT_SYMBOL(obd_dev);
EXPORT_SYMBOL(obdo_cachep);
EXPORT_SYMBOL(obd_fail_loc);
EXPORT_SYMBOL(obd_timeout);
EXPORT_SYMBOL(obd_recovery_upcall);
+EXPORT_SYMBOL(ptlrpc_put_connection_superhack);
EXPORT_SYMBOL(class_register_type);
EXPORT_SYMBOL(class_unregister_type);
//EXPORT_SYMBOL(class_multi_cleanup);
EXPORT_SYMBOL(class_signal_connection_failure);
-EXPORT_SYMBOL(mds_destroy_export);
-EXPORT_SYMBOL(ldlm_destroy_export);
EXPORT_SYMBOL(ll_sync_io_cb);
EXPORT_SYMBOL(ll_init_cb);
+EXPORT_SYMBOL(class_nm_to_type);
static int __init init_obdclass(void)
{
obd->obd_minor = i;
err = obd_init_caches();
+
if (err)
return err;
obd_sysctl_init();
+
+ err=lprocfs_reg_main();
+
return 0;
}
static void __exit cleanup_obdclass(void)
{
- int i;
+ int i, err;
ENTRY;
misc_deregister(&obd_psdev);
obd_cleanup_caches();
obd_sysctl_clean();
+
+ err = lprocfs_dereg_main();
+
CERROR("obd memory leaked: %ld bytes\n", obd_memory);
EXIT;
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff