* Re: [PATCH v2 2/3] xen/x86: add dom0 memory sizing variants @ 2018-12-06 11:34 Juergen Gross 0 siblings, 0 replies; 5+ messages in thread From: Juergen Gross @ 2018-12-06 11:34 UTC (permalink / raw) To: Jan Beulich Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan, Julien Grall, xen-devel, Roger Pau Monne On 06/12/2018 12:28, Jan Beulich wrote: >>>> On 06.12.18 at 12:20, <jgross@suse.com> wrote: >> On 06/12/2018 12:08, Jan Beulich wrote: >>>>>> On 06.12.18 at 09:06, <jgross@suse.com> wrote: >>>> Today the memory size of dom0 can be specified only in terms of bytes >>>> (either an absolute value or "host-mem - value"). When dom0 shouldn't >>>> be auto-ballooned this requires nearly always a manual adaption of the >>>> Xen boot parameters to reflect the actual host memory size. >>>> >>>> Add more possibilities to specify memory sizes. Today we have: >>>> >>>> dom0_mem= List of ( min:<size> | max:<size> | <size> ) >>>> >>>> with <size> being a positive or negative size value (e.g. 1G). >>>> >>>> Modify that to: >>>> >>>> dom0_mem= List of ( min:<sz> | max:<sz> | <sz> ) >>>> <sz>: <size> | [<size>+]<frac>% >>>> <frac>: integer value < 100 >>>> >>>> With the following semantics: >>>> >>>> <frac>% specifies a fraction of host memory size in percent. >>>> <sz> is a percentage of host memory plus an offset. >>>> >>>> So <sz> being 1G+25% on a 256G host would result in 65G. >>>> >>>> Signed-off-by: Juergen Gross <jgross@suse.com> >>> >>> Reviewed-by: Jan Beulich <jbeulich@suse.com> >>> >>> I notice though that ... >>> >>>> -static long __init parse_amt(const char *s, const char **ps) >>>> +static int __init parse_amt(const char *s, const char **ps, struct memsize *sz) >>>> { >>>> - long pages = parse_size_and_unit((*s == '-') ? s+1 : s, ps) >> PAGE_SHIFT; >>>> - return (*s == '-') ? -pages : pages; >>>> + unsigned long val; >>>> + struct memsize tmp = { }; >>>> + >>>> + tmp.minus = (*s == '-'); >>>> + if ( tmp.minus ) >>>> + s++; >>>> + >>>> + /* Avoid accessing s[-1] in case value starts with '%'. */ >>>> + if ( *s == '%' ) >>>> + return -EINVAL; >>>> + >>>> + while ( isdigit(*s) ) >>>> + { >>>> + val = parse_size_and_unit_or_int(s, ps, '%'); >>>> + s = *ps; >>>> + if ( *s == '%' ) >>>> + { >>>> + if ( !isdigit(s[-1]) || val >= 100 ) >>>> + return -EINVAL; >>>> + tmp.percent = val; >>>> + s++; >>>> + } >>>> + else >>>> + tmp.nr_pages = val >> PAGE_SHIFT; >>>> + if ( *s == '+' ) >>>> + s++; >>>> + } >>> >>> ... you allow more flexibility here than you document (i.e. also >>> <percentage>+<basesize>). You may want to consider >>> refusing something like 1G+10%+10%, though. >> >> Okay, should be fairly easy. >> >> Can I keep your R-b: with adding something like: >> >> + bool percent = false; >> ... >> - while ( isdigit(*s) ) >> + while ( isdigit(*s) && !percent ) >> ... >> if ( *s == '%' ) >> { >> + percent = true; >> ... > > Something like this, yes. The double percent value was just an > example though, "1G+10%+1G" then too would better either work > as written, or be refused. Okay, I'll modify the patch accordingly and drop your R-b. Juergen > > Jan > _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel ^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH v2 0/3] xen/x86: support setting dom0_mem depending on host size @ 2018-12-06 8:06 Juergen Gross 2018-12-06 8:06 ` [PATCH v2 2/3] xen/x86: add dom0 memory sizing variants Juergen Gross 0 siblings, 1 reply; 5+ messages in thread From: Juergen Gross @ 2018-12-06 8:06 UTC (permalink / raw) To: xen-devel Cc: Juergen Gross, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan, Julien Grall, Jan Beulich, Roger Pau Monné Setting the memory size of dom0 on a server for the non autoballooning case requires always specification of a boot parameter today. The value to set will depend mostly on the host memory size. In order to support that scenario add the possibility to set dom0_mem depending on the amount of physical memory by allowing to specify a percentage of host memory (e.g. 10%) with an offset (like 1G+10%). To make it easy for a distributor to use such a setting as the default make the standard setting for dom0_mem configurable via Kconfig. Changes since V1: - replaced old patch 1 by new one - rewritten patch 2 according to remarks by Jan Beulich - changed patch 3 to allow config item on arm, too Juergen Gross (3): xen: introduce parse_size_and_unit_or_int xen/x86: add dom0 memory sizing variants xen: add CONFIG item for default dom0 memory size docs/misc/xen-command-line.markdown | 19 ++++-- xen/arch/arm/domain_build.c | 7 +++ xen/arch/x86/dom0_build.c | 112 +++++++++++++++++++++++++++--------- xen/common/Kconfig | 13 +++++ xen/common/lib.c | 11 +++- xen/include/xen/lib.h | 2 + 6 files changed, 130 insertions(+), 34 deletions(-) -- 2.16.4 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel ^ permalink raw reply [flat|nested] 5+ messages in thread
* [PATCH v2 2/3] xen/x86: add dom0 memory sizing variants 2018-12-06 8:06 [PATCH v2 0/3] xen/x86: support setting dom0_mem depending on host size Juergen Gross @ 2018-12-06 8:06 ` Juergen Gross 2018-12-06 11:08 ` Jan Beulich [not found] ` <5C09031502000078002039F0@suse.com> 0 siblings, 2 replies; 5+ messages in thread From: Juergen Gross @ 2018-12-06 8:06 UTC (permalink / raw) To: xen-devel Cc: Juergen Gross, Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan, Julien Grall, Jan Beulich, Roger Pau Monné Today the memory size of dom0 can be specified only in terms of bytes (either an absolute value or "host-mem - value"). When dom0 shouldn't be auto-ballooned this requires nearly always a manual adaption of the Xen boot parameters to reflect the actual host memory size. Add more possibilities to specify memory sizes. Today we have: dom0_mem= List of ( min:<size> | max:<size> | <size> ) with <size> being a positive or negative size value (e.g. 1G). Modify that to: dom0_mem= List of ( min:<sz> | max:<sz> | <sz> ) <sz>: <size> | [<size>+]<frac>% <frac>: integer value < 100 With the following semantics: <frac>% specifies a fraction of host memory size in percent. <sz> is a percentage of host memory plus an offset. So <sz> being 1G+25% on a 256G host would result in 65G. Signed-off-by: Juergen Gross <jgross@suse.com> --- docs/misc/xen-command-line.markdown | 19 +++++-- xen/arch/x86/dom0_build.c | 106 +++++++++++++++++++++++++++--------- 2 files changed, 93 insertions(+), 32 deletions(-) diff --git a/docs/misc/xen-command-line.markdown b/docs/misc/xen-command-line.markdown index 9028bcde2e..6248b68595 100644 --- a/docs/misc/xen-command-line.markdown +++ b/docs/misc/xen-command-line.markdown @@ -759,17 +759,17 @@ Set the amount of memory for the initial domain (dom0). It must be greater than zero. This parameter is required. ### dom0\_mem (x86) -> `= List of ( min:<size> | max:<size> | <size> )` +> `= List of ( min:<sz> | max:<sz> | <sz> )` Set the amount of memory for the initial domain (dom0). If a size is positive, it represents an absolute value. If a size is negative, it is subtracted from the total available memory. -* `<size>` specifies the exact amount of memory. -* `min:<size>` specifies the minimum amount of memory. -* `max:<size>` specifies the maximum amount of memory. +* `<sz>` specifies the exact amount of memory. +* `min:<sz>` specifies the minimum amount of memory. +* `max:<sz>` specifies the maximum amount of memory. -If `<size>` is not specified, the default is all the available memory +If `<sz>` is not specified, the default is all the available memory minus some reserve. The reserve is 1/16 of the available memory or 128 MB (whichever is smaller). @@ -777,13 +777,20 @@ The amount of memory will be at least the minimum but never more than the maximum (i.e., `max` overrides the `min` option). If there isn't enough memory then as much as possible is allocated. -`max:<size>` also sets the maximum reservation (the maximum amount of +`max:<sz>` also sets the maximum reservation (the maximum amount of memory dom0 can balloon up to). If this is omitted then the maximum reservation is unlimited. For example, to set dom0's initial memory allocation to 512MB but allow it to balloon up as far as 1GB use `dom0_mem=512M,max:1G` +> `<sz>` is: `<size> | [<size>+]<frac>%` +> `<frac>` is an integer < 100 + +* `<frac>` specifies a fraction of host memory size in percent. + +So `<sz>` being `1G+25%` on a 256 GB host would result in 65 GB. + If you use this option then it is highly recommended that you disable any dom0 autoballooning feature present in your toolstack. See the _xl.conf(5)_ man page or [Xen Best diff --git a/xen/arch/x86/dom0_build.c b/xen/arch/x86/dom0_build.c index 5e2ad4bd56..8de71346db 100644 --- a/xen/arch/x86/dom0_build.c +++ b/xen/arch/x86/dom0_build.c @@ -20,17 +20,42 @@ #include <asm/p2m.h> #include <asm/setup.h> -static long __initdata dom0_nrpages; -static long __initdata dom0_min_nrpages; -static long __initdata dom0_max_nrpages = LONG_MAX; +struct memsize { + long nr_pages; + unsigned int percent; + bool minus; +}; + +static struct memsize __initdata dom0_size; +static struct memsize __initdata dom0_min_size; +static struct memsize __initdata dom0_max_size = { .nr_pages = LONG_MAX }; + +static bool __init memsize_gt_zero(const struct memsize *sz) +{ + return !sz->minus && sz->nr_pages; +} + +static unsigned long __init get_memsize(const struct memsize *sz, + unsigned long avail) +{ + unsigned long pages; + + pages = sz->nr_pages + sz->percent * avail / 100; + return sz->minus ? avail - pages : pages; +} /* * dom0_mem=[min:<min_amt>,][max:<max_amt>,][<amt>] - * + * * <min_amt>: The minimum amount of memory which should be allocated for dom0. * <max_amt>: The maximum amount of memory which should be allocated for dom0. * <amt>: The precise amount of memory to allocate for dom0. - * + * + * The format of <min_amt>, <max_amt> and <amt> is as follows: + * <size> | <frac>% | <size>+<frac>% + * <size> is a size value like 1G (1 GByte), <frac> is percentage of host + * memory (so 1G+10% means 10 percent of host memory + 1 GByte). + * * Notes: * 1. <amt> is clamped from below by <min_amt> and from above by available * memory and <max_amt> @@ -39,19 +64,53 @@ static long __initdata dom0_max_nrpages = LONG_MAX; * 4. If <amt> is not specified, it is calculated as follows: * "All of memory is allocated to domain 0, minus 1/16th which is reserved * for uses such as DMA buffers (the reservation is clamped to 128MB)." - * + * * Each value can be specified as positive or negative: * If +ve: The specified amount is an absolute value. * If -ve: The specified amount is subtracted from total available memory. */ -static long __init parse_amt(const char *s, const char **ps) +static int __init parse_amt(const char *s, const char **ps, struct memsize *sz) { - long pages = parse_size_and_unit((*s == '-') ? s+1 : s, ps) >> PAGE_SHIFT; - return (*s == '-') ? -pages : pages; + unsigned long val; + struct memsize tmp = { }; + + tmp.minus = (*s == '-'); + if ( tmp.minus ) + s++; + + /* Avoid accessing s[-1] in case value starts with '%'. */ + if ( *s == '%' ) + return -EINVAL; + + while ( isdigit(*s) ) + { + val = parse_size_and_unit_or_int(s, ps, '%'); + s = *ps; + if ( *s == '%' ) + { + if ( !isdigit(s[-1]) || val >= 100 ) + return -EINVAL; + tmp.percent = val; + s++; + } + else + tmp.nr_pages = val >> PAGE_SHIFT; + if ( *s == '+' ) + s++; + } + *ps = s; + if ( *s && *s != ',' ) + return -EINVAL; + + *sz = tmp; + + return 0; } static int __init parse_dom0_mem(const char *s) { + int ret; + /* xen-shim uses shim_mem parameter instead of dom0_mem */ if ( pv_shim ) { @@ -61,14 +120,14 @@ static int __init parse_dom0_mem(const char *s) do { if ( !strncmp(s, "min:", 4) ) - dom0_min_nrpages = parse_amt(s+4, &s); + ret = parse_amt(s + 4, &s, &dom0_min_size); else if ( !strncmp(s, "max:", 4) ) - dom0_max_nrpages = parse_amt(s+4, &s); + ret = parse_amt(s + 4, &s, &dom0_max_size); else - dom0_nrpages = parse_amt(s, &s); - } while ( *s++ == ',' ); + ret = parse_amt(s, &s, &dom0_size); + } while ( *s++ == ',' && !ret ); - return s[-1] ? -EINVAL : 0; + return s[-1] ? -EINVAL : ret; } custom_param("dom0_mem", parse_dom0_mem); @@ -298,9 +357,9 @@ unsigned long __init dom0_compute_nr_pages( (!iommu_hap_pt_share || !paging_mode_hap(d)); for ( ; ; need_paging = false ) { - nr_pages = dom0_nrpages; - min_pages = dom0_min_nrpages; - max_pages = dom0_max_nrpages; + nr_pages = get_memsize(&dom0_size, avail); + min_pages = get_memsize(&dom0_min_size, avail); + max_pages = get_memsize(&dom0_max_size, avail); /* * If allocation isn't specified, reserve 1/16th of available memory @@ -308,14 +367,9 @@ unsigned long __init dom0_compute_nr_pages( * maximum of 128MB. */ if ( !nr_pages ) - nr_pages = -(pv_shim ? pv_shim_mem(avail) + nr_pages = avail - (pv_shim ? pv_shim_mem(avail) : min(avail / 16, 128UL << (20 - PAGE_SHIFT))); - /* Negative specification means "all memory - specified amount". */ - if ( (long)nr_pages < 0 ) nr_pages += avail; - if ( (long)min_pages < 0 ) min_pages += avail; - if ( (long)max_pages < 0 ) max_pages += avail; - /* Clamp according to min/max limits and available memory. */ nr_pages = max(nr_pages, min_pages); nr_pages = min(nr_pages, max_pages); @@ -329,8 +383,8 @@ unsigned long __init dom0_compute_nr_pages( } if ( is_pv_domain(d) && - (parms->p2m_base == UNSET_ADDR) && (dom0_nrpages <= 0) && - ((dom0_min_nrpages <= 0) || (nr_pages > min_pages)) ) + (parms->p2m_base == UNSET_ADDR) && !memsize_gt_zero(&dom0_size) && + (!memsize_gt_zero(&dom0_min_size) || (nr_pages > min_pages)) ) { /* * Legacy Linux kernels (i.e. such without a XEN_ELFNOTE_INIT_P2M @@ -356,7 +410,7 @@ unsigned long __init dom0_compute_nr_pages( { end = sizeof_long >= sizeof(end) ? 0 : 1UL << (8 * sizeof_long); nr_pages = (end - vend) / (2 * sizeof_long); - if ( dom0_min_nrpages > 0 && nr_pages < min_pages ) + if ( memsize_gt_zero(&dom0_min_size) && nr_pages < min_pages ) nr_pages = min_pages; printk("Dom0 memory clipped to %lu pages\n", nr_pages); } -- 2.16.4 _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel ^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [PATCH v2 2/3] xen/x86: add dom0 memory sizing variants 2018-12-06 8:06 ` [PATCH v2 2/3] xen/x86: add dom0 memory sizing variants Juergen Gross @ 2018-12-06 11:08 ` Jan Beulich [not found] ` <5C09031502000078002039F0@suse.com> 1 sibling, 0 replies; 5+ messages in thread From: Jan Beulich @ 2018-12-06 11:08 UTC (permalink / raw) To: Juergen Gross Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan, Julien Grall, xen-devel, Roger Pau Monne >>> On 06.12.18 at 09:06, <jgross@suse.com> wrote: > Today the memory size of dom0 can be specified only in terms of bytes > (either an absolute value or "host-mem - value"). When dom0 shouldn't > be auto-ballooned this requires nearly always a manual adaption of the > Xen boot parameters to reflect the actual host memory size. > > Add more possibilities to specify memory sizes. Today we have: > > dom0_mem= List of ( min:<size> | max:<size> | <size> ) > > with <size> being a positive or negative size value (e.g. 1G). > > Modify that to: > > dom0_mem= List of ( min:<sz> | max:<sz> | <sz> ) > <sz>: <size> | [<size>+]<frac>% > <frac>: integer value < 100 > > With the following semantics: > > <frac>% specifies a fraction of host memory size in percent. > <sz> is a percentage of host memory plus an offset. > > So <sz> being 1G+25% on a 256G host would result in 65G. > > Signed-off-by: Juergen Gross <jgross@suse.com> Reviewed-by: Jan Beulich <jbeulich@suse.com> I notice though that ... > -static long __init parse_amt(const char *s, const char **ps) > +static int __init parse_amt(const char *s, const char **ps, struct memsize *sz) > { > - long pages = parse_size_and_unit((*s == '-') ? s+1 : s, ps) >> PAGE_SHIFT; > - return (*s == '-') ? -pages : pages; > + unsigned long val; > + struct memsize tmp = { }; > + > + tmp.minus = (*s == '-'); > + if ( tmp.minus ) > + s++; > + > + /* Avoid accessing s[-1] in case value starts with '%'. */ > + if ( *s == '%' ) > + return -EINVAL; > + > + while ( isdigit(*s) ) > + { > + val = parse_size_and_unit_or_int(s, ps, '%'); > + s = *ps; > + if ( *s == '%' ) > + { > + if ( !isdigit(s[-1]) || val >= 100 ) > + return -EINVAL; > + tmp.percent = val; > + s++; > + } > + else > + tmp.nr_pages = val >> PAGE_SHIFT; > + if ( *s == '+' ) > + s++; > + } ... you allow more flexibility here than you document (i.e. also <percentage>+<basesize>). You may want to consider refusing something like 1G+10%+10%, though. Jan _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel ^ permalink raw reply [flat|nested] 5+ messages in thread
[parent not found: <5C09031502000078002039F0@suse.com>]
* Re: [PATCH v2 2/3] xen/x86: add dom0 memory sizing variants [not found] ` <5C09031502000078002039F0@suse.com> @ 2018-12-06 11:20 ` Juergen Gross 2018-12-06 11:28 ` Jan Beulich 0 siblings, 1 reply; 5+ messages in thread From: Juergen Gross @ 2018-12-06 11:20 UTC (permalink / raw) To: Jan Beulich Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan, Julien Grall, xen-devel, Roger Pau Monne On 06/12/2018 12:08, Jan Beulich wrote: >>>> On 06.12.18 at 09:06, <jgross@suse.com> wrote: >> Today the memory size of dom0 can be specified only in terms of bytes >> (either an absolute value or "host-mem - value"). When dom0 shouldn't >> be auto-ballooned this requires nearly always a manual adaption of the >> Xen boot parameters to reflect the actual host memory size. >> >> Add more possibilities to specify memory sizes. Today we have: >> >> dom0_mem= List of ( min:<size> | max:<size> | <size> ) >> >> with <size> being a positive or negative size value (e.g. 1G). >> >> Modify that to: >> >> dom0_mem= List of ( min:<sz> | max:<sz> | <sz> ) >> <sz>: <size> | [<size>+]<frac>% >> <frac>: integer value < 100 >> >> With the following semantics: >> >> <frac>% specifies a fraction of host memory size in percent. >> <sz> is a percentage of host memory plus an offset. >> >> So <sz> being 1G+25% on a 256G host would result in 65G. >> >> Signed-off-by: Juergen Gross <jgross@suse.com> > > Reviewed-by: Jan Beulich <jbeulich@suse.com> > > I notice though that ... > >> -static long __init parse_amt(const char *s, const char **ps) >> +static int __init parse_amt(const char *s, const char **ps, struct memsize *sz) >> { >> - long pages = parse_size_and_unit((*s == '-') ? s+1 : s, ps) >> PAGE_SHIFT; >> - return (*s == '-') ? -pages : pages; >> + unsigned long val; >> + struct memsize tmp = { }; >> + >> + tmp.minus = (*s == '-'); >> + if ( tmp.minus ) >> + s++; >> + >> + /* Avoid accessing s[-1] in case value starts with '%'. */ >> + if ( *s == '%' ) >> + return -EINVAL; >> + >> + while ( isdigit(*s) ) >> + { >> + val = parse_size_and_unit_or_int(s, ps, '%'); >> + s = *ps; >> + if ( *s == '%' ) >> + { >> + if ( !isdigit(s[-1]) || val >= 100 ) >> + return -EINVAL; >> + tmp.percent = val; >> + s++; >> + } >> + else >> + tmp.nr_pages = val >> PAGE_SHIFT; >> + if ( *s == '+' ) >> + s++; >> + } > > ... you allow more flexibility here than you document (i.e. also > <percentage>+<basesize>). You may want to consider > refusing something like 1G+10%+10%, though. Okay, should be fairly easy. Can I keep your R-b: with adding something like: + bool percent = false; ... - while ( isdigit(*s) ) + while ( isdigit(*s) && !percent ) ... if ( *s == '%' ) { + percent = true; ... Juergen _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel ^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH v2 2/3] xen/x86: add dom0 memory sizing variants 2018-12-06 11:20 ` Juergen Gross @ 2018-12-06 11:28 ` Jan Beulich 0 siblings, 0 replies; 5+ messages in thread From: Jan Beulich @ 2018-12-06 11:28 UTC (permalink / raw) To: Juergen Gross Cc: Stefano Stabellini, Wei Liu, Konrad Rzeszutek Wilk, George Dunlap, Andrew Cooper, Ian Jackson, Tim Deegan, Julien Grall, xen-devel, Roger Pau Monne >>> On 06.12.18 at 12:20, <jgross@suse.com> wrote: > On 06/12/2018 12:08, Jan Beulich wrote: >>>>> On 06.12.18 at 09:06, <jgross@suse.com> wrote: >>> Today the memory size of dom0 can be specified only in terms of bytes >>> (either an absolute value or "host-mem - value"). When dom0 shouldn't >>> be auto-ballooned this requires nearly always a manual adaption of the >>> Xen boot parameters to reflect the actual host memory size. >>> >>> Add more possibilities to specify memory sizes. Today we have: >>> >>> dom0_mem= List of ( min:<size> | max:<size> | <size> ) >>> >>> with <size> being a positive or negative size value (e.g. 1G). >>> >>> Modify that to: >>> >>> dom0_mem= List of ( min:<sz> | max:<sz> | <sz> ) >>> <sz>: <size> | [<size>+]<frac>% >>> <frac>: integer value < 100 >>> >>> With the following semantics: >>> >>> <frac>% specifies a fraction of host memory size in percent. >>> <sz> is a percentage of host memory plus an offset. >>> >>> So <sz> being 1G+25% on a 256G host would result in 65G. >>> >>> Signed-off-by: Juergen Gross <jgross@suse.com> >> >> Reviewed-by: Jan Beulich <jbeulich@suse.com> >> >> I notice though that ... >> >>> -static long __init parse_amt(const char *s, const char **ps) >>> +static int __init parse_amt(const char *s, const char **ps, struct memsize *sz) >>> { >>> - long pages = parse_size_and_unit((*s == '-') ? s+1 : s, ps) >> PAGE_SHIFT; >>> - return (*s == '-') ? -pages : pages; >>> + unsigned long val; >>> + struct memsize tmp = { }; >>> + >>> + tmp.minus = (*s == '-'); >>> + if ( tmp.minus ) >>> + s++; >>> + >>> + /* Avoid accessing s[-1] in case value starts with '%'. */ >>> + if ( *s == '%' ) >>> + return -EINVAL; >>> + >>> + while ( isdigit(*s) ) >>> + { >>> + val = parse_size_and_unit_or_int(s, ps, '%'); >>> + s = *ps; >>> + if ( *s == '%' ) >>> + { >>> + if ( !isdigit(s[-1]) || val >= 100 ) >>> + return -EINVAL; >>> + tmp.percent = val; >>> + s++; >>> + } >>> + else >>> + tmp.nr_pages = val >> PAGE_SHIFT; >>> + if ( *s == '+' ) >>> + s++; >>> + } >> >> ... you allow more flexibility here than you document (i.e. also >> <percentage>+<basesize>). You may want to consider >> refusing something like 1G+10%+10%, though. > > Okay, should be fairly easy. > > Can I keep your R-b: with adding something like: > > + bool percent = false; > ... > - while ( isdigit(*s) ) > + while ( isdigit(*s) && !percent ) > ... > if ( *s == '%' ) > { > + percent = true; > ... Something like this, yes. The double percent value was just an example though, "1G+10%+1G" then too would better either work as written, or be refused. Jan _______________________________________________ Xen-devel mailing list Xen-devel@lists.xenproject.org https://lists.xenproject.org/mailman/listinfo/xen-devel ^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2018-12-06 11:34 UTC | newest] Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2018-12-06 11:34 [PATCH v2 2/3] xen/x86: add dom0 memory sizing variants Juergen Gross -- strict thread matches above, loose matches on Subject: below -- 2018-12-06 8:06 [PATCH v2 0/3] xen/x86: support setting dom0_mem depending on host size Juergen Gross 2018-12-06 8:06 ` [PATCH v2 2/3] xen/x86: add dom0 memory sizing variants Juergen Gross 2018-12-06 11:08 ` Jan Beulich [not found] ` <5C09031502000078002039F0@suse.com> 2018-12-06 11:20 ` Juergen Gross 2018-12-06 11:28 ` Jan Beulich
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).