Whamcloud - gitweb
LU-6142 lustre: convert use of container_of0 in include/ 80/38380/5
authorMr NeilBrown <neilb@suse.de>
Mon, 27 Apr 2020 04:54:13 +0000 (14:54 +1000)
committerOleg Drokin <green@whamcloud.com>
Sat, 4 Jul 2020 03:02:25 +0000 (03:02 +0000)
Most uses of container_of0() are changed to the upstream-standard
interface container_of_safe().  There is no clear context suggesting
that the pointer is known to be value, so it is consistent with the
current code to use the _safe() version.

In a few cases it is clear that the pointer must be valid.
This may be because:
 - it is a '.next' for a struct list_head
 - it from lo_object_next() whic his a special case of above
 - the returned value is confirmed to be valid by an LINVRNT()

So change all container_of0() to either container_of_safe() or
container_of().

Signed-off-by: Mr NeilBrown <neilb@suse.de>
Change-Id: I9fdb8b7216667e58d3837ea555889f9346e4b10a
Reviewed-on: https://review.whamcloud.com/38380
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: James Simmons <jsimmons@infradead.org>
Reviewed-by: Jian Yu <yujian@whamcloud.com>
Reviewed-by: Arshad Hussain <arshad.super@gmail.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>
lustre/include/cl_object.h
lustre/include/dt_object.h
lustre/include/lu_object.h
lustre/include/lustre_osc.h
lustre/include/md_object.h

index e66584c..abd341d 100644 (file)
@@ -2051,8 +2051,8 @@ static inline struct cl_site *lu2cl_site(const struct lu_site *site)
 
 static inline struct cl_device *lu2cl_dev(const struct lu_device *d)
 {
 
 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 lu_device *cl2lu_dev(struct cl_device *d)
@@ -2062,45 +2062,45 @@ static inline struct lu_device *cl2lu_dev(struct cl_device *d)
 
 static inline struct cl_object *lu2cl(const struct lu_object *o)
 {
 
 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)
 {
 }
 
 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)
 {
 }
 
 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)
 {
 }
 
 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)
 {
 }
 
 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)
 {
 }
 
 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)
 {
 }
 
 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)
 {
 }
 
 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,
 }
 
 void cl_page_slice_add(struct cl_page *page, struct cl_page_slice *slice,
index c1c5d28..752ac11 100644 (file)
@@ -1867,8 +1867,8 @@ static inline int lu_device_is_dt(const struct lu_device *d)
 
 static inline struct dt_device * lu2dt_dev(struct lu_device *l)
 {
 
 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 {
 }
 
 struct dt_object {
@@ -1903,8 +1903,8 @@ static inline struct lu_device *dt2lu_dev(struct dt_device *d)
 
 static inline struct dt_object *lu2dt(struct lu_object *l)
 {
 
 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,
 }
 
 int  dt_object_init(struct dt_object *obj,
@@ -1925,13 +1925,13 @@ static inline int dt_object_remote(const struct dt_object *dt)
 static inline struct dt_object *lu2dt_obj(struct lu_object *o)
 {
        LASSERT(ergo(o != NULL, lu_device_is_dt(o->lo_dev)));
 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)
 {
 }
 
 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);
 }
 
 /**
 }
 
 /**
index 4afaa18..782384a 100644 (file)
@@ -759,7 +759,7 @@ struct lu_object *lu_object_find_slice(const struct lu_env *env,
 static inline struct lu_object *lu_object_top(struct lu_object_header *h)
 {
        LASSERT(!list_empty(&h->loh_layers));
 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);
 }
 
 /**
 }
 
 /**
@@ -767,7 +767,7 @@ static inline struct lu_object *lu_object_top(struct lu_object_header *h)
  */
 static inline struct lu_object *lu_object_next(const struct lu_object *o)
 {
  */
 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);
 }
 
 /**
 }
 
 /**
index bd2bcff..ae7b06e 100644 (file)
@@ -738,7 +738,7 @@ static inline struct osc_io *osc_env_io(const struct lu_env *env)
 
 static inline struct osc_device *lu2osc_dev(const struct lu_device *d)
 {
 
 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 obd_export *osc_export(const struct osc_object *obj)
@@ -753,7 +753,7 @@ static inline struct client_obd *osc_cli(const struct osc_object *obj)
 
 static inline struct osc_object *cl2osc(const struct cl_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 cl_object *osc2cl(const struct osc_object *obj)
@@ -763,8 +763,8 @@ static inline struct cl_object *osc2cl(const struct osc_object *obj)
 
 static inline struct osc_device *obd2osc_dev(const struct obd_device *obd)
 {
 
 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 lu_device *osc2lu_dev(struct osc_device *osc)
@@ -779,13 +779,13 @@ static inline struct lu_object *osc2lu(struct osc_object *osc)
 
 static inline struct osc_object *lu2osc(const struct lu_object *obj)
 {
 
 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)
 {
 }
 
 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;
 
        LINVRNT(oio == osc_env_io(env));
        return oio;
@@ -813,12 +813,12 @@ static inline enum cl_lock_mode osc_ldlm2cl_lock(enum ldlm_mode mode)
 
 static inline struct osc_page *cl2osc_page(const struct cl_page_slice *slice)
 {
 
 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)
 {
 }
 
 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 pgoff_t osc_index(struct osc_page *opg)
@@ -848,7 +848,7 @@ osc_cl_page_osc(struct cl_page *page, struct osc_object *osc)
 
 static inline struct osc_lock *cl2osc_lock(const struct cl_lock_slice *slice)
 {
 
 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 int osc_io_srvlock(struct osc_io *oio)
index 95fa430..baafdc4 100644 (file)
@@ -384,8 +384,8 @@ struct md_object {
 
 static inline struct md_device *lu2md_dev(const struct lu_device *d)
 {
 
 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 lu_device *md2lu_dev(struct md_device *d)
@@ -395,8 +395,8 @@ static inline struct lu_device *md2lu_dev(struct md_device *d)
 
 static inline struct md_object *lu2md(const struct lu_object *o)
 {
 
 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)
 }
 
 static inline int md_device_init(struct md_device *md, struct lu_device_type *t)