Beispiel #1
0
static int mds_cmd_cleanup(struct obd_device *obd)
{
        struct mds_obd *mds = &obd->u.mds;
        struct lvfs_run_ctxt saved;
        int rc = 0;
        ENTRY;

        mds->mds_lov_exp = NULL;

        if (obd->obd_fail)
                LCONSOLE_WARN("%s: shutting down for failover; client state "
                              "will be preserved.\n", obd->obd_name);

        if (strncmp(obd->obd_name, MDD_OBD_NAME, strlen(MDD_OBD_NAME)))
                RETURN(0);

        push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);

        mds_lov_destroy_objids(obd);

        if (mds->mds_objects_dir != NULL) {
                l_dput(mds->mds_objects_dir);
                mds->mds_objects_dir = NULL;
        }

        dput(mds->mds_fid_de);
        LL_DQUOT_OFF(obd->u.obt.obt_sb);
        shrink_dcache_sb(mds->mds_obt.obt_sb);
        fsfilt_put_ops(obd->obd_fsops);

        pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);
        RETURN(rc);
}
Beispiel #2
0
/* This is a callback from the llog_* functions.
 * Assumes caller has already pushed us into the kernel context. */
static int llog_lvfs_create(const struct lu_env *env,
			    struct llog_handle *handle,
			    struct thandle *th)
{
	struct llog_ctxt	*ctxt = handle->lgh_ctxt;
	struct obd_device	*obd;
	struct dentry		*dchild = NULL;
	struct file		*file;
	struct obdo		*oa = NULL;
	int			 rc = 0;
	int			 open_flags = O_RDWR | O_CREAT | O_LARGEFILE;

	LASSERT(ctxt);
	LASSERT(ctxt->loc_exp);
	obd = ctxt->loc_exp->exp_obd;
	LASSERT(handle->lgh_file == NULL);

	if (handle->lgh_name) {
		file = llog_filp_open(MOUNT_CONFIGS_DIR, handle->lgh_name,
				      open_flags, 0644);
		if (IS_ERR(file))
			return PTR_ERR(file);

		lustre_build_llog_lvfs_oid(&handle->lgh_id,
				file->f_dentry->d_inode->i_ino,
				file->f_dentry->d_inode->i_generation);
		handle->lgh_file = file;
	} else {
		OBDO_ALLOC(oa);
		if (oa == NULL)
			return -ENOMEM;

		ostid_set_seq_llog(&oa->o_oi);
		oa->o_valid = OBD_MD_FLGENER | OBD_MD_FLGROUP;

		rc = obd_create(NULL, ctxt->loc_exp, oa, NULL, NULL);
		if (rc)
			GOTO(out, rc);

		/* FIXME: rationalize the misuse of o_generation in
		 *	this API along with mds_obd_{create,destroy}.
		 *	Hopefully it is only an internal API issue. */
#define o_generation o_parent_oid
		dchild = obd_lvfs_fid2dentry(ctxt->loc_exp, &oa->o_oi,
					     oa->o_generation);
		if (IS_ERR(dchild))
			GOTO(out, rc = PTR_ERR(dchild));

		file = l_dentry_open(&obd->obd_lvfs_ctxt, dchild, open_flags);
		l_dput(dchild);
		if (IS_ERR(file))
			GOTO(out, rc = PTR_ERR(file));
		handle->lgh_id.lgl_oi = oa->o_oi;
		handle->lgh_id.lgl_ogen = oa->o_generation;
		handle->lgh_file = file;
out:
		OBDO_FREE(oa);
	}
	return rc;
}
Beispiel #3
0
int mgs_fs_cleanup(struct obd_device *obd)
{
        struct mgs_obd *mgs = &obd->u.mgs;
        struct lvfs_run_ctxt saved;
        int rc = 0;

        class_disconnect_exports(obd); /* cleans up client info too */

        push_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);

        if (mgs->mgs_configs_dir) {
                l_dput(mgs->mgs_configs_dir);
                mgs->mgs_configs_dir = NULL;
        }

        shrink_dcache_sb(mgs->mgs_sb);

        pop_ctxt(&saved, &obd->obd_lvfs_ctxt, NULL);

        return rc;
}
Beispiel #4
0
/* This is a callback from the llog_* functions.
 * Assumes caller has already pushed us into the kernel context. */
