static int ofd_preprw_read(const struct lu_env *env, struct obd_export *exp, struct ofd_device *ofd, struct lu_fid *fid, struct lu_attr *la, int niocount, struct niobuf_remote *rnb, int *nr_local, struct niobuf_local *lnb, char *jobid) { struct ofd_object *fo; int i, j, rc, tot_bytes = 0; ENTRY; LASSERT(env != NULL); fo = ofd_object_find(env, ofd, fid); if (IS_ERR(fo)) RETURN(PTR_ERR(fo)); LASSERT(fo != NULL); ofd_read_lock(env, fo); if (!ofd_object_exists(fo)) GOTO(unlock, rc = -ENOENT); /* parse remote buffers to local buffers and prepare the latter */ *nr_local = 0; for (i = 0, j = 0; i < niocount; i++) { rc = dt_bufs_get(env, ofd_object_child(fo), rnb + i, lnb + j, 0, ofd_object_capa(env, fo)); if (unlikely(rc < 0)) GOTO(buf_put, rc); LASSERT(rc <= PTLRPC_MAX_BRW_PAGES); /* correct index for local buffers to continue with */ j += rc; *nr_local += rc; LASSERT(j <= PTLRPC_MAX_BRW_PAGES); tot_bytes += rnb[i].rnb_len; } LASSERT(*nr_local > 0 && *nr_local <= PTLRPC_MAX_BRW_PAGES); rc = dt_attr_get(env, ofd_object_child(fo), la, ofd_object_capa(env, fo)); if (unlikely(rc)) GOTO(buf_put, rc); rc = dt_read_prep(env, ofd_object_child(fo), lnb, *nr_local); if (unlikely(rc)) GOTO(buf_put, rc); ofd_counter_incr(exp, LPROC_OFD_STATS_READ, jobid, tot_bytes); RETURN(0); buf_put: dt_bufs_put(env, ofd_object_child(fo), lnb, *nr_local); unlock: ofd_read_unlock(env, fo); ofd_object_put(env, fo); return rc; }
int ofd_attr_get(const struct lu_env *env, struct ofd_object *fo, struct lu_attr *la) { int rc = 0; ENTRY; if (ofd_object_exists(fo)) { 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) /* 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. * This fixes up any bad values stored on disk before * returning them to the client, and ensures any timestamp * updates are correct. LU-1042 */ if (unlikely(la->la_atime == LU221_BAD_TIME)) la->la_atime = 0; if (unlikely(la->la_mtime == LU221_BAD_TIME)) 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; } 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_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; }
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); }
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; }
static int ofd_preprw_write(const struct lu_env *env, struct obd_export *exp, struct ofd_device *ofd, struct lu_fid *fid, struct lu_attr *la, struct obdo *oa, int objcount, struct obd_ioobj *obj, struct niobuf_remote *rnb, int *nr_local, struct niobuf_local *lnb, char *jobid) { struct ofd_object *fo; int i, j, k, rc = 0, tot_bytes = 0; ENTRY; LASSERT(env != NULL); LASSERT(objcount == 1); if (unlikely(exp->exp_obd->obd_recovering)) { struct ofd_thread_info *info = ofd_info(env); /* copied from ofd_precreate_object */ /* XXX this should be consolidated to use the same code * instead of a copy, due to the ongoing risk of bugs. */ memset(&info->fti_attr, 0, sizeof(info->fti_attr)); info->fti_attr.la_valid = LA_TYPE | LA_MODE; info->fti_attr.la_mode = S_IFREG | S_ISUID | S_ISGID | 0666; info->fti_attr.la_valid |= LA_ATIME | LA_MTIME | LA_CTIME; /* 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_atime = 0; info->fti_attr.la_mtime = 0; info->fti_attr.la_ctime = 0; fo = ofd_object_find_or_create(env, ofd, fid, &info->fti_attr); } else { fo = ofd_object_find(env, ofd, fid); } if (IS_ERR(fo)) GOTO(out, rc = PTR_ERR(fo)); LASSERT(fo != NULL); ofd_read_lock(env, fo); if (!ofd_object_exists(fo)) { CERROR("%s: BRW to missing obj "DOSTID"\n", exp->exp_obd->obd_name, POSTID(&obj->ioo_oid)); ofd_read_unlock(env, fo); ofd_object_put(env, fo); GOTO(out, rc = -ENOENT); } /* Process incoming grant info, set OBD_BRW_GRANTED flag and grant some * space back if possible */ ofd_grant_prepare_write(env, exp, oa, rnb, obj->ioo_bufcnt); /* parse remote buffers to local buffers and prepare the latter */ *nr_local = 0; for (i = 0, j = 0; i < obj->ioo_bufcnt; i++) { rc = dt_bufs_get(env, ofd_object_child(fo), rnb + i, lnb + j, 1, ofd_object_capa(env, fo)); if (unlikely(rc < 0)) GOTO(err, rc); LASSERT(rc <= PTLRPC_MAX_BRW_PAGES); /* correct index for local buffers to continue with */ for (k = 0; k < rc; k++) { lnb[j+k].lnb_flags = rnb[i].rnb_flags; if (!(rnb[i].rnb_flags & OBD_BRW_GRANTED)) lnb[j+k].lnb_rc = -ENOSPC; /* remote client can't break through quota */ if (exp_connect_rmtclient(exp)) lnb[j+k].lnb_flags &= ~OBD_BRW_NOQUOTA; } j += rc; *nr_local += rc; LASSERT(j <= PTLRPC_MAX_BRW_PAGES); tot_bytes += rnb[i].rnb_len; } LASSERT(*nr_local > 0 && *nr_local <= PTLRPC_MAX_BRW_PAGES); rc = dt_write_prep(env, ofd_object_child(fo), lnb, *nr_local); if (unlikely(rc != 0)) GOTO(err, rc); ofd_counter_incr(exp, LPROC_OFD_STATS_WRITE, jobid, tot_bytes); RETURN(0); err: dt_bufs_put(env, ofd_object_child(fo), lnb, *nr_local); ofd_read_unlock(env, fo); /* ofd_grant_prepare_write() was called, so we must commit */ ofd_grant_commit(env, exp, rc); out: /* let's still process incoming grant information packed in the oa, * but without enforcing grant since we won't proceed with the write. * Just like a read request actually. */ ofd_grant_prepare_read(env, exp, oa); return rc; }