Android 警告：格式'；%lx'；应为类型为'；长无符号整数'；，但参数4的类型为'；pmd#t'；[-Wformat]

/android/kernel/arch/arm/mm/rodata.c:91:4:警告：格式“%lx”要求参数类型为“long unsigned int”，但参数4的类型为“pmd_t”[-Wformat]

如何结束这一警告

/*
*linux/arch/arm/mm/rodata.c
*
*版权所有（C）2011谷歌公司。
*
*作者：科林·克罗斯
*
*基于arch/x86/mm/init_32.c中的x86实现
*
*这个程序是自由软件；您可以重新分发和/或修改它
*根据GNU通用公共许可证第2版的条款
*由自由软件基金会发布。
*/
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括“mm.h”
静态int内核设置为只读，大部分为只读；
#ifdef配置调试数据测试
静态常数int rodata_test_data=0xC3；
静态noinline空隙rodata_试验（空隙）
{
int结果；
pr_info（“%s:正在尝试写入只读节：\n”，\uu func\uuu）；
如果（*（volatile int*）和rodata\u test\u data！=0xC3）{
pr_err（“测试前更改的只读数据”）；
返回；
}
/*
*尝试写入rodata_测试_数据，捕获预期的
*数据中止。如果执行陷阱，结果将为1。如果未执行，
*结果将是0xFF。
*/
挥发性物质(
“0:str%[zero]，%[rodata\u test\u data]]\n”
“mov%[结果]，#0xFF\n”
“b 2f\n”
“1:mov%[结果]，#1\n”
“2:\n”
/*异常修复-如果存储在标签0错误，则跳到1*/
.pushsection\uuuEx\uTable，\“a\”\n
.long 0b，1b\n
“.popsection\n”
：[结果]“=r”（结果）
：[rodata_test_data]“r”（&rodata_test_data），[zero]“r”（0）
：“内存”
);
如果（结果==1）
pr_info（“写入只读节，成功”）；
其他的
pr_err（“写入只读节未被捕获，测试失败\n”）；
如果（*（volatile int*）和rodata\u test\u data！=0xC3）
pr_err（“写入期间更改的只读数据”）；
}
#否则
静态内联无效rodata_试验（无效）{
#恩迪夫
静态int set\u page\u属性（无符号长virt、int numpages、，
私人股本（*f）（私人股本））
{
pmd_t*pmd；
私人有限公司；
无符号长启动=virt；
无符号长端=virt+（numpages>PAGE\u SHIFT）；
}
无效集\u内核\u文本\u ro（无效）
{
无符号长起始=页面对齐（（无符号长）\文本）；
无符号长尺寸=页面对齐（（无符号长）\uuuuuu结束\uurodata）-开始；
如果（！kernel\u设置为\u readonly）
返回；
pr_info_once（“写保护内核文本部分%lx-%lx\n”，
开始，开始+大小）；
pr_debug（“将内核文本：%lx-%lx设置为只读\n”，
开始，开始+大小）；
设置内存（开始，大小>>页面移位）；
}
无效标记（无效）
{
内核设置为只读=1；
设置_kernel_text_ro（）；
rodata_测试（）；
}

如何结束此警告，对不起，我不是程序员，但我想成为一名程序员：D刚刚删除了L 改为：

pr\u err（“%s:pmd%p=%08x，用于%08lx非页表”，

而且它能起作用。

---

感谢@R_Kapp

错误行为=pr_err（“%s:pmd%p=%08lx，表示%08lx未在页表中定义”\n），函数

pmd_val

在哪里定义？它返回类型为

pmd_t

的内容（定义在哪里？），但您的格式说明符指定了一个

长无符号int

。将

%08

的第一个实例更改为对

pmd\u t

有效的格式说明符，将函数

pmd\u val

更改为返回一个

长无符号int

，或者（如果您确定这应该有效）只需将

pmd_val

的结果转换为

（长无符号int）pmd_val（*pmd）

。我将其更改为>（长无符号int）pmd_val（*pmd），但这是一个错误make[4]：***[arch/arm/mm/rodata.o]Error 1

Error 1

不是错误消息；错误消息说了什么？可能是您输入错误或其他错误。

/*


*  linux/arch/arm/mm/rodata.c
 *
 *  Copyright (C) 2011 Google, Inc.
 *
 *  Author: Colin Cross <ccross@android.com>
 *
 *  Based on x86 implementation in arch/x86/mm/init_32.c
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/module.h>

#include <asm/cache.h>
#include <asm/pgtable.h>
#include <asm/rodata.h>
#include <asm/sections.h>
#include <asm/tlbflush.h>

#include "mm.h"

static int kernel_set_to_readonly __read_mostly;

#ifdef CONFIG_DEBUG_RODATA_TEST
static const int rodata_test_data = 0xC3;

static noinline void rodata_test(void)
{
    int result;

    pr_info("%s: attempting to write to read-only section:\n", __func__);

    if (*(volatile int *)&rodata_test_data != 0xC3) {
        pr_err("read only data changed before test\n");
        return;
    }

    /*
     * Attempt to to write to rodata_test_data, trapping the expected
     * data abort.  If the trap executed, result will be 1.  If it didn't,
     * result will be 0xFF.
     */
    asm volatile(
        "0: str %[zero], [%[rodata_test_data]]\n"
        "   mov %[result], #0xFF\n"
        "   b   2f\n"
        "1: mov %[result], #1\n"
        "2:\n"

        /* Exception fixup - if store at label 0 faults, jumps to 1 */
        ".pushsection __ex_table, \"a\"\n"
        "   .long   0b, 1b\n"
        ".popsection\n"

        : [result] "=r" (result)
        : [rodata_test_data] "r" (&rodata_test_data), [zero] "r" (0)
        : "memory"
    );

    if (result == 1)
        pr_info("write to read-only section trapped, success\n");
    else
        pr_err("write to read-only section NOT trapped, test failed\n");

    if (*(volatile int *)&rodata_test_data != 0xC3)
        pr_err("read only data changed during write\n");
}
#else
static inline void rodata_test(void) { }
#endif

