/* llo_* api support */
#include <md_object.h>
-/* dt_acct_features */
-#include <lquota.h>
+#include <lustre_quota.h>
#ifdef HAVE_LDISKFS_PDO
int ldiskfs_pdo = 1;
return osd_invariant(osd_obj(l));
}
-#ifdef HAVE_QUOTA_SUPPORT
-static inline void
-osd_push_ctxt(const struct lu_env *env, struct osd_ctxt *save, bool is_md)
-{
- struct md_ucred *uc;
- struct cred *tc;
-
- if (!is_md)
- /* OFD support */
- return;
-
- uc = md_ucred(env);
-
- LASSERT(uc != NULL);
-
- save->oc_uid = current_fsuid();
- save->oc_gid = current_fsgid();
- save->oc_cap = current_cap();
- if ((tc = prepare_creds())) {
- tc->fsuid = uc->mu_fsuid;
- tc->fsgid = uc->mu_fsgid;
- commit_creds(tc);
- }
- /* XXX not suboptimal */
- cfs_curproc_cap_unpack(uc->mu_cap);
-}
-
-static inline void
-osd_pop_ctxt(struct osd_ctxt *save, bool is_md)
-{
- struct cred *tc;
-
- if (!is_md)
- /* OFD support */
- return;
-
- if ((tc = prepare_creds())) {
- tc->fsuid = save->oc_uid;
- tc->fsgid = save->oc_gid;
- tc->cap_effective = save->oc_cap;
- commit_creds(tc);
- }
-}
-#endif
-
/*
* Concurrency: doesn't matter
*/
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);
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);
}
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;
}
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
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",
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);
/*
* 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;
}
/*
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
lu_device_get(&d->dd_lu_dev);
oh->ot_dev_link = lu_ref_add(&d->dd_lu_dev.ld_reference,
"osd-tx", th);
-
- /*
- * XXX: current rule is that we first start tx,
- * then lock object(s), but we can't use
- * this rule for data (due to locking specifics
- * in ldiskfs). also in long-term we'd like to
- * use usually-used (locks;tx) ordering. so,
- * UGLY thing is that we'll use one ordering for
- * data (ofd) and reverse ordering for metadata
- * (mdd). then at some point we'll fix the latter
- */
- if (dev->od_is_md) {
- LASSERT(oti->oti_r_locks == 0);
- LASSERT(oti->oti_w_locks == 0);
- }
-
oti->oti_txns++;
rc = 0;
} else {
if (oh->ot_handle != NULL) {
handle_t *hdl = oh->ot_handle;
- hdl->h_sync = th->th_sync;
-
/*
* add commit callback
* notice we don't do this in osd_trans_start()
LASSERT(oti->oti_txns == 1);
oti->oti_txns--;
- /*
- * XXX: current rule is that we first start tx,
- * then lock object(s), but we can't use
- * this rule for data (due to locking specifics
- * in ldiskfs). also in long-term we'd like to
- * use usually-used (locks;tx) ordering. so,
- * UGLY thing is that we'll use one ordering for
- * data (ofd) and reverse ordering for metadata
- * (mdd). then at some point we'll fix the latter
- */
- if (osd_dt_dev(th->th_dev)->od_is_md) {
- LASSERT(oti->oti_r_locks == 0);
- LASSERT(oti->oti_w_locks == 0);
- }
rc = dt_txn_hook_stop(env, th);
if (rc != 0)
CERROR("Failure in transaction hook: %d\n", rc);
+
+ /* hook functions might modify th_sync */
+ hdl->h_sync = th->th_sync;
+
oh->ot_handle = NULL;
OSD_CHECK_SLOW_TH(oh, oti->oti_dev,
rc = ldiskfs_journal_stop(hdl));
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);
+ }
}
}
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;
}
}
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.
*/
param->ddp_max_name_len = LDISKFS_NAME_LEN;
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;
}
/**
- * 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.
*/
.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,
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);
OSD_EXEC_OP(handle, attr_set);
inode = obj->oo_inode;
- if (!osd_dt_dev(handle->th_dev)->od_is_md) {
- /* OFD support */
- rc = osd_quota_transfer(inode, attr);
- if (rc)
- return rc;
- } else {
-#ifdef HAVE_QUOTA_SUPPORT
- if ((attr->la_valid & LA_UID && attr->la_uid != inode->i_uid) ||
- (attr->la_valid & LA_GID && attr->la_gid != inode->i_gid)) {
- struct osd_ctxt *save = &osd_oti_get(env)->oti_ctxt;
- struct iattr iattr;
- int rc;
-
- iattr.ia_valid = 0;
- if (attr->la_valid & LA_UID)
- iattr.ia_valid |= ATTR_UID;
- if (attr->la_valid & LA_GID)
- iattr.ia_valid |= ATTR_GID;
- iattr.ia_uid = attr->la_uid;
- iattr.ia_gid = attr->la_gid;
- osd_push_ctxt(env, save, 1);
- rc = ll_vfs_dq_transfer(inode, &iattr) ? -EDQUOT : 0;
- osd_pop_ctxt(save, 1);
- if (rc != 0)
- return rc;
- }
-#endif
- }
+ ll_vfs_dq_init(inode);
+
+ rc = osd_quota_transfer(inode, attr);
+ if (rc)
+ return rc;
+
cfs_spin_lock(&obj->oo_guard);
rc = osd_inode_setattr(env, inode, attr);
cfs_spin_unlock(&obj->oo_guard);
struct osd_thandle *oth;
struct dt_object *parent = NULL;
struct inode *inode;
-#ifdef HAVE_QUOTA_SUPPORT
- struct osd_ctxt *save = &info->oti_ctxt;
-#endif
LINVRNT(osd_invariant(obj));
LASSERT(obj->oo_inode == NULL);
if (hint && hint->dah_parent)
parent = hint->dah_parent;
-#ifdef HAVE_QUOTA_SUPPORT
- osd_push_ctxt(info->oti_env, save, osd_dt_dev(th->th_dev)->od_is_md);
-#endif
inode = ldiskfs_create_inode(oth->ot_handle,
parent ? osd_dt_obj(parent)->oo_inode :
osd_sb(osd)->s_root->d_inode,
mode);
-#ifdef HAVE_QUOTA_SUPPORT
- osd_pop_ctxt(save, osd_dt_dev(th->th_dev)->od_is_md);
-#endif
if (!IS_ERR(inode)) {
/* Do not update file c/mtime in ldiskfs.
* NB: don't need any lock because no contention at this
{
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));
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;
}
if ((valid & LA_MTIME) && (attr->la_mtime == LTIME_S(inode->i_mtime)))
attr->la_valid &= ~LA_MTIME;
- if (!osd_obj2dev(obj)->od_is_md) {
- /* OFD support */
- result = osd_quota_transfer(inode, attr);
- if (result)
- return;
- } else {
-#ifdef HAVE_QUOTA_SUPPORT
- attr->la_valid &= ~(LA_UID | LA_GID);
-#endif
- }
+ result = osd_quota_transfer(inode, attr);
+ if (result)
+ return;
if (attr->la_valid != 0) {
result = osd_inode_setattr(info->oti_env, inode, attr);
LASSERT(obj->oo_inode != NULL);
- if (osd->od_is_md) {
- struct md_ucred *uc = md_ucred(env);
- LASSERT(uc != NULL);
- }
-
osd_id_gen(id, obj->oo_inode->i_ino, obj->oo_inode->i_generation);
return osd_oi_insert(info, osd, fid, id, th);
}
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);
* 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,
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);
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;
}
/*
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;
}
/*
LASSERT(dt_object_exists(dt));
LASSERT(inode->i_op != NULL && inode->i_op->getxattr != NULL);
- LASSERT(osd_read_locked(env, obj) || osd_write_locked(env, obj));
if (osd_object_auth(env, dt, capa, CAPA_OPC_META_READ))
return -EACCES;
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;
}
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;
}
/*
OSD_EXEC_OP(handle, xattr_set);
+ ll_vfs_dq_init(inode);
dentry->d_inode = inode;
rc = inode->i_op->removexattr(dentry, name);
return rc;
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));
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;
}
LINVRNT(osd_invariant(obj));
+ if (is_quota_glb_feat(feat))
+ result = osd_quota_migration(env, dt, feat);
+
return result;
}
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;
}
/**
}
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);
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));
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;
}
/**
struct iam_path_descr *ipd;
struct osd_thandle *oh;
struct iam_container *bag = &obj->oo_dir->od_container;
-#ifdef HAVE_QUOTA_SUPPORT
- cfs_cap_t save = cfs_curproc_cap_pack();
-#endif
struct osd_thread_info *oti = osd_oti_get(env);
struct iam_rec *iam_rec;
int rc;
oh = container_of0(th, struct osd_thandle, ot_super);
LASSERT(oh->ot_handle != NULL);
LASSERT(oh->ot_handle->h_transaction != NULL);
-#ifdef HAVE_QUOTA_SUPPORT
- if (ignore_quota)
- cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
- else
- cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
-#endif
if (S_ISDIR(obj->oo_inode->i_mode)) {
iam_rec = (struct iam_rec *)oti->oti_ldp;
osd_fid_pack((struct osd_fid_pack *)iam_rec, rec, &oti->oti_fid);
rc = iam_insert(oh->ot_handle, bag, (const struct iam_key *)key,
iam_rec, ipd);
-#ifdef HAVE_QUOTA_SUPPORT
- cfs_curproc_cap_unpack(save);
-#endif
osd_ipd_put(env, bag, ipd);
LINVRNT(osd_invariant(obj));
RETURN(rc);
} 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);
return rc;
}
-static int
+static void
osd_consistency_check(struct osd_thread_info *oti, struct osd_device *dev,
struct osd_idmap_cache *oic)
{
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);
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);
goto again;
}
- RETURN(rc = -EREMCHG);
+ EXIT;
}
/**
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);
}
(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;
}
}
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);
struct lu_fid *fid = (struct lu_fid *) rec;
const char *name = (const char *)key;
struct osd_object *child;
-#ifdef HAVE_QUOTA_SUPPORT
- cfs_cap_t save = cfs_curproc_cap_pack();
-#endif
int rc;
ENTRY;
child = osd_object_find(env, dt, fid);
if (!IS_ERR(child)) {
-#ifdef HAVE_QUOTA_SUPPORT
- if (ignore_quota)
- cfs_cap_raise(CFS_CAP_SYS_RESOURCE);
- else
- cfs_cap_lower(CFS_CAP_SYS_RESOURCE);
-#endif
rc = osd_ea_add_rec(env, obj, child->oo_inode, name, rec, th);
-#ifdef HAVE_QUOTA_SUPPORT
- cfs_curproc_cap_unpack(save);
-#endif
osd_object_put(env, child);
} else {
rc = PTR_ERR(child);
}
};
+
/**
* Creates or initializes iterator context.
*
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);
}
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);
}
return -EACCES;
rc = osd_ea_lookup_rec(env, obj, rec, key);
-
if (rc == 0)
rc = +1;
RETURN(rc);
OBD_PAGE_ALLOC(__page, CFS_ALLOC_STD);
if (__page == NULL)
- RETURN(-ENOMEM);
+ GOTO(out, rc = -ENOMEM);
str = lustre_cfg_string(cfg, 2);
s_flags = simple_strtoul(str, NULL, 0);
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)
OBD_PAGE_FREE(__page);
+ if (rc)
+ fsfilt_put_ops(o->od_fsops);
RETURN(rc);
}
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)
strncpy(o->od_svname, lustre_cfg_string(cfg, 4),
sizeof(o->od_svname) - 1);
- if (strstr(o->od_svname, "-OST")) {
- rc = osd_compat_init(o);
- if (rc != 0)
- GOTO(out_mnt, rc);
- }
+ rc = osd_compat_init(o);
+ if (rc != 0)
+ GOTO(out_scrub, rc);
rc = lu_site_init(&o->od_site, l);
if (rc)
GOTO(out_compat, rc);
+ o->od_site.ls_bottom_dev = l;
rc = lu_site_init_finish(&o->od_site);
if (rc)
- GOTO(out_compat, rc);
+ GOTO(out_site, rc);
rc = osd_procfs_init(o, o->od_svname);
if (rc != 0) {
CERROR("%s: can't initialize procfs: rc = %d\n",
o->od_svname, rc);
- GOTO(out_compat, rc);
+ GOTO(out_site, rc);
}
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:
osd_compat_fini(o);
+out_scrub:
+ osd_scrub_cleanup(env, o);
out_mnt:
osd_oi_fini(info, o);
osd_shutdown(env, o);
break;
case LCFG_CLEANUP:
lu_dev_del_linkage(d->ld_site, d);
- err = 0;
- break;
+ err = osd_shutdown(env, o);
+ break;
default:
err = -ENOSYS;
}
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);
}
/*
struct lu_device *dev)
{
struct osd_device *osd = osd_dev(dev);
- int result;
+ int result = 0;
ENTRY;
- /* 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;
- RETURN(result);
+ if (dev->ld_site && lu_device_is_md(dev->ld_site->ls_top_dev)) {
+ /* MDT/MDD still use old infrastructure to create
+ * special files */
+ result = llo_local_objects_setup(env, lu2md_dev(pdev),
+ lu2dt_dev(dev));
+ if (result)
+ RETURN(result);
}
-#if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(2, 3, 55, 0)
- /* Unfortunately, the current MDD implementation relies on some specific
- * code to be executed in the OSD layer. Since OFD now also uses the OSD
- * module, we need a way to skip the metadata-specific code when running
- * with OFD.
- * The hack here is to check the type of the parent device which is
- * either MD (i.e. MDD device) with the current MDT stack or DT (i.e.
- * OFD device) on an OST. As a reminder, obdfilter does not use the OSD
- * layer and still relies on lvfs. This hack won't work any more when
- * LOD is landed since LOD is of DT type.
- * This code should be removed once the orion MDT changes (LOD/OSP, ...)
- * have been landed */
- osd->od_is_md = lu_device_is_md(pdev);
-#else
-#warning "all is_md checks must be removed from osd-ldiskfs"
-#endif
-
- if (!osd->od_is_md)
- RETURN(0);
+ if (osd->od_quota_slave != NULL)
+ /* set up quota slave objects */
+ result = qsd_prepare(env, osd->od_quota_slave);
- /* 3. setup local objects */
- result = llo_local_objects_setup(env, lu2md_dev(pdev), lu2dt_dev(dev));
- RETURN(result);
+ RETURN(result);
}
static const struct lu_object_operations osd_lu_obj_ops = {
git://git.whamcloud.com / fs / lustre-release.git / blobdiff