X-Git-Url: https://git.whamcloud.com/?p=fs%2Flustre-release.git;a=blobdiff_plain;f=lustre%2Fosd-ldiskfs%2Fosd_handler.c;h=819d963e5d8822927bbc1f3074a4888485a7ebd7;hp=426717b7750705767b98664c79616e069c862253;hb=e88b3bf26a477a2b42182c4b451bc2fe55fa88fa;hpb=7b6aaef15a6547550c99cdaa538ea8b1d4d87c88 diff --git a/lustre/osd-ldiskfs/osd_handler.c b/lustre/osd-ldiskfs/osd_handler.c index 426717b..819d963 100644 --- a/lustre/osd-ldiskfs/osd_handler.c +++ b/lustre/osd-ldiskfs/osd_handler.c @@ -72,8 +72,7 @@ /* llo_* api support */ #include -/* dt_acct_features */ -#include +#include #ifdef HAVE_LDISKFS_PDO int ldiskfs_pdo = 1; @@ -151,11 +150,7 @@ static struct lu_object *osd_object_alloc(const struct lu_env *env, l = &mo->oo_dt.do_lu; dt_object_init(&mo->oo_dt, NULL, d); - if (osd_dev(d)->od_iop_mode) - mo->oo_dt.do_ops = &osd_obj_ea_ops; - else - mo->oo_dt.do_ops = &osd_obj_ops; - + mo->oo_dt.do_ops = &osd_obj_ea_ops; l->lo_ops = &osd_lu_obj_ops; cfs_init_rwsem(&mo->oo_sem); cfs_init_rwsem(&mo->oo_ext_idx_sem); @@ -276,12 +271,10 @@ osd_iget_verify(struct osd_thread_info *info, struct osd_device *dev, return inode; rc = osd_get_lma(inode, &info->oti_obj_dentry, lma); + if (rc == -ENODATA) + return inode; + if (rc != 0) { - if (rc == -ENODATA) { - CDEBUG(D_LFSCK, "inconsistent obj: NULL, %lu, "DFID"\n", - inode->i_ino, PFID(fid)); - rc = -EREMCHG; - } iput(inode); return ERR_PTR(rc); } @@ -290,8 +283,9 @@ osd_iget_verify(struct osd_thread_info *info, struct osd_device *dev, CDEBUG(D_LFSCK, "inconsistent obj: "DFID", %lu, "DFID"\n", PFID(&lma->lma_self_fid), inode->i_ino, PFID(fid)); iput(inode); - return ERR_PTR(EREMCHG); + return ERR_PTR(-EREMCHG); } + return inode; } @@ -321,26 +315,27 @@ static int osd_fid_lookup(const struct lu_env *env, struct osd_object *obj, info = osd_oti_get(env); LASSERT(info); oic = &info->oti_cache; - id = &oic->oic_lid; if (OBD_FAIL_CHECK(OBD_FAIL_OST_ENOENT)) RETURN(-ENOENT); - if (fid_is_norm(fid)) { - /* Search order: 1. per-thread cache. */ - if (lu_fid_eq(fid, &oic->oic_fid)) { - goto iget; - } else if (!cfs_list_empty(&scrub->os_inconsistent_items)) { - /* Search order: 2. OI scrub pending list. */ - result = osd_oii_lookup(dev, fid, id); - if (result == 0) - goto iget; - } + /* Search order: 1. per-thread cache. */ + if (lu_fid_eq(fid, &oic->oic_fid)) { + id = &oic->oic_lid; + goto iget; + } - if (sf->sf_flags & SF_INCONSISTENT) - verify = 1; + id = &info->oti_id; + if (!cfs_list_empty(&scrub->os_inconsistent_items)) { + /* Search order: 2. OI scrub pending list. */ + result = osd_oii_lookup(dev, fid, id); + if (result == 0) + goto iget; } + if (sf->sf_flags & SF_INCONSISTENT) + verify = 1; + /* * Objects are created as locking anchors or place holders for objects * yet to be created. No need to osd_oi_lookup() at here because FID @@ -380,7 +375,7 @@ iget: trigger: if (thread_is_running(&scrub->os_thread)) { result = -EINPROGRESS; - } else if (!scrub->os_no_scrub) { + } else if (!dev->od_noscrub) { result = osd_scrub_start(dev); LCONSOLE_ERROR("%.16s: trigger OI scrub by RPC " "for "DFID", rc = %d [1]\n", @@ -398,10 +393,9 @@ trigger: obj->oo_inode = inode; LASSERT(obj->oo_inode->i_sb == osd_sb(dev)); - if (dev->od_iop_mode) { - obj->oo_compat_dot_created = 1; - obj->oo_compat_dotdot_created = 1; - } + + obj->oo_compat_dot_created = 1; + obj->oo_compat_dotdot_created = 1; if (!S_ISDIR(inode->i_mode) || !ldiskfs_pdo) /* done */ GOTO(out, result = 0); @@ -592,12 +586,12 @@ static void __osd_th_check_slow(void *oth, struct osd_device *dev, /* * Concurrency: doesn't access mutable data. */ -static int osd_param_is_sane(const struct osd_device *dev, - const struct thandle *th) +static int osd_param_is_not_sane(const struct osd_device *dev, + const struct thandle *th) { - struct osd_thandle *oh; - oh = container_of0(th, struct osd_thandle, ot_super); - return oh->ot_credits <= osd_journal(dev)->j_max_transaction_buffers; + struct osd_thandle *oh = container_of(th, typeof(*oh), ot_super); + + return oh->ot_credits > osd_journal(dev)->j_max_transaction_buffers; } /* @@ -693,30 +687,48 @@ int osd_trans_start(const struct lu_env *env, struct dt_device *d, if (rc != 0) GOTO(out, rc); - if (!osd_param_is_sane(dev, th)) { + if (unlikely(osd_param_is_not_sane(dev, th))) { + static unsigned long last_printed; + static int last_credits; + CWARN("%.16s: too many transaction credits (%d > %d)\n", LDISKFS_SB(osd_sb(dev))->s_es->s_volume_name, oh->ot_credits, osd_journal(dev)->j_max_transaction_buffers); - /* XXX Limit the credits to 'max_transaction_buffers', and - * let the underlying filesystem to catch the error if - * we really need so many credits. - * - * This should be removed when we can calculate the - * credits precisely. */ - oh->ot_credits = osd_journal(dev)->j_max_transaction_buffers; #ifdef OSD_TRACK_DECLARES - CERROR(" attr_set: %d, punch: %d, xattr_set: %d,\n", - oh->ot_declare_attr_set, oh->ot_declare_punch, - oh->ot_declare_xattr_set); - CERROR(" create: %d, ref_add: %d, ref_del: %d, write: %d\n", - oh->ot_declare_create, oh->ot_declare_ref_add, - oh->ot_declare_ref_del, oh->ot_declare_write); - CERROR(" insert: %d, delete: %d, destroy: %d\n", - oh->ot_declare_insert, oh->ot_declare_delete, - oh->ot_declare_destroy); + CWARN(" create: %u/%u, delete: %u/%u, destroy: %u/%u\n", + oh->ot_declare_create, oh->ot_declare_create_cred, + oh->ot_declare_delete, oh->ot_declare_delete_cred, + oh->ot_declare_destroy, oh->ot_declare_destroy_cred); + CWARN(" attr_set: %u/%u, xattr_set: %u/%u\n", + oh->ot_declare_attr_set, oh->ot_declare_attr_set_cred, + oh->ot_declare_xattr_set, oh->ot_declare_xattr_set_cred); + CWARN(" write: %u/%u, punch: %u/%u, quota %u/%u\n", + oh->ot_declare_write, oh->ot_declare_write_cred, + oh->ot_declare_punch, oh->ot_declare_punch_cred, + oh->ot_declare_quota, oh->ot_declare_quota_cred); + CWARN(" insert: %u/%u, delete: %u/%u\n", + oh->ot_declare_insert, oh->ot_declare_insert_cred, + oh->ot_declare_delete, oh->ot_declare_destroy_cred); + CWARN(" ref_add: %u/%u, ref_del: %u/%u\n", + oh->ot_declare_ref_add, oh->ot_declare_ref_add_cred, + oh->ot_declare_ref_del, oh->ot_declare_ref_del_cred); + + if (last_credits != oh->ot_credits && + time_after(jiffies, last_printed + 60 * HZ)) { + libcfs_debug_dumpstack(NULL); + last_credits = oh->ot_credits; + last_printed = jiffies; + } #endif - } + /* XXX Limit the credits to 'max_transaction_buffers', and + * let the underlying filesystem to catch the error if + * we really need so many credits. + * + * This should be removed when we can calculate the + * credits precisely. */ + oh->ot_credits = osd_journal(dev)->j_max_transaction_buffers; + } /* * XXX temporary stuff. Some abstraction layer should @@ -840,8 +852,24 @@ static void osd_object_delete(const struct lu_env *env, struct lu_object *l) osd_index_fini(obj); if (inode != NULL) { + struct qsd_instance *qsd = osd_obj2dev(obj)->od_quota_slave; + qid_t uid = inode->i_uid; + qid_t gid = inode->i_gid; + iput(inode); obj->oo_inode = NULL; + + if (qsd != NULL) { + struct osd_thread_info *info = osd_oti_get(env); + struct lquota_id_info *qi = &info->oti_qi; + + /* Release granted quota to master if necessary */ + qi->lqi_id.qid_uid = uid; + qsd_op_adjust(env, qsd, &qi->lqi_id, USRQUOTA); + + qi->lqi_id.qid_uid = gid; + qsd_op_adjust(env, qsd, &qi->lqi_id, GRPQUOTA); + } } } @@ -904,6 +932,8 @@ int osd_statfs(const struct lu_env *env, struct dt_device *d, if (likely(result == 0)) { /* N.B. statfs can't really fail */ osd->od_osfs_age = cfs_time_current_64(); statfs_pack(&osd->od_statfs, ksfs); + if (sb->s_flags & MS_RDONLY) + sfs->os_state = OS_STATE_READONLY; } } @@ -917,6 +947,17 @@ int osd_statfs(const struct lu_env *env, struct dt_device *d, return result; } +/** + * Estimate space needed for file creations. We assume the largest filename + * which is 2^64 - 1, hence a filename of 20 chars. + * This is 28 bytes per object which is 28MB for 1M objects ... no so bad. + */ +#ifdef __LDISKFS_DIR_REC_LEN +#define PER_OBJ_USAGE __LDISKFS_DIR_REC_LEN(20) +#else +#define PER_OBJ_USAGE LDISKFS_DIR_REC_LEN(20) +#endif + /* * Concurrency: doesn't access mutable data. */ @@ -934,6 +975,15 @@ static void osd_conf_get(const struct lu_env *env, param->ddp_max_nlink = LDISKFS_LINK_MAX; param->ddp_block_shift = sb->s_blocksize_bits; param->ddp_mount_type = LDD_MT_LDISKFS; + param->ddp_maxbytes = sb->s_maxbytes; + /* Overhead estimate should be fairly accurate, so we really take a tiny + * error margin which also avoids fragmenting the filesystem too much */ + param->ddp_grant_reserved = 2; /* end up to be 1.9% after conversion */ + /* inode are statically allocated, so per-inode space consumption + * is the space consumed by the directory entry */ + param->ddp_inodespace = PER_OBJ_USAGE; + /* per-fragment overhead to be used by the client code */ + param->ddp_grant_frag = 6 * LDISKFS_BLOCK_SIZE(sb); param->ddp_mntopts = 0; if (test_opt(sb, XATTR_USER)) param->ddp_mntopts |= MNTOPT_USERXATTR; @@ -1027,25 +1077,6 @@ static int osd_init_capa_ctxt(const struct lu_env *env, struct dt_device *d, } /** - * Concurrency: serialization provided by callers. - */ -static void osd_init_quota_ctxt(const struct lu_env *env, struct dt_device *d, - struct dt_quota_ctxt *ctxt, void *data) -{ - struct obd_device *obd = (void *)ctxt; - struct vfsmount *mnt = (struct vfsmount *)data; - ENTRY; - - obd->u.obt.obt_sb = mnt->mnt_root->d_inode->i_sb; - OBD_SET_CTXT_MAGIC(&obd->obd_lvfs_ctxt); - obd->obd_lvfs_ctxt.pwdmnt = mnt; - obd->obd_lvfs_ctxt.pwd = mnt->mnt_root; - obd->obd_lvfs_ctxt.fs = get_ds(); - - EXIT; -} - -/** * Note: we do not count into QUOTA here. * If we mount with --data_journal we may need more. */ @@ -1113,7 +1144,6 @@ static const struct dt_device_operations osd_dt_ops = { .dt_ro = osd_ro, .dt_commit_async = osd_commit_async, .dt_init_capa_ctxt = osd_init_capa_ctxt, - .dt_init_quota_ctxt= osd_init_quota_ctxt, }; static void osd_object_read_lock(const struct lu_env *env, @@ -1362,8 +1392,8 @@ static int osd_declare_attr_set(const struct lu_env *env, oh = container_of0(handle, struct osd_thandle, ot_super); LASSERT(oh->ot_handle == NULL); - OSD_DECLARE_OP(oh, attr_set); - oh->ot_credits += osd_dto_credits_noquota[DTO_ATTR_SET_BASE]; + OSD_DECLARE_OP(oh, attr_set, + osd_dto_credits_noquota[DTO_ATTR_SET_BASE]); if (attr == NULL || obj->oo_inode == NULL) RETURN(rc); @@ -1571,6 +1601,7 @@ static int osd_attr_set(const struct lu_env *env, OSD_EXEC_OP(handle, attr_set); inode = obj->oo_inode; + ll_vfs_dq_init(inode); rc = osd_quota_transfer(inode, attr); if (rc) @@ -1654,7 +1685,6 @@ static int osd_mkdir(struct osd_thread_info *info, struct osd_object *obj, { int result; struct osd_thandle *oth; - struct osd_device *osd = osd_obj2dev(obj); __u32 mode = (attr->la_mode & (S_IFMT | S_IRWXUGO | S_ISVTX)); LASSERT(S_ISDIR(attr->la_mode)); @@ -1662,16 +1692,7 @@ static int osd_mkdir(struct osd_thread_info *info, struct osd_object *obj, oth = container_of(th, struct osd_thandle, ot_super); LASSERT(oth->ot_handle->h_transaction != NULL); result = osd_mkfile(info, obj, mode, hint, th); - if (result == 0 && osd->od_iop_mode == 0) { - LASSERT(obj->oo_inode != NULL); - /* - * XXX uh-oh... call low-level iam function directly. - */ - result = iam_lvar_create(obj->oo_inode, OSD_NAME_LEN, 4, - sizeof (struct osd_fid_pack), - oth->ot_handle); - } return result; } @@ -1898,42 +1919,40 @@ static int __osd_oi_insert(const struct lu_env *env, struct osd_object *obj, } static int osd_declare_object_create(const struct lu_env *env, - struct dt_object *dt, - struct lu_attr *attr, - struct dt_allocation_hint *hint, - struct dt_object_format *dof, - struct thandle *handle) + struct dt_object *dt, + struct lu_attr *attr, + struct dt_allocation_hint *hint, + struct dt_object_format *dof, + struct thandle *handle) { struct osd_thandle *oh; int rc; ENTRY; - LASSERT(handle != NULL); + LASSERT(handle != NULL); - oh = container_of0(handle, struct osd_thandle, ot_super); - LASSERT(oh->ot_handle == NULL); + oh = container_of0(handle, struct osd_thandle, ot_super); + LASSERT(oh->ot_handle == NULL); - OSD_DECLARE_OP(oh, create); - oh->ot_credits += osd_dto_credits_noquota[DTO_OBJECT_CREATE]; - /* XXX: So far, only normal fid needs be inserted into the oi, - * things could be changed later. Revise following code then. */ - if (fid_is_norm(lu_object_fid(&dt->do_lu))) { - OSD_DECLARE_OP(oh, insert); - oh->ot_credits += osd_dto_credits_noquota[DTO_INDEX_INSERT]; + OSD_DECLARE_OP(oh, create, osd_dto_credits_noquota[DTO_OBJECT_CREATE]); + /* XXX: So far, only normal fid needs be inserted into the oi, + * things could be changed later. Revise following code then. */ + if (fid_is_norm(lu_object_fid(&dt->do_lu))) { /* Reuse idle OI block may cause additional one OI block * to be changed. */ - oh->ot_credits += 1; - } - /* If this is directory, then we expect . and .. to be inserted as - * well. The one directory block always needs to be created for the - * directory, so we could use DTO_WRITE_BASE here (GDT, block bitmap, - * block), there is no danger of needing a tree for the first block. - */ - if (attr && S_ISDIR(attr->la_mode)) { - OSD_DECLARE_OP(oh, insert); - OSD_DECLARE_OP(oh, insert); - oh->ot_credits += osd_dto_credits_noquota[DTO_WRITE_BASE]; - } + OSD_DECLARE_OP(oh, insert, + osd_dto_credits_noquota[DTO_INDEX_INSERT] + 1); + } + /* If this is directory, then we expect . and .. to be inserted as + * well. The one directory block always needs to be created for the + * directory, so we could use DTO_WRITE_BASE here (GDT, block bitmap, + * block), there is no danger of needing a tree for the first block. + */ + if (attr && S_ISDIR(attr->la_mode)) { + OSD_DECLARE_OP(oh, insert, + osd_dto_credits_noquota[DTO_WRITE_BASE]); + OSD_DECLARE_OP(oh, insert, 0); + } if (!attr) RETURN(0); @@ -1983,40 +2002,36 @@ static int osd_object_create(const struct lu_env *env, struct dt_object *dt, * Concurrency: must be locked */ static int osd_declare_object_destroy(const struct lu_env *env, - struct dt_object *dt, - struct thandle *th) + struct dt_object *dt, + struct thandle *th) { - struct osd_object *obj = osd_dt_obj(dt); - struct inode *inode = obj->oo_inode; - struct osd_thandle *oh; - int rc; - ENTRY; + struct osd_object *obj = osd_dt_obj(dt); + struct inode *inode = obj->oo_inode; + struct osd_thandle *oh; + int rc; + ENTRY; - oh = container_of0(th, struct osd_thandle, ot_super); - LASSERT(oh->ot_handle == NULL); - LASSERT(inode); + oh = container_of0(th, struct osd_thandle, ot_super); + LASSERT(oh->ot_handle == NULL); + LASSERT(inode); - OSD_DECLARE_OP(oh, destroy); - OSD_DECLARE_OP(oh, delete); - oh->ot_credits += osd_dto_credits_noquota[DTO_OBJECT_DELETE]; - /* XXX: So far, only normal fid needs to be inserted into the OI, - * so only normal fid needs to be removed from the OI also. */ - if (fid_is_norm(lu_object_fid(&dt->do_lu))) { - oh->ot_credits += osd_dto_credits_noquota[DTO_INDEX_DELETE]; - /* Recycle idle OI leaf may cause additional three OI blocks - * to be changed. */ - oh->ot_credits += 3; - } + OSD_DECLARE_OP(oh, delete, osd_dto_credits_noquota[DTO_OBJECT_DELETE]); + /* XXX: So far, only normal fid needs to be inserted into the OI, + * so only normal fid needs to be removed from the OI also. + * Recycle idle OI leaf may cause additional three OI blocks + * to be changed. */ + OSD_DECLARE_OP(oh, destroy, fid_is_norm(lu_object_fid(&dt->do_lu)) ? + osd_dto_credits_noquota[DTO_INDEX_DELETE] + 3 : 0); /* one less inode */ - rc = osd_declare_inode_qid(env, inode->i_uid, inode->i_gid, -1, oh, + rc = osd_declare_inode_qid(env, inode->i_uid, inode->i_gid, -1, oh, false, true, NULL, false); if (rc) RETURN(rc); /* data to be truncated */ - rc = osd_declare_inode_qid(env, inode->i_uid, inode->i_gid, 0, oh, true, - true, NULL, false); - RETURN(rc); + rc = osd_declare_inode_qid(env, inode->i_uid, inode->i_gid, 0, oh, + true, true, NULL, false); + RETURN(rc); } static int osd_object_destroy(const struct lu_env *env, @@ -2089,6 +2104,7 @@ static int __osd_xattr_set(const struct lu_env *env, struct dt_object *dt, if (fl & LU_XATTR_CREATE) fs_flags |= XATTR_CREATE; + ll_vfs_dq_init(inode); dentry->d_inode = inode; rc = inode->i_op->setxattr(dentry, name, buf->lb_buf, buf->lb_len, fs_flags); @@ -2220,10 +2236,9 @@ static int osd_declare_object_ref_add(const struct lu_env *env, oh = container_of0(handle, struct osd_thandle, ot_super); LASSERT(oh->ot_handle == NULL); - OSD_DECLARE_OP(oh, ref_add); - oh->ot_credits += osd_dto_credits_noquota[DTO_ATTR_SET_BASE]; + OSD_DECLARE_OP(oh, ref_add, osd_dto_credits_noquota[DTO_ATTR_SET_BASE]); - return 0; + return 0; } /* @@ -2279,10 +2294,9 @@ static int osd_declare_object_ref_del(const struct lu_env *env, oh = container_of0(handle, struct osd_thandle, ot_super); LASSERT(oh->ot_handle == NULL); - OSD_DECLARE_OP(oh, ref_del); - oh->ot_credits += osd_dto_credits_noquota[DTO_ATTR_SET_BASE]; + OSD_DECLARE_OP(oh, ref_del, osd_dto_credits_noquota[DTO_ATTR_SET_BASE]); - return 0; + return 0; } /* @@ -2374,11 +2388,9 @@ static int osd_declare_xattr_set(const struct lu_env *env, oh = container_of0(handle, struct osd_thandle, ot_super); LASSERT(oh->ot_handle == NULL); - OSD_DECLARE_OP(oh, xattr_set); - if (strcmp(name, XATTR_NAME_VERSION) == 0) - oh->ot_credits += osd_dto_credits_noquota[DTO_ATTR_SET_BASE]; - else - oh->ot_credits += osd_dto_credits_noquota[DTO_XATTR_SET]; + OSD_DECLARE_OP(oh, xattr_set, strcmp(name, XATTR_NAME_VERSION) == 0 ? + osd_dto_credits_noquota[DTO_ATTR_SET_BASE] : + osd_dto_credits_noquota[DTO_XATTR_SET]); return 0; } @@ -2460,10 +2472,9 @@ static int osd_declare_xattr_del(const struct lu_env *env, oh = container_of0(handle, struct osd_thandle, ot_super); LASSERT(oh->ot_handle == NULL); - OSD_DECLARE_OP(oh, xattr_set); - oh->ot_credits += osd_dto_credits_noquota[DTO_XATTR_SET]; + OSD_DECLARE_OP(oh, xattr_set, osd_dto_credits_noquota[DTO_XATTR_SET]); - return 0; + return 0; } /* @@ -2489,6 +2500,7 @@ static int osd_xattr_del(const struct lu_env *env, struct dt_object *dt, OSD_EXEC_OP(handle, xattr_set); + ll_vfs_dq_init(inode); dentry->d_inode = inode; rc = inode->i_op->removexattr(dentry, name); return rc; @@ -2676,7 +2688,6 @@ static int osd_index_try(const struct lu_env *env, struct dt_object *dt, int result; int skip_iam = 0; struct osd_object *obj = osd_dt_obj(dt); - struct osd_device *osd = osd_obj2dev(obj); LINVRNT(osd_invariant(obj)); LASSERT(dt_object_exists(dt)); @@ -2684,7 +2695,7 @@ static int osd_index_try(const struct lu_env *env, struct dt_object *dt, if (osd_object_is_root(obj)) { dt->do_index_ops = &osd_index_ea_ops; result = 0; - } else if (feat == &dt_directory_features && osd->od_iop_mode) { + } else if (feat == &dt_directory_features) { dt->do_index_ops = &osd_index_ea_ops; if (S_ISDIR(obj->oo_inode->i_mode)) result = 0; @@ -2833,10 +2844,9 @@ static int osd_index_declare_iam_delete(const struct lu_env *env, oh = container_of0(handle, struct osd_thandle, ot_super); LASSERT(oh->ot_handle == NULL); - OSD_DECLARE_OP(oh, delete); - oh->ot_credits += osd_dto_credits_noquota[DTO_INDEX_DELETE]; + OSD_DECLARE_OP(oh, delete, osd_dto_credits_noquota[DTO_INDEX_DELETE]); - return 0; + return 0; } /** @@ -2896,23 +2906,22 @@ static int osd_index_iam_delete(const struct lu_env *env, struct dt_object *dt, } static int osd_index_declare_ea_delete(const struct lu_env *env, - struct dt_object *dt, - const struct dt_key *key, - struct thandle *handle) + struct dt_object *dt, + const struct dt_key *key, + struct thandle *handle) { - struct osd_thandle *oh; + struct osd_thandle *oh; struct inode *inode; int rc; ENTRY; - LASSERT(dt_object_exists(dt)); - LASSERT(handle != NULL); + LASSERT(dt_object_exists(dt)); + LASSERT(handle != NULL); - oh = container_of0(handle, struct osd_thandle, ot_super); - LASSERT(oh->ot_handle == NULL); + oh = container_of0(handle, struct osd_thandle, ot_super); + LASSERT(oh->ot_handle == NULL); - OSD_DECLARE_OP(oh, delete); - oh->ot_credits += osd_dto_credits_noquota[DTO_INDEX_DELETE]; + OSD_DECLARE_OP(oh, delete, osd_dto_credits_noquota[DTO_INDEX_DELETE]); inode = osd_dt_obj(dt)->oo_inode; LASSERT(inode); @@ -2974,6 +2983,7 @@ static int osd_index_ea_delete(const struct lu_env *env, struct dt_object *dt, if (osd_object_auth(env, dt, capa, CAPA_OPC_INDEX_DELETE)) RETURN(-EACCES); + ll_vfs_dq_init(dir); dentry = osd_child_dentry_get(env, obj, (char *)key, strlen((char *)key)); @@ -3086,10 +3096,9 @@ static int osd_index_declare_iam_insert(const struct lu_env *env, oh = container_of0(handle, struct osd_thandle, ot_super); LASSERT(oh->ot_handle == NULL); - OSD_DECLARE_OP(oh, insert); - oh->ot_credits += osd_dto_credits_noquota[DTO_INDEX_INSERT]; + OSD_DECLARE_OP(oh, insert, osd_dto_credits_noquota[DTO_INDEX_INSERT]); - return 0; + return 0; } /** @@ -3193,6 +3202,8 @@ static int __osd_ea_add_rec(struct osd_thread_info *info, } else { child->d_fsdata = NULL; } + LASSERT(pobj->oo_inode); + ll_vfs_dq_init(pobj->oo_inode); rc = osd_ldiskfs_add_entry(oth->ot_handle, child, cinode, hlock); RETURN(rc); @@ -3308,7 +3319,7 @@ static int osd_ea_add_rec(const struct lu_env *env, struct osd_object *pobj, return rc; } -static int +static void osd_consistency_check(struct osd_thread_info *oti, struct osd_device *dev, struct osd_idmap_cache *oic) { @@ -3319,13 +3330,16 @@ osd_consistency_check(struct osd_thread_info *oti, struct osd_device *dev, int rc; ENTRY; + if (!fid_is_norm(fid) && !fid_is_igif(fid)) + RETURN_EXIT; + again: rc = osd_oi_lookup(oti, dev, fid, id); if (rc != 0 && rc != -ENOENT) - RETURN(rc); + RETURN_EXIT; if (rc == 0 && osd_id_eq(id, &oic->oic_lid)) - RETURN(0); + RETURN_EXIT; if (thread_is_running(&scrub->os_thread)) { rc = osd_oii_insert(dev, oic, rc == -ENOENT); @@ -3336,10 +3350,10 @@ again: if (unlikely(rc == -EAGAIN)) goto again; - RETURN(rc); + RETURN_EXIT; } - if (!scrub->os_no_scrub && ++once == 1) { + if (!dev->od_noscrub && ++once == 1) { CDEBUG(D_LFSCK, "Trigger OI scrub by RPC for "DFID"\n", PFID(fid)); rc = osd_scrub_start(dev); @@ -3351,7 +3365,7 @@ again: goto again; } - RETURN(rc = -EREMCHG); + EXIT; } /** @@ -3404,7 +3418,7 @@ static int osd_ea_lookup_rec(const struct lu_env *env, struct osd_object *obj, rc = osd_ea_fid_get(env, obj, ino, fid, &oic->oic_lid); else osd_id_gen(&oic->oic_lid, ino, OSD_OII_NOGEN); - if (rc != 0 || !fid_is_norm(fid)) { + if (rc != 0) { fid_zero(&oic->oic_fid); GOTO(out, rc); } @@ -3414,7 +3428,7 @@ static int osd_ea_lookup_rec(const struct lu_env *env, struct osd_object *obj, (sf->sf_flags & SF_INCONSISTENT || ldiskfs_test_bit(osd_oi_fid2idx(dev, fid), sf->sf_oi_bitmap))) - rc = osd_consistency_check(oti, dev, oic); + osd_consistency_check(oti, dev, oic); } else { rc = -ENOENT; } @@ -3497,24 +3511,23 @@ static inline void osd_object_put(const struct lu_env *env, } static int osd_index_declare_ea_insert(const struct lu_env *env, - struct dt_object *dt, - const struct dt_rec *rec, - const struct dt_key *key, - struct thandle *handle) + struct dt_object *dt, + const struct dt_rec *rec, + const struct dt_key *key, + struct thandle *handle) { - struct osd_thandle *oh; + struct osd_thandle *oh; struct inode *inode; int rc; ENTRY; - LASSERT(dt_object_exists(dt)); - LASSERT(handle != NULL); + LASSERT(dt_object_exists(dt)); + LASSERT(handle != NULL); - oh = container_of0(handle, struct osd_thandle, ot_super); - LASSERT(oh->ot_handle == NULL); + oh = container_of0(handle, struct osd_thandle, ot_super); + LASSERT(oh->ot_handle == NULL); - OSD_DECLARE_OP(oh, insert); - oh->ot_credits += osd_dto_credits_noquota[DTO_INDEX_INSERT]; + OSD_DECLARE_OP(oh, insert, osd_dto_credits_noquota[DTO_INDEX_INSERT]); inode = osd_dt_obj(dt)->oo_inode; LASSERT(inode); @@ -3849,6 +3862,7 @@ static const struct dt_index_operations osd_index_iam_ops = { } }; + /** * Creates or initializes iterator context. * @@ -4136,8 +4150,10 @@ static inline int osd_it_ea_rec(const struct lu_env *env, if (!fid_is_sane(fid)) { rc = osd_ea_fid_get(env, obj, ino, fid, &oic->oic_lid); - if (rc != 0) + if (rc != 0) { + fid_zero(&oic->oic_fid); RETURN(rc); + } } else { osd_id_gen(&oic->oic_lid, ino, OSD_OII_NOGEN); } @@ -4146,16 +4162,11 @@ static inline int osd_it_ea_rec(const struct lu_env *env, it->oie_dirent->oied_name, it->oie_dirent->oied_namelen, it->oie_dirent->oied_type, attr); - if (!fid_is_norm(fid)) { - fid_zero(&oic->oic_fid); - RETURN(0); - } - oic->oic_fid = *fid; if ((scrub->os_pos_current <= ino) && (sf->sf_flags & SF_INCONSISTENT || ldiskfs_test_bit(osd_oi_fid2idx(dev, fid), sf->sf_oi_bitmap))) - rc = osd_consistency_check(oti, dev, oic); + osd_consistency_check(oti, dev, oic); RETURN(rc); } @@ -4225,7 +4236,6 @@ static int osd_index_ea_lookup(const struct lu_env *env, struct dt_object *dt, return -EACCES; rc = osd_ea_lookup_rec(env, obj, rec, key); - if (rc == 0) rc = +1; RETURN(rc); @@ -4422,13 +4432,8 @@ static int osd_mount(const struct lu_env *env, GOTO(out, rc = -EINVAL); } - if (lmd_flags & LMD_FLG_IAM) { - o->od_iop_mode = 0; - LCONSOLE_WARN("%s: OSD: IAM mode enabled\n", name); - } else - o->od_iop_mode = 1; if (lmd_flags & LMD_FLG_NOSCRUB) - o->od_scrub.os_no_scrub = 1; + o->od_noscrub = 1; out: if (__page) @@ -4494,6 +4499,7 @@ static int osd_device_init0(const struct lu_env *env, o->od_read_cache = 1; o->od_writethrough_cache = 1; + o->od_readcache_max_filesize = OSD_MAX_CACHE_SIZE; rc = osd_mount(env, o, cfg); if (rc) @@ -4529,7 +4535,18 @@ static int osd_device_init0(const struct lu_env *env, LASSERT(l->ld_site->ls_linkage.next && l->ld_site->ls_linkage.prev); + /* initialize quota slave instance */ + o->od_quota_slave = qsd_init(env, o->od_svname, &o->od_dt_dev, + o->od_proc_entry); + if (IS_ERR(o->od_quota_slave)) { + rc = PTR_ERR(o->od_quota_slave); + o->od_quota_slave = NULL; + GOTO(out_procfs, rc); + } + RETURN(0); +out_procfs: + osd_procfs_fini(o); out_site: lu_site_fini(&o->od_site); out_compat: @@ -4616,7 +4633,17 @@ static int osd_process_config(const struct lu_env *env, static int osd_recovery_complete(const struct lu_env *env, struct lu_device *d) { - RETURN(0); + struct osd_device *osd = osd_dev(d); + int rc = 0; + ENTRY; + + if (osd->od_quota_slave == NULL) + RETURN(0); + + /* start qsd instance on recovery completion, this notifies the quota + * slave code that we are about to process new requests now */ + rc = qsd_start(env, osd->od_quota_slave); + RETURN(rc); } /* @@ -4687,13 +4714,9 @@ static int osd_prepare(const struct lu_env *env, struct lu_device *pdev, RETURN(result); } - /* 2. setup quota slave instance */ - osd->od_quota_slave = qsd_init(env, osd->od_svname, &osd->od_dt_dev, - osd->od_proc_entry); - if (IS_ERR(osd->od_quota_slave)) { - result = PTR_ERR(osd->od_quota_slave); - osd->od_quota_slave = NULL; - } + if (osd->od_quota_slave != NULL) + /* set up quota slave objects */ + result = qsd_prepare(env, osd->od_quota_slave); RETURN(result); }