static int set_page_attributes(unsigned long virt, int numpages,
    pte_t (*f)(pte_t))
{
    pmd_t *pmd;
    pte_t *pte;
    unsigned long start = virt;
    unsigned long end = virt + (numpages << PAGE_SHIFT);
    unsigned long pmd_end;

    while (virt < end) {
        pmd = pmd_off_k(virt);
        pmd_end = min(ALIGN(virt + 1, PMD_SIZE), end);

        if ((pmd_val(*pmd) & PMD_TYPE_MASK) != PMD_TYPE_TABLE) {
            pr_err("%s: pmd %p=%08lx for %08lx not page table\n",
                __func__, pmd, pmd_val(*pmd), virt);
            virt = pmd_end;
            continue;
        }

        while (virt < pmd_end) {
            pte = pte_offset_kernel(pmd, virt);
            set_pte_ext(pte, f(*pte), 0);
            virt += PAGE_SIZE;
        }
    }

    flush_tlb_kernel_range(start, end);

    return 0;
}

int set_memory_ro(unsigned long virt, int numpages)
{
    return set_page_attributes(virt, numpages, pte_wrprotect);
}
EXPORT_SYMBOL(set_memory_ro);

int set_memory_rw(unsigned long virt, int numpages)
{
    return set_page_attributes(virt, numpages, pte_mkwrite);
}
EXPORT_SYMBOL(set_memory_rw);

void set_kernel_text_rw(void)
{
    unsigned long start = PAGE_ALIGN((unsigned long)_text);
    unsigned long size = PAGE_ALIGN((unsigned long)__end_rodata) - start;

    if (!kernel_set_to_readonly)
        return;

    pr_debug("Set kernel text: %lx - %lx to read-write\n",
         start, start + size);

    set_memory_rw(start, size >> PAGE_SHIFT);
}

void set_kernel_text_ro(void)
{
    unsigned long start = PAGE_ALIGN((unsigned long)_text);
    unsigned long size = PAGE_ALIGN((unsigned long)__end_rodata) - start;

    if (!kernel_set_to_readonly)
        return;

    pr_info_once("Write protecting the kernel text section %lx - %lx\n",
        start, start + size);

    pr_debug("Set kernel text: %lx - %lx to read only\n",
         start, start + size);

    set_memory_ro(start, size >> PAGE_SHIFT);
}

void mark_rodata_ro(void)
{
    kernel_set_to_readonly = 1;

    set_kernel_text_ro();

    rodata_test();
}