OpenVZ Forum - RDF feed
type: channel
items: [PATCH v5] slab: Ignore internal flags in cache creation
items: Re: [PATCH v5] slab: Ignore internal flags in cache creation

[PATCH v5] slab: Ignore internal flags in cache creation
type: item
description: Some flags are used internally by the allocators for management purposes. One example of that is the CFLGS_OFF_SLAB flag that slab uses to mark that the metadata for that cache is stored outside of the slab. No cache should ever pass those as a creation flags. We can just ignore this bit if it happens to be passed (such as when duplicating a cache in the kmem memcg patches). Because such flags can vary from allocator to allocator, we allow them to make their own decisions on that, defining SLAB_AVAILABLE_FLAGS with all flags that are valid at creation time. Allocators that doesn't have any specific flag requirement should define that to mean all flags. Common code will mask out all flags not belonging to that set. [ v2: leave the mask out decision up to the allocators ] [ v3: define flags for all allocators ] [ v4: move all definitions to slab.h ] Signed-off-by: Glauber Costa <glommer@parallels.com> Acked-by: Christoph Lameter <cl@linux.com> CC: David Rientjes <rientjes@google.com> CC: Pekka Enberg <penberg@cs.helsinki.fi> --- mm/slab.c | 22 ---------------------- mm/slab.h | 25 +++++++++++++++++++++++++ mm/slab_common.c | 7 +++++++ mm/slub.c | 3 --- 4 files changed, 32 insertions(+), 25 deletions(-) diff --git a/mm/slab.c b/mm/slab.c index 8524923..8c1d447 100644 --- a/mm/slab.c +++ b/mm/slab.c @@ -162,23 +162,6 @@ */ static bool pfmemalloc_active __read_mostly; -/* Legal flag mask for kmem_cache_create(). */ -#if DEBUG -# define CREATE_MASK (SLAB_RED_ZONE | \ - SLAB_POISON | SLAB_HWCACHE_ALIGN | \ - SLAB_CACHE_DMA | \ - SLAB_STORE_USER | \ - SLAB_RECLAIM_ACCOUNT | SLAB_PANIC | \ - SLAB_DESTROY_BY_RCU | SLAB_MEM_SPREAD | \ - SLAB_DEBUG_OBJECTS | SLAB_NOLEAKTRACE | SLAB_NOTRACK) -#else -# define CREATE_MASK (SLAB_HWCACHE_ALIGN | \ - SLAB_CACHE_DMA | \ - SLAB_RECLAIM_ACCOUNT | SLAB_PANIC | \ - SLAB_DESTROY_BY_RCU | SLAB_MEM_SPREAD | \ - SLAB_DEBUG_OBJECTS | SLAB_NOLEAKTRACE | SLAB_NOTRACK) -#endif - /* * kmem_bufctl_t: * @@ -2385,11 +2368,6 @@ __kmem_cache_create (st…
creator: Glauber Costa
date: 2012-10-17T11:36:51-00:00

Re: [PATCH v5] slab: Ignore internal flags in cache creation
type: item
description: On Wed, 17 Oct 2012, Glauber Costa wrote: > Some flags are used internally by the allocators for management > purposes. One example of that is the CFLGS_OFF_SLAB flag that slab uses > to mark that the metadata for that cache is stored outside of the slab. > > No cache should ever pass those as a creation flags. We can just ignore > this bit if it happens to be passed (such as when duplicating a cache in > the kmem memcg patches). > > Because such flags can vary from allocator to allocator, we allow them > to make their own decisions on that, defining SLAB_AVAILABLE_FLAGS with > all flags that are valid at creation time. Allocators that doesn't have > any specific flag requirement should define that to mean all flags. > > Common code will mask out all flags not belonging to that set. > > [ v2: leave the mask out decision up to the allocators ] > [ v3: define flags for all allocators ] > [ v4: move all definitions to slab.h ] > > Signed-off-by: Glauber Costa <glommer@parallels.com> > Acked-by: Christoph Lameter <cl@linux.com> > CC: David Rientjes <rientjes@google.com> > CC: Pekka Enberg <penberg@cs.helsinki.fi> Acked-by: David Rientjes <rientjes@google.com>
creator: David Rientjes
date: 2012-10-17T21:07:55-00:00

