| Message ID | 20180223144807.1180-8-igor.stoppa@huawei.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On 2/23/18 6:48 AM, Igor Stoppa wrote: > Detailed documentation about the protectable memory allocator. > > Signed-off-by: Igor Stoppa <igor.stoppa@huawei.com> > --- > Documentation/core-api/index.rst | 1 + > Documentation/core-api/pmalloc.rst | 114 +++++++++++++++++++++++++++++++++++++ > 2 files changed, 115 insertions(+) > create mode 100644 Documentation/core-api/pmalloc.rst > > diff --git a/Documentation/core-api/index.rst b/Documentation/core-api/index.rst > index c670a8031786..8f5de42d6571 100644 > --- a/Documentation/core-api/index.rst > +++ b/Documentation/core-api/index.rst > @@ -25,6 +25,7 @@ Core utilities > genalloc > errseq > printk-formats > + pmalloc > > Interfaces for kernel debugging > =============================== > diff --git a/Documentation/core-api/pmalloc.rst b/Documentation/core-api/pmalloc.rst > new file mode 100644 > index 000000000000..d9725870444e > --- /dev/null > +++ b/Documentation/core-api/pmalloc.rst > @@ -0,0 +1,114 @@ > +.. SPDX-License-Identifier: GPL-2.0 > + > +Protectable memory allocator > +============================ > + > +Purpose > +------- > + > +The pmalloc library is meant to provide R/O status to data that, for some > +reason, could neither be declared as constant, nor could it take advantage > +of the qualifier __ro_after_init, but is write-once and read-only in spirit. > +It protects data from both accidental and malicious overwrites. > + > +Example: A policy that is loaded from userspace. > + > + > +Concept > +------- > + > +pmalloc builds on top of genalloc, using the same concept of memory pools. > + > +The value added by pmalloc is that now the memory contained in a pool can > +become R/O, for the rest of the life of the pool. > + > +Different kernel drivers and threads can use different pools, for finer > +control of what becomes R/O and when. And for improved lockless concurrency. > + > + > +Caveats > +------- > + > +- Memory freed while a pool is not yet protected will be reused. > + > +- Once a pool is protected, it's not possible to allocate any more memory > + from it. > + > +- Memory "freed" from a protected pool indicates that such memory is not > + in use anymore by the requester; however, it will not become available > + for further use, until the pool is destroyed. > + > +- Before destroying a pool, all the memory allocated from it must be > + released. Is that true? pmalloc_destroy_pool() has: . . + pmalloc_pool_set_protection(pool, false); + gen_pool_for_each_chunk(pool, pmalloc_chunk_free, NULL); + gen_pool_destroy(pool); + kfree(data); which to me looks like is the opposite, the data (ie, "memory") is being released first, then the pool is destroyed. > + > +- pmalloc does not provide locking support with respect to allocating vs > + protecting an individual pool, for performance reasons. What is the recommendation to using locks then, as the computing real-world mainly operates in multi-threaded/process world? Maybe show an example of an issue that occur if locks aren't used and give a coding example. > + It is recommended not to share the same pool between unrelated functions. > + Should sharing be a necessity, the user of the shared pool is expected > + to implement locking for that pool. > + > +- pmalloc uses genalloc to optimize the use of the space it allocates > + through vmalloc. Some more TLB entries will be used, however less than > + in the case of using vmalloc directly. The exact number depends on the > + size of each allocation request and possible slack. > + > +- Considering that not much data is supposed to be dynamically allocated > + and then marked as read-only, it shouldn't be an issue that the address > + range for pmalloc is limited, on 32-bit systems. Why is 32-bit systems mentioned and not 64-bit? Is there a problem with 64-bit here? Thanks, Jay
On 24/02/18 02:26, J Freyensee wrote: > > > On 2/23/18 6:48 AM, Igor Stoppa wrote: [...] >> +- Before destroying a pool, all the memory allocated from it must be >> + released. > > Is that true? pmalloc_destroy_pool() has: > > . > . > + pmalloc_pool_set_protection(pool, false); > + gen_pool_for_each_chunk(pool, pmalloc_chunk_free, NULL); > + gen_pool_destroy(pool); > + kfree(data); > > which to me looks like is the opposite, the data (ie, "memory") is being > released first, then the pool is destroyed. well, this is embarrassing ... yes I had this prototype code, because I was wondering if it wouldn't make more sense to tear down the pool as fast as possible. It slipped in, apparently. I'm actually tempted to leave it in and fix the comment. [...] >> + >> +- pmalloc does not provide locking support with respect to allocating vs >> + protecting an individual pool, for performance reasons. > > What is the recommendation to using locks then, as the computing > real-world mainly operates in multi-threaded/process world? How common are multi-threaded allocations of write-once memory? Here we are talking exclusively about the part of the memory life-cycle where it is allocated (from pmalloc). > Maybe show > an example of an issue that occur if locks aren't used and give a coding > example. An example of how to use a mutex to access a shared resource? :-O This part below, under your question, was supposed to be the answer :-( >> + It is recommended not to share the same pool between unrelated functions. >> + Should sharing be a necessity, the user of the shared pool is expected >> + to implement locking for that pool. [...] >> +- pmalloc uses genalloc to optimize the use of the space it allocates >> + through vmalloc. Some more TLB entries will be used, however less than >> + in the case of using vmalloc directly. The exact number depends on the >> + size of each allocation request and possible slack. >> + >> +- Considering that not much data is supposed to be dynamically allocated >> + and then marked as read-only, it shouldn't be an issue that the address >> + range for pmalloc is limited, on 32-bit systems. > > Why is 32-bit systems mentioned and not 64-bit? Because, as written, on 32 bit system the vmalloc range is relatively small, so one might wonder if there are enough addresses. > Is there a problem with 64-bit here? Quite the opposite. I thought it was clear, but obviously it isn't, I'll reword this. -igor
[...] On 2/26/18 7:39 AM, Igor Stoppa wrote: > > On 24/02/18 02:26, J Freyensee wrote: >> >> On 2/23/18 6:48 AM, Igor Stoppa wrote: > [...] > >>> +- Before destroying a pool, all the memory allocated from it must be >>> + released. >> Is that true? pmalloc_destroy_pool() has: >> >> . >> . >> + pmalloc_pool_set_protection(pool, false); >> + gen_pool_for_each_chunk(pool, pmalloc_chunk_free, NULL); >> + gen_pool_destroy(pool); >> + kfree(data); >> >> which to me looks like is the opposite, the data (ie, "memory") is being >> released first, then the pool is destroyed. > well, this is embarrassing ... yes I had this prototype code, because I > was wondering if it wouldn't make more sense to tear down the pool as > fast as possible. It slipped in, apparently. > > I'm actually tempted to leave it in and fix the comment. Sure, one or the other. > > [...] > >>> + >>> +- pmalloc does not provide locking support with respect to allocating vs >>> + protecting an individual pool, for performance reasons. >> What is the recommendation to using locks then, as the computing >> real-world mainly operates in multi-threaded/process world? > How common are multi-threaded allocations of write-once memory? > Here we are talking exclusively about the part of the memory life-cycle > where it is allocated (from pmalloc). Yah, that's true, good point. > >> Maybe show >> an example of an issue that occur if locks aren't used and give a coding >> example. > An example of how to use a mutex to access a shared resource? :-O > > This part below, under your question, was supposed to be the answer :-( > >>> + It is recommended not to share the same pool between unrelated functions. >>> + Should sharing be a necessity, the user of the shared pool is expected >>> + to implement locking for that pool. My bad, I was suggesting a code sample, if there was a simple code sample to provide (like 5-10 lines?). If it's a lot of code to write, no bother. > [...] > >>> +- pmalloc uses genalloc to optimize the use of the space it allocates >>> + through vmalloc. Some more TLB entries will be used, however less than >>> + in the case of using vmalloc directly. The exact number depends on the >>> + size of each allocation request and possible slack. >>> + >>> +- Considering that not much data is supposed to be dynamically allocated >>> + and then marked as read-only, it shouldn't be an issue that the address >>> + range for pmalloc is limited, on 32-bit systems. >> Why is 32-bit systems mentioned and not 64-bit? > Because, as written, on 32 bit system the vmalloc range is relatively > small, so one might wonder if there are enough addresses. > >> Is there a problem with 64-bit here? > Quite the opposite. > I thought it was clear, but obviously it isn't, I'll reword this. Sounds good, thank you, Jay > > -igor > >
diff --git a/Documentation/core-api/index.rst b/Documentation/core-api/index.rst index c670a8031786..8f5de42d6571 100644 --- a/Documentation/core-api/index.rst +++ b/Documentation/core-api/index.rst @@ -25,6 +25,7 @@ Core utilities genalloc errseq printk-formats + pmalloc Interfaces for kernel debugging =============================== diff --git a/Documentation/core-api/pmalloc.rst b/Documentation/core-api/pmalloc.rst new file mode 100644 index 000000000000..d9725870444e --- /dev/null +++ b/Documentation/core-api/pmalloc.rst @@ -0,0 +1,114 @@ +.. SPDX-License-Identifier: GPL-2.0 + +Protectable memory allocator +============================ + +Purpose +------- + +The pmalloc library is meant to provide R/O status to data that, for some +reason, could neither be declared as constant, nor could it take advantage +of the qualifier __ro_after_init, but is write-once and read-only in spirit. +It protects data from both accidental and malicious overwrites. + +Example: A policy that is loaded from userspace. + + +Concept +------- + +pmalloc builds on top of genalloc, using the same concept of memory pools. + +The value added by pmalloc is that now the memory contained in a pool can +become R/O, for the rest of the life of the pool. + +Different kernel drivers and threads can use different pools, for finer +control of what becomes R/O and when. And for improved lockless concurrency. + + +Caveats +------- + +- Memory freed while a pool is not yet protected will be reused. + +- Once a pool is protected, it's not possible to allocate any more memory + from it. + +- Memory "freed" from a protected pool indicates that such memory is not + in use anymore by the requester; however, it will not become available + for further use, until the pool is destroyed. + +- Before destroying a pool, all the memory allocated from it must be + released. + +- pmalloc does not provide locking support with respect to allocating vs + protecting an individual pool, for performance reasons. + It is recommended not to share the same pool between unrelated functions. + Should sharing be a necessity, the user of the shared pool is expected + to implement locking for that pool. + +- pmalloc uses genalloc to optimize the use of the space it allocates + through vmalloc. Some more TLB entries will be used, however less than + in the case of using vmalloc directly. The exact number depends on the + size of each allocation request and possible slack. + +- Considering that not much data is supposed to be dynamically allocated + and then marked as read-only, it shouldn't be an issue that the address + range for pmalloc is limited, on 32-bit systems. + +- Regarding SMP systems, the allocations are expected to happen mostly + during an initial transient, after which there should be no more need to + perform cross-processor synchronizations of page tables. + +- To facilitate the conversion of existing code to pmalloc pools, several + helper functions are provided, mirroring their kmalloc counterparts. + + +Use +--- + +The typical sequence, when using pmalloc, is: + +1. create a pool + +.. kernel-doc:: include/linux/pmalloc.h + :functions: pmalloc_create_pool + +2. [optional] pre-allocate some memory in the pool + +.. kernel-doc:: include/linux/pmalloc.h + :functions: pmalloc_prealloc + +3. issue one or more allocation requests to the pool with locking as needed + +.. kernel-doc:: include/linux/pmalloc.h + :functions: pmalloc + +.. kernel-doc:: include/linux/pmalloc.h + :functions: pzalloc + +4. initialize the memory obtained with desired values + +5. [optional] iterate over points 3 & 4 as needed + +6. write-protect the pool + +.. kernel-doc:: include/linux/pmalloc.h + :functions: pmalloc_protect_pool + +7. use in read-only mode the handles obtained through the allocations + +8. [optional] release all the memory allocated + +.. kernel-doc:: include/linux/pmalloc.h + :functions: pfree + +9. [optional, but depends on point 8] destroy the pool + +.. kernel-doc:: include/linux/pmalloc.h + :functions: pmalloc_destroy_pool + +API +--- + +.. kernel-doc:: include/linux/pmalloc.h
Detailed documentation about the protectable memory allocator. Signed-off-by: Igor Stoppa <igor.stoppa@huawei.com> --- Documentation/core-api/index.rst | 1 + Documentation/core-api/pmalloc.rst | 114 +++++++++++++++++++++++++++++++++++++ 2 files changed, 115 insertions(+) create mode 100644 Documentation/core-api/pmalloc.rst