# include <sys/statfs.h>
#endif
-#include <fs.h>
+#ifdef HAVE_XTIO_H
+#include <xtio.h>
+#endif
#include <sysio.h>
#include <mount.h>
#include <inode.h>
+#include <fs.h>
+#ifdef HAVE_FILE_H
#include <file.h>
+#endif
#undef LIST_HEAD
#include "llite_lib.h"
static void llu_fsop_gone(struct filesys *fs)
{
- struct llu_sb_info *sbi = (struct llu_sb_info *) fs->fs_private;
- struct obd_device *obd = class_exp2obd(sbi->ll_lmv_exp);
- struct lustre_cfg lcfg;
+ struct llu_sb_info *sbi = (struct llu_sb_info *)fs->fs_private;
+ struct obd_device *obd = class_exp2obd(sbi->ll_md_exp);
+ struct lustre_cfg_bufs bufs;
+ struct lustre_cfg *lcfg;
int next = 0;
ENTRY;
list_del(&sbi->ll_conn_chain);
- obd_disconnect(sbi->ll_lov_exp, 0);
- obd_disconnect(sbi->ll_lmv_exp, 0);
+ obd_disconnect(sbi->ll_dt_exp, 0);
+ obd_disconnect(sbi->ll_md_exp, 0);
while ((obd = class_devices_in_group(&sbi->ll_sb_uuid, &next)) != NULL)
{
int err;
-
- LCFG_INIT(lcfg, LCFG_CLEANUP, obd->obd_name);
+
+ lustre_cfg_bufs_reset(&bufs, obd->obd_name);
+ lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs);
err = class_process_config(&lcfg);
if (err) {
CERROR("cleanup failed: %s\n", obd->obd_name);
}
-
- LCFG_INIT(lcfg, LCFG_DETACH, obd->obd_name);
+
+ lcfg->lcfg_command = LCFG_DETACH;
err = class_process_config(&lcfg);
+ lustre_cfg_free(lcfg);
if (err) {
CERROR("detach failed: %s\n", obd->obd_name);
}
}
- obd_disconnect(sbi->ll_lmv_exp, 0);
+ obd_disconnect(sbi->ll_md_exp, 0);
OBD_FREE(sbi, sizeof(*sbi));
EXIT;
}
}
}
- /*
- * updating inode lustre id. We try optimize things a little bit here,
- * thus do not do it all the time.
- */
- if (body->valid & OBD_MD_FID)
- id_assign_fid(&lli->lli_id, &body->id1);
- if ((body->valid & OBD_MD_FLID) || (body->valid & OBD_MD_FLGENER))
+ id_assign_fid(&lli->lli_id, &body->id1);
+
+ if ((body->valid & OBD_MD_FLID) || (body->valid & OBD_MD_FLGENER))
id_assign_stc(&lli->lli_id, &body->id1);
if (body->valid & OBD_MD_FLID)
lli->lli_st_ino = id_ino(&body->id1);
valid &= src->o_valid;
if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
- CDEBUG(D_INODE, "valid %x, cur time %lu/%lu, new %lu/%lu\n",
+ CDEBUG(D_INODE, "valid "LPX64", cur time %lu/%lu, new %lu/%lu\n",
src->o_valid,
LTIME_S(lli->lli_st_mtime), LTIME_S(lli->lli_st_ctime),
(long)src->o_mtime, (long)src->o_ctime);
obd_valid newvalid = 0;
if (valid & (OBD_MD_FLCTIME | OBD_MD_FLMTIME))
- CDEBUG(D_INODE, "valid %x, new time %lu/%lu\n",
+ CDEBUG(D_INODE, "valid "LPX64", new time %lu/%lu\n",
valid, LTIME_S(lli->lli_st_mtime),
LTIME_S(lli->lli_st_ctime));
int llu_inode_getattr(struct inode *inode, struct lov_stripe_md *lsm)
{
struct llu_inode_info *lli = llu_i2info(inode);
- struct obd_export *exp = llu_i2obdexp(inode);
+ struct obd_export *exp = llu_i2dtexp(inode);
struct ptlrpc_request_set *set;
struct obdo oa;
obd_valid refresh_valid;
LASSERT(inode);
- obddev = sbi->ll_lmv_exp->exp_obd;
+ obddev = sbi->ll_md_exp->exp_obd;
res_id.name[0] = id_fid(&lli->lli_id);
res_id.name[1] = id_group(&lli->lli_id);
/* Why don't we update all valid MDS fields here, if we're doing
* an RPC anyways? -phil */
if (S_ISREG(lli->lli_st_mode)) {
- ealen = obd_size_diskmd(sbi->ll_lov_exp, NULL);
+ ealen = obd_size_diskmd(sbi->ll_dt_exp, NULL);
valid |= OBD_MD_FLEASIZE;
}
ll_inode2id(&id, inode);
- rc = mdc_getattr(sbi->ll_lmv_exp, &id, valid, ealen, &req);
+ rc = mdc_getattr(sbi->ll_md_exp, &id, valid, NULL, 0,
+ ealen, &req);
if (rc) {
CERROR("failure %d inode %lu\n", rc, lli->lli_st_ino);
RETURN(-abs(rc));
}
- rc = mdc_req2lustre_md(sbi->ll_lmv_exp, req, 0,
- sbi->ll_lov_exp, &md);
+ rc = mdc_req2lustre_md(sbi->ll_md_exp, req, 0,
+ sbi->ll_dt_exp, &md);
/* XXX Too paranoid? */
if (((md.body->valid ^ valid) & OBD_MD_FLEASIZE) &&
llu_update_inode(inode, md.body, md.lsm);
if (md.lsm != NULL && llu_i2info(inode)->lli_smd != md.lsm)
- obd_free_memmd(sbi->ll_lov_exp, &md.lsm);
+ obd_free_memmd(sbi->ll_dt_exp, &md.lsm);
if (md.body->valid & OBD_MD_FLSIZE)
set_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
ll_inode2id(&id, inode);
clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK, &(lli->lli_flags));
- mdc_change_cbdata(sbi->ll_lmv_exp, &id, null_if_equal, inode);
+ mdc_change_cbdata(sbi->ll_md_exp, &id, null_if_equal, inode);
if (lli->lli_smd)
- obd_change_cbdata(sbi->ll_lov_exp, lli->lli_smd,
+ obd_change_cbdata(sbi->ll_dt_exp, lli->lli_smd,
null_if_equal, inode);
if (lli->lli_smd) {
- obd_free_memmd(sbi->ll_lov_exp, &lli->lli_smd);
+ obd_free_memmd(sbi->ll_dt_exp, &lli->lli_smd);
lli->lli_smd = NULL;
}
struct lustre_md md;
llu_prepare_mdc_data(&op_data, inode, NULL, NULL, 0, 0);
- rc = mdc_setattr(sbi->ll_lmv_exp, &op_data,
+ rc = mdc_setattr(sbi->ll_md_exp, &op_data,
attr, NULL, 0, NULL, 0, &request);
if (rc) {
RETURN(rc);
}
- rc = mdc_req2lustre_md(sbi->ll_lmv_exp, request, 0,
- sbi->ll_lov_exp, &md);
+ rc = mdc_req2lustre_md(sbi->ll_md_exp, request, 0,
+ sbi->ll_dt_exp, &md);
if (rc) {
ptlrpc_req_finished(request);
RETURN(rc);
oa.o_valid = OBD_MD_FLID;
obdo_from_inode(&oa, inode, OBD_MD_FLTYPE | OBD_MD_FLATIME |
OBD_MD_FLMTIME | OBD_MD_FLCTIME);
- rc = obd_setattr(sbi->ll_lov_exp, &oa, lsm, NULL);
+ rc = obd_setattr(sbi->ll_dt_exp, &oa, lsm, NULL);
if (rc)
CERROR("obd_setattr fails: rc=%d\n", rc);
}
RETURN(err);
llu_prepare_mdc_data(&op_data, dir, NULL, name, len, 0);
- err = mdc_create(sbi->ll_lmv_exp, &op_data,
+ err = mdc_create(sbi->ll_md_exp, &op_data,
tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
current->fsuid, current->fsgid, 0, &request);
ptlrpc_req_finished(request);
}
ll_inode2id(&id, inode);
- rc = mdc_getattr(sbi->ll_lmv_exp, &id,
- OBD_MD_LINKNAME, symlen, request);
+ rc = mdc_getattr(sbi->ll_md_exp, &id,
+ OBD_MD_LINKNAME, NULL, 0, symlen, request);
if (rc) {
CERROR("inode %lu: rc = %d\n", lli->lli_st_ino, rc);
RETURN(rc);
int err = -EMLINK;
ENTRY;
- CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu\n",
- pno->p_base->pb_name.name, llu_i2info(dir)->lli_st_ino);
+ CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu\n",
+ (int)pno->p_base->pb_name.len, pno->p_base->pb_name.name,
+ llu_i2info(dir)->lli_st_ino);
if (llu_i2info(dir)->lli_st_nlink >= EXT2_LINK_MAX)
RETURN(err);
pno->p_base->pb_name.name,
pno->p_base->pb_name.len,
0);
- err = mdc_create(sbi->ll_lmv_exp, &op_data, NULL, 0, mode,
+ err = mdc_create(sbi->ll_md_exp, &op_data, NULL, 0, mode,
current->fsuid, current->fsgid, dev, &request);
ptlrpc_req_finished(request);
break;
liblustre_wait_event(0);
llu_prepare_mdc_data(&op_data, src, dir, name, namelen, 0);
- rc = mdc_link(llu_i2sbi(src)->ll_lmv_exp, &op_data, &request);
+ rc = mdc_link(llu_i2sbi(src)->ll_md_exp, &op_data, &request);
ptlrpc_req_finished(request);
liblustre_wait_event(0);
liblustre_wait_event(0);
llu_prepare_mdc_data(&op_data, dir, NULL, name, len, 0);
- rc = mdc_unlink(llu_i2sbi(dir)->ll_lmv_exp, &op_data, &request);
+ rc = mdc_unlink(llu_i2sbi(dir)->ll_md_exp, &op_data, &request);
if (!rc)
rc = llu_objects_destroy(request, dir);
ptlrpc_req_finished(request);
LASSERT(tgt);
llu_prepare_mdc_data(&op_data, src, tgt, NULL, 0, 0);
- rc = mdc_rename(llu_i2sbi(src)->ll_lmv_exp, &op_data,
+ rc = mdc_rename(llu_i2sbi(src)->ll_md_exp, &op_data,
oldname, oldnamelen, newname, newnamelen,
&request);
if (!rc) {
int rc;
ENTRY;
- rc = obd_statfs(class_exp2obd(sbi->ll_lmv_exp), osfs, max_age);
+ rc = obd_statfs(class_exp2obd(sbi->ll_md_exp), osfs, max_age);
if (rc) {
CERROR("mdc_statfs fails: rc = %d\n", rc);
RETURN(rc);
CDEBUG(D_SUPER, "MDC blocks "LPU64"/"LPU64" objects "LPU64"/"LPU64"\n",
osfs->os_bavail, osfs->os_blocks, osfs->os_ffree,osfs->os_files);
- rc = obd_statfs(class_exp2obd(sbi->ll_lov_exp), &obd_osfs, max_age);
+ rc = obd_statfs(class_exp2obd(sbi->ll_dt_exp), &obd_osfs, max_age);
if (rc) {
CERROR("obd_statfs fails: rc = %d\n", rc);
RETURN(rc);
struct mdc_op_data op_data;
int err = -EMLINK;
ENTRY;
- CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%lu(%p)\n",
- name, lli->lli_st_ino, lli->lli_st_generation, dir);
+ CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%lu(%p)\n",
+ len, name, lli->lli_st_ino, lli->lli_st_generation, dir);
if (lli->lli_st_nlink >= EXT2_LINK_MAX)
RETURN(err);
mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
llu_prepare_mdc_data(&op_data, dir, NULL, name, len, 0);
- err = mdc_create(llu_i2sbi(dir)->ll_lmv_exp, &op_data, NULL, 0, mode,
+ err = mdc_create(llu_i2sbi(dir)->ll_md_exp, &op_data, NULL, 0, mode,
current->fsuid, current->fsgid, 0, &request);
ptlrpc_req_finished(request);
RETURN(err);
struct llu_inode_info *lli = llu_i2info(dir);
int rc;
ENTRY;
- CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%lu(%p)\n",
- name, lli->lli_st_ino, lli->lli_st_generation, dir);
+ CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%lu(%p)\n",
+ len, name, lli->lli_st_ino, lli->lli_st_generation, dir);
llu_prepare_mdc_data(&op_data, dir, NULL, name, len, S_IFDIR);
- rc = mdc_unlink(llu_i2sbi(dir)->ll_lmv_exp, &op_data, &request);
+ rc = mdc_unlink(llu_i2sbi(dir)->ll_md_exp, &op_data, &request);
ptlrpc_req_finished(request);
RETURN(rc);
flags = va_arg(ap, long);
flags &= FCNTL_FLMASK;
if (flags & FCNTL_FLMASK_INVALID) {
- CERROR("liblustre does not support O_NONBLOCK, O_ASYNC, "
+ CERROR("liblustre don't support O_NONBLOCK, O_ASYNC, "
"and O_DIRECT on file descriptor\n");
*rtn = -1;
return EINVAL;
if ((md->body->valid &
(OBD_MD_FLGENER | OBD_MD_FLID | OBD_MD_FLTYPE)) !=
(OBD_MD_FLGENER | OBD_MD_FLID | OBD_MD_FLTYPE)) {
- CERROR("bad md body valid mask 0x%x\n", md->body->valid);
+ CERROR("bad md body valid mask 0x"LPX64"\n",
+ md->body->valid);
LBUG();
return ERR_PTR(-EPERM);
}
}
obd_set_info(obd->obd_self_export, strlen("async"), "async",
sizeof(async), &async);
-#warning "FIXME ASAP!"
#if 0
- if (mdc_init_ea_size(obd, lov))
+ if (mdc_init_ea_size(obd, osc))
GOTO(out_free, err = -EINVAL);
#endif
/* setup mdc */
- err = obd_connect(&lmv_conn, obd, &sbi->ll_sb_uuid, 0);
+ err = obd_connect(&lmv_conn, obd, &sbi->ll_sb_uuid, NULL, 0);
if (err) {
CERROR("cannot connect to %s: rc = %d\n", lmv, err);
GOTO(out_free, err);
}
- sbi->ll_lmv_exp = class_conn2export(&lmv_conn);
+ sbi->ll_md_exp = class_conn2export(&lmv_conn);
err = obd_statfs(obd, &osfs, 100000000);
if (err)
obd_set_info(obd->obd_self_export, strlen("async"), "async",
sizeof(async), &async);
- err = obd_connect(&lov_conn, obd, &sbi->ll_sb_uuid, 0);
+ err = obd_connect(&lov_conn, obd, &sbi->ll_sb_uuid, NULL, 0);
if (err) {
CERROR("cannot connect to %s: rc = %d\n", lov, err);
GOTO(out_lmv, err);
}
- sbi->ll_lov_exp = class_conn2export(&lov_conn);
+ sbi->ll_dt_exp = class_conn2export(&lov_conn);
- err = mdc_getstatus(sbi->ll_lmv_exp, &rootid);
+ err = mdc_getstatus(sbi->ll_md_exp, &rootid);
if (err) {
CERROR("cannot mds_connect: rc = %d\n", err);
GOTO(out_lov, err);
sbi->ll_rootino = rootid.li_stc.u.e3s.l3s_ino;
/* fetch attr of root inode */
- err = mdc_getattr(sbi->ll_lmv_exp, &rootid,
- OBD_MD_FLNOTOBD|OBD_MD_FLBLOCKS, 0, &request);
+ err = mdc_getattr(sbi->ll_md_exp, &rootid,
+ OBD_MD_FLNOTOBD|OBD_MD_FLBLOCKS, NULL, 0,
+ 0, &request);
if (err) {
CERROR("mdc_getattr failed for root: rc = %d\n", err);
GOTO(out_lov, err);
}
- err = mdc_req2lustre_md(sbi->ll_lmv_exp, request, 0,
- sbi->ll_lov_exp, &md);
+ err = mdc_req2lustre_md(sbi->ll_md_exp, request, 0,
+ sbi->ll_dt_exp, &md);
if (err) {
CERROR("failed to understand root inode md: rc = %d\n",err);
GOTO(out_request, err);
out_request:
ptlrpc_req_finished(request);
out_lov:
- obd_disconnect(sbi->ll_lov_exp, 0);
+ obd_disconnect(sbi->ll_dt_exp, 0);
out_lmv:
- obd_disconnect(sbi->ll_lmv_exp, 0);
+ obd_disconnect(sbi->ll_md_exp, 0);
out_free:
OBD_FREE(sbi, sizeof(*sbi));
return err;