Re: [PATCH v5] slab: Ignore internal flags in cache creation
type: item
description: On Wed, 17 Oct 2012 15:36:51 +0400 Glauber Costa <glommer@parallels.com> wrote: > Some flags are used internally by the allocators for management > purposes. One example of that is the CFLGS_OFF_SLAB flag that slab uses > to mark that the metadata for that cache is stored outside of the slab. > > No cache should ever pass those as a creation flags. We can just ignore > this bit if it happens to be passed (such as when duplicating a cache in > the kmem memcg patches). I may be minunderstanding this, but... If some caller to kmem_cache_create() is passing in bogus flags then that's a bug, and it is undesirable to hide such a bug in this fashion? > Because such flags can vary from allocator to allocator, we allow them > to make their own decisions on that, defining SLAB_AVAILABLE_FLAGS with > all flags that are valid at creation time. Allocators that doesn't have > any specific flag requirement should define that to mean all flags. > > Common code will mask out all flags not belonging to that set.
creator: akpm
date: 2012-10-18T22:42:03-00:00

Re: [PATCH v5] slab: Ignore internal flags in cache creation
type: item
description: On 10/19/2012 02:42 AM, Andrew Morton wrote: > On Wed, 17 Oct 2012 15:36:51 +0400 > Glauber Costa <glommer@parallels.com> wrote: > >> Some flags are used internally by the allocators for management >> purposes. One example of that is the CFLGS_OFF_SLAB flag that slab uses >> to mark that the metadata for that cache is stored outside of the slab. >> >> No cache should ever pass those as a creation flags. We can just ignore >> this bit if it happens to be passed (such as when duplicating a cache in >> the kmem memcg patches). > > I may be minunderstanding this, but... > > If some caller to kmem_cache_create() is passing in bogus flags then > that's a bug, and it is undesirable to hide such a bug in this fashion? > Not necessarily. This part is part of the kmemcg-slab series. In that use case, I copy the flags from the original kmem cache, and create a duplicate. That duplicate need to have the same flags, but only the creation flags. We had many attempts to mask it out in different places, and after some discussion, it seemed best to independently do it from common code in slab_common.c at creation time. It gets quite independent from the kmemcg-slab this way, and so I posted independently to reduce my churn
creator: Glauber Costa
date: 2012-10-19T09:32:43-00:00

Re: [PATCH v5] slab: Ignore internal flags in cache creation
type: item
description: On Thu, Oct 18, 2012 at 12:07 AM, David Rientjes <rientjes@google.com> wrote: > On Wed, 17 Oct 2012, Glauber Costa wrote: > >> Some flags are used internally by the allocators for management >> purposes. One example of that is the CFLGS_OFF_SLAB flag that slab uses >> to mark that the metadata for that cache is stored outside of the slab. >> >> No cache should ever pass those as a creation flags. We can just ignore >> this bit if it happens to be passed (such as when duplicating a cache in >> the kmem memcg patches). >> >> Because such flags can vary from allocator to allocator, we allow them >> to make their own decisions on that, defining SLAB_AVAILABLE_FLAGS with >> all flags that are valid at creation time. Allocators that doesn't have >> any specific flag requirement should define that to mean all flags. >> >> Common code will mask out all flags not belonging to that set. >> >> [ v2: leave the mask out decision up to the allocators ] >> [ v3: define flags for all allocators ] >> [ v4: move all definitions to slab.h ] >> >> Signed-off-by: Glauber Costa <glommer@parallels.com> >> Acked-by: Christoph Lameter <cl@linux.com> >> CC: David Rientjes <rientjes@google.com> >> CC: Pekka Enberg <penberg@cs.helsinki.fi> > > Acked-by: David Rientjes <rientjes@google.com> Applied, thanks!
creator: Pekka Enberg
date: 2012-10-31T07:13:49-00:00