int ofd_object_destroy(const struct lu_env *env, struct ofd_object *fo, int orphan) { struct ofd_device *ofd = ofd_obj2dev(fo); struct thandle *th; int rc = 0; ENTRY; ofd_write_lock(env, fo); if (!ofd_object_exists(fo)) GOTO(unlock, rc = -ENOENT); th = ofd_trans_create(env, ofd); if (IS_ERR(th)) GOTO(unlock, rc = PTR_ERR(th)); dt_declare_ref_del(env, ofd_object_child(fo), th); dt_declare_destroy(env, ofd_object_child(fo), th); if (orphan) rc = dt_trans_start_local(env, ofd->ofd_osd, th); else rc = ofd_trans_start(env, ofd, NULL, th); if (rc) GOTO(stop, rc); ofd_fmd_drop(ofd_info(env)->fti_exp, &fo->ofo_header.loh_fid); dt_ref_del(env, ofd_object_child(fo), th); dt_destroy(env, ofd_object_child(fo), th); stop: ofd_trans_stop(env, ofd, th, rc); unlock: ofd_write_unlock(env, fo); RETURN(rc); }
/** * Set attributes of object during write bulk IO processing. * * Change object attributes and write parent FID into extended * attributes when needed. * * \param[in] env execution environment * \param[in] ofd OFD device * \param[in] ofd_obj OFD object * \param[in] la object attributes * \param[in] ff parent FID * * \retval 0 on successful attributes update * \retval negative value on error */ static int ofd_write_attr_set(const struct lu_env *env, struct ofd_device *ofd, struct ofd_object *ofd_obj, struct lu_attr *la, struct filter_fid *ff) { struct ofd_thread_info *info = ofd_info(env); __u64 valid = la->la_valid; int rc; struct thandle *th; struct dt_object *dt_obj; int ff_needed = 0; ENTRY; LASSERT(la); dt_obj = ofd_object_child(ofd_obj); LASSERT(dt_obj != NULL); la->la_valid &= LA_UID | LA_GID; rc = ofd_attr_handle_ugid(env, ofd_obj, la, 0 /* !is_setattr */); if (rc != 0) GOTO(out, rc); if (ff != NULL) { rc = ofd_object_ff_load(env, ofd_obj); if (rc == -ENODATA) ff_needed = 1; else if (rc < 0) GOTO(out, rc); } if (!la->la_valid && !ff_needed) /* no attributes to set */ GOTO(out, rc = 0); th = ofd_trans_create(env, ofd); if (IS_ERR(th)) GOTO(out, rc = PTR_ERR(th)); if (la->la_valid) { rc = dt_declare_attr_set(env, dt_obj, la, th); if (rc) GOTO(out_tx, rc); } if (ff_needed) { if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_UNMATCHED_PAIR1)) ff->ff_parent.f_oid = cpu_to_le32(1UL << 31); if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_UNMATCHED_PAIR2)) ff->ff_parent.f_oid = cpu_to_le32(le32_to_cpu(ff->ff_parent.f_oid) - 1); info->fti_buf.lb_buf = ff; info->fti_buf.lb_len = sizeof(*ff); rc = dt_declare_xattr_set(env, dt_obj, &info->fti_buf, XATTR_NAME_FID, 0, th); if (rc) GOTO(out_tx, rc); } /* We don't need a transno for this operation which will be re-executed * anyway when the OST_WRITE (with a transno assigned) is replayed */ rc = dt_trans_start_local(env, ofd->ofd_osd , th); if (rc) GOTO(out_tx, rc); /* set uid/gid */ if (la->la_valid) { rc = dt_attr_set(env, dt_obj, la, th); if (rc) GOTO(out_tx, rc); } /* set filter fid EA */ if (ff_needed) { if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NOPFID)) GOTO(out_tx, rc); rc = dt_xattr_set(env, dt_obj, &info->fti_buf, XATTR_NAME_FID, 0, th); if (rc == 0) { ofd_obj->ofo_pfid.f_seq = le64_to_cpu(ff->ff_parent.f_seq); ofd_obj->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. */ ofd_obj->ofo_pfid.f_stripe_idx = le32_to_cpu(ff->ff_parent.f_stripe_idx); } } GOTO(out_tx, rc); out_tx: dt_trans_stop(env, ofd->ofd_osd, th); out: la->la_valid = valid; return rc; }
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 obdo *oa) { struct ofd_thread_info *info = ofd_info(env); struct ofd_device *ofd = ofd_obj2dev(fo); struct ofd_mod_data *fmd; struct dt_object *dob = ofd_object_child(fo); struct thandle *th; int ff_needed = 0; int rc; ENTRY; /* we support truncate, not punch yet */ LASSERT(end == OBD_OBJECT_EOF); fmd = ofd_fmd_get(info->fti_exp, &fo->ofo_header.loh_fid); if (fmd && fmd->fmd_mactime_xid < info->fti_xid) fmd->fmd_mactime_xid = info->fti_xid; ofd_fmd_put(info->fti_exp, fmd); ofd_write_lock(env, 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); rc = ofd_attr_handle_ugid(env, fo, la, 0 /* !is_setattr */); if (rc != 0) GOTO(unlock, rc); if (ff != NULL) { rc = ofd_object_ff_load(env, fo); if (rc == -ENODATA) ff_needed = 1; else if (rc < 0) GOTO(unlock, rc); } th = ofd_trans_create(env, ofd); if (IS_ERR(th)) GOTO(unlock, rc = PTR_ERR(th)); rc = dt_declare_attr_set(env, dob, la, th); if (rc) GOTO(stop, rc); rc = dt_declare_punch(env, dob, start, OBD_OBJECT_EOF, th); if (rc) GOTO(stop, rc); if (ff_needed) { info->fti_buf.lb_buf = ff; info->fti_buf.lb_len = sizeof(*ff); rc = dt_declare_xattr_set(env, ofd_object_child(fo), &info->fti_buf, XATTR_NAME_FID, 0, th); if (rc) GOTO(stop, rc); } rc = ofd_trans_start(env, ofd, fo, th); if (rc) GOTO(stop, rc); rc = dt_punch(env, dob, start, OBD_OBJECT_EOF, th, ofd_object_capa(env, fo)); if (rc) GOTO(stop, rc); rc = dt_attr_set(env, dob, la, th, ofd_object_capa(env, fo)); if (rc) GOTO(stop, rc); 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; }
int ofd_precreate_objects(const struct lu_env *env, struct ofd_device *ofd, obd_id id, struct ofd_seq *oseq, int nr, int sync) { struct ofd_thread_info *info = ofd_info(env); struct ofd_object *fo = NULL; struct dt_object *next; struct thandle *th; struct ofd_object **batch; struct lu_fid *fid = &info->fti_fid; obd_id tmp; int rc; int i; int objects = 0; int nr_saved = nr; ENTRY; /* Don't create objects beyond the valid range for this SEQ */ if (unlikely(fid_seq_is_mdt0(ostid_seq(&oseq->os_oi)) && (id + nr) >= IDIF_MAX_OID)) { CERROR("%s:"DOSTID" hit the IDIF_MAX_OID (1<<48)!\n", ofd_name(ofd), id, ostid_seq(&oseq->os_oi)); RETURN(rc = -ENOSPC); } else if (unlikely(!fid_seq_is_mdt0(ostid_seq(&oseq->os_oi)) && (id + nr) >= OBIF_MAX_OID)) { CERROR("%s:"DOSTID" hit the OBIF_MAX_OID (1<<32)!\n", ofd_name(ofd), id, ostid_seq(&oseq->os_oi)); RETURN(rc = -ENOSPC); } OBD_ALLOC(batch, nr_saved * sizeof(struct ofd_object *)); if (batch == NULL) 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; info->fti_attr.la_ctime = 0; LASSERT(id != 0); /* prepare objects */ *fid = *lu_object_fid(&oseq->os_lastid_obj->do_lu); for (i = 0; i < nr; i++) { rc = fid_set_id(fid, id + i); if (rc != 0) { if (i == 0) GOTO(out, rc); nr = i; break; } fo = ofd_object_find(env, ofd, fid); if (IS_ERR(fo)) { if (i == 0) GOTO(out, rc = PTR_ERR(fo)); nr = i; break; } ofd_write_lock(env, fo); batch[i] = fo; } info->fti_buf.lb_buf = &tmp; info->fti_buf.lb_len = sizeof(tmp); info->fti_off = 0; th = ofd_trans_create(env, ofd); if (IS_ERR(th)) GOTO(out, rc = PTR_ERR(th)); th->th_sync |= sync; rc = dt_declare_record_write(env, oseq->os_lastid_obj, &info->fti_buf, info->fti_off, th); if (rc) GOTO(trans_stop, rc); for (i = 0; i < nr; i++) { fo = batch[i]; LASSERT(fo); if (unlikely(ofd_object_exists(fo))) { /* object may exist being re-created by write replay */ CDEBUG(D_INODE, "object "LPX64"/"LPX64" exists: " DFID"\n", ostid_seq(&oseq->os_oi), id, PFID(lu_object_fid(&fo->ofo_obj.do_lu))); continue; } next = ofd_object_child(fo); LASSERT(next != NULL); rc = dt_declare_create(env, next, &info->fti_attr, NULL, &info->fti_dof, th); if (rc) { nr = i; break; } } rc = dt_trans_start_local(env, ofd->ofd_osd, th); if (rc) GOTO(trans_stop, rc); 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 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. * So from the LFSCK view, it needs to re-load the last_id from disk * file, and if the latest last_id is still smaller than the object's * ID, then the LAST_ID file is real crashed. * * To make above mechanism to work, before OFD pre-create OST-objects, * it needs to update the LAST_ID file firstly, otherwise, the LFSCK * may cannot get latest last_id although new OST-object created. */ if (!OBD_FAIL_CHECK(OBD_FAIL_LFSCK_SKIP_LASTID)) { tmp = cpu_to_le64(id + nr - 1); dt_write_lock(env, oseq->os_lastid_obj, 0); rc = dt_record_write(env, oseq->os_lastid_obj, &info->fti_buf, &info->fti_off, th); dt_write_unlock(env, oseq->os_lastid_obj); if (rc != 0) GOTO(trans_stop, rc); } for (i = 0; i < nr; i++) { fo = batch[i]; LASSERT(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) break; LASSERT(ofd_object_exists(fo)); } ofd_seq_last_oid_set(oseq, id + i); } objects = i; /* NOT all the wanted objects have been created, * set the LAST_ID as the real created. */ if (unlikely(objects < nr)) { int rc1; info->fti_off = 0; tmp = cpu_to_le64(ofd_seq_last_oid(oseq)); dt_write_lock(env, oseq->os_lastid_obj, 0); rc1 = dt_record_write(env, oseq->os_lastid_obj, &info->fti_buf, &info->fti_off, th); dt_write_unlock(env, oseq->os_lastid_obj); if (rc1 != 0) CERROR("%s: fail to reset the LAST_ID for seq ("LPX64 ") from "LPU64" to "LPU64"\n", ofd_name(ofd), ostid_seq(&oseq->os_oi), id + nr - 1, ofd_seq_last_oid(oseq)); } trans_stop: ofd_trans_stop(env, ofd, th, rc); out: for (i = 0; i < nr_saved; i++) { fo = batch[i]; if (fo) { ofd_write_unlock(env, fo); ofd_object_put(env, fo); } } OBD_FREE(batch, nr_saved * sizeof(struct ofd_object *)); CDEBUG((objects == 0 && rc == 0) ? D_ERROR : D_OTHER, "created %d/%d objects: %d\n", objects, nr_saved, rc); LASSERT(ergo(objects == 0, rc < 0)); RETURN(objects > 0 ? objects : rc); }
int ofd_attr_set(const struct lu_env *env, struct ofd_object *fo, struct lu_attr *la, struct filter_fid *ff) { struct ofd_thread_info *info = ofd_info(env); struct ofd_device *ofd = ofd_obj2dev(fo); struct thandle *th; struct ofd_mod_data *fmd; int ff_needed = 0; int rc; ENTRY; ofd_write_lock(env, fo); if (!ofd_object_exists(fo)) GOTO(unlock, rc = -ENOENT); if (la->la_valid & (LA_ATIME | LA_MTIME | LA_CTIME)) { fmd = ofd_fmd_get(info->fti_exp, &fo->ofo_header.loh_fid); if (fmd && fmd->fmd_mactime_xid < info->fti_xid) fmd->fmd_mactime_xid = info->fti_xid; ofd_fmd_put(info->fti_exp, fmd); } /* VBR: version recovery check */ rc = ofd_version_get_check(info, fo); if (rc) GOTO(unlock, rc); rc = ofd_attr_handle_ugid(env, fo, la, 1 /* is_setattr */); if (rc != 0) GOTO(unlock, rc); if (ff != NULL) { rc = ofd_object_ff_load(env, fo); if (rc == -ENODATA) ff_needed = 1; else if (rc < 0) GOTO(unlock, rc); } th = ofd_trans_create(env, ofd); if (IS_ERR(th)) GOTO(unlock, rc = PTR_ERR(th)); rc = dt_declare_attr_set(env, ofd_object_child(fo), la, th); if (rc) GOTO(stop, rc); if (ff_needed) { info->fti_buf.lb_buf = ff; info->fti_buf.lb_len = sizeof(*ff); rc = dt_declare_xattr_set(env, ofd_object_child(fo), &info->fti_buf, XATTR_NAME_FID, 0, th); if (rc) GOTO(stop, rc); } rc = ofd_trans_start(env, ofd, la->la_valid & LA_SIZE ? fo : NULL, th); if (rc) GOTO(stop, rc); rc = dt_attr_set(env, ofd_object_child(fo), la, th, ofd_object_capa(env, fo)); if (rc) GOTO(stop, rc); 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; }
/** * Set attributes of object during write bulk IO processing. * * Change object attributes and write parent FID into extended * attributes when needed. * * \param[in] env execution environment * \param[in] ofd OFD device * \param[in] ofd_obj OFD object * \param[in] la object attributes * \param[in] oa obdo * * \retval 0 on successful attributes update * \retval negative value on error */ static int ofd_write_attr_set(const struct lu_env *env, struct ofd_device *ofd, struct ofd_object *ofd_obj, struct lu_attr *la, struct obdo *oa) { struct ofd_thread_info *info = ofd_info(env); struct filter_fid *ff = &info->fti_mds_fid; __u64 valid = la->la_valid; struct thandle *th; struct dt_object *dt_obj; int fl = 0; int rc; ENTRY; LASSERT(la); dt_obj = ofd_object_child(ofd_obj); LASSERT(dt_obj != NULL); la->la_valid &= LA_UID | LA_GID | LA_PROJID; rc = ofd_attr_handle_id(env, ofd_obj, la, 0 /* !is_setattr */); if (rc != 0) GOTO(out, rc); fl = ofd_object_ff_update(env, ofd_obj, oa, ff); if (fl < 0) GOTO(out, rc = fl); if (!la->la_valid && !fl) /* no attributes to set */ GOTO(out, rc = 0); th = ofd_trans_create(env, ofd); if (IS_ERR(th)) GOTO(out, rc = PTR_ERR(th)); if (la->la_valid) { rc = dt_declare_attr_set(env, dt_obj, la, th); if (rc) GOTO(out_tx, rc); } if (fl) { if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_UNMATCHED_PAIR1)) ff->ff_parent.f_oid = cpu_to_le32(1UL << 31); else if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_UNMATCHED_PAIR2)) le32_add_cpu(&ff->ff_parent.f_oid, -1); rc = dt_declare_xattr_set(env, dt_obj, &info->fti_buf, XATTR_NAME_FID, 0, th); if (rc) GOTO(out_tx, rc); } /* We don't need a transno for this operation which will be re-executed * anyway when the OST_WRITE (with a transno assigned) is replayed */ rc = dt_trans_start_local(env, ofd->ofd_osd , th); if (rc) GOTO(out_tx, rc); /* set uid/gid/projid */ if (la->la_valid) { rc = dt_attr_set(env, dt_obj, la, th); if (rc) GOTO(out_tx, rc); } /* set filter fid EA. * FIXME: it holds read lock of ofd object to modify the XATTR_NAME_FID * while the write lock should be held. However, it should work because * write RPCs only modify ff_{parent,layout} and those information will * be the same from all the write RPCs. The reason that fl is not used * in dt_xattr_set() is to allow this race. */ if (fl) { if (OBD_FAIL_CHECK(OBD_FAIL_LFSCK_NOPFID)) GOTO(out_tx, rc); info->fti_buf.lb_buf = ff; info->fti_buf.lb_len = sizeof(*ff); rc = dt_xattr_set(env, dt_obj, &info->fti_buf, XATTR_NAME_FID, 0, th); if (rc == 0) filter_fid_le_to_cpu(&ofd_obj->ofo_ff, ff, sizeof(*ff)); } GOTO(out_tx, rc); out_tx: dt_trans_stop(env, ofd->ofd_osd, th); out: la->la_valid = valid; return rc; }
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 ofd_thread_info *info = ofd_info(env); struct ofd_device *ofd = ofd_obj2dev(fo); struct ofd_mod_data *fmd; struct dt_object *dob = ofd_object_child(fo); struct thandle *th; int ff_needed = 0; int rc; ENTRY; /* we support truncate, not punch yet */ LASSERT(end == OBD_OBJECT_EOF); fmd = ofd_fmd_get(info->fti_exp, &fo->ofo_header.loh_fid); if (fmd && fmd->fmd_mactime_xid < info->fti_xid) fmd->fmd_mactime_xid = info->fti_xid; ofd_fmd_put(info->fti_exp, fmd); ofd_write_lock(env, fo); if (!ofd_object_exists(fo)) GOTO(unlock, rc = -ENOENT); /* VBR: version recovery check */ rc = ofd_version_get_check(info, fo); if (rc) GOTO(unlock, rc); rc = ofd_attr_handle_ugid(env, fo, la, 0 /* !is_setattr */); if (rc != 0) GOTO(unlock, rc); if (ff != NULL) { rc = ofd_object_ff_check(env, fo); if (rc == -ENODATA) ff_needed = 1; else if (rc < 0) GOTO(unlock, rc); } th = ofd_trans_create(env, ofd); if (IS_ERR(th)) GOTO(unlock, rc = PTR_ERR(th)); rc = dt_declare_attr_set(env, dob, la, th); if (rc) GOTO(stop, rc); rc = dt_declare_punch(env, dob, start, OBD_OBJECT_EOF, th); if (rc) GOTO(stop, rc); if (ff_needed) { info->fti_buf.lb_buf = ff; info->fti_buf.lb_len = sizeof(*ff); rc = dt_declare_xattr_set(env, ofd_object_child(fo), &info->fti_buf, XATTR_NAME_FID, 0, th); if (rc) GOTO(stop, rc); } rc = ofd_trans_start(env, ofd, fo, th); if (rc) GOTO(stop, rc); rc = dt_punch(env, dob, start, OBD_OBJECT_EOF, th, ofd_object_capa(env, fo)); if (rc) GOTO(stop, rc); rc = dt_attr_set(env, dob, la, th, ofd_object_capa(env, fo)); if (rc) GOTO(stop, rc); if (ff_needed) rc = dt_xattr_set(env, ofd_object_child(fo), &info->fti_buf, XATTR_NAME_FID, 0, th, BYPASS_CAPA); stop: ofd_trans_stop(env, ofd, th, rc); unlock: ofd_write_unlock(env, fo); RETURN(rc); }
int ofd_attr_set(const struct lu_env *env, struct ofd_object *fo, struct lu_attr *la, struct filter_fid *ff) { struct ofd_thread_info *info = ofd_info(env); struct ofd_device *ofd = ofd_obj2dev(fo); struct thandle *th; struct ofd_mod_data *fmd; int ff_needed = 0; int rc; ENTRY; ofd_write_lock(env, fo); if (!ofd_object_exists(fo)) GOTO(unlock, rc = -ENOENT); if (la->la_valid & (LA_ATIME | LA_MTIME | LA_CTIME)) { fmd = ofd_fmd_get(info->fti_exp, &fo->ofo_header.loh_fid); if (fmd && fmd->fmd_mactime_xid < info->fti_xid) fmd->fmd_mactime_xid = info->fti_xid; ofd_fmd_put(info->fti_exp, fmd); } /* VBR: version recovery check */ rc = ofd_version_get_check(info, fo); if (rc) GOTO(unlock, rc); rc = ofd_attr_handle_ugid(env, fo, la, 1 /* is_setattr */); if (rc != 0) GOTO(unlock, rc); if (ff != NULL) { rc = ofd_object_ff_check(env, fo); if (rc == -ENODATA) ff_needed = 1; else if (rc < 0) GOTO(unlock, rc); } th = ofd_trans_create(env, ofd); if (IS_ERR(th)) GOTO(unlock, rc = PTR_ERR(th)); rc = dt_declare_attr_set(env, ofd_object_child(fo), la, th); if (rc) GOTO(stop, rc); if (ff_needed) { info->fti_buf.lb_buf = ff; info->fti_buf.lb_len = sizeof(*ff); rc = dt_declare_xattr_set(env, ofd_object_child(fo), &info->fti_buf, XATTR_NAME_FID, 0, th); if (rc) GOTO(stop, rc); } rc = ofd_trans_start(env, ofd, la->la_valid & LA_SIZE ? fo : NULL, th); if (rc) GOTO(stop, rc); rc = dt_attr_set(env, ofd_object_child(fo), la, th, ofd_object_capa(env, fo)); if (rc) GOTO(stop, rc); if (ff_needed) rc = dt_xattr_set(env, ofd_object_child(fo), &info->fti_buf, XATTR_NAME_FID, 0, th, BYPASS_CAPA); stop: ofd_trans_stop(env, ofd, th, rc); unlock: ofd_write_unlock(env, fo); RETURN(rc); }
int ofd_precreate_objects(const struct lu_env *env, struct ofd_device *ofd, obd_id id, struct ofd_seq *oseq, int nr, int sync) { struct ofd_thread_info *info = ofd_info(env); struct ofd_object *fo = NULL; struct dt_object *next; struct thandle *th; struct ofd_object **batch; obd_id tmp; int rc; int i; int objects = 0; int nr_saved = nr; ENTRY; /* Don't create objects beyond the valid range for this SEQ */ if (unlikely(fid_seq_is_mdt0(ostid_seq(&oseq->os_oi)) && (id + nr) >= IDIF_MAX_OID)) { CERROR("%s:"DOSTID" hit the IDIF_MAX_OID (1<<48)!\n", ofd_name(ofd), id, ostid_seq(&oseq->os_oi)); RETURN(rc = -ENOSPC); } else if (unlikely(!fid_seq_is_mdt0(ostid_seq(&oseq->os_oi)) && (id + nr) >= OBIF_MAX_OID)) { CERROR("%s:"DOSTID" hit the OBIF_MAX_OID (1<<32)!\n", ofd_name(ofd), id, ostid_seq(&oseq->os_oi)); RETURN(rc = -ENOSPC); } OBD_ALLOC(batch, nr_saved * sizeof(struct ofd_object *)); if (batch == NULL) 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; info->fti_attr.la_ctime = 0; /* prepare objects */ ostid_set_seq(&info->fti_ostid, ostid_seq(&oseq->os_oi)); for (i = 0; i < nr; i++) { ostid_set_id(&info->fti_ostid, id + i); rc = ostid_to_fid(&info->fti_fid, &info->fti_ostid, 0); if (rc) { if (i == 0) GOTO(out, rc); nr = i; break; } fo = ofd_object_find(env, ofd, &info->fti_fid); if (IS_ERR(fo)) { if (i == 0) GOTO(out, rc = PTR_ERR(fo)); nr = i; break; } ofd_write_lock(env, fo); batch[i] = fo; } info->fti_buf.lb_buf = &tmp; info->fti_buf.lb_len = sizeof(tmp); info->fti_off = 0; th = ofd_trans_create(env, ofd); if (IS_ERR(th)) GOTO(out, rc = PTR_ERR(th)); th->th_sync |= sync; rc = dt_declare_record_write(env, oseq->os_lastid_obj, sizeof(tmp), info->fti_off, th); if (rc) GOTO(trans_stop, rc); for (i = 0; i < nr; i++) { fo = batch[i]; LASSERT(fo); if (unlikely(ofd_object_exists(fo))) { /* object may exist being re-created by write replay */ CDEBUG(D_INODE, "object "LPX64"/"LPX64" exists: " DFID"\n", ostid_seq(&oseq->os_oi), id, PFID(&info->fti_fid)); continue; } next = ofd_object_child(fo); LASSERT(next != NULL); rc = dt_declare_create(env, next, &info->fti_attr, NULL, &info->fti_dof, th); if (rc) { nr = i; break; } } rc = dt_trans_start_local(env, ofd->ofd_osd, th); if (rc) GOTO(trans_stop, rc); CDEBUG(D_OTHER, "%s: create new object "DFID" nr %d\n", ofd_name(ofd), PFID(&info->fti_fid), nr); for (i = 0; i < nr; i++) { fo = batch[i]; LASSERT(fo); if (likely(!ofd_object_exists(fo))) { next = ofd_object_child(fo); LASSERT(next != NULL); rc = dt_create(env, next, &info->fti_attr, NULL, &info->fti_dof, th); if (rc) break; LASSERT(ofd_object_exists(fo)); } ofd_seq_last_oid_set(oseq, id + i); } objects = i; if (objects > 0) { tmp = cpu_to_le64(ofd_seq_last_oid(oseq)); rc = dt_record_write(env, oseq->os_lastid_obj, &info->fti_buf, &info->fti_off, th); } trans_stop: ofd_trans_stop(env, ofd, th, rc); out: for (i = 0; i < nr_saved; i++) { fo = batch[i]; if (fo) { ofd_write_unlock(env, fo); ofd_object_put(env, fo); } } OBD_FREE(batch, nr_saved * sizeof(struct ofd_object *)); CDEBUG((objects == 0 && rc == 0) ? D_ERROR : D_OTHER, "created %d/%d objects: %d\n", objects, nr_saved, rc); LASSERT(ergo(objects == 0, rc < 0)); RETURN(objects > 0 ? objects : rc); }
static int ofd_write_attr_set(const struct lu_env *env, struct ofd_device *ofd, struct ofd_object *ofd_obj, struct lu_attr *la, struct filter_fid *ff) { struct ofd_thread_info *info = ofd_info(env); __u64 valid = la->la_valid; int rc; struct thandle *th; struct dt_object *dt_obj; int ff_needed = 0; ENTRY; LASSERT(la); dt_obj = ofd_object_child(ofd_obj); LASSERT(dt_obj != NULL); la->la_valid &= LA_UID | LA_GID; rc = ofd_attr_handle_ugid(env, ofd_obj, la, 0 /* !is_setattr */); if (rc != 0) GOTO(out, rc); if (ff != NULL) { rc = ofd_object_ff_check(env, ofd_obj); if (rc == -ENODATA) ff_needed = 1; else if (rc < 0) GOTO(out, rc); } if (!la->la_valid && !ff_needed) /* no attributes to set */ GOTO(out, rc = 0); th = ofd_trans_create(env, ofd); if (IS_ERR(th)) GOTO(out, rc = PTR_ERR(th)); if (la->la_valid) { rc = dt_declare_attr_set(env, dt_obj, la, th); if (rc) GOTO(out_tx, rc); } if (ff_needed) { info->fti_buf.lb_buf = ff; info->fti_buf.lb_len = sizeof(*ff); rc = dt_declare_xattr_set(env, dt_obj, &info->fti_buf, XATTR_NAME_FID, 0, th); if (rc) GOTO(out_tx, rc); } /* We don't need a transno for this operation which will be re-executed * anyway when the OST_WRITE (with a transno assigned) is replayed */ rc = dt_trans_start_local(env, ofd->ofd_osd , th); if (rc) GOTO(out_tx, rc); /* set uid/gid */ if (la->la_valid) { rc = dt_attr_set(env, dt_obj, la, th, ofd_object_capa(env, ofd_obj)); if (rc) GOTO(out_tx, rc); } /* set filter fid EA */ if (ff_needed) { rc = dt_xattr_set(env, dt_obj, &info->fti_buf, XATTR_NAME_FID, 0, th, BYPASS_CAPA); if (rc) GOTO(out_tx, rc); } EXIT; out_tx: dt_trans_stop(env, ofd->ofd_osd, th); out: la->la_valid = valid; return rc; }