lkml.org 
[lkml]   [2015]   [May]   [29]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v11 10/12] x86, mm, asm: Add WT support to set_page_memtype()
    Date
    From: Toshi Kani <toshi.kani@hp.com>

    As set_memory_wb() calls free_ram_pages_type(), which then calls
    set_page_memtype() with -1, _PGMT_DEFAULT is used for tracking
    the WB type. _PGMT_WB is defined but unused. Hence, this patch
    renames _PGMT_DEFAULT to _PGMT_WB to clarify the usage, and
    releases the slot used by _PGMT_WB before. free_ram_pages_type()
    is changed to call set_page_memtype() with _PGMT_WB, and
    get_page_memtype() returns _PAGE_CACHE_MODE_WB for _PGMT_WB.

    This patch then defines _PGMT_WT to the released slot. This enables
    set_page_memtype() to track the WT type.

    Signed-off-by: Toshi Kani <toshi.kani@hp.com>
    ---
    arch/x86/mm/pat.c | 60 +++++++++++++++++++++++++++--------------------------
    1 file changed, 30 insertions(+), 30 deletions(-)

    diff --git a/arch/x86/mm/pat.c b/arch/x86/mm/pat.c
    index 1a2c84c..15d37c3 100644
    --- a/arch/x86/mm/pat.c
    +++ b/arch/x86/mm/pat.c
    @@ -70,18 +70,22 @@ static u64 __read_mostly boot_pat_state;

    #ifdef CONFIG_X86_PAT
    /*
    - * X86 PAT uses page flags WC and Uncached together to keep track of
    - * memory type of pages that have backing page struct. X86 PAT supports 3
    - * different memory types, _PAGE_CACHE_MODE_WB, _PAGE_CACHE_MODE_WC and
    - * _PAGE_CACHE_MODE_UC_MINUS and fourth state where page's memory type has not
    - * been changed from its default (value of -1 used to denote this).
    - * Note we do not support _PAGE_CACHE_MODE_UC here.
    + * X86 PAT uses page flags arch_1 and uncached together to keep track of
    + * memory type of pages that have backing page struct.
    + *
    + * X86 PAT supports 4 different memory types:
    + * - _PAGE_CACHE_MODE_WB
    + * - _PAGE_CACHE_MODE_WC
    + * - _PAGE_CACHE_MODE_UC_MINUS
    + * - _PAGE_CACHE_MODE_WT
    + *
    + * _PAGE_CACHE_MODE_WB is the default type.
    */

    -#define _PGMT_DEFAULT 0
    +#define _PGMT_WB 0
    #define _PGMT_WC (1UL << PG_arch_1)
    #define _PGMT_UC_MINUS (1UL << PG_uncached)
    -#define _PGMT_WB (1UL << PG_uncached | 1UL << PG_arch_1)
    +#define _PGMT_WT (1UL << PG_uncached | 1UL << PG_arch_1)
    #define _PGMT_MASK (1UL << PG_uncached | 1UL << PG_arch_1)
    #define _PGMT_CLEAR_MASK (~_PGMT_MASK)

    @@ -89,14 +93,14 @@ static inline enum page_cache_mode get_page_memtype(struct page *pg)
    {
    unsigned long pg_flags = pg->flags & _PGMT_MASK;

    - if (pg_flags == _PGMT_DEFAULT)
    - return -1;
    + if (pg_flags == _PGMT_WB)
    + return _PAGE_CACHE_MODE_WB;
    else if (pg_flags == _PGMT_WC)
    return _PAGE_CACHE_MODE_WC;
    else if (pg_flags == _PGMT_UC_MINUS)
    return _PAGE_CACHE_MODE_UC_MINUS;
    else
    - return _PAGE_CACHE_MODE_WB;
    + return _PAGE_CACHE_MODE_WT;
    }

    static inline void set_page_memtype(struct page *pg,
    @@ -113,11 +117,12 @@ static inline void set_page_memtype(struct page *pg,
    case _PAGE_CACHE_MODE_UC_MINUS:
    memtype_flags = _PGMT_UC_MINUS;
    break;
    - case _PAGE_CACHE_MODE_WB:
    - memtype_flags = _PGMT_WB;
    + case _PAGE_CACHE_MODE_WT:
    + memtype_flags = _PGMT_WT;
    break;
    + case _PAGE_CACHE_MODE_WB:
    default:
    - memtype_flags = _PGMT_DEFAULT;
    + memtype_flags = _PGMT_WB;
    break;
    }

    @@ -389,8 +394,11 @@ static int pat_pagerange_is_ram(resource_size_t start, resource_size_t end)

    /*
    * For RAM pages, we use page flags to mark the pages with appropriate type.
    - * The page flags are limited to three types, WB, WC and UC-.
    - * WT and WP requests fail with -EINVAL, and UC gets redirected to UC-.
    + * The page flags are limited to four types, WB (default), WC, WT and UC-.
    + * WP request fails with -EINVAL, and UC gets redirected to UC-. Setting
    + * a new memory type is only allowed to a page mapped with the default WB
    + * type.
    + *
    * Here we do two pass:
    * - Find the memtype of all the pages in the range, look for any conflicts
    * - In case of no conflicts, set the new memtype for pages in the range
    @@ -402,8 +410,7 @@ static int reserve_ram_pages_type(u64 start, u64 end,
    struct page *page;
    u64 pfn;

    - if ((req_type == _PAGE_CACHE_MODE_WT) ||
    - (req_type == _PAGE_CACHE_MODE_WP)) {
    + if (req_type == _PAGE_CACHE_MODE_WP) {
    if (new_type)
    *new_type = _PAGE_CACHE_MODE_UC_MINUS;
    return -EINVAL;
    @@ -420,7 +427,7 @@ static int reserve_ram_pages_type(u64 start, u64 end,

    page = pfn_to_page(pfn);
    type = get_page_memtype(page);
    - if (type != -1) {
    + if (type != _PAGE_CACHE_MODE_WB) {
    pr_info("x86/PAT: reserve_ram_pages_type failed [mem %#010Lx-%#010Lx], track 0x%x, req 0x%x\n",
    start, end - 1, type, req_type);
    if (new_type)
    @@ -447,7 +454,7 @@ static int free_ram_pages_type(u64 start, u64 end)

    for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
    page = pfn_to_page(pfn);
    - set_page_memtype(page, -1);
    + set_page_memtype(page, _PAGE_CACHE_MODE_WB);
    }
    return 0;
    }
    @@ -588,7 +595,7 @@ int free_memtype(u64 start, u64 end)
    * Only to be called when PAT is enabled
    *
    * Returns _PAGE_CACHE_MODE_WB, _PAGE_CACHE_MODE_WC, _PAGE_CACHE_MODE_UC_MINUS
    - * or _PAGE_CACHE_MODE_UC
    + * or _PAGE_CACHE_MODE_WT.
    */
    static enum page_cache_mode lookup_memtype(u64 paddr)
    {
    @@ -600,16 +607,9 @@ static enum page_cache_mode lookup_memtype(u64 paddr)

    if (pat_pagerange_is_ram(paddr, paddr + PAGE_SIZE)) {
    struct page *page;
    - page = pfn_to_page(paddr >> PAGE_SHIFT);
    - rettype = get_page_memtype(page);
    - /*
    - * -1 from get_page_memtype() implies RAM page is in its
    - * default state and not reserved, and hence of type WB
    - */
    - if (rettype == -1)
    - rettype = _PAGE_CACHE_MODE_WB;

    - return rettype;
    + page = pfn_to_page(paddr >> PAGE_SHIFT);
    + return get_page_memtype(page);
    }

    spin_lock(&memtype_lock);

    \
     
     \ /
      Last update: 2015-05-30 02:01    [W:4.802 / U:23.776 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site