static inline struct cl_device *lu2cl_dev(const struct lu_device *d)
{
- LASSERT(d == NULL || IS_ERR(d) || lu_device_is_cl(d));
- return container_of0(d, struct cl_device, cd_lu_dev);
+ LASSERT(d == NULL || IS_ERR(d) || lu_device_is_cl(d));
+ return container_of_safe(d, struct cl_device, cd_lu_dev);
}
static inline struct lu_device *cl2lu_dev(struct cl_device *d)
static inline struct cl_object *lu2cl(const struct lu_object *o)
{
- LASSERT(o == NULL || IS_ERR(o) || lu_device_is_cl(o->lo_dev));
- return container_of0(o, struct cl_object, co_lu);
+ LASSERT(o == NULL || IS_ERR(o) || lu_device_is_cl(o->lo_dev));
+ return container_of_safe(o, struct cl_object, co_lu);
}
static inline const struct cl_object_conf *
lu2cl_conf(const struct lu_object_conf *conf)
{
- return container_of0(conf, struct cl_object_conf, coc_lu);
+ return container_of_safe(conf, struct cl_object_conf, coc_lu);
}
static inline struct cl_object *cl_object_next(const struct cl_object *obj)
{
- return obj ? lu2cl(lu_object_next(&obj->co_lu)) : NULL;
+ return obj ? lu2cl(lu_object_next(&obj->co_lu)) : NULL;
}
static inline struct cl_object_header *luh2coh(const struct lu_object_header *h)
{
- return container_of0(h, struct cl_object_header, coh_lu);
+ return container_of_safe(h, struct cl_object_header, coh_lu);
}
static inline struct cl_site *cl_object_site(const struct cl_object *obj)
{
- return lu2cl_site(obj->co_lu.lo_dev->ld_site);
+ return lu2cl_site(obj->co_lu.lo_dev->ld_site);
}
static inline
struct cl_object_header *cl_object_header(const struct cl_object *obj)
{
- return luh2coh(obj->co_lu.lo_header);
+ return luh2coh(obj->co_lu.lo_header);
}
static inline int cl_device_init(struct cl_device *d, struct lu_device_type *t)
{
- return lu_device_init(&d->cd_lu_dev, t);
+ return lu_device_init(&d->cd_lu_dev, t);
}
static inline void cl_device_fini(struct cl_device *d)
{
- lu_device_fini(&d->cd_lu_dev);
+ lu_device_fini(&d->cd_lu_dev);
}
void cl_page_slice_add(struct cl_page *page, struct cl_page_slice *slice,
static inline struct dt_device * lu2dt_dev(struct lu_device *l)
{
- LASSERT(lu_device_is_dt(l));
- return container_of0(l, struct dt_device, dd_lu_dev);
+ LASSERT(lu_device_is_dt(l));
+ return container_of_safe(l, struct dt_device, dd_lu_dev);
}
struct dt_object {
static inline struct dt_object *lu2dt(struct lu_object *l)
{
- LASSERT(l == NULL || IS_ERR(l) || lu_device_is_dt(l->lo_dev));
- return container_of0(l, struct dt_object, do_lu);
+ LASSERT(l == NULL || IS_ERR(l) || lu_device_is_dt(l->lo_dev));
+ return container_of_safe(l, struct dt_object, do_lu);
}
int dt_object_init(struct dt_object *obj,
static inline struct dt_object *lu2dt_obj(struct lu_object *o)
{
LASSERT(ergo(o != NULL, lu_device_is_dt(o->lo_dev)));
- return container_of0(o, struct dt_object, do_lu);
+ return container_of_safe(o, struct dt_object, do_lu);
}
static inline struct dt_object *dt_object_child(struct dt_object *o)
{
- return container_of0(lu_object_next(&(o)->do_lu),
- struct dt_object, do_lu);
+ return container_of(lu_object_next(&(o)->do_lu),
+ struct dt_object, do_lu);
}
/**
static inline struct lu_object *lu_object_top(struct lu_object_header *h)
{
LASSERT(!list_empty(&h->loh_layers));
- return container_of0(h->loh_layers.next, struct lu_object, lo_linkage);
+ return container_of(h->loh_layers.next, struct lu_object, lo_linkage);
}
/**
*/
static inline struct lu_object *lu_object_next(const struct lu_object *o)
{
- return container_of0(o->lo_linkage.next, struct lu_object, lo_linkage);
+ return container_of(o->lo_linkage.next, struct lu_object, lo_linkage);
}
/**
static inline struct osc_device *lu2osc_dev(const struct lu_device *d)
{
- return container_of0(d, struct osc_device, od_cl.cd_lu_dev);
+ return container_of_safe(d, struct osc_device, od_cl.cd_lu_dev);
}
static inline struct obd_export *osc_export(const struct osc_object *obj)
static inline struct osc_object *cl2osc(const struct cl_object *obj)
{
- return container_of0(obj, struct osc_object, oo_cl);
+ return container_of_safe(obj, struct osc_object, oo_cl);
}
static inline struct cl_object *osc2cl(const struct osc_object *obj)
static inline struct osc_device *obd2osc_dev(const struct obd_device *obd)
{
- return container_of0(obd->obd_lu_dev, struct osc_device,
- od_cl.cd_lu_dev);
+ return container_of_safe(obd->obd_lu_dev, struct osc_device,
+ od_cl.cd_lu_dev);
}
static inline struct lu_device *osc2lu_dev(struct osc_device *osc)
static inline struct osc_object *lu2osc(const struct lu_object *obj)
{
- return container_of0(obj, struct osc_object, oo_cl.co_lu);
+ return container_of_safe(obj, struct osc_object, oo_cl.co_lu);
}
static inline struct osc_io *cl2osc_io(const struct lu_env *env,
const struct cl_io_slice *slice)
{
- struct osc_io *oio = container_of0(slice, struct osc_io, oi_cl);
+ struct osc_io *oio = container_of(slice, struct osc_io, oi_cl);
LINVRNT(oio == osc_env_io(env));
return oio;
static inline struct osc_page *cl2osc_page(const struct cl_page_slice *slice)
{
- return container_of0(slice, struct osc_page, ops_cl);
+ return container_of_safe(slice, struct osc_page, ops_cl);
}
static inline struct osc_page *oap2osc(struct osc_async_page *oap)
{
- return container_of0(oap, struct osc_page, ops_oap);
+ return container_of_safe(oap, struct osc_page, ops_oap);
}
static inline pgoff_t osc_index(struct osc_page *opg)
static inline struct osc_lock *cl2osc_lock(const struct cl_lock_slice *slice)
{
- return container_of0(slice, struct osc_lock, ols_cl);
+ return container_of_safe(slice, struct osc_lock, ols_cl);
}
static inline int osc_io_srvlock(struct osc_io *oio)
static inline struct md_device *lu2md_dev(const struct lu_device *d)
{
- LASSERT(IS_ERR(d) || lu_device_is_md(d));
- return container_of0(d, struct md_device, md_lu_dev);
+ LASSERT(IS_ERR(d) || lu_device_is_md(d));
+ return container_of_safe(d, struct md_device, md_lu_dev);
}
static inline struct lu_device *md2lu_dev(struct md_device *d)
static inline struct md_object *lu2md(const struct lu_object *o)
{
- LASSERT(o == NULL || IS_ERR(o) || lu_device_is_md(o->lo_dev));
- return container_of0(o, struct md_object, mo_lu);
+ LASSERT(o == NULL || IS_ERR(o) || lu_device_is_md(o->lo_dev));
+ return container_of_safe(o, struct md_object, mo_lu);
}
static inline int md_device_init(struct md_device *md, struct lu_device_type *t)