*/
/*
* This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
*/
#define DEBUG_SUBSYSTEM S_ECHO
#include <linux/user_namespace.h>
-#ifdef HAVE_UIDGID_HEADER
-# include <linux/uidgid.h>
-#endif
-#include <libcfs/libcfs.h>
+#include <linux/uidgid.h>
+#include <libcfs/libcfs.h>
#include <obd.h>
#include <obd_support.h>
#include <obd_class.h>
-#include <lustre_debug.h>
#include <lprocfs_status.h>
#include <cl_object.h>
#include <lustre_fid.h>
* @{
*/
+/* echo thread key have a CL_THREAD flag, which set cl_env function directly */
+#define ECHO_MD_CTX_TAG (LCT_REMEMBER | LCT_MD_THREAD)
+#define ECHO_DT_CTX_TAG (LCT_REMEMBER | LCT_DT_THREAD)
+#define ECHO_SES_TAG (LCT_REMEMBER | LCT_SESSION | LCT_SERVER_SESSION)
+
struct echo_device {
struct cl_device ed_cl;
struct echo_client_obd *ed_ec;
struct echo_page {
struct cl_page_slice ep_cl;
- struct mutex ep_lock;
+ unsigned long ep_lock;
};
struct echo_lock {
#endif /* HAVE_SERVER_SUPPORT */
static int echo_client_setup(const struct lu_env *env,
- struct obd_device *obddev,
+ struct obd_device *obd,
struct lustre_cfg *lcfg);
-static int echo_client_cleanup(struct obd_device *obddev);
+static int echo_client_cleanup(struct obd_device *obd);
/** \defgroup echo_helpers Helper functions
* @{
*/
static inline struct echo_device *cl2echo_dev(const struct cl_device *dev)
{
- return container_of0(dev, struct echo_device, ed_cl);
+ return container_of_safe(dev, struct echo_device, ed_cl);
}
static inline struct cl_device *echo_dev2cl(struct echo_device *d)
#ifdef HAVE_SERVER_SUPPORT
static inline struct echo_md_device *lu2emd_dev(struct lu_device *d)
{
- return container_of0(d, struct echo_md_device, emd_md_dev.md_lu_dev);
+ return container_of_safe(d, struct echo_md_device,
+ emd_md_dev.md_lu_dev);
}
static inline struct lu_device *emd2lu_dev(struct echo_md_device *d)
{
struct echo_page *ep = cl2echo_page(slice);
- if (!nonblock)
- mutex_lock(&ep->ep_lock);
- else if (!mutex_trylock(&ep->ep_lock))
- return -EAGAIN;
+ if (!nonblock) {
+ if (test_and_set_bit(0, &ep->ep_lock))
+ return -EAGAIN;
+ } else {
+ while (test_and_set_bit(0, &ep->ep_lock))
+ wait_on_bit(&ep->ep_lock, 0, TASK_UNINTERRUPTIBLE);
+ }
return 0;
}
{
struct echo_page *ep = cl2echo_page(slice);
- LASSERT(mutex_is_locked(&ep->ep_lock));
- mutex_unlock(&ep->ep_lock);
+ LASSERT(test_bit(0, &ep->ep_lock));
+ clear_and_wake_up_bit(0, &ep->ep_lock);
}
static void echo_page_discard(const struct lu_env *env,
static int echo_page_is_vmlocked(const struct lu_env *env,
const struct cl_page_slice *slice)
{
- if (mutex_is_locked(&cl2echo_page(slice)->ep_lock))
+ if (test_bit(0, &cl2echo_page(slice)->ep_lock))
return -EBUSY;
return -ENODATA;
}
struct echo_page *ep = cl2echo_page(slice);
(*printer)(env, cookie, LUSTRE_ECHO_CLIENT_NAME"-page@%p %d vm@%p\n",
- ep, mutex_is_locked(&ep->ep_lock),
+ ep, test_bit(0, &ep->ep_lock),
slice->cpl_page->cp_vmpage);
return 0;
}
OBD_SLAB_FREE_PTR(ecl, echo_lock_kmem);
}
-static struct cl_lock_operations echo_lock_ops = {
- .clo_fini = echo_lock_fini,
+static const struct cl_lock_operations echo_lock_ops = {
+ .clo_fini = echo_lock_fini,
};
/** @} echo_lock */
ENTRY;
get_page(page->cp_vmpage);
- mutex_init(&ep->ep_lock);
- cl_page_slice_add(page, &ep->ep_cl, obj, index, &echo_page_ops);
+ /*
+ * ep_lock is similar to the lock_page() lock, and
+ * cannot usefully be monitored by lockdep.
+ * So just use a bit in an "unsigned long" and use the
+ * wait_on_bit() interface to wait for the bit to be clear.
+ */
+ ep->ep_lock = 0;
+ cl_page_slice_add(page, &ep->ep_cl, obj, &echo_page_ops);
atomic_inc(&eco->eo_npages);
RETURN(0);
}
RETURN(0);
}
-static void echo_object_free(const struct lu_env *env, struct lu_object *obj)
+static void echo_object_delete(const struct lu_env *env, struct lu_object *obj)
{
struct echo_object *eco = cl2echo_obj(lu2cl(obj));
- struct echo_client_obd *ec = eco->eo_dev->ed_ec;
+ struct echo_client_obd *ec;
ENTRY;
+
+ /* object delete called unconditolally - layer init or not */
+ if (eco->eo_dev == NULL)
+ return;
+
+ ec = eco->eo_dev->ed_ec;
+
LASSERT(atomic_read(&eco->eo_npages) == 0);
spin_lock(&ec->ec_lock);
list_del_init(&eco->eo_obj_chain);
spin_unlock(&ec->ec_lock);
- lu_object_fini(obj);
- lu_object_header_fini(obj->lo_header);
-
if (eco->eo_oinfo)
OBD_FREE_PTR(eco->eo_oinfo);
+}
- OBD_SLAB_FREE_PTR(eco, echo_object_kmem);
+static void echo_object_free_rcu(struct rcu_head *head)
+{
+ struct echo_object *eco = container_of(head, struct echo_object,
+ eo_hdr.coh_lu.loh_rcu);
+
+ kmem_cache_free(echo_object_kmem, eco);
+}
+
+static void echo_object_free(const struct lu_env *env, struct lu_object *obj)
+{
+ struct echo_object *eco = cl2echo_obj(lu2cl(obj));
+
+ ENTRY;
+
+ lu_object_fini(obj);
+ lu_object_header_fini(obj->lo_header);
+
+ OBD_FREE_PRE(eco, sizeof(*eco), "slab-freed");
+ call_rcu(&eco->eo_hdr.coh_lu.loh_rcu, echo_object_free_rcu);
EXIT;
}
static const struct lu_object_operations echo_lu_obj_ops = {
.loo_object_init = echo_object_init,
- .loo_object_delete = NULL,
+ .loo_object_delete = echo_object_delete,
.loo_object_release = NULL,
.loo_object_free = echo_object_free,
.loo_object_print = echo_object_print,
RETURN(obj);
}
-static struct lu_device_operations echo_device_lu_ops = {
+static const struct lu_device_operations echo_device_lu_ops = {
.ldo_object_alloc = echo_object_alloc,
};
snprintf(prefix, MAX_OBD_NAME + 5, "srv-%s", obd_name);
/* Init client side sequence-manager */
- rc = seq_client_init(ed->ed_cl_seq, NULL,
- LUSTRE_SEQ_METADATA,
- prefix, ss->ss_server_seq);
+ seq_client_init(ed->ed_cl_seq, NULL,
+ LUSTRE_SEQ_METADATA,
+ prefix, ss->ss_server_seq);
ed->ed_cl_seq->lcs_width = ECHO_SEQ_WIDTH;
OBD_FREE(prefix, MAX_OBD_NAME + 5);
- if (rc)
- GOTO(out_free_seq, rc);
RETURN(0);
RETURN(rc);
}
-static int echo_fid_fini(struct obd_device *obddev)
+static int echo_fid_fini(struct obd_device *obd)
{
- struct echo_device *ed = obd2echo_dev(obddev);
+ struct echo_device *ed = obd2echo_dev(obd);
ENTRY;
if (ed->ed_cl_seq) {
CERROR("Cleanup obd device %s error(%d)\n",
obd->obd_name, rc2);
}
+ /* fallthrough */
case 3:
echo_site_fini(env, ed);
+ /* fallthrough */
case 2:
cl_device_fini(&ed->ed_cl);
+ /* fallthrough */
case 1:
OBD_FREE_PTR(ed);
+ /* fallthrough */
case 0:
default:
break;
spin_unlock(&ec->ec_lock);
CERROR(
"echo_client still has objects at cleanup time, wait for 1 second\n");
- set_current_state(TASK_UNINTERRUPTIBLE);
- schedule_timeout(cfs_time_seconds(1));
+ schedule_timeout_uninterruptible(cfs_time_seconds(1));
lu_site_purge(env, ed->ed_site, -1);
spin_lock(&ec->ec_lock);
}
}
static void echo_commit_callback(const struct lu_env *env, struct cl_io *io,
- struct cl_page *page)
+ struct pagevec *pvec)
{
struct echo_thread_info *info;
struct cl_2queue *queue;
+ int i = 0;
info = echo_env_info(env);
LASSERT(io == &info->eti_io);
queue = &info->eti_queue;
- cl_page_list_add(&queue->c2_qout, page);
+
+ for (i = 0; i < pagevec_count(pvec); i++) {
+ struct page *vmpage = pvec->pages[i];
+ struct cl_page *page = (struct cl_page *)vmpage->private;
+
+ cl_page_list_add(&queue->c2_qout, page, true);
+ }
}
static int cl_echo_object_brw(struct echo_object *eco, int rw, u64 offset,
break;
}
- cl_2queue_add(queue, clp);
+ cl_2queue_add(queue, clp, true);
/*
* drop the reference count for cl_page_find, so that the page
}
}
-#ifdef CONFIG_FS_POSIX_ACL
+#ifdef CONFIG_LUSTRE_FS_POSIX_ACL
if ((ma->ma_need & MA_ACL_DEF) && S_ISDIR(mode)) {
buf->lb_buf = ma->ma_acl;
buf->lb_len = ma->ma_acl_size;
}
lmv = (struct lmv_mds_md_v1 *)ma->ma_lmm;
- if (le32_to_cpu(lmv->lmv_magic) != LMV_MAGIC_V1) {
+ if (!lmv_is_sane(lmv)) {
rc = -EINVAL;
CERROR("Invalid mds md magic %x "DFID": rc = %d\n",
le32_to_cpu(lmv->lmv_magic), PFID(lu_object_fid(obj)),
echo_md_build_name(&tmp_ln_name, info->eti_name, id);
}
- idx = lmv_name_to_stripe_index(LMV_HASH_TYPE_FNV_1A_64,
- le32_to_cpu(lmv->lmv_stripe_count),
- tmp_ln_name.ln_name, tmp_ln_name.ln_namelen);
+ idx = lmv_name_to_stripe_index(lmv, tmp_ln_name.ln_name,
+ tmp_ln_name.ln_namelen);
LASSERT(idx < le32_to_cpu(lmv->lmv_stripe_count));
fid_le_to_cpu(&stripe_fid, &lmv->lmv_stripe_fids[idx]);
static void echo_ucred_init(struct lu_env *env)
{
struct lu_ucred *ucred = lu_ucred(env);
+ kernel_cap_t kcap = current_cap();
ucred->uc_valid = UCRED_INVALID;
ucred->uc_cap = cfs_curproc_cap_pack();
/* remove fs privilege for non-root user. */
- if (ucred->uc_fsuid)
- ucred->uc_cap &= ~CFS_CAP_FS_MASK;
+ if (ucred->uc_fsuid) {
+ kcap = cap_drop_nfsd_set(kcap);
+ kcap = cap_drop_fs_set(kcap);
+ }
+ ucred->uc_cap = kcap.cap[0];
ucred->uc_valid = UCRED_NEW;
}
ucred->uc_valid = UCRED_INIT;
}
-#define ECHO_MD_CTX_TAG (LCT_REMEMBER | LCT_MD_THREAD)
-#define ECHO_MD_SES_TAG (LCT_REMEMBER | LCT_SESSION | LCT_SERVER_SESSION)
static int echo_md_handler(struct echo_device *ed, int command,
char *path, int path_len, __u64 id, int count,
struct obd_ioctl_data *data)
if (IS_ERR(env))
RETURN(PTR_ERR(env));
- rc = lu_env_refill_by_tags(env, ECHO_MD_CTX_TAG, ECHO_MD_SES_TAG);
+ rc = lu_env_refill_by_tags(env, ECHO_MD_CTX_TAG, ECHO_SES_TAG);
if (rc != 0)
GOTO(out_env, rc);
if (rw == OBD_BRW_WRITE)
brw_flags = OBD_BRW_ASYNC;
- OBD_ALLOC(pga, npages * sizeof(*pga));
+ OBD_ALLOC_PTR_ARRAY_LARGE(pga, npages);
if (!pga)
RETURN(-ENOMEM);
- OBD_ALLOC(pages, npages * sizeof(*pages));
+ OBD_ALLOC_PTR_ARRAY_LARGE(pages, npages);
if (!pages) {
- OBD_FREE(pga, npages * sizeof(*pga));
+ OBD_FREE_PTR_ARRAY_LARGE(pga, npages);
RETURN(-ENOMEM);
}
if (!pgp->pg)
goto out;
+ /* set mapping so page is not considered encrypted */
+ pgp->pg->mapping = ECHO_MAPPING_UNENCRYPTED;
pages[i] = pgp->pg;
pgp->count = PAGE_SIZE;
pgp->off = off;
}
__free_page(pgp->pg);
}
- OBD_FREE(pga, npages * sizeof(*pga));
- OBD_FREE(pages, npages * sizeof(*pages));
+ OBD_FREE_PTR_ARRAY_LARGE(pga, npages);
+ OBD_FREE_PTR_ARRAY_LARGE(pages, npages);
RETURN(rc);
}
apc = npages = batch >> PAGE_SHIFT;
tot_pages = count >> PAGE_SHIFT;
- OBD_ALLOC_LARGE(lnb, apc * sizeof(struct niobuf_local));
+ OBD_ALLOC_PTR_ARRAY_LARGE(lnb, apc);
if (!lnb)
RETURN(-ENOMEM);
}
out:
- OBD_FREE_LARGE(lnb, apc * sizeof(struct niobuf_local));
+ OBD_FREE_PTR_ARRAY_LARGE(lnb, apc);
RETURN(ret);
}
struct echo_object *eco;
struct obd_ioctl_data *data = karg;
struct lu_env *env;
+ unsigned long env_tags = 0;
+ __u16 refcheck;
struct obdo *oa;
struct lu_fid fid;
int rw = OBD_BRW_READ;
int rc = 0;
-#ifdef HAVE_SERVER_SUPPORT
- struct lu_context echo_session;
-#endif
ENTRY;
oa = &data->ioc_obdo1;
if (rc < 0)
RETURN(rc);
- OBD_ALLOC_PTR(env);
- if (!env)
- RETURN(-ENOMEM);
+ env = cl_env_get(&refcheck);
+ if (IS_ERR(env))
+ RETURN(PTR_ERR(env));
- rc = lu_env_init(env, LCT_DT_THREAD);
- if (rc)
- GOTO(out_alloc, rc = -ENOMEM);
lu_env_add(env);
- if (rc)
- GOTO(out_env_fini, rc = -ENOMEM);
#ifdef HAVE_SERVER_SUPPORT
- env->le_ses = &echo_session;
- rc = lu_context_init(env->le_ses, LCT_SERVER_SESSION | LCT_NOREF);
- if (unlikely(rc < 0))
- GOTO(out_env, rc);
- lu_context_enter(env->le_ses);
+ if (cmd == OBD_IOC_ECHO_MD || cmd == OBD_IOC_ECHO_ALLOC_SEQ)
+ env_tags = ECHO_MD_CTX_TAG;
+ else
+#endif
+ env_tags = ECHO_DT_CTX_TAG;
+
+ rc = lu_env_refill_by_tags(env, env_tags, ECHO_SES_TAG);
+ if (rc != 0)
+ GOTO(out, rc);
+#ifdef HAVE_SERVER_SUPPORT
tsi = tgt_ses_info(env);
- tsi->tsi_exp = ec->ec_exp;
+ /* treat as local operation */
+ tsi->tsi_exp = NULL;
tsi->tsi_jobid = NULL;
#endif
+
switch (cmd) {
case OBD_IOC_CREATE: /* may create echo object */
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!capable(CAP_SYS_ADMIN))
GOTO(out, rc = -EPERM);
rc = echo_create_object(env, ed, oa);
int dirlen;
__u64 id;
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!capable(CAP_SYS_ADMIN))
GOTO(out, rc = -EPERM);
count = data->ioc_count;
GOTO(out, rc);
}
case OBD_IOC_ECHO_ALLOC_SEQ: {
- struct lu_env *cl_env;
- __u16 refcheck;
__u64 seq;
int max_count;
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!capable(CAP_SYS_ADMIN))
GOTO(out, rc = -EPERM);
- cl_env = cl_env_get(&refcheck);
- if (IS_ERR(cl_env))
- GOTO(out, rc = PTR_ERR(cl_env));
-
- rc = lu_env_refill_by_tags(cl_env, ECHO_MD_CTX_TAG,
- ECHO_MD_SES_TAG);
- if (rc != 0) {
- cl_env_put(cl_env, &refcheck);
- GOTO(out, rc);
- }
-
- rc = seq_client_get_seq(cl_env, ed->ed_cl_seq, &seq);
- cl_env_put(cl_env, &refcheck);
+ rc = seq_client_get_seq(env, ed->ed_cl_seq, &seq);
if (rc < 0) {
CERROR("%s: Can not alloc seq: rc = %d\n",
obd->obd_name, rc);
}
#endif /* HAVE_SERVER_SUPPORT */
case OBD_IOC_DESTROY:
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!capable(CAP_SYS_ADMIN))
GOTO(out, rc = -EPERM);
rc = echo_get_object(&eco, ed, oa);
GOTO(out, rc);
case OBD_IOC_SETATTR:
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!capable(CAP_SYS_ADMIN))
GOTO(out, rc = -EPERM);
rc = echo_get_object(&eco, ed, oa);
GOTO(out, rc);
case OBD_IOC_BRW_WRITE:
- if (!cfs_capable(CFS_CAP_SYS_ADMIN))
+ if (!capable(CAP_SYS_ADMIN))
GOTO(out, rc = -EPERM);
rw = OBD_BRW_WRITE;
EXIT;
out:
-#ifdef HAVE_SERVER_SUPPORT
- lu_context_exit(env->le_ses);
- lu_context_fini(env->le_ses);
-out_env:
-#endif
lu_env_remove(env);
-out_env_fini:
- lu_env_fini(env);
-out_alloc:
- OBD_FREE_PTR(env);
+ cl_env_put(env, &refcheck);
return rc;
}
static int echo_client_setup(const struct lu_env *env,
- struct obd_device *obddev, struct lustre_cfg *lcfg)
+ struct obd_device *obd, struct lustre_cfg *lcfg)
{
- struct echo_client_obd *ec = &obddev->u.echo_client;
+ struct echo_client_obd *ec = &obd->u.echo_client;
struct obd_device *tgt;
struct obd_uuid echo_uuid = { "ECHO_UUID" };
struct obd_connect_data *ocd = NULL;
INIT_LIST_HEAD(&ec->ec_locks);
ec->ec_unique = 0;
+ lu_context_tags_update(ECHO_DT_CTX_TAG);
+ lu_session_tags_update(ECHO_SES_TAG);
+
if (!strcmp(tgt->obd_type->typ_name, LUSTRE_MDT_NAME)) {
#ifdef HAVE_SERVER_SUPPORT
lu_context_tags_update(ECHO_MD_CTX_TAG);
- lu_session_tags_update(ECHO_MD_SES_TAG);
#else
CERROR(
"Local operations are NOT supported on client side. Only remote operations are supported. Metadata client must be run on server side.\n");
OBD_CONNECT_BRW_SIZE |
OBD_CONNECT_GRANT | OBD_CONNECT_FULL20 |
OBD_CONNECT_64BITHASH | OBD_CONNECT_LVB_TYPE |
- OBD_CONNECT_FID;
+ OBD_CONNECT_FID | OBD_CONNECT_FLAGS2;
+ ocd->ocd_connect_flags2 = OBD_CONNECT2_REP_MBITS;
+
ocd->ocd_brw_size = DT_MAX_BRW_SIZE;
ocd->ocd_version = LUSTRE_VERSION_CODE;
ocd->ocd_group = FID_SEQ_ECHO;
RETURN(rc);
}
-static int echo_client_cleanup(struct obd_device *obddev)
+static int echo_client_cleanup(struct obd_device *obd)
{
- struct echo_device *ed = obd2echo_dev(obddev);
- struct echo_client_obd *ec = &obddev->u.echo_client;
+ struct echo_device *ed = obd2echo_dev(obd);
+ struct echo_client_obd *ec = &obd->u.echo_client;
int rc;
ENTRY;
if (!ed)
RETURN(0);
+ lu_session_tags_clear(ECHO_SES_TAG & ~LCT_SESSION);
+ lu_context_tags_clear(ECHO_DT_CTX_TAG);
if (ed->ed_next_ismd) {
#ifdef HAVE_SERVER_SUPPORT
lu_context_tags_clear(ECHO_MD_CTX_TAG);
- lu_session_tags_clear(ECHO_MD_SES_TAG);
#else
CERROR(
"This is client-side only module, does not support metadata echo client.\n");
RETURN(0);
}
- if (!list_empty(&obddev->obd_exports)) {
+ if (!list_empty(&obd->obd_exports)) {
CERROR("still has clients!\n");
RETURN(-EBUSY);
}
- LASSERT(atomic_read(&ec->ec_exp->exp_refcount) > 0);
+ LASSERT(refcount_read(&ec->ec_exp->exp_handle.h_ref) > 0);
rc = obd_disconnect(ec->ec_exp);
if (rc != 0)
CERROR("fail to disconnect device: %d\n", rc);
return rc;
}
-static struct obd_ops echo_client_obd_ops = {
+static const struct obd_ops echo_client_obd_ops = {
.o_owner = THIS_MODULE,
.o_iocontrol = echo_client_iocontrol,
.o_connect = echo_client_connect,
if (rc != 0)
goto failed_0;
- rc = class_register_type(&echo_obd_ops, NULL, true, NULL,
+ rc = class_register_type(&echo_obd_ops, NULL, true,
LUSTRE_ECHO_NAME, &echo_srv_type);
if (rc != 0)
goto failed_1;
rc = lu_kmem_init(echo_caches);
if (rc == 0) {
rc = class_register_type(&echo_client_obd_ops, NULL, false,
- NULL, LUSTRE_ECHO_CLIENT_NAME,
+ LUSTRE_ECHO_CLIENT_NAME,
&echo_device_type);
if (rc)
lu_kmem_fini(echo_caches);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff