* mdc_add_obd() find that obd by uuid and connects to it.
* Local MDT uuid is used for connection
* */
-static int mdc_add_obd(struct mdc_device *mc, struct lustre_cfg *cfg)
+static int mdc_add_obd(const struct lu_context *ctx,
+ struct mdc_device *mc, struct lustre_cfg *cfg)
{
struct mdc_cli_desc *desc = &mc->mc_desc;
struct obd_device *mdc, *mdt;
CDEBUG(D_CONFIG, "connect to %s(%s)\n",
mdc->obd_name, mdc->obd_uuid.uuid);
- rc = obd_connect(conn, mdc, &mdt->obd_uuid, NULL);
+ rc = obd_connect(ctx, conn, mdc, &mdt->obd_uuid, NULL);
if (rc) {
CERROR("target %s connect error %d\n",
ENTRY;
switch (cfg->lcfg_command) {
case LCFG_ADD_MDC:
- rc = mdc_add_obd(mc, cfg);
+ rc = mdc_add_obd(ctx, mc, cfg);
break;
default:
rc = -EOPNOTSUPP;
/* ldlm/ldlm_lib.c */
int client_obd_setup(struct obd_device *obddev, struct lustre_cfg *lcfg);
int client_obd_cleanup(struct obd_device *obddev);
-int client_connect_import(struct lustre_handle *conn, struct obd_device *obd,
+int client_connect_import(const struct lu_context *ctx,
+ struct lustre_handle *conn, struct obd_device *obd,
struct obd_uuid *cluuid, struct obd_connect_data *);
int client_disconnect_export(struct obd_export *exp);
int client_import_add_conn(struct obd_import *imp, struct obd_uuid *uuid,
struct md_lov_info;
struct md_lov_ops {
- int (*ml_read_objids)(struct obd_device *obd, struct md_lov_info *mli,
+ int (*ml_read_objids)(struct obd_device *obd, struct md_lov_info *mli,
const void *ctxt);
int (*ml_write_objids)(struct obd_device *obd, struct md_lov_info *mli,
const void *ctxt);
int max_cookiesize;
int server_timeout;
struct semaphore init_sem;
-
+
struct lmv_tgt_desc *tgts;
int tgts_size;
#define LUSTRE_OPC_SYMLINK (1 << 1)
#define LUSTRE_OPC_MKNOD (1 << 2)
#define LUSTRE_OPC_CREATE (1 << 3)
-
+
struct lu_placement_hint {
struct qstr *ph_pname;
struct qstr *ph_cname;
struct fsfilt_operations *obd_fsops;
spinlock_t obd_osfs_lock;
struct obd_statfs obd_osfs; /* locked by obd_osfs_lock */
- cfs_time_t obd_osfs_age;
+ cfs_time_t obd_osfs_age;
struct lvfs_run_ctxt obd_lvfs_ctxt;
struct llog_ctxt *obd_llog_ctxt[LLOG_MAX_CTXTS];
struct obd_device *obd_observer;
unsigned int md_cntr_base;
struct lprocfs_stats *md_stats;
-
+
cfs_proc_dir_entry_t *obd_svc_procroot;
struct lprocfs_stats *obd_svc_stats;
};
#define KEY_INIT_RECOV "initial_recov"
#define KEY_INIT_RECOV_BACKUP "init_recov_bk"
+struct lu_context;
+
struct obd_ops {
struct module *o_owner;
int (*o_iocontrol)(unsigned int cmd, struct obd_export *exp, int len,
* data. @ocd->ocd_connect_flags is modified to reflect flags actually
* granted by the target, which are guaranteed to be a subset of flags
* asked for. If @ocd == NULL, use default parameters. */
- int (*o_connect)(struct lustre_handle *conn, struct obd_device *src,
+ int (*o_connect)(const struct lu_context *ctx,
+ struct lustre_handle *conn, struct obd_device *src,
struct obd_uuid *cluuid, struct obd_connect_data *ocd);
int (*o_reconnect)(struct obd_export *exp, struct obd_device *src,
struct obd_uuid *cluuid,
int (*o_fid_alloc)(struct obd_export *exp, struct lu_fid *fid,
struct lu_placement_hint *hint);
-
+
int (*o_fid_delete)(struct obd_export *exp, struct lu_fid *fid);
-
+
int (*o_statfs)(struct obd_device *obd, struct obd_statfs *osfs,
unsigned long max_age);
int (*o_packmd)(struct obd_export *exp, struct lov_mds_md **disk_tgt,
int, int, int, struct ptlrpc_request **);
int (*m_init_ea_size)(struct obd_export *, int, int, int);
-
+
int (*m_get_lustre_md)(struct obd_export *, struct ptlrpc_request *,
int, struct obd_export *, struct lustre_md *);
-
+
int (*m_free_lustre_md)(struct obd_export *, struct lustre_md *);
-
+
int (*m_set_open_replay_data)(struct obd_export *,
struct obd_client_handle *,
struct ptlrpc_request *);
int (*m_clear_open_replay_data)(struct obd_export *,
struct obd_client_handle *);
int (*m_set_lock_data)(struct obd_export *, __u64 *, void *);
-
+
int (*m_lock_match)(struct obd_export *, int, struct lu_fid *,
ldlm_type_t, ldlm_policy_data_t *, ldlm_mode_t,
struct lustre_handle *);
-
+
int (*m_cancel_unused)(struct obd_export *, struct lu_fid *,
int flags, void *opaque);
RETURN(rc);
}
-static inline int obd_connect(struct lustre_handle *conn,struct obd_device *obd,
+static inline int obd_connect(const struct lu_context *ctx,
+ struct lustre_handle *conn,struct obd_device *obd,
struct obd_uuid *cluuid,
struct obd_connect_data *d)
{
OBD_CHECK_DT_OP(obd, connect, -EOPNOTSUPP);
OBD_COUNTER_INCREMENT(obd, connect);
- rc = OBP(obd, connect)(conn, obd, cluuid, d);
+ rc = OBP(obd, connect)(ctx, conn, obd, cluuid, d);
/* check that only subset is granted */
LASSERT(ergo(d != NULL,
(d->ocd_connect_flags & ocf) == d->ocd_connect_flags));
Index: iam/fs/ext3/Makefile
===================================================================
--- iam.orig/fs/ext3/Makefile 2006-05-31 20:24:32.000000000 +0400
-+++ iam/fs/ext3/Makefile 2006-07-19 15:20:42.000000000 +0400
++++ iam/fs/ext3/Makefile 2006-07-19 16:58:55.000000000 +0400
@@ -6,7 +6,7 @@ obj-$(CONFIG_EXT3_FS) += ext3.o
ext3-y := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o iopen.o \
Index: iam/include/linux/lustre_iam.h
===================================================================
--- iam.orig/include/linux/lustre_iam.h 2006-05-31 20:24:32.000000000 +0400
-+++ iam/include/linux/lustre_iam.h 2006-07-19 15:20:42.000000000 +0400
++++ iam/include/linux/lustre_iam.h 2006-07-19 16:58:55.000000000 +0400
@@ -1,9 +1,68 @@
+/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
+ * vim:expandtab:shiftwidth=8:tabstop=8:
Index: iam/fs/ext3/Makefile
===================================================================
---- iam.orig/fs/ext3/Makefile 2006-07-19 15:20:42.000000000 +0400
-+++ iam/fs/ext3/Makefile 2006-07-19 15:20:43.000000000 +0400
+--- iam.orig/fs/ext3/Makefile 2006-07-19 16:58:55.000000000 +0400
++++ iam/fs/ext3/Makefile 2006-07-19 16:58:56.000000000 +0400
@@ -6,7 +6,7 @@ obj-$(CONFIG_EXT3_FS) += ext3.o
ext3-y := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o iopen.o \
ext3-$(CONFIG_EXT3_FS_POSIX_ACL) += acl.o
Index: iam/fs/ext3/dir.c
===================================================================
---- iam.orig/fs/ext3/dir.c 2006-07-19 15:20:42.000000000 +0400
-+++ iam/fs/ext3/dir.c 2006-07-19 15:20:43.000000000 +0400
+--- iam.orig/fs/ext3/dir.c 2006-07-19 16:58:55.000000000 +0400
++++ iam/fs/ext3/dir.c 2006-07-19 16:58:56.000000000 +0400
@@ -28,6 +28,7 @@
#include <linux/smp_lock.h>
#include <linux/slab.h>
(filp->f_version != inode->i_version)) {
Index: iam/fs/ext3/file.c
===================================================================
---- iam.orig/fs/ext3/file.c 2006-07-19 15:20:42.000000000 +0400
-+++ iam/fs/ext3/file.c 2006-07-19 15:20:43.000000000 +0400
+--- iam.orig/fs/ext3/file.c 2006-07-19 16:58:55.000000000 +0400
++++ iam/fs/ext3/file.c 2006-07-19 16:58:56.000000000 +0400
@@ -23,6 +23,7 @@
#include <linux/jbd.h>
#include <linux/ext3_fs.h>
Index: iam/fs/ext3/iam-uapi.c
===================================================================
--- iam.orig/fs/ext3/iam-uapi.c 2004-04-06 17:27:52.000000000 +0400
-+++ iam/fs/ext3/iam-uapi.c 2006-07-19 15:20:43.000000000 +0400
++++ iam/fs/ext3/iam-uapi.c 2006-07-19 16:58:56.000000000 +0400
@@ -0,0 +1,361 @@
+/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
+ * vim:expandtab:shiftwidth=8:tabstop=8:
+}
Index: iam/fs/ext3/ioctl.c
===================================================================
---- iam.orig/fs/ext3/ioctl.c 2006-07-19 15:20:42.000000000 +0400
-+++ iam/fs/ext3/ioctl.c 2006-07-19 15:20:43.000000000 +0400
+--- iam.orig/fs/ext3/ioctl.c 2006-07-19 16:58:55.000000000 +0400
++++ iam/fs/ext3/ioctl.c 2006-07-19 16:58:56.000000000 +0400
@@ -250,6 +250,6 @@ flags_err:
}
Index: iam/include/linux/lustre_iam.h
===================================================================
---- iam.orig/include/linux/lustre_iam.h 2006-07-19 15:20:42.000000000 +0400
-+++ iam/include/linux/lustre_iam.h 2006-07-19 15:20:43.000000000 +0400
+--- iam.orig/include/linux/lustre_iam.h 2006-07-19 16:58:55.000000000 +0400
++++ iam/include/linux/lustre_iam.h 2006-07-19 16:58:56.000000000 +0400
@@ -30,9 +30,6 @@
#ifndef __LINUX_LUSTRE_IAM_H__
#define __LINUX_LUSTRE_IAM_H__
}
/* ->o_connect() method for client side (OSC and MDC and MGC) */
-int client_connect_import(struct lustre_handle *dlm_handle,
+int client_connect_import(const struct lu_context *ctx,
+ struct lustre_handle *dlm_handle,
struct obd_device *obd, struct obd_uuid *cluuid,
struct obd_connect_data *data)
{
rc = -EBUSY;
} else {
dont_check_exports:
- rc = obd_connect(&conn, target, &cluuid, data);
+ rc = obd_connect(req->rq_svc_thread->t_ctx,
+ &conn, target, &cluuid, data);
}
} else {
rc = obd_reconnect(export, target, &cluuid, data);
spin_unlock_bh(&obd->obd_processing_task_lock);
return;
}
- cfs_timer_arm(&obd->obd_recovery_timer,
+ cfs_timer_arm(&obd->obd_recovery_timer,
cfs_time_shift(OBD_RECOVERY_TIMEOUT));
spin_unlock_bh(&obd->obd_processing_task_lock);
CDEBUG(D_HA, "%s: timer will expire in %u seconds\n", obd->obd_name,
strlen(KEY_INIT_RECOV), KEY_INIT_RECOV,
sizeof(allow_recov), &allow_recov, NULL);
- rc = obd_connect(&mdc_conn, obd, &mdc_uuid, ocd);
+ rc = obd_connect(NULL, &mdc_conn, obd, &mdc_uuid, ocd);
if (rc) {
CERROR("cannot connect to %s: rc = %d\n", mdsname, rc);
GOTO(out_cleanup, rc);
#endif
/* FIXME: fix this later */
.st_mode = 0,
-
+
.st_uid = geteuid(),
.st_gid = getegid(),
};
ealen = obd_size_diskmd(sbi->ll_dt_exp, NULL);
valid |= OBD_MD_FLEASIZE;
}
- rc = md_getattr(sbi->ll_md_exp, ll_inode2fid(inode),
+ rc = md_getattr(sbi->ll_md_exp, ll_inode2fid(inode),
valid, ealen, &req);
if (rc) {
CERROR("failure %d inode %llu\n", rc,
inode);
clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK, &(lli->lli_flags));
- md_change_cbdata(sbi->ll_md_exp, ll_inode2fid(inode),
+ md_change_cbdata(sbi->ll_md_exp, ll_inode2fid(inode),
null_if_equal, inode);
if (lli->lli_smd)
.ph_cname = qstr,
.ph_opc = LUSTRE_OPC_MKDIR
};
-
+
int err = -EMLINK;
ENTRY;
struct ldlm_res_id res_id =
{ .name = {fid_seq(&lli->lli_fid),
fid_oid(&lli->lli_fid),
- fid_ver(&lli->lli_fid),
+ fid_ver(&lli->lli_fid),
LDLM_FLOCK} };
struct lustre_handle lockh = {0};
ldlm_policy_data_t flock;
ocd.ocd_version = LUSTRE_VERSION_CODE;
/* setup mdc */
- err = obd_connect(&mdc_conn, obd, &sbi->ll_sb_uuid, &ocd);
+ err = obd_connect(NULL, &mdc_conn, obd, &sbi->ll_sb_uuid, &ocd);
if (err) {
CERROR("cannot connect to %s: rc = %d\n", mdc, err);
GOTO(out_free, err);
ocd.ocd_connect_flags = OBD_CONNECT_SRVLOCK|OBD_CONNECT_REQPORTAL|
OBD_CONNECT_VERSION|OBD_CONNECT_TRUNCLOCK;
ocd.ocd_version = LUSTRE_VERSION_CODE;
- err = obd_connect(&osc_conn, obd, &sbi->ll_sb_uuid, &ocd);
+ err = obd_connect(NULL, &osc_conn, obd, &sbi->ll_sb_uuid, &ocd);
if (err) {
CERROR("cannot connect to %s: rc = %d\n", osc, err);
GOTO(out_mdc, err);
sbi->ll_async_page_max = (num_physpages / 4) * 3;
sbi->ll_ra_info.ra_max_pages = min(num_physpages / 8,
SBI_DEFAULT_READAHEAD_MAX);
- sbi->ll_ra_info.ra_max_read_ahead_whole_pages =
+ sbi->ll_ra_info.ra_max_read_ahead_whole_pages =
SBI_DEFAULT_READAHEAD_WHOLE_MAX;
INIT_LIST_HEAD(&sbi->ll_conn_chain);
/* real client */
data->ocd_connect_flags |= OBD_CONNECT_REAL;
- err = obd_connect(&md_conn, obd, &sbi->ll_sb_uuid, data);
+ err = obd_connect(NULL, &md_conn, obd, &sbi->ll_sb_uuid, data);
if (err == -EBUSY) {
CERROR("An MDT (mdc %s) is performing recovery, of which this"
" client is not a part. Please wait for recovery to "
CERROR("can't init FIDs framework, rc %d\n", err);
GOTO(out_mdc, err);
}
-
+
obd = class_name2obd(osc);
if (!obd) {
CERROR("OSC %s: not setup or attached\n", osc);
obd->obd_upcall.onu_owner = &sbi->ll_lco;
obd->obd_upcall.onu_upcall = ll_ocd_update;
- err = obd_connect(&osc_conn, obd, &sbi->ll_sb_uuid, data);
+ err = obd_connect(NULL, &osc_conn, obd, &sbi->ll_sb_uuid, data);
if (err == -EBUSY) {
CERROR("An OST (osc %s) is performing recovery, of which this"
" client is not a part. Please wait for recovery to "
CERROR("can't init FIDs framework, rc %d\n", err);
GOTO(out_osc, err);
}
-
+
err = md_getstatus(sbi->ll_md_exp, &rootfid);
if (err) {
CERROR("cannot mds_connect: rc = %d\n", err);
/* We need to set force before the lov_disconnect in
lustre_common_put_super, since l_d cleans up osc's as well. */
next = 0;
- while ((obd = class_devices_in_group(&sbi->ll_sb_uuid, &next))
+ while ((obd = class_devices_in_group(&sbi->ll_sb_uuid, &next))
!= NULL) {
obd->obd_force = force;
}
}
client_common_put_super(sb);
-
+
next = 0;
while ((obd = class_devices_in_group(&sbi->ll_sb_uuid, &next)) !=NULL) {
class_manual_cleanup(obd);
CDEBUG(D_INODE, "set mtime on OST inode %lu to %lu\n",
inode->i_ino, LTIME_S(attr->ia_mtime));
-
+
oa.o_id = lsm->lsm_object_id;
oa.o_valid = OBD_MD_FLID;
flags = OBD_MD_FLTYPE | OBD_MD_FLATIME |
OBD_MD_FLMTIME | OBD_MD_FLCTIME |
OBD_MD_FLFID | OBD_MD_FLGENER;
-
+
obdo_from_inode(&oa, inode, flags);
rc = obd_setattr(sbi->ll_dt_exp, &oa, lsm, NULL);
if (rc)
static void ll_replace_lsm(struct inode *inode, struct lov_stripe_md *lsm)
{
struct ll_inode_info *lli = ll_i2info(inode);
-
+
dump_lsm(D_INODE, lsm);
- dump_lsm(D_INODE, lli->lli_smd);
- LASSERTF(lsm->lsm_magic == LOV_MAGIC_JOIN,
+ dump_lsm(D_INODE, lli->lli_smd);
+ LASSERTF(lsm->lsm_magic == LOV_MAGIC_JOIN,
"lsm must be joined lsm %p\n", lsm);
obd_free_memmd(ll_i2dtexp(inode), &lli->lli_smd);
CDEBUG(D_INODE, "replace lsm %p to lli_smd %p for inode %lu%u(%p)\n",
LASSERT ((lsm != NULL) == ((body->valid & OBD_MD_FLEASIZE) != 0));
if (lsm != NULL) {
if (lli->lli_smd == NULL) {
- if (lsm->lsm_magic != LOV_MAGIC &&
+ if (lsm->lsm_magic != LOV_MAGIC &&
lsm->lsm_magic != LOV_MAGIC_JOIN) {
dump_lsm(D_ERROR, lsm);
LBUG();
lli->lli_maxbytes = PAGE_CACHE_MAXBYTES;
} else {
if (lli->lli_smd->lsm_magic == lsm->lsm_magic &&
- lli->lli_smd->lsm_stripe_count ==
+ lli->lli_smd->lsm_stripe_count ==
lsm->lsm_stripe_count) {
if (lov_stripe_md_cmp(lli->lli_smd, lsm)) {
CERROR("lsm mismatch for inode %ld\n",
dump_lsm(D_ERROR, lsm);
LBUG();
}
- } else
+ } else
ll_replace_lsm(inode, lsm);
}
/* bug 2844 - limit i_blksize for broken user-space apps */
if (body->valid & OBD_MD_FLID)
lli->lli_fid = body->fid1;
-
+
LASSERT(fid_seq(&lli->lli_fid) != 0);
}
if (rc) {
CERROR("fid_delete() failed, rc %d\n", rc);
}
-
+
EXIT;
}
struct ll_sb_info *sbi = ll_s2sbi(sb);
int err;
__u32 read_only;
-
+
if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY)) {
read_only = *flags & MS_RDONLY;
err = obd_set_info_async(sbi->ll_md_exp, strlen("read-only"),
- "read-only", sizeof(read_only),
+ "read-only", sizeof(read_only),
&read_only, NULL);
if (err) {
CERROR("Failed to change the read-only flag during "
"remount: %d\n", err);
return err;
}
-
+
if (read_only)
sb->s_flags |= MS_RDONLY;
else
* client generated for creating some inode. So using ->fid1 is
* okay here. */
LASSERT(fid_is_sane(&md.body->fid1));
-
+
*inode = ll_iget(sb, ll_fid_build_ino(sbi, &md.body->fid1), &md);
if (*inode == NULL || is_bad_inode(*inode)) {
md_free_lustre_md(sbi->ll_dt_exp, &md);
/* this is fake connect function. Its purpose is to initialize lmv and say
* caller that everything is okay. Real connection will be performed later. */
-static int lmv_connect(struct lustre_handle *conn, struct obd_device *obd,
+static int lmv_connect(const struct lu_context *ctx,
+ struct lustre_handle *conn, struct obd_device *obd,
struct obd_uuid *cluuid, struct obd_connect_data *data)
{
#ifdef __KERNEL__
RETURN(-EINVAL);
}
- rc = obd_connect(&conn, mdc_obd, &lmv_mdc_uuid, &lmv->conn_data);
+ rc = obd_connect(NULL, &conn, mdc_obd, &lmv_mdc_uuid, &lmv->conn_data);
if (rc) {
CERROR("target %s connect error %d\n", tgt->uuid.uuid, rc);
RETURN(rc);
RETURN(0);
}
- rc = obd_connect(&conn, tgt_obd, &lov_osc_uuid, data);
+ rc = obd_connect(NULL, &conn, tgt_obd, &lov_osc_uuid, data);
if (rc) {
CERROR("Target %s connect error %d\n",
obd_uuid2str(tgt_uuid), rc);
RETURN(0);
}
-static int lov_connect(struct lustre_handle *conn, struct obd_device *obd,
+static int lov_connect(const struct lu_context *ctx,
+ struct lustre_handle *conn, struct obd_device *obd,
struct obd_uuid *cluuid, struct obd_connect_data *data)
{
struct lov_obd *lov = &obd->u.lov;
* about that client, like open files, the last operation number it did
* on the server, etc.
*/
-static int mds_connect(struct lustre_handle *conn, struct obd_device *obd,
+static int mds_connect(const struct lu_context *ctx,
+ struct lustre_handle *conn, struct obd_device *obd,
struct obd_uuid *cluuid, struct obd_connect_data *data)
{
struct obd_export *exp;
void mds_lov_update_objids(struct obd_device *obd, obd_id *ids)
{
struct mds_obd *mds = &obd->u.mds;
-
+
md_lov_info_update_objids(&mds->mds_lov_info, ids);
}
-static int mds_lov_read_objids(struct obd_device *obd, struct md_lov_info *mli,
+static int mds_lov_read_objids(struct obd_device *obd, struct md_lov_info *mli,
const void *ctxt)
{
struct file *filp = (struct file *)mli->md_lov_objid_obj;
LASSERT(!mli->md_lov_objids_size);
LASSERT(!mli->md_lov_objids_dirty);
- /* Read everything in the file, even if our current lov desc
- has fewer targets. Old targets not in the lov descriptor
+ /* Read everything in the file, even if our current lov desc
+ has fewer targets. Old targets not in the lov descriptor
during mds setup may still have valid objids. */
size = filp->f_dentry->d_inode->i_size;
if (size == 0)
CERROR("Error reading objids %d\n", rc);
RETURN(rc);
}
-
- mli->md_lov_objids_in_file = size / sizeof(*ids);
-
+
+ mli->md_lov_objids_in_file = size / sizeof(*ids);
+
for (i = 0; i < mli->md_lov_objids_in_file; i++) {
CDEBUG(D_INFO, "read last object "LPU64" for idx %d\n",
mli->md_lov_objids[i], i);
RETURN(0);
}
-int mds_lov_write_objids(struct obd_device *obd, struct md_lov_info *mli,
+int mds_lov_write_objids(struct obd_device *obd, struct md_lov_info *mli,
const void *ctxt)
{
struct file *filp = (struct file *)mli->md_lov_objid_obj;
loff_t off = 0;
- int i, rc, tgts;
+ int i, rc, tgts;
ENTRY;
if (!mli->md_lov_objids_dirty)
CDEBUG(D_INFO, "writing last object "LPU64" for idx %d\n",
mli->md_lov_objids[i], i);
- rc = fsfilt_write_record(obd, filp, mli->md_lov_objids,
+ rc = fsfilt_write_record(obd, filp, mli->md_lov_objids,
tgts * sizeof(obd_id),
&off, 0);
if (rc >= 0) {
}
/* update the LOV-OSC knowledge of the last used object id's */
-static int md_lov_info_set_nextid(struct obd_device *obd,
+static int md_lov_info_set_nextid(struct obd_device *obd,
struct md_lov_info *mli)
{
int rc;
int md_lov_info_update_desc(struct md_lov_info *mli, struct obd_export *lov)
{
- struct lov_desc *ld;
+ struct lov_desc *ld;
__u32 size, stripes, valsize = sizeof(mli->md_lov_desc);
int rc = 0;
ENTRY;
/* The size of the LOV target table may have increased. */
size = ld->ld_tgt_count * sizeof(obd_id);
- if ((mli->md_lov_objids_size == 0) ||
+ if ((mli->md_lov_objids_size == 0) ||
(size > mli->md_lov_objids_size)) {
obd_id *ids;
-
+
/* add room by powers of 2 */
size = 1;
- while (size < ld->ld_tgt_count)
+ while (size < ld->ld_tgt_count)
size = size << 1;
size = size * sizeof(obd_id);
memset(ids, 0, size);
if (mli->md_lov_objids_size) {
obd_id *old_ids = mli->md_lov_objids;
- memcpy(ids, mli->md_lov_objids,
+ memcpy(ids, mli->md_lov_objids,
mli->md_lov_objids_size);
mli->md_lov_objids = ids;
OBD_FREE(old_ids, mli->md_lov_objids_size);
CDEBUG(D_CONFIG, "updated lov_desc, tgt_count: %d\n",
mli->md_lov_desc.ld_tgt_count);
- stripes = min((__u32)LOV_MAX_STRIPE_COUNT,
+ stripes = min((__u32)LOV_MAX_STRIPE_COUNT,
max(mli->md_lov_desc.ld_tgt_count,
mli->md_lov_objids_in_file));
/* Inform MDS about new/updated target */
static int mds_lov_update_mds(struct obd_device *obd,
struct md_lov_info *mli,
- struct obd_device *watched,
+ struct obd_device *watched,
__u32 idx, const void *ctxt)
{
int old_count;
/* idx is set as data from lov_notify. */
if (idx != MDSLOV_NO_INDEX && !obd->obd_recovering) {
if (idx >= mli->md_lov_desc.ld_tgt_count) {
- CERROR("index %d > count %d!\n", idx,
+ CERROR("index %d > count %d!\n", idx,
mli->md_lov_desc.ld_tgt_count);
RETURN(-EINVAL);
}
-
+
if (idx >= mli->md_lov_objids_in_file) {
/* We never read this lastid; ask the osc */
obd_id lastid;
__u32 size = sizeof(lastid);
rc = obd_get_info(watched->obd_self_export,
- strlen("last_id"),
+ strlen("last_id"),
"last_id", &size, &lastid);
if (rc)
RETURN(rc);
mli->md_lov_ops->ml_write_objids(obd, mli, ctxt);
} else {
/* We have read this lastid from disk; tell the osc.
- Don't call this during recovery. */
+ Don't call this during recovery. */
rc = md_lov_info_set_nextid(obd, mli);
}
-
+
CDEBUG(D_CONFIG, "last object "LPU64" from OST %d\n",
mli->md_lov_objids[idx], idx);
}
}
int md_lov_connect(struct obd_device *obd, struct md_lov_info *mli,
- char *lov_name, struct obd_uuid *uuid,
+ char *lov_name, struct obd_uuid *uuid,
struct md_lov_ops *mlo, const void *ctxt)
{
struct lustre_handle conn = {0,};
RETURN(-ENOTCONN);
}
- mli->md_lov_ops = mlo;
+ mli->md_lov_ops = mlo;
OBD_ALLOC(data, sizeof(*data));
if (data == NULL)
data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_INDEX |
OBD_CONNECT_REQPORTAL;
data->ocd_version = LUSTRE_VERSION_CODE;
-
+
/* NB: lov_connect() needs to fill in .ocd_index for each OST */
- rc = obd_connect(&conn, mli->md_lov_obd, uuid, data);
+ rc = obd_connect(NULL, &conn, mli->md_lov_obd, uuid, data);
OBD_FREE(data, sizeof(*data));
if (rc) {
CERROR("MDS cannot connect to LOV %s (%d)\n", lov_name, rc);
}
CDEBUG(D_INFO, "regist observer %s to lov %s \n",
obd->obd_name, mli->md_lov_obd->obd_name);
-
+
rc = mli->md_lov_ops->ml_read_objids(obd, mli, ctxt);
if (rc) {
CERROR("cannot read %s: rc = %d\n", "lov_objids", rc);
}
EXPORT_SYMBOL(md_lov_connect);
-int md_lov_update_objids(struct obd_device *obd, struct md_lov_info *mli,
+int md_lov_update_objids(struct obd_device *obd, struct md_lov_info *mli,
const void *ctxt)
{
int rc = 0, i;
int rc;
ENTRY;
- rc = md_lov_connect(obd, mli, lov_name, &obd->obd_uuid, &mli_ops,
+ rc = md_lov_connect(obd, mli, lov_name, &obd->obd_uuid, &mli_ops,
NULL);
if (rc)
GOTO(err_reg, rc);
/* If we're mounting this code for the first time on an existing FS,
* we need to populate the objids array from the real OST values */
rc = md_lov_update_objids(obd, mli, NULL);
-
+
/* I want to see a callback happen when the OBD moves to a
* "For General Use" state, and that's when we'll call
* set_nextid(). The class driver can help us here, because
struct mds_lov_sync_info {
struct obd_device *mlsi_obd; /* the lov device to sync */
- struct md_lov_info *mlsi_mli;
+ struct md_lov_info *mlsi_mli;
struct obd_device *mlsi_watched; /* target osc */
__u32 mlsi_index; /* index of target */
const void *mlsi_ctxt;
/* We only sync one osc at a time, so that we don't have to hold
- any kind of lock on the whole mds_lov_desc, which may change
+ any kind of lock on the whole mds_lov_desc, which may change
(grow) as a result of mds_lov_add_ost. This also avoids any
- kind of mismatch between the lov_desc and the mds_lov_desc,
+ kind of mismatch between the lov_desc and the mds_lov_desc,
which are not in lock-step during lov_add_obd */
static int __mds_lov_synchronize(void *data)
{
rc = mds_lov_update_mds(obd, mli, watched, idx, ctxt);
if (rc != 0)
GOTO(out, rc);
-
+
rc = obd_set_info_async(mli->md_lov_exp, strlen(KEY_MDS_CONN),
KEY_MDS_CONN, 0, uuid, NULL);
if (rc != 0)
rc = llog_connect(llog_get_context(obd, LLOG_MDS_OST_ORIG_CTXT),
mds->mds_lov_desc.ld_tgt_count,
NULL, NULL, uuid);
-
+
if (rc != 0) {
CERROR("%s: failed at llog_origin_connect: %d\n",
obd->obd_name, rc);
mlsi->mlsi_watched = watched;
mlsi->mlsi_mli = mli;
mlsi->mlsi_ctxt = ctxt;
- if (data)
+ if (data)
mlsi->mlsi_index = *(__u32 *)data;
else
mlsi->mlsi_index = MDSLOV_NO_INDEX;
}
EXPORT_SYMBOL(md_lov_start_synchronize);
-int mds_lov_start_synchronize(struct obd_device *obd,
+int mds_lov_start_synchronize(struct obd_device *obd,
struct obd_device *watched,
void *data, int nonblock)
{
if (obd->obd_recovering) {
CWARN("MDS %s: in recovery, not resetting orphans on %s\n",
- obd->obd_name,
+ obd->obd_name,
obd_uuid2str(&watched->u.cli.cl_target_uuid));
- /* We still have to fix the lov descriptor for ost's added
+ /* We still have to fix the lov descriptor for ost's added
after the mdt in the config log. They didn't make it into
mds_lov_connect. */
rc = md_lov_info_update_desc(mli, mli->md_lov_exp);
}
LASSERT(llog_get_context(obd, LLOG_MDS_OST_ORIG_CTXT) != NULL);
- rc = mds_lov_start_synchronize(obd, watched, data,
+ rc = mds_lov_start_synchronize(obd, watched, data,
!(ev == OBD_NOTIFY_SYNC));
lquota_recovery(quota_interface, obd);
int rc, err;
ENTRY;
- if (le32_to_cpu(lmm->lmm_magic) == LOV_MAGIC ||
+ if (le32_to_cpu(lmm->lmm_magic) == LOV_MAGIC ||
le32_to_cpu(lmm->lmm_magic == LOV_MAGIC_JOIN))
RETURN(0);
CDEBUG(D_INODE, "converting LOV EA on %lu/%u from %#08x to %#08x\n",
inode->i_ino, inode->i_generation, le32_to_cpu(lmm->lmm_magic),
LOV_MAGIC);
-
+
rc = obd_unpackmd(obd->u.mds.mds_osc_exp, &lsm, lmm, lmm_size);
if (rc < 0)
GOTO(conv_end, rc);
last_transno = le64_to_cpu(mcd->mcd_last_transno);
- /* These exports are cleaned up by mdt_obd_disconnect(), so they
- * need to be set up like real exports as mdt_obd_connect() does.
+ /* These exports are cleaned up by mdt_obd_disconnect(), so
+ * they need to be set up like real exports as
+ * mdt_obd_connect() does.
*/
CDEBUG(D_HA, "RCVRNG CLIENT uuid: %s idx: %d lr: "LPU64
" srv lr: "LPU64" lx: "LPU64"\n", mcd->mcd_uuid, cl_idx,
/*
* struct mdt_body is passed in the incoming message, and object
* identified by this fid exists on disk.
+ *
+ * "habeo corpus" == "I have a body"
*/
HABEO_CORPUS = (1 << 0),
/*
* struct ldlm_request is passed in the incoming message.
+ *
+ * "habeo clavis" == "I have a key"
*/
HABEO_CLAVIS = (1 << 1),
/*
* this request has fixed reply format, so that reply message can be
* packed by generic code.
+ *
+ * "habeo refero" == "I have a reply"
*/
HABEO_REFERO = (1 << 2),
/*
* this request will modify something, so check whether the filesystem
* is readonly or not, then return -EROFS to client asap if necessary.
+ *
+ * "mutabor" == "I shall modify"
*/
- HABEO_MUTABOR = (1 << 3)
+ MUTABOR = (1 << 3)
};
struct mdt_opc_slice {
}
- if (result == 0 && flags & HABEO_MUTABOR) {
- if (req->rq_export->exp_connect_flags & OBD_CONNECT_RDONLY)
- result = -EROFS;
- }
+ if (result == 0 && flags & MUTABOR &&
+ req->rq_export->exp_connect_flags & OBD_CONNECT_RDONLY)
+ result = -EROFS;
+
if (result == 0 && flags & HABEO_CLAVIS) {
struct ldlm_request *dlm_req;
},
[MDT_IT_OCREAT] = {
.it_fmt = &RQF_LDLM_INTENT,
- .it_flags = HABEO_MUTABOR,
+ .it_flags = MUTABOR,
.it_act = mdt_intent_reint,
.it_reint = REINT_OPEN
},
[MDT_IT_CREATE] = {
.it_fmt = &RQF_LDLM_INTENT,
- .it_flags = HABEO_MUTABOR,
+ .it_flags = MUTABOR,
.it_act = mdt_intent_reint,
.it_reint = REINT_CREATE
},
},
[MDT_IT_UNLINK] = {
.it_fmt = &RQF_LDLM_INTENT_UNLINK,
- .it_flags = HABEO_MUTABOR,
+ .it_flags = MUTABOR,
.it_act = NULL, /* XXX can be mdt_intent_reint, ? */
.it_reint = REINT_UNLINK
},
[MDT_IT_TRUNC] = {
.it_fmt = NULL,
- .it_flags = HABEO_MUTABOR,
+ .it_flags = MUTABOR,
.it_act = NULL
},
[MDT_IT_GETXATTR] = {
rc = mdt_unpack_req_pack_rep(info, flv->it_flags);
if (rc == 0) {
struct ptlrpc_request *req = mdt_info_req(info);
- if (flv->it_flags & HABEO_MUTABOR &&
+ if (flv->it_flags & MUTABOR &&
req->rq_export->exp_connect_flags & OBD_CONNECT_RDONLY)
rc = -EROFS;
}
CDEBUG(D_CONFIG, "connect to controller %s(%s)\n",
mdc->obd_name, mdc->obd_uuid.uuid);
- rc = obd_connect(&conn, mdc, &mdc->obd_uuid, NULL);
+ rc = obd_connect(ctx, &conn, mdc, &mdc->obd_uuid, NULL);
if (rc) {
CERROR("target %s connect error %d\n",
}
/* mds_connect copy */
-static int mdt_obd_connect(struct lustre_handle *conn, struct obd_device *obd,
+static int mdt_obd_connect(const struct lu_context *ctx,
+ struct lustre_handle *conn, struct obd_device *obd,
struct obd_uuid *cluuid,
struct obd_connect_data *data)
{
struct mdt_device *mdt;
struct mdt_export_data *med;
struct mdt_client_data *mcd;
- struct lu_context ctxt;
int rc;
ENTRY;
+ LASSERT(ctx != NULL);
if (!conn || !obd || !cluuid)
RETURN(-EINVAL);
if (mcd != NULL) {
memcpy(mcd->mcd_uuid, cluuid, sizeof mcd->mcd_uuid);
med->med_mcd = mcd;
- rc = lu_context_init(&ctxt, LCT_MD_THREAD);
- if (rc == 0) {
- lu_context_enter(&ctxt);
- /*
- * rc = mdt_client_add(&ctxt, mdt, med, -1);
- */
- lu_context_exit(&ctxt);
- lu_context_fini(&ctxt);
- }
+ /*
+ * rc = mdt_client_add(ctx, mdt, med, -1);
+ */
if (rc != 0)
OBD_FREE_PTR(mcd);
} else
DEF_MDT_HNDL_F(0 |HABEO_REFERO, GETSTATUS, mdt_getstatus),
DEF_MDT_HNDL_F(HABEO_CORPUS, GETATTR, mdt_getattr),
DEF_MDT_HNDL_F(HABEO_CORPUS, GETATTR_NAME, mdt_getattr_name),
-DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO|HABEO_MUTABOR,
+DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO|MUTABOR,
SETXATTR, mdt_setxattr),
DEF_MDT_HNDL_F(HABEO_CORPUS, GETXATTR, mdt_getxattr),
DEF_MDT_HNDL_F(0 |HABEO_REFERO, STATFS, mdt_statfs),
DEF_MDT_HNDL_F(HABEO_CORPUS, READPAGE, mdt_readpage),
-DEF_MDT_HNDL_F(0 |HABEO_MUTABOR,
+DEF_MDT_HNDL_F(0 |MUTABOR,
REINT, mdt_reint),
DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO, CLOSE, mdt_close),
DEF_MDT_HNDL_0(0, DONE_WRITING, mdt_done_writing),
* or should be placed somewhere else. */
int mdt_max_mdsize;
int mdt_max_cookiesize;
- __u64 mdt_mount_count;
-
+ __u64 mdt_mount_count;
+
struct mdt_server_data mdt_msd;
unsigned long mdt_client_bitmap[(LR_MAX_CLIENTS >> 3) / sizeof(long)];
};
return info->mti_pill.rc_req;
}
-static inline void mdt_object_get(const struct lu_context *ctxt,
+static inline void mdt_object_get(const struct lu_context *ctxt,
struct mdt_object *o)
{
lu_object_get(&o->mot_obj.mo_lu);
}
-static inline void mdt_object_put(const struct lu_context *ctxt,
+static inline void mdt_object_put(const struct lu_context *ctxt,
struct mdt_object *o)
{
lu_object_put(ctxt, &o->mot_obj.mo_lu);
int mdt_object_lock(struct mdt_thread_info *,
struct mdt_object *,
- struct mdt_lock_handle *,
+ struct mdt_lock_handle *,
__u64);
-void mdt_object_unlock(struct mdt_thread_info *,
+void mdt_object_unlock(struct mdt_thread_info *,
struct mdt_object *,
struct mdt_lock_handle *);
struct mdt_object *mdt_object_find(const struct lu_context *,
- struct mdt_device *,
+ struct mdt_device *,
const struct lu_fid *);
struct mdt_object *mdt_object_find_lock(struct mdt_thread_info *,
const struct lu_fid *,
struct mdt_lock_handle *,
__u64);
-void mdt_object_unlock_put(struct mdt_thread_info *,
+void mdt_object_unlock_put(struct mdt_thread_info *,
struct mdt_object *,
struct mdt_lock_handle *);
int mdt_reint_unpack(struct mdt_thread_info *info, __u32 op);
int mdt_reint_rec(struct mdt_thread_info *);
-void mdt_pack_attr2body(struct mdt_body *b, struct lu_attr *attr,
+void mdt_pack_attr2body(struct mdt_body *b, struct lu_attr *attr,
const struct lu_fid *fid);
int mdt_getxattr(struct mdt_thread_info *info);
int mdt_pin(struct mdt_thread_info* info);
-int mdt_lock_new_child(struct mdt_thread_info *info,
+int mdt_lock_new_child(struct mdt_thread_info *info,
struct mdt_object *o,
struct mdt_lock_handle *child_lockh);
/* Establish a connection to the MGS.*/
-static int mgs_connect(struct lustre_handle *conn, struct obd_device *obd,
+static int mgs_connect(const struct lu_context *ctx,
+ struct lustre_handle *conn, struct obd_device *obd,
struct obd_uuid *cluuid, struct obd_connect_data *data)
{
struct obd_export *exp;
RETURN(-ENOENT);
}
- rc = obd_connect(&exph, mdc_obd, &uuid, NULL /* obd_connect_data */);
+ rc = obd_connect(NULL,
+ &exph, mdc_obd, &uuid, NULL /* obd_connect_data */);
if (rc) {
CERROR("6: failed to connect to MDC: %s\n", mdc_obd->obd_name);
RETURN(rc);
int result;
int i;
+ LASSERT(key->lct_init != NULL);
+ LASSERT(key->lct_fini != NULL);
+ LASSERT(key->lct_tags != 0);
+
result = -ENFILE;
spin_lock(&lu_keys_guard);
for (i = 0; i < ARRAY_SIZE(lu_keys); ++i) {
#include <lustre_fsfilt.h>
#include <obd_class.h>
#include <lustre/lustre_user.h>
-#include <linux/version.h>
+#include <linux/version.h>
#include <lustre_log.h>
#include <lustre_disk.h>
#include <lustre_param.h>
#include <lustre_ver.h>
-
+
static int (*client_fill_super)(struct super_block *sb) = NULL;
/*********** string parsing utils *********/
list_for_each(tmp, &server_mount_info_list) {
lmi = list_entry(tmp, struct lustre_mount_info, lmi_list_chain);
- if (strcmp(name, lmi->lmi_name) == 0)
+ if (strcmp(name, lmi->lmi_name) == 0)
RETURN(lmi);
}
RETURN(NULL);
/* Deregister anyone referencing the mnt. Everyone should have
put_mount in *_cleanup, but this is a catch-all in case of err... */
/* FIXME this should be removed from lustre_free_lsi, which may be called
- from server_put_mount _before_ it gets to server_deregister_mount.
+ from server_put_mount _before_ it gets to server_deregister_mount.
Leave it here for now for the error message it shows... */
static void server_deregister_mount_all(struct vfsmount *mnt)
{
lsi = s2lsi(lmi->lmi_sb);
mntget(lmi->lmi_mnt);
atomic_inc(&lsi->lsi_mounts);
-
- CDEBUG(D_MOUNT, "get_mnt %p from %s, refs=%d, vfscount=%d\n",
+
+ CDEBUG(D_MOUNT, "get_mnt %p from %s, refs=%d, vfscount=%d\n",
lmi->lmi_mnt, name, atomic_read(&lsi->lsi_mounts),
atomic_read(&lmi->lmi_mnt->mnt_count));
or not? If there's truly one MGS per site, the MGS uuids
_should_ all be the same. Maybe check here?
*/
-
+
/* If we are restarting the MGS, don't try to keep the MGC's
old connection, or registration will fail. */
if ((lsi->lsi_flags & LSI_SERVER) && IS_MGS(lsi->lsi_ldd)) {
recov_bk = 1;
}
- /* Try all connections, but only once (again).
+ /* Try all connections, but only once (again).
We don't want to block another target from starting
(using its local copy of the log), but we do want to connect
if at all possible. */
/* Try all connections, but only once. */
recov_bk = 1;
rc = obd_set_info_async(obd->obd_self_export,
- strlen(KEY_INIT_RECOV_BACKUP),
+ strlen(KEY_INIT_RECOV_BACKUP),
KEY_INIT_RECOV_BACKUP,
sizeof(recov_bk), &recov_bk, NULL);
- if (rc)
+ if (rc)
/* nonfatal */
CERROR("can't set %s %d\n", KEY_INIT_RECOV_BACKUP, rc);
//ocd.ocd_connect_flags = OBD_CONNECT_ACL;
/* We connect to the MGS at setup, and don't disconnect until cleanup */
- rc = obd_connect(&mgc_conn, obd, &(obd->obd_uuid), &ocd);
+ rc = obd_connect(NULL, &mgc_conn, obd, &(obd->obd_uuid), &ocd);
if (rc) {
CERROR("connect failed %d\n", rc);
GOTO(out, rc);
ENTRY;
CDEBUG(D_MOUNT, "Unassign mgc disk\n");
-
+
rc = obd_set_info_async(mgc->obd_self_export,
strlen("clear_fs"), "clear_fs",
0, NULL, NULL);
char *label;
int err;
CDEBUG(D_MOUNT, "Changing on-disk index from %#x to %#x "
- "for %s\n", ldd->ldd_svindex, mti->mti_stripe_index,
+ "for %s\n", ldd->ldd_svindex, mti->mti_stripe_index,
mti->mti_svname);
ldd->ldd_svindex = mti->mti_stripe_index;
strncpy(ldd->ldd_svname, mti->mti_svname,
if (err)
CERROR("Label set error %d\n", err);
label = fsfilt_get_label(mgc, lsi->lsi_srv_mnt->mnt_sb);
- if (label)
+ if (label)
CDEBUG(D_MOUNT, "Disk label changed to %s\n", label);
}
ENTRY;
LASSERT(lsiflags & LSI_SERVER);
-
+
tmpname_sz = strlen(lsi->lsi_ldd->ldd_svname) + 1;
OBD_ALLOC(tmpname, tmpname_sz);
memcpy(tmpname, lsi->lsi_ldd->ldd_svname, tmpname_sz);
CDEBUG(D_MOUNT, "server put_super %s\n", tmpname);
-
+
/* Stop the target */
if (IS_MDT(lsi->lsi_ldd) || IS_OST(lsi->lsi_ldd)) {
LPROC_ECHO_LAST = LPROC_ECHO_WRITE_BYTES +1
};
-static int echo_connect(struct lustre_handle *conn, struct obd_device *obd,
+static int echo_connect(const struct lu_context *ctx,
+ struct lustre_handle *conn, struct obd_device *obd,
struct obd_uuid *cluuid, struct obd_connect_data *data)
{
data->ocd_connect_flags &= ECHO_CONNECT_SUPPORTED;
*offp = offset * stripe_size + woffset % stripe_size;
}
-static void
-echo_client_page_debug_setup(struct lov_stripe_md *lsm,
- cfs_page_t *page, int rw, obd_id id,
+static void
+echo_client_page_debug_setup(struct lov_stripe_md *lsm,
+ cfs_page_t *page, int rw, obd_id id,
obd_off offset, obd_off count)
{
char *addr;
cfs_kunmap(page);
}
-static int echo_client_page_debug_check(struct lov_stripe_md *lsm,
- cfs_page_t *page, obd_id id,
+static int echo_client_page_debug_check(struct lov_stripe_md *lsm,
+ cfs_page_t *page, obd_id id,
obd_off offset, obd_off count)
{
obd_off stripe_off;
if (oa->o_id != ECHO_PERSISTENT_OBJID &&
(oa->o_valid & OBD_MD_FLFLAGS) != 0 &&
(oa->o_flags & OBD_FL_DEBUG_CHECK) != 0)
- echo_client_page_debug_setup(lsm, eap->eap_page, rw,
- oa->o_id,
+ echo_client_page_debug_setup(lsm, eap->eap_page, rw,
+ oa->o_id,
eap->eap_off, CFS_PAGE_SIZE);
/* always asserts urgent, which isn't quite right */
ocd->ocd_connect_flags = OBD_CONNECT_VERSION;
ocd->ocd_version = LUSTRE_VERSION_CODE;
- rc = obd_connect(&conn, tgt, &echo_uuid, ocd);
+ rc = obd_connect(NULL, &conn, tgt, &echo_uuid, ocd);
OBD_FREE(ocd, sizeof(*ocd));
RETURN(rc);
}
-static int echo_client_connect(struct lustre_handle *conn,
+static int echo_client_connect(const struct lu_context *ctx,
+ struct lustre_handle *conn,
struct obd_device *src, struct obd_uuid *cluuid,
struct obd_connect_data *data)
{
}
/* nearly identical to mds_connect */
-static int filter_connect(struct lustre_handle *conn, struct obd_device *obd,
+static int filter_connect(const struct lu_context *ctx,
+ struct lustre_handle *conn, struct obd_device *obd,
struct obd_uuid *cluuid,
struct obd_connect_data *data)
{
git://git.whamcloud.com / fs / lustre-release.git / commitdiff