*
* You should have received a copy of the GNU General Public License
* version 2 along with this program; If not, see
- * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
+ * http://www.gnu.org/licenses/gpl-2.0.html
*
* GPL HEADER END
*/
* Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2012, 2013, Intel Corporation.
+ * Copyright (c) 2012, 2014 Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
*
* lustre/ofd/ofd_objects.c
*
- * Author: Alex Zhuravlev <bzzz@whamcloud.com>
- * Author: Mikhail Pershin <tappro@whamcloud.com>
+ * This file contains OSD API methods related to OBD Filter Device (OFD)
+ * object operations.
+ *
+ * Author: Alex Zhuravlev <alexey.zhuravlev@intel.com>
+ * Author: Mikhail Pershin <mike.pershin@intel.com>
*/
#define DEBUG_SUBSYSTEM S_FILTER
#include <dt_object.h>
#include <lustre/lustre_idl.h>
+#include <lustre_lfsck.h>
#include "ofd_internal.h"
+/**
+ * Get object version from disk and check it.
+ *
+ * This function checks object version from disk with
+ * ofd_thread_info::fti_pre_version filled from incoming RPC. This is part of
+ * VBR (Version-Based Recovery) and ensures that object has the same version
+ * upon replay as it has during original modification.
+ *
+ * \param[in] info execution thread OFD private data
+ * \param[in] fo OFD object
+ *
+ * \retval 0 if version matches
+ * \retval -EOVERFLOW on version mismatch
+ */
int ofd_version_get_check(struct ofd_thread_info *info,
struct ofd_object *fo)
{
dt_obj_version_t curr_version;
LASSERT(ofd_object_exists(fo));
- LASSERT(info->fti_exp);
+
+ if (info->fti_exp == NULL)
+ RETURN(0);
curr_version = dt_version_get(info->fti_env, ofd_object_child(fo));
if ((__s64)curr_version == -EOPNOTSUPP)
RETURN(0);
}
+/**
+ * Get OFD object by FID.
+ *
+ * This function finds OFD slice of compound object with the given FID.
+ *
+ * \param[in] env execution environment
+ * \param[in] ofd OFD device
+ * \param[in] fid FID of the object
+ *
+ * \retval pointer to the found ofd_object
+ * \retval ERR_PTR(errno) in case of error
+ */
struct ofd_object *ofd_object_find(const struct lu_env *env,
struct ofd_device *ofd,
const struct lu_fid *fid)
RETURN(fo);
}
-struct ofd_object *ofd_object_find_or_create(const struct lu_env *env,
- struct ofd_device *ofd,
- const struct lu_fid *fid,
- struct lu_attr *attr)
+/**
+ * Get FID of parent MDT object.
+ *
+ * This function reads extended attribute XATTR_NAME_FID of OFD object which
+ * contains the MDT parent object FID and saves it in ofd_object::ofo_pfid.
+ *
+ * The filter_fid::ff_parent::f_ver field currently holds
+ * the OST-object index in the parent MDT-object's layout EA,
+ * not the actual FID::f_ver of the parent. We therefore access
+ * it via the macro f_stripe_idx.
+ *
+ * \param[in] env execution environment
+ * \param[in] fo OFD object
+ *
+ * \retval 0 if successful
+ * \retval -ENODATA if there is no such xattr
+ * \retval negative value on error
+ */
+int ofd_object_ff_load(const struct lu_env *env, struct ofd_object *fo)
{
struct ofd_thread_info *info = ofd_info(env);
- struct lu_object *fo_obj;
- struct dt_object *dto;
+ struct filter_fid_old *ff = &info->fti_mds_fid_old;
+ struct lu_buf *buf = &info->fti_buf;
+ struct lu_fid *pfid = &fo->ofo_pfid;
+ int rc = 0;
- ENTRY;
-
- info->fti_dof.dof_type = dt_mode_to_dft(S_IFREG);
+ if (fid_is_sane(pfid))
+ return 0;
- dto = dt_find_or_create(env, ofd->ofd_osd, fid, &info->fti_dof, attr);
- if (IS_ERR(dto))
- RETURN(ERR_CAST(dto));
+ buf->lb_buf = ff;
+ buf->lb_len = sizeof(*ff);
+ rc = dt_xattr_get(env, ofd_object_child(fo), buf, XATTR_NAME_FID,
+ BYPASS_CAPA);
+ if (rc < 0)
+ return rc;
- fo_obj = lu_object_locate(dto->do_lu.lo_header,
- ofd->ofd_dt_dev.dd_lu_dev.ld_type);
- RETURN(ofd_obj(fo_obj));
-}
+ if (rc < sizeof(struct lu_fid)) {
+ fid_zero(pfid);
-int ofd_object_ff_check(const struct lu_env *env, struct ofd_object *fo)
-{
- int rc = 0;
+ return -ENODATA;
+ }
- ENTRY;
+ pfid->f_seq = le64_to_cpu(ff->ff_parent.f_seq);
+ pfid->f_oid = le32_to_cpu(ff->ff_parent.f_oid);
+ pfid->f_stripe_idx = le32_to_cpu(ff->ff_parent.f_stripe_idx);
- if (!fo->ofo_ff_exists) {
- /*
- * This actually means that we don't know whether the object
- * has the "fid" EA or not.
- */
- rc = dt_xattr_get(env, ofd_object_child(fo), &LU_BUF_NULL,
- XATTR_NAME_FID, BYPASS_CAPA);
- if (rc >= 0 || rc == -ENODATA) {
- /*
- * Here we assume that, if the object doesn't have the
- * "fid" EA, the caller will add one, unless a fatal
- * error (e.g., a memory or disk failure) prevents it
- * from doing so.
- */
- fo->ofo_ff_exists = 1;
- }
- if (rc > 0)
- rc = 0;
- }
- RETURN(rc);
+ return 0;
}
+/**
+ * Put OFD object reference.
+ *
+ * \param[in] env execution environment
+ * \param[in] fo OFD object
+ */
void ofd_object_put(const struct lu_env *env, struct ofd_object *fo)
{
lu_object_put(env, &fo->ofo_obj.do_lu);
}
+/**
+ * Precreate the given number \a nr of objects in the given sequence \a oseq.
+ *
+ * This function precreates new OST objects in the given sequence.
+ * The precreation starts from \a id and creates \a nr objects sequentially.
+ *
+ * Notes:
+ * This function may create fewer objects than requested.
+ *
+ * We mark object SUID+SGID to flag it for accepting UID+GID from client on
+ * first write. Currently the permission bits on the OST are never used,
+ * so this is OK.
+ *
+ * Initialize a/c/m time so any client timestamp will always be newer and
+ * update the inode. The ctime = 0 case is also handled specially in
+ * osd_inode_setattr(). See LU-221, LU-1042 for details.
+ *
+ * \param[in] env execution environment
+ * \param[in] ofd OFD device
+ * \param[in] id object ID to start precreation from
+ * \param[in] oseq object sequence
+ * \param[in] nr number of objects to precreate
+ * \param[in] sync synchronous precreation flag
+ *
+ * \retval 0 if successful
+ * \retval negative value on error
+ */
int ofd_precreate_objects(const struct lu_env *env, struct ofd_device *ofd,
obd_id id, struct ofd_seq *oseq, int nr, int sync)
{
RETURN(-ENOMEM);
info->fti_attr.la_valid = LA_TYPE | LA_MODE;
- /*
- * We mark object SUID+SGID to flag it for accepting UID+GID from
- * client on first write. Currently the permission bits on the OST are
- * never used, so this is OK.
- */
info->fti_attr.la_mode = S_IFREG | S_ISUID | S_ISGID | 0666;
info->fti_dof.dof_type = dt_mode_to_dft(S_IFREG);
- /* Initialize a/c/m time so any client timestamp will always
- * be newer and update the inode. ctime = 0 is also handled
- * specially in osd_inode_setattr(). See LU-221, LU-1042 */
info->fti_attr.la_valid |= LA_ATIME | LA_MTIME | LA_CTIME;
info->fti_attr.la_atime = 0;
info->fti_attr.la_mtime = 0;
th->th_sync |= sync;
- rc = dt_declare_record_write(env, oseq->os_lastid_obj, sizeof(tmp),
+ rc = dt_declare_record_write(env, oseq->os_lastid_obj, &info->fti_buf,
info->fti_off, th);
if (rc)
GOTO(trans_stop, rc);
rc = dt_declare_create(env, next, &info->fti_attr, NULL,
&info->fti_dof, th);
- if (rc) {
+ if (rc < 0) {
+ if (i == 0)
+ GOTO(trans_stop, rc);
+
nr = i;
break;
}
CDEBUG(D_OTHER, "%s: create new object "DFID" nr %d\n",
ofd_name(ofd), PFID(fid), nr);
- LASSERT(nr > 0);
-
/* When the LFSCK scanning the whole device to verify the LAST_ID file
* consistency, it will load the last_id into RAM firstly, and compare
- * the last_id with echo OST-object's ID. If the later one is larger,
+ * the last_id with each OST-object's ID. If the later one is larger,
* then it will regard the LAST_ID file crashed. But during the LFSCK
* scanning, the OFD may continue to create new OST-objects. Those new
* created OST-objects will have larger IDs than the LFSCK known ones.
fo = batch[i];
LASSERT(fo);
- if (likely(!ofd_object_exists(fo))) {
+ /* Only the new created objects need to be recorded. */
+ if (ofd->ofd_osd->dd_record_fid_accessed) {
+ lfsck_pack_rfa(&ofd_info(env)->fti_lr,
+ lu_object_fid(&fo->ofo_obj.do_lu));
+ lfsck_in_notify(env, ofd->ofd_osd,
+ &ofd_info(env)->fti_lr);
+ }
+
+ if (likely(!ofd_object_exists(fo) &&
+ !OBD_FAIL_CHECK(OBD_FAIL_LFSCK_DANGLING))) {
next = ofd_object_child(fo);
LASSERT(next != NULL);
rc = dt_create(env, next, &info->fti_attr, NULL,
&info->fti_dof, th);
- if (rc)
+ if (rc < 0) {
+ if (i == 0)
+ GOTO(trans_stop, rc);
+
+ rc = 0;
break;
+ }
LASSERT(ofd_object_exists(fo));
}
ofd_seq_last_oid_set(oseq, id + i);
RETURN(objects > 0 ? objects : rc);
}
-/*
- * If the object still has SUID+SGID bits set (see ofd_precreate_object()) then
- * we will accept the UID+GID if sent by the client for initializing the
+/**
+ * Fix the OFD object ownership.
+ *
+ * If the object still has SUID+SGID bits set, meaning that it was precreated
+ * by the MDT before it was assigned to any file, (see ofd_precreate_objects())
+ * then we will accept the UID+GID if sent by the client for initializing the
* ownership of this object. We only allow this to happen once (so clear these
* bits) and later only allow setattr.
+ *
+ * \param[in] env execution environment
+ * \param[in] fo OFD object
+ * \param[in] la object attributes
+ * \param[in] is_setattr was this function called from setattr or not
+ *
+ * \retval 0 if successful
+ * \retval negative value on error
*/
int ofd_attr_handle_ugid(const struct lu_env *env, struct ofd_object *fo,
struct lu_attr *la, int is_setattr)
RETURN(0);
}
+/**
+ * Set OFD object attributes.
+ *
+ * This function sets OFD object attributes taken from incoming request.
+ * It sets not only regular attributes but also XATTR_NAME_FID extended
+ * attribute if needed. The "fid" xattr allows the object's MDT parent inode
+ * to be found and verified by LFSCK and other tools in case of inconsistency.
+ *
+ * \param[in] env execution environment
+ * \param[in] fo OFD object
+ * \param[in] la object attributes
+ * \param[in] ff filter_fid structure, contains additional attributes
+ *
+ * \retval 0 if successful
+ * \retval negative value on error
+ */
int ofd_attr_set(const struct lu_env *env, struct ofd_object *fo,
struct lu_attr *la, struct filter_fid *ff)
{
GOTO(unlock, rc);
if (ff != NULL) {
- rc = ofd_object_ff_check(env, fo);
+ rc = ofd_object_ff_load(env, fo);
if (rc == -ENODATA)
ff_needed = 1;
else if (rc < 0)
if (rc)
GOTO(stop, rc);
- if (ff_needed)
+ if (ff_needed) {
rc = dt_xattr_set(env, ofd_object_child(fo), &info->fti_buf,
XATTR_NAME_FID, 0, th, BYPASS_CAPA);
+ if (rc == 0) {
+ fo->ofo_pfid.f_seq = le64_to_cpu(ff->ff_parent.f_seq);
+ fo->ofo_pfid.f_oid = le32_to_cpu(ff->ff_parent.f_oid);
+ /* Currently, the filter_fid::ff_parent::f_ver is not
+ * the real parent MDT-object's FID::f_ver, instead it
+ * is the OST-object index in its parent MDT-object's
+ * layout EA. */
+ fo->ofo_pfid.f_stripe_idx =
+ le32_to_cpu(ff->ff_parent.f_stripe_idx);
+ }
+ }
+
+ GOTO(stop, rc);
stop:
ofd_trans_stop(env, ofd, th, rc);
unlock:
ofd_write_unlock(env, fo);
- RETURN(rc);
+
+ return rc;
}
+/**
+ * Truncate/punch OFD object.
+ *
+ * This function frees all of the allocated object's space from the \a start
+ * offset to the \a end offset. For truncate() operations the \a end offset
+ * is OBD_OBJECT_EOF. The functionality to punch holes in an object via
+ * fallocate(FALLOC_FL_PUNCH_HOLE) is not yet implemented (see LU-3606).
+ *
+ * \param[in] env execution environment
+ * \param[in] fo OFD object
+ * \param[in] start start offset to punch from
+ * \param[in] end end of punch
+ * \param[in] la object attributes
+ * \param[in] ff filter_fid structure
+ * \param[in] oa obdo struct from incoming request
+ *
+ * \retval 0 if successful
+ * \retval negative value on error
+ */
int ofd_object_punch(const struct lu_env *env, struct ofd_object *fo,
__u64 start, __u64 end, struct lu_attr *la,
- struct filter_fid *ff)
+ struct filter_fid *ff, struct obdo *oa)
{
struct ofd_thread_info *info = ofd_info(env);
struct ofd_device *ofd = ofd_obj2dev(fo);
if (!ofd_object_exists(fo))
GOTO(unlock, rc = -ENOENT);
+ if (ofd->ofd_lfsck_verify_pfid && oa->o_valid & OBD_MD_FLFID) {
+ rc = ofd_verify_ff(env, fo, oa);
+ if (rc != 0)
+ GOTO(unlock, rc);
+ }
+
/* VBR: version recovery check */
rc = ofd_version_get_check(info, fo);
if (rc)
GOTO(unlock, rc);
if (ff != NULL) {
- rc = ofd_object_ff_check(env, fo);
+ rc = ofd_object_ff_load(env, fo);
if (rc == -ENODATA)
ff_needed = 1;
else if (rc < 0)
if (rc)
GOTO(stop, rc);
- if (ff_needed)
+ if (ff_needed) {
rc = dt_xattr_set(env, ofd_object_child(fo), &info->fti_buf,
XATTR_NAME_FID, 0, th, BYPASS_CAPA);
+ if (rc == 0) {
+ fo->ofo_pfid.f_seq = le64_to_cpu(ff->ff_parent.f_seq);
+ fo->ofo_pfid.f_oid = le32_to_cpu(ff->ff_parent.f_oid);
+ /* Currently, the filter_fid::ff_parent::f_ver is not
+ * the real parent MDT-object's FID::f_ver, instead it
+ * is the OST-object index in its parent MDT-object's
+ * layout EA. */
+ fo->ofo_pfid.f_stripe_idx =
+ le32_to_cpu(ff->ff_parent.f_stripe_idx);
+ }
+ }
+
+ GOTO(stop, rc);
stop:
ofd_trans_stop(env, ofd, th, rc);
unlock:
ofd_write_unlock(env, fo);
- RETURN(rc);
+
+ return rc;
}
+/**
+ * Destroy OFD object.
+ *
+ * This function destroys OFD object. If object wasn't used at all (orphan)
+ * then local transaction is used, which means the transaction data is not
+ * returned back in reply.
+ *
+ * \param[in] env execution environment
+ * \param[in] fo OFD object
+ * \param[in] orphan flag to indicate that object is orphaned
+ *
+ * \retval 0 if successful
+ * \retval negative value on error
+ */
int ofd_object_destroy(const struct lu_env *env, struct ofd_object *fo,
int orphan)
{
RETURN(rc);
}
+/**
+ * Get OFD object attributes.
+ *
+ * This function gets OFD object regular attributes. It is used to serve
+ * incoming request as well as for local OFD purposes.
+ *
+ * \param[in] env execution environment
+ * \param[in] fo OFD object
+ * \param[in] la object attributes
+ *
+ * \retval 0 if successful
+ * \retval negative value on error
+ */
int ofd_attr_get(const struct lu_env *env, struct ofd_object *fo,
struct lu_attr *la)
{
rc = dt_attr_get(env, ofd_object_child(fo), la,
ofd_object_capa(env, fo));
-#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 7, 50, 0)
+#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 7, 53, 0)
/* Try to correct for a bug in 2.1.0 (LU-221) that caused
* negative timestamps to appear to be in the far future,
* due old timestamp being stored on disk as an unsigned value.
la->la_mtime = 0;
if (unlikely(la->la_ctime == LU221_BAD_TIME))
la->la_ctime = 0;
-#else
-#warning "remove old LU-221/LU-1042 workaround code"
#endif
} else {
rc = -ENOENT;
git://git.whamcloud.com / fs / lustre-release.git / blobdiff