static int llog_lvfs_create(struct llog_ctxt *ctxt, struct llog_handle **res,
                            struct llog_logid *logid, char *name)
{
        struct llog_handle *handle;
        struct obd_device *obd;
        struct l_dentry *dchild = NULL;
        struct obdo *oa = NULL;
        int rc = 0;
        int open_flags = O_RDWR | O_CREAT | O_LARGEFILE;
        ENTRY;

        handle = llog_alloc_handle();
        if (handle == NULL)
                RETURN(-ENOMEM);
        *res = handle;

        LASSERT(ctxt);
        LASSERT(ctxt->loc_exp);
        obd = ctxt->loc_exp->exp_obd;

        if (logid != NULL) {
                dchild = obd_lvfs_fid2dentry(ctxt->loc_exp, logid->lgl_oid,
                                             logid->lgl_ogen, logid->lgl_oseq);

                if (IS_ERR(dchild)) {
                        rc = PTR_ERR(dchild);
                        CERROR("error looking up logfile "LPX64":0x%x: rc %d\n",
                               logid->lgl_oid, logid->lgl_ogen, rc);
                        GOTO(out, rc);
                }

                if (dchild->d_inode == NULL) {
                        l_dput(dchild);
                        rc = -ENOENT;
                        CERROR("nonexistent log file "LPX64":"LPX64": rc %d\n",
                               logid->lgl_oid, logid->lgl_oseq, rc);
                        GOTO(out, rc);
                }

                /* l_dentry_open will call dput(dchild) if there is an error */
                handle->lgh_file = l_dentry_open(&obd->obd_lvfs_ctxt, dchild,
                                                    O_RDWR | O_LARGEFILE);
                if (IS_ERR(handle->lgh_file)) {
                        rc = PTR_ERR(handle->lgh_file);
                        CERROR("error opening logfile "LPX64"0x%x: rc %d\n",
                               logid->lgl_oid, logid->lgl_ogen, rc);
                        GOTO(out, rc);
                }

                /* assign the value of lgh_id for handle directly */
                handle->lgh_id = *logid;

        } else if (name) {
                handle->lgh_file = llog_filp_open(MOUNT_CONFIGS_DIR,
                                                  name, open_flags, 0644);
                if (IS_ERR(handle->lgh_file))
                        GOTO(out, rc = PTR_ERR(handle->lgh_file));

                handle->lgh_id.lgl_oseq = 1;
                handle->lgh_id.lgl_oid =
                        handle->lgh_file->f_dentry->d_inode->i_ino;
                handle->lgh_id.lgl_ogen =
                        handle->lgh_file->f_dentry->d_inode->i_generation;
        } else {
                OBDO_ALLOC(oa);
                if (oa == NULL)
                        GOTO(out, rc = -ENOMEM);

                oa->o_seq = FID_SEQ_LLOG;
                oa->o_valid = OBD_MD_FLGENER | OBD_MD_FLGROUP;

                rc = obd_create(ctxt->loc_exp, oa, NULL, NULL);
                if (rc)
                        GOTO(out, rc);

                /* FIXME: rationalize the misuse of o_generation in
                 *        this API along with mds_obd_{create,destroy}.
                 *        Hopefully it is only an internal API issue. */
#define o_generation o_parent_oid
                dchild = obd_lvfs_fid2dentry(ctxt->loc_exp, oa->o_id,
                                             oa->o_generation, oa->o_seq);

                if (IS_ERR(dchild))
                        GOTO(out, rc = PTR_ERR(dchild));

                handle->lgh_file = l_dentry_open(&obd->obd_lvfs_ctxt, dchild,
                                                 open_flags);
                if (IS_ERR(handle->lgh_file))
                        GOTO(out, rc = PTR_ERR(handle->lgh_file));

                handle->lgh_id.lgl_oseq = oa->o_seq;
                handle->lgh_id.lgl_oid = oa->o_id;
                handle->lgh_id.lgl_ogen = oa->o_generation;
        }

