/** get (name+parent_id) for an entry
* \param linkno hardlink index
* \retval -ENODATA after last link
* \retval -ERANGE if namelen is too small
*/
int Lustre_GetNameParent(const char *path, int linkno,
lustre_fid *pfid, char *name,
int namelen)
{
int rc, i, len;
char buf[4096];
struct linkea_data ldata = { 0 };
struct lu_buf lb = { 0 };
rc = lgetxattr(path, XATTR_NAME_LINK, buf, sizeof(buf));
if (rc < 0)
return -errno;
lb.lb_buf = buf;
lb.lb_len = sizeof(buf);
ldata.ld_buf = &lb;
ldata.ld_leh = (struct link_ea_header *)buf;
ldata.ld_lee = LINKEA_FIRST_ENTRY(ldata);
ldata.ld_reclen = (ldata.ld_lee->lee_reclen[0] << 8)
| ldata.ld_lee->lee_reclen[1];
if (linkno >= ldata.ld_leh->leh_reccount)
/* beyond last link */
return -ENODATA;
for (i = 0; i < linkno; i++) {
ldata.ld_lee = LINKEA_NEXT_ENTRY(ldata);
ldata.ld_reclen = (ldata.ld_lee->lee_reclen[0] << 8)
| ldata.ld_lee->lee_reclen[1];
}
memcpy(pfid, &ldata.ld_lee->lee_parent_fid, sizeof(*pfid));
fid_be_to_cpu(pfid, pfid);
if (!fid_is_sane(pfid))
{
DisplayLog(LVL_MAJOR, __func__, "insane fid: "DFID, PFID(pfid));
return -EPROTO;
}
len = ldata.ld_reclen - sizeof(struct link_ea_entry);
if (len >= namelen)
return -ERANGE;
strncpy(name, ldata.ld_lee->lee_name, len);
name[len] = '\0';
return 0;
}
/*
* Concurrency: no concurrent access is possible that early in object
* life-cycle.
*/
static int osd_object_init(const struct lu_env *env, struct lu_object *l,
const struct lu_object_conf *conf)
{
struct osd_object *obj = osd_obj(l);
struct osd_device *osd = osd_obj2dev(obj);
uint64_t oid;
int rc;
ENTRY;
LASSERT(osd_invariant(obj));
if (fid_is_otable_it(&l->lo_header->loh_fid)) {
obj->oo_dt.do_ops = &osd_obj_otable_it_ops;
l->lo_header->loh_attr |= LOHA_EXISTS;
RETURN(0);
}
if (conf != NULL && conf->loc_flags & LOC_F_NEW)
GOTO(out, rc = 0);
rc = osd_fid_lookup(env, osd, lu_object_fid(l), &oid);
if (rc == 0) {
LASSERT(obj->oo_db == NULL);
rc = __osd_obj2dbuf(env, osd->od_os, oid, &obj->oo_db);
/* EEXIST will be returned if object is being deleted in ZFS */
if (rc == -EEXIST) {
rc = 0;
GOTO(out, rc);
}
if (rc != 0) {
CERROR("%s: lookup "DFID"/"LPX64" failed: rc = %d\n",
osd->od_svname, PFID(lu_object_fid(l)), oid, rc);
GOTO(out, rc);
}
LASSERT(obj->oo_db);
rc = osd_object_init0(env, obj);
if (rc != 0)
GOTO(out, rc);
rc = osd_check_lma(env, obj);
if (rc != 0)
GOTO(out, rc);
} else if (rc == -ENOENT) {
rc = 0;
}
LASSERT(osd_invariant(obj));
out:
RETURN(rc);
}
/* Get POSIX path from fid (fid2path wrapper) */
int Lustre_GetFullPath( const entry_id_t * p_id, char *fullpath, unsigned int len )
{
char *curr = fullpath;
int rc;
long long recno = -1;
int linkno = 0;
char fid[256];
const char *mpath = NULL;
unsigned int mlen = 0;
mpath = get_mount_point(&mlen);
/* set mountpoint at the beginning of the path */
strcpy( fullpath, mpath );
curr += mlen;
/* add the slash only if fid2path doesn't */
#ifndef _FID2PATH_LEADING_SLASH
/* add slash */
*curr = '/';
curr ++;
#endif
/* just in case fid2path returns nothing */
*curr = '\0';
/* fid string */
sprintf( fid, DFID, PFID(p_id) );
/* MDT device */
/* ask the path to lustre */
rc = llapi_fid2path( mpath, fid, curr, len - mlen - 2, &recno,
&linkno );
if ( (rc != 0) && (rc != -ENOENT) && (rc != -ESTALE) )
DisplayLog( LVL_CRIT, "Fid2Path",
"Error %d calling llapi_fid2path(%s,%s,%lld,%d), errno=%d."
" Cannot retrieve full path for %s",
rc, mpath, fid, recno, linkno, errno, fid );
/* curr == fullpath => fullpath is root: '/'
* so don't remove final slash */
else if (curr != fullpath)
{
while (FINAL_SLASH(fullpath))
REMOVE_FINAL_SLASH(fullpath);
}
return rc;
}
/* Partial request to create object only */
static int mdt_md_mkobj(struct mdt_thread_info *info)
{
struct mdt_device *mdt = info->mti_mdt;
struct mdt_object *o;
struct mdt_body *repbody;
struct md_attr *ma = &info->mti_attr;
int rc;
ENTRY;
DEBUG_REQ(D_INODE, mdt_info_req(info), "Partial create "DFID"",
PFID(info->mti_rr.rr_fid2));
repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
o = mdt_object_find(info->mti_env, mdt, info->mti_rr.rr_fid2,
MDT_OBJ_MAY_NOT_EXIST);
if (!IS_ERR(o)) {
struct md_object *next = mdt_object_child(o);
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
/*
* Cross-ref create can encounter already created obj in case of
* recovery, just get attr in that case.
*/
if (mdt_object_exists(o) == 1) {
rc = mo_attr_get(info->mti_env, next, ma);
} else {
/*
* Here, NO permission check for object_create,
* such check has been done on the original MDS.
*/
rc = mo_object_create(info->mti_env, next,
&info->mti_spec, ma);
}
if (rc == 0) {
/* Return fid & attr to client. */
if (ma->ma_valid & MA_INODE)
mdt_pack_attr2body(info, repbody, &ma->ma_attr,
mdt_object_fid(o));
}
mdt_object_put(info->mti_env, o);
} else
rc = PTR_ERR(o);
mdt_create_pack_capa(info, rc, o, repbody);
RETURN(rc);
}
static int
lprocfs_fid_fid_seq_show(struct seq_file *m, void *unused)
{
struct lu_client_seq *seq = (struct lu_client_seq *)m->private;
int rc;
ENTRY;
LASSERT(seq != NULL);
mutex_lock(&seq->lcs_mutex);
rc = seq_printf(m, DFID"\n", PFID(&seq->lcs_fid));
mutex_unlock(&seq->lcs_mutex);
RETURN(rc);
}
static int lov_layout_wait(const struct lu_env *env, struct lov_object *lov)
{
struct l_wait_info lwi = { 0 };
ENTRY;
while (cfs_atomic_read(&lov->lo_active_ios) > 0) {
CDEBUG(D_INODE, "file:"DFID" wait for active IO, now: %d.\n",
PFID(lu_object_fid(lov2lu(lov))),
cfs_atomic_read(&lov->lo_active_ios));
l_wait_event(lov->lo_waitq,
cfs_atomic_read(&lov->lo_active_ios) == 0, &lwi);
}
RETURN(0);
}
/**
* Get the first operation for a given id.
* @return an operation to be processed when it is possible.
* NULL else.
*
*/
entry_proc_op_t *id_constraint_get_first_op( entry_id_t * p_id )
{
unsigned int hash_index;
id_constraint_item_t *p_curr;
entry_proc_op_t *p_op = NULL;
/* compute id hash value */
hash_index = hash_id( p_id, ID_HASH_SIZE );
P( id_hash[hash_index].lock );
for ( p_curr = id_hash[hash_index].id_list_first; p_curr != NULL; p_curr = p_curr->p_next )
{
if ( entry_id_equal( p_id, &p_curr->op_ptr->entry_id ) )
{
p_op = p_curr->op_ptr;
break;
}
}
#ifdef _DEBUG_ID_CONSTRAINT
if ( p_op )
printf( "first op on id "DFID" at stage %u (list %u)\n",
PFID(&p_op->entry_id), p_op->pipeline_stage, hash_index );
else
{
printf( "no registered operation on "DFID"?\n", PFID(p_id));
printf( "etat de la file %u:\n", hash_index );
for ( p_curr = id_hash[hash_index].id_list_first; p_curr != NULL; p_curr = p_curr->p_next )
printf( DFID"\n", PFID(&p_curr->op_ptr->entry_id) );
}
#endif
V( id_hash[hash_index].lock );
return p_op;
}
static int vvp_prune(const struct lu_env *env, struct cl_object *obj)
{
struct inode *inode = vvp_object_inode(obj);
int rc;
rc = cl_sync_file_range(inode, 0, OBD_OBJECT_EOF, CL_FSYNC_LOCAL, 1);
if (rc < 0) {
CDEBUG(D_VFSTRACE, DFID ": writeback failed: %d\n",
PFID(lu_object_fid(&obj->co_lu)), rc);
return rc;
}
truncate_inode_pages(inode->i_mapping, 0);
return 0;
}
static int out_xattr_get(struct tgt_session_info *tsi)
{
const struct lu_env *env = tsi->tsi_env;
struct tgt_thread_info *tti = tgt_th_info(env);
struct update *update = tti->tti_u.update.tti_update;
struct lu_buf *lbuf = &tti->tti_buf;
struct update_reply *reply = tti->tti_u.update.tti_update_reply;
struct dt_object *obj = tti->tti_u.update.tti_dt_object;
char *name;
void *ptr;
int rc;
ENTRY;
name = (char *)update_param_buf(update, 0, NULL);
if (name == NULL) {
CERROR("%s: empty name for xattr get: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
ptr = update_get_buf_internal(reply, 0, NULL);
LASSERT(ptr != NULL);
/* The first 4 bytes(int) are used to store the result */
lbuf->lb_buf = (char *)ptr + sizeof(int);
lbuf->lb_len = UPDATE_BUFFER_SIZE - sizeof(struct update_reply);
dt_read_lock(env, obj, MOR_TGT_CHILD);
rc = dt_xattr_get(env, obj, lbuf, name, NULL);
dt_read_unlock(env, obj);
if (rc < 0) {
lbuf->lb_len = 0;
GOTO(out, rc);
}
if (rc == 0) {
lbuf->lb_len = 0;
GOTO(out, rc = -ENOENT);
}
lbuf->lb_len = rc;
rc = 0;
CDEBUG(D_INFO, "%s: "DFID" get xattr %s len %d\n",
tgt_name(tsi->tsi_tgt), PFID(lu_object_fid(&obj->do_lu)),
name, (int)lbuf->lb_len);
out:
*(int *)ptr = rc;
reply->ur_lens[0] = lbuf->lb_len + sizeof(int);
RETURN(rc);
}
static int ll_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
{
int count = 0;
bool printed = false;
bool retry;
int result;
ll_stats_ops_tally(ll_i2sbi(file_inode(vma->vm_file)),
LPROC_LL_MKWRITE, 1);
file_update_time(vma->vm_file);
do {
retry = false;
result = ll_page_mkwrite0(vma, vmf->page, &retry);
if (!printed && ++count > 16) {
const struct dentry *de = file_dentry(vma->vm_file);
CWARN("app(%s): the page %lu of file "DFID" is under"
" heavy contention\n",
current->comm, vmf->pgoff,
PFID(ll_inode2fid(de->d_inode)));
printed = true;
}
} while (retry);
switch(result) {
case 0:
LASSERT(PageLocked(vmf->page));
result = VM_FAULT_LOCKED;
break;
case -ENODATA:
case -EFAULT:
result = VM_FAULT_NOPAGE;
break;
case -ENOMEM:
result = VM_FAULT_OOM;
break;
case -EAGAIN:
result = VM_FAULT_RETRY;
break;
default:
result = VM_FAULT_SIGBUS;
break;
}
return result;
}
/**
* Cliens updates SOM attributes on MDS (including llog cookies):
* obd_getattr with no lock and md_setattr.
*/
int ll_som_update(struct inode *inode, struct md_op_data *op_data)
{
struct ll_inode_info *lli = ll_i2info(inode);
struct ptlrpc_request *request = NULL;
__u32 old_flags;
struct obdo *oa;
int rc;
LASSERT(op_data != NULL);
if (lli->lli_flags & LLIF_MDS_SIZE_LOCK)
CERROR("ino %lu/%u(flags %u) som valid it just after recovery\n",
inode->i_ino, inode->i_generation,
lli->lli_flags);
oa = kmem_cache_alloc(obdo_cachep, GFP_NOFS | __GFP_ZERO);
if (!oa) {
CERROR("can't allocate memory for Size-on-MDS update.\n");
return -ENOMEM;
}
old_flags = op_data->op_flags;
op_data->op_flags = MF_SOM_CHANGE;
/* If inode is already in another epoch, skip getattr from OSTs. */
if (lli->lli_ioepoch == op_data->op_ioepoch) {
rc = ll_inode_getattr(inode, oa, op_data->op_ioepoch,
old_flags & MF_GETATTR_LOCK);
if (rc) {
oa->o_valid = 0;
if (rc != -ENOENT)
CERROR("inode_getattr failed (%d): unable to send a Size-on-MDS attribute update for inode %lu/%u\n",
rc, inode->i_ino,
inode->i_generation);
} else {
CDEBUG(D_INODE, "Size-on-MDS update on "DFID"\n",
PFID(&lli->lli_fid));
}
/* Install attributes into op_data. */
md_from_obdo(op_data, oa, oa->o_valid);
}
rc = md_setattr(ll_i2sbi(inode)->ll_md_exp, op_data,
NULL, 0, NULL, 0, &request, NULL);
ptlrpc_req_finished(request);
kmem_cache_free(obdo_cachep, oa);
return rc;
}
static int
seq_client_proc_read_fid(char *page, char **start, off_t off,
int count, int *eof, void *data)
{
struct lu_client_seq *seq = (struct lu_client_seq *)data;
int rc;
ENTRY;
LASSERT(seq != NULL);
cfs_down(&seq->lcs_sem);
rc = snprintf(page, count, DFID"\n", PFID(&seq->lcs_fid));
cfs_up(&seq->lcs_sem);
RETURN(rc);
}
static int out_tx_ref_add_undo(struct mdt_thread_info *info, struct thandle *th,
struct tx_arg *arg)
{
struct dt_object *dt_obj = arg->object;
LASSERT(dt_obj != NULL && !IS_ERR(dt_obj));
CDEBUG(D_OTHER, "ref del "DFID"\n",
PFID(lu_object_fid(&arg->object->do_lu)));
dt_write_lock(info->mti_env, dt_obj, MOR_TGT_CHILD);
dt_ref_del(info->mti_env, dt_obj, th);
dt_write_unlock(info->mti_env, dt_obj);
return 0;
}
static int osc_object_prune(const struct lu_env *env, struct cl_object *obj)
{
struct osc_object *osc = cl2osc(obj);
struct ldlm_res_id *resname = &osc_env_info(env)->oti_resname;
LASSERTF(osc->oo_npages == 0,
DFID "still have %lu pages, obj: %p, osc: %p\n",
PFID(lu_object_fid(&obj->co_lu)), osc->oo_npages, obj, osc);
/* DLM locks don't hold a reference of osc_object so we have to
* clear it before the object is being destroyed. */
ostid_build_res_name(&osc->oo_oinfo->loi_oi, resname);
ldlm_resource_iterate(osc_export(osc)->exp_obd->obd_namespace, resname,
osc_object_ast_clear, osc);
return 0;
}
/**
* Lookup method for "fid" object. Only filenames with correct SEQ:OID format
* are valid. We also check if object with passed fid exists or not.
*/
static int obf_lookup(const struct lu_env *env, struct md_object *p,
const struct lu_name *lname, struct lu_fid *f,
struct md_op_spec *spec)
{
char *name = (char *)lname->ln_name;
struct mdd_device *mdd = mdo2mdd(p);
struct mdd_object *child;
int rc = 0;
while (*name == '[')
name++;
sscanf(name, SFID, RFID(f));
if (!fid_is_sane(f)) {
CWARN("%s: Trying to lookup invalid FID [%s] in %s/%s, FID "
"format should be "DFID"\n", mdd2obd_dev(mdd)->obd_name,
lname->ln_name, dot_lustre_name, mdd_obf_dir_name,
(__u64)FID_SEQ_NORMAL, 1, 0);
GOTO(out, rc = -EINVAL);
}
if (!fid_is_norm(f) && !fid_is_igif(f) && !fid_is_root(f) &&
!fid_seq_is_dot(f->f_seq)) {
CWARN("%s: Trying to lookup invalid FID "DFID" in %s/%s, "
"sequence should be >= "LPX64" or within ["LPX64","
""LPX64"].\n", mdd2obd_dev(mdd)->obd_name, PFID(f),
dot_lustre_name, mdd_obf_dir_name, (__u64)FID_SEQ_NORMAL,
(__u64)FID_SEQ_IGIF, (__u64)FID_SEQ_IGIF_MAX);
GOTO(out, rc = -EINVAL);
}
/* Check if object with this fid exists */
child = mdd_object_find(env, mdd, f);
if (child == NULL)
GOTO(out, rc = 0);
if (IS_ERR(child))
GOTO(out, rc = PTR_ERR(child));
if (mdd_object_exists(child) == 0)
rc = -ENOENT;
mdd_object_put(env, child);
out:
return rc;
}
static int out_tx_ref_add_exec(struct mdt_thread_info *info, struct thandle *th,
struct tx_arg *arg)
{
struct dt_object *dt_obj = arg->object;
LASSERT(dt_obj != NULL && !IS_ERR(dt_obj));
CDEBUG(D_OTHER, "ref add "DFID"\n",
PFID(lu_object_fid(&arg->object->do_lu)));
dt_write_lock(info->mti_env, dt_obj, MOR_TGT_CHILD);
dt_ref_add(info->mti_env, dt_obj, th);
dt_write_unlock(info->mti_env, dt_obj);
update_insert_reply(arg->reply, NULL, 0, arg->index, 0);
return 0;
}
/**
* delete an orphan \a obj from orphan index.
* \param obj file or directory.
* \param th transaction for index deletion and object destruction.
*
* \pre obj->mod_count == 0 && ORPHAN_OBJ is set for obj.
*
* \retval 0 success
* \retval -ve index operation error.
*/
int mdd_orphan_delete(const struct lu_env *env, struct mdd_object *obj,
struct thandle *th)
{
struct mdd_device *mdd = mdo2mdd(&obj->mod_obj);
struct dt_object *dor = mdd->mdd_orphans;
struct dt_key *key;
int rc = 0;
ENTRY;
LASSERT(mdd_write_locked(env, obj) != 0);
LASSERT(obj->mod_flags & ORPHAN_OBJ);
LASSERT(obj->mod_count == 0);
LASSERT(dor);
key = mdd_orphan_key_fill(env, mdo2fid(obj));
dt_write_lock(env, mdd->mdd_orphans, MOR_TGT_ORPHAN);
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_ORPHAN_DELETE))
goto ref_del;
rc = dt_delete(env, mdd->mdd_orphans, key, th);
if (rc == -ENOENT) {
key = mdd_orphan_key_fill_20(env, mdo2fid(obj));
rc = dt_delete(env, mdd->mdd_orphans, key, th);
}
ref_del:
if (!rc) {
/* lov objects will be destroyed by caller */
mdo_ref_del(env, obj, th);
if (S_ISDIR(mdd_object_type(obj))) {
mdo_ref_del(env, obj, th);
dt_ref_del(env, mdd->mdd_orphans, th);
}
obj->mod_flags &= ~ORPHAN_OBJ;
} else {
CERROR("%s: could not delete orphan object "DFID": rc = %d\n",
mdd2obd_dev(mdd)->obd_name, PFID(mdo2fid(obj)), rc);
}
dt_write_unlock(env, mdd->mdd_orphans);
RETURN(rc);
}
int ShookRecoverById(const entry_id_t *p_id, file_status_t *p_status)
{
int rc;
shook_state st;
rc = shook_recov_pending(get_fsname(), p_id, &st, 0);
if (rc < 0)
return rc;
*p_status = shook2rbh_status(st);
if (*p_status == (file_status_t)-1) {
DisplayLog(LVL_CRIT, SHOOK_TAG,
"ERROR getting recovering " DFID ": unknown status %d",
PFID(p_id), (int)st);
return -EINVAL;
}
return 0;
}
/**
* \a connectable - is nfsd will connect himself or this should be done
* at lustre
*
* The return value is file handle type:
* 1 -- contains child file handle;
* 2 -- contains child file handle and parent file handle;
* 255 -- error.
*/
static int ll_encode_fh(struct inode *inode, __u32 *fh, int *plen,
struct inode *parent)
{
struct lustre_nfs_fid *nfs_fid = (void *)fh;
CDEBUG(D_INFO, "encoding for (%lu,"DFID") maxlen=%d minlen=%d\n",
inode->i_ino, PFID(ll_inode2fid(inode)), *plen,
(int)sizeof(struct lustre_nfs_fid));
if (*plen < sizeof(struct lustre_nfs_fid) / 4)
return 255;
nfs_fid->lnf_child = *ll_inode2fid(inode);
nfs_fid->lnf_parent = *ll_inode2fid(parent);
*plen = sizeof(struct lustre_nfs_fid) / 4;
return LUSTRE_NFS_FID;
}
/**
* FLR: verify the layout version of object.
*
* \param[in] env execution environment
* \param[in] fo OFD object
* \param[in] oa OBDO structure with layout version
*
* \retval 0 on successful verification
* \retval -EINPROGRESS layout version is in transfer
* \retval -ESTALE the layout version on client is stale
*/
int ofd_verify_layout_version(const struct lu_env *env,
struct ofd_object *fo, const struct obdo *oa)
{
__u32 layout_version;
int rc;
ENTRY;
if (unlikely(OBD_FAIL_CHECK(OBD_FAIL_OST_SKIP_LV_CHECK)))
GOTO(out, rc = 0);
rc = ofd_object_ff_load(env, fo);
if (rc < 0) {
if (rc == -ENODATA)
rc = -EINPROGRESS;
GOTO(out, rc);
}
layout_version = fo->ofo_ff.ff_layout_version;
if (oa->o_layout_version >= layout_version &&
oa->o_layout_version <= layout_version + fo->ofo_ff.ff_range)
GOTO(out, rc = 0);
/* normal traffic, decide if to return ESTALE or EINPROGRESS */
layout_version &= ~LU_LAYOUT_RESYNC;
/* this update is not legitimate */
if ((oa->o_layout_version & ~LU_LAYOUT_RESYNC) <= layout_version)
GOTO(out, rc = -ESTALE);
/* layout version may not be transmitted yet */
if ((oa->o_layout_version & ~LU_LAYOUT_RESYNC) > layout_version)
GOTO(out, rc = -EINPROGRESS);
EXIT;
out:
CDEBUG(D_INODE, DFID " verify layout version: %u vs. %u/%u, rc: %d\n",
PFID(lu_object_fid(&fo->ofo_obj.do_lu)),
oa->o_layout_version, fo->ofo_ff.ff_layout_version,
fo->ofo_ff.ff_range, rc);
return rc;
}
/**
* Mark the linkEA as overflow with current timestamp,
* and remove the last linkEA entry.
*
* Return the new linkEA size.
*/
int linkea_overflow_shrink(struct linkea_data *ldata)
{
struct link_ea_header *leh;
struct lu_name tname;
struct lu_fid tfid;
int count;
leh = ldata->ld_leh = ldata->ld_buf->lb_buf;
if (leh->leh_magic == __swab32(LINK_EA_MAGIC)) {
leh->leh_magic = LINK_EA_MAGIC;
leh->leh_reccount = __swab32(leh->leh_reccount);
leh->leh_overflow_time = __swab32(leh->leh_overflow_time);
leh->leh_padding = __swab32(leh->leh_padding);
}
LASSERT(leh->leh_reccount > 0);
leh->leh_len = sizeof(struct link_ea_header);
leh->leh_reccount--;
if (unlikely(leh->leh_reccount == 0))
return 0;
leh->leh_overflow_time = cfs_time_current_sec();
if (unlikely(leh->leh_overflow_time == 0))
leh->leh_overflow_time++;
ldata->ld_reclen = 0;
ldata->ld_lee = (struct link_ea_entry *)(leh + 1);
for (count = 0; count < leh->leh_reccount; count++) {
linkea_entry_unpack(ldata->ld_lee, &ldata->ld_reclen,
&tname, &tfid);
leh->leh_len += ldata->ld_reclen;
ldata->ld_lee = (struct link_ea_entry *)((char *)ldata->ld_lee +
ldata->ld_reclen);
}
linkea_entry_unpack(ldata->ld_lee, &ldata->ld_reclen, &tname, &tfid);
CDEBUG(D_INODE, "No enough space to hold the last linkea entry '"
DFID": %.*s', shrink it, left %d linkea entries, size %llu\n",
PFID(&tfid), tname.ln_namelen, tname.ln_name,
leh->leh_reccount, leh->leh_len);
return leh->leh_len;
}
static int plain_print_cb(const struct lu_env *env, struct llog_handle *llh,
struct llog_rec_hdr *rec, void *data)
{
struct lu_fid fid = {0};
if (!(llh->lgh_hdr->llh_flags & LLOG_F_IS_PLAIN)) {
CERROR("log is not plain\n");
return -EINVAL;
}
logid_to_fid(&llh->lgh_id, &fid);
CDEBUG(D_INFO, "seeing record at index %d in log "DFID"\n",
rec->lrh_index, PFID(&fid));
plain_counter++;
return 0;
}
/** Cliens updates SOM attributes on MDS: obd_getattr and md_setattr. */
int llu_som_update(struct inode *inode, struct md_op_data *op_data)
{
struct llu_inode_info *lli = llu_i2info(inode);
struct llu_sb_info *sbi = llu_i2sbi(inode);
struct obdo oa = { 0 };
__u32 old_flags;
int rc;
ENTRY;
LASSERT(!(lli->lli_flags & LLIF_MDS_SIZE_LOCK));
LASSERT(sbi->ll_lco.lco_flags & OBD_CONNECT_SOM);
old_flags = op_data->op_flags;
op_data->op_flags = MF_SOM_CHANGE;
/* If inode is already in another epoch, skip getattr from OSTs. */
if (lli->lli_ioepoch == op_data->op_ioepoch) {
rc = llu_inode_getattr(inode, &oa, op_data->op_ioepoch,
old_flags & MF_GETATTR_LOCK);
if (rc) {
oa.o_valid = 0;
if (rc == -ENOENT)
CDEBUG(D_INODE, "objid "LPX64" is destroyed\n",
lli->lli_smd->lsm_object_id);
else
CERROR("inode_getattr failed (%d): unable to "
"send a Size-on-MDS attribute update "
"for inode %llu/%lu\n", rc,
(long long)llu_i2stat(inode)->st_ino,
lli->lli_st_generation);
} else {
CDEBUG(D_INODE, "Size-on-MDS update on "DFID"\n",
PFID(&lli->lli_fid));
}
/* Install attributes into op_data. */
md_from_obdo(op_data, &oa, oa.o_valid);
}
rc = llu_md_setattr(inode, op_data, NULL);
RETURN(rc);
}
static int out_obj_index_delete(const struct lu_env *env,
struct dt_object *dt_obj,
const struct dt_key *key,
struct thandle *th)
{
int rc;
CDEBUG(D_INFO, "%s: index delete "DFID" name: %s\n",
dt_obd_name(th->th_dev), PFID(lu_object_fid(&dt_obj->do_lu)),
(char *)key);
if (dt_try_as_dir(env, dt_obj) == 0)
return -ENOTDIR;
dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
rc = dt_delete(env, dt_obj, key, th, NULL);
dt_write_unlock(env, dt_obj);
return rc;
}
static int out_tx_attr_set_exec(const struct lu_env *env, struct thandle *th,
struct tx_arg *arg)
{
struct dt_object *dt_obj = arg->object;
int rc;
CDEBUG(D_OTHER, "%s: attr set "DFID"\n", dt_obd_name(th->th_dev),
PFID(lu_object_fid(&dt_obj->do_lu)));
dt_write_lock(env, dt_obj, MOR_TGT_CHILD);
rc = dt_attr_set(env, dt_obj, &arg->u.attr_set.attr, th, NULL);
dt_write_unlock(env, dt_obj);
CDEBUG(D_INFO, "%s: insert attr_set reply %p index %d: rc = %d\n",
dt_obd_name(th->th_dev), arg->reply, arg->index, rc);
update_insert_reply(arg->reply, NULL, 0, arg->index, rc);
return rc;
}
void mdt_dump_lmv(unsigned int level, const union lmv_mds_md *lmv)
{
const struct lmv_mds_md_v1 *lmm1;
int i;
if (likely(!cfs_cdebug_show(level, DEBUG_SUBSYSTEM)))
return;
lmm1 = &lmv->lmv_md_v1;
CDEBUG(level, "magic 0x%08X, master %#X stripe_count %#x\n",
le32_to_cpu(lmm1->lmv_magic),
le32_to_cpu(lmm1->lmv_master_mdt_index),
le32_to_cpu(lmm1->lmv_stripe_count));
for (i = 0; i < le32_to_cpu(lmm1->lmv_stripe_count); i++) {
struct lu_fid fid;
fid_le_to_cpu(&fid, &lmm1->lmv_stripe_fids[i]);
CDEBUG(level, "idx %u subobj "DFID"\n", i, PFID(&fid));
}
}
static int out_tx_attr_set_exec(struct mdt_thread_info *info,
struct thandle *th, struct tx_arg *arg)
{
struct dt_object *dt_obj = arg->object;
int rc;
LASSERT(dt_obj != NULL && !IS_ERR(dt_obj));
CDEBUG(D_OTHER, "attr set "DFID"\n",
PFID(lu_object_fid(&arg->object->do_lu)));
dt_write_lock(info->mti_env, dt_obj, MOR_TGT_CHILD);
rc = dt_attr_set(info->mti_env, dt_obj, &arg->u.attr_set.attr,
th, NULL);
dt_write_unlock(info->mti_env, dt_obj);
update_insert_reply(arg->reply, NULL, 0, arg->index, rc);
return rc;
}
static int vvp_object_print(const struct lu_env *env, void *cookie,
lu_printer_t p, const struct lu_object *o)
{
struct vvp_object *obj = lu2vvp(o);
struct inode *inode = obj->vob_inode;
struct ll_inode_info *lli;
(*p)(env, cookie, "(%d %d) inode: %p ",
atomic_read(&obj->vob_transient_pages),
atomic_read(&obj->vob_mmap_cnt),
inode);
if (inode) {
lli = ll_i2info(inode);
(*p)(env, cookie, "%lu/%u %o %u %d %p "DFID,
inode->i_ino, inode->i_generation, inode->i_mode,
inode->i_nlink, atomic_read(&inode->i_count),
lli->lli_clob, PFID(&lli->lli_fid));
}
return 0;
}
static struct dentry *
ll_iget_for_nfs(struct super_block *sb, struct lu_fid *fid, struct lu_fid *parent)
{
struct inode *inode;
struct dentry *result;
CDEBUG(D_INFO, "Get dentry for fid: "DFID"\n", PFID(fid));
if (!fid_is_sane(fid))
return ERR_PTR(-ESTALE);
inode = search_inode_for_lustre(sb, fid);
if (IS_ERR(inode))
return ERR_CAST(inode);
if (is_bad_inode(inode)) {
/* we didn't find the right inode.. */
iput(inode);
return ERR_PTR(-ESTALE);
}
/**
* It is an anonymous dentry without OST objects created yet.
* We have to find the parent to tell MDS how to init lov objects.
*/
if (S_ISREG(inode->i_mode) && !ll_i2info(inode)->lli_has_smd &&
parent != NULL) {
struct ll_inode_info *lli = ll_i2info(inode);
spin_lock(&lli->lli_lock);
lli->lli_pfid = *parent;
spin_unlock(&lli->lli_lock);
}
result = d_obtain_alias(inode);
if (IS_ERR(result)) {
iput(inode);
return result;
}
return result;
}
static int out_index_insert(struct tgt_session_info *tsi)
{
struct tgt_thread_info *tti = tgt_th_info(tsi->tsi_env);
struct object_update *update = tti->tti_u.update.tti_update;
struct dt_object *obj = tti->tti_u.update.tti_dt_object;
struct lu_fid *fid;
char *name;
int rc = 0;
int size;
ENTRY;
name = object_update_param_get(update, 0, NULL);
if (name == NULL) {
CERROR("%s: empty name for index insert: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
fid = object_update_param_get(update, 1, &size);
if (fid == NULL || size != sizeof(*fid)) {
CERROR("%s: invalid fid: rc = %d\n",
tgt_name(tsi->tsi_tgt), -EPROTO);
RETURN(err_serious(-EPROTO));
}
if (ptlrpc_req_need_swab(tsi->tsi_pill->rc_req))
lustre_swab_lu_fid(fid);
if (!fid_is_sane(fid)) {
CERROR("%s: invalid FID "DFID": rc = %d\n",
tgt_name(tsi->tsi_tgt), PFID(fid), -EPROTO);
RETURN(err_serious(-EPROTO));
}
rc = out_tx_index_insert(tsi->tsi_env, obj, name, fid,
&tti->tti_tea,
tti->tti_u.update.tti_update_reply,
tti->tti_u.update.tti_update_reply_index);
RETURN(rc);
}
