Source of test_printf.c - linux-imx - PHYTEC BitBucket (Stash)

Ignore whitespace
Show whitespace characters
Hide e-diff
Unified diff
Side-by-side diff
Source viewDiff to previous
 
 * Test cases for printf facility.
 */
​
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
​
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/printk.h>
#include <linux/random.h>
#include <linux/rtc.h>
#include <linux/slab.h>
#include <linux/string.h>
​
#include <linux/bitmap.h>
#include <linux/dcache.h>
#include <linux/socket.h>
#include <linux/in.h>
​
#include <linux/gfp.h>
#include <linux/mm.h>
Show more
static int __init
plain_format(void)
{
    /* Format is implicitly tested for 32 bit machines by plain_hash() */
    return 0;
}
​
#endif  /* BITS_PER_LONG == 64 */
​
static int __init
plain_hash(void)
plain_hash_to_buffer(const void *p, char *buf, size_t len)
{
    char buf[PLAIN_BUF_SIZE];
    int nchars;
​
    nchars = snprintf(buf, PLAIN_BUF_SIZE, "%p", PTR);
    nchars = snprintf(buf, len, "%p", p);
​
    if (nchars != PTR_WIDTH)
        return -1;
​
    if (strncmp(buf, PTR_VAL_NO_CRNG, PTR_WIDTH) == 0) {
        pr_warn("crng possibly not yet initialized. plain 'p' buffer contains \"%s\"",
            PTR_VAL_NO_CRNG);
        return 0;
    }
​
    return 0;
}
​
​
static int __init
plain_hash(void)
{
    char buf[PLAIN_BUF_SIZE];
    int ret;
​
    ret = plain_hash_to_buffer(PTR, buf, PLAIN_BUF_SIZE);
    if (ret)
        return ret;
​
    if (strncmp(buf, PTR_STR, PTR_WIDTH) == 0)
        return -1;
​
    return 0;
}
​
/*
 * We can't use test() to test %p because we don't know what output to expect
 * after an address is hashed.
 */
Show more
        return;
    }
​
    err = plain_format();
    if (err) {
        pr_warn("hashing plain 'p' has unexpected format\n");
        failed_tests++;
    }
}
​
static void __init
test_hashed(const char *fmt, const void *p)
{
    char buf[PLAIN_BUF_SIZE];
    int ret;
​
    /*
     * No need to increase failed test counter since this is assumed
     * to be called after plain().
     */
    ret = plain_hash_to_buffer(p, buf, PLAIN_BUF_SIZE);
    if (ret)
        return;
​
    test(buf, fmt, p);
}
​
static void __init
symbol_ptr(void)
{
}
​
static void __init
kernel_ptr(void)
{
    /* We can't test this without access to kptr_restrict. */
}
Show more
​
    test("bravo/alfa  |bravo/alfa  ", "%-12pd2|%*pd2", &test_dentry[2], -12, &test_dentry[2]);
    test("  bravo/alfa|  bravo/alfa", "%12pd2|%*pd2", &test_dentry[2], 12, &test_dentry[2]);
}
​
static void __init
struct_va_format(void)
{
}
​
static void __init
struct_rtc_time(void)
{
    /* 1543210543 */
    const struct rtc_time tm = {
        .tm_sec = 43,
        .tm_min = 35,
        .tm_hour = 5,
        .tm_mday = 26,
        .tm_mon = 10,
        .tm_year = 118,
    };
​
    test_hashed("%pt", &tm);
​
    test("2018-11-26T05:35:43", "%ptR", &tm);
    test("0118-10-26T05:35:43", "%ptRr", &tm);
    test("05:35:43|2018-11-26", "%ptRt|%ptRd", &tm, &tm);
    test("05:35:43|0118-10-26", "%ptRtr|%ptRdr", &tm, &tm);
    test("05:35:43|2018-11-26", "%ptRttr|%ptRdtr", &tm, &tm);
    test("05:35:43 tr|2018-11-26 tr", "%ptRt tr|%ptRd tr", &tm, &tm);
}
​
static void __init
struct_clk(void)
{
}
​
static void __init
large_bitmap(void)
{
    const int nbits = 1 << 16;
    unsigned long *bits = kcalloc(BITS_TO_LONGS(nbits), sizeof(long), GFP_KERNEL);
Show more
    kernel_ptr();
    struct_resource();
    addr();
    escaped_str();
    hex_string();
    mac();
    ip();
    uuid();
    dentry();
    struct_va_format();
    struct_rtc_time();
    struct_clk();
    bitmap();
    netdev_features();
    flags();
}
​
static int __init
test_printf_init(void)
{
    alloced_buffer = kmalloc(BUF_SIZE + 2*PAD_SIZE, GFP_KERNEL);