        handle->lgh_ctxt = ctxt;
out:
        if (rc)
                llog_free_handle(handle);

        if (oa)
                OBDO_FREE(oa);
        RETURN(rc);
}
Beispiel #5
0
static int llog_lvfs_open(const struct lu_env *env,  struct llog_handle *handle,
			  struct llog_logid *logid, char *name,
			  enum llog_open_param open_param)
{
	struct llog_ctxt	*ctxt = handle->lgh_ctxt;
	struct dentry		*dchild = NULL;
	struct obd_device	*obd;
	int			 rc = 0;

	LASSERT(ctxt);
	LASSERT(ctxt->loc_exp);
	LASSERT(ctxt->loc_exp->exp_obd);
	obd = ctxt->loc_exp->exp_obd;

	LASSERT(handle);
	if (logid != NULL) {
		dchild = obd_lvfs_fid2dentry(ctxt->loc_exp, &logid->lgl_oi,
					     logid->lgl_ogen);
		if (IS_ERR(dchild)) {
			rc = PTR_ERR(dchild);
			CERROR("%s: error looking up logfile #"DOSTID "#%08x:"
			       " rc = %d\n", ctxt->loc_obd->obd_name,
			       POSTID(&logid->lgl_oi), logid->lgl_ogen, rc);
			GOTO(out, rc);
		}
		if (dchild->d_inode == NULL) {
			l_dput(dchild);
			rc = -ENOENT;
			CERROR("%s: nonexistent llog #"DOSTID"#%08x:"
			       "rc = %d\n", ctxt->loc_obd->obd_name,
			       POSTID(&logid->lgl_oi), logid->lgl_ogen, rc);
			GOTO(out, rc);
		}
		handle->lgh_file = l_dentry_open(&obd->obd_lvfs_ctxt, dchild,
						 O_RDWR | O_LARGEFILE);
		l_dput(dchild);
		if (IS_ERR(handle->lgh_file)) {
			rc = PTR_ERR(handle->lgh_file);
			handle->lgh_file = NULL;
			CERROR("%s: error opening llog #"DOSTID"#%08x:"
			       "rc = %d\n", ctxt->loc_obd->obd_name,
			       POSTID(&logid->lgl_oi), logid->lgl_ogen, rc);
			GOTO(out, rc);
		}
		handle->lgh_id = *logid;
	} else if (name) {
		handle->lgh_file = llog_filp_open(MOUNT_CONFIGS_DIR, name,
						  O_RDWR | O_LARGEFILE, 0644);
		if (IS_ERR(handle->lgh_file)) {
			rc = PTR_ERR(handle->lgh_file);
			handle->lgh_file = NULL;
			if (rc == -ENOENT && open_param == LLOG_OPEN_NEW) {
				OBD_ALLOC(handle->lgh_name, strlen(name) + 1);
				if (handle->lgh_name)
					strcpy(handle->lgh_name, name);
				else
					GOTO(out, rc = -ENOMEM);
				rc = 0;
			} else {
				GOTO(out, rc);
			}
		} else {
			lustre_build_llog_lvfs_oid(&handle->lgh_id,
			    handle->lgh_file->f_dentry->d_inode->i_ino,
			    handle->lgh_file->f_dentry->d_inode->i_generation);
		}
	} else {
		LASSERTF(open_param == LLOG_OPEN_NEW, "%#x\n", open_param);
		handle->lgh_file = NULL;
	}

	/* No new llog is expected but doesn't exist */
	if (open_param != LLOG_OPEN_NEW && handle->lgh_file == NULL)
		GOTO(out_name, rc = -ENOENT);

	return 0;
out_name:
	if (handle->lgh_name != NULL)
		OBD_FREE(handle->lgh_name, strlen(name) + 1);
out:
	return rc;
}