hc
2024-08-16 62c46c9150c4afde7e5b25436263fddf79d66f0b
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
// SPDX-License-Identifier: GPL-2.0
/*
 * /proc/bootconfig - Extra boot configuration
 */
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/printk.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/bootconfig.h>
#include <linux/slab.h>
 
static char *saved_boot_config;
 
static int boot_config_proc_show(struct seq_file *m, void *v)
{
   if (saved_boot_config)
       seq_puts(m, saved_boot_config);
   return 0;
}
 
/* Rest size of buffer */
#define rest(dst, end) ((end) > (dst) ? (end) - (dst) : 0)
 
/* Return the needed total length if @size is 0 */
static int __init copy_xbc_key_value_list(char *dst, size_t size)
{
   struct xbc_node *leaf, *vnode;
   char *key, *end = dst + size;
   const char *val;
   char q;
   int ret = 0;
 
   key = kzalloc(XBC_KEYLEN_MAX, GFP_KERNEL);
   if (!key)
       return -ENOMEM;
 
   xbc_for_each_key_value(leaf, val) {
       ret = xbc_node_compose_key(leaf, key, XBC_KEYLEN_MAX);
       if (ret < 0)
           break;
       ret = snprintf(dst, rest(dst, end), "%s = ", key);
       if (ret < 0)
           break;
       dst += ret;
       vnode = xbc_node_get_child(leaf);
       if (vnode) {
           xbc_array_for_each_value(vnode, val) {
               if (strchr(val, '"'))
                   q = '\'';
               else
                   q = '"';
               ret = snprintf(dst, rest(dst, end), "%c%s%c%s",
                   q, val, q, xbc_node_is_array(vnode) ? ", " : "\n");
               if (ret < 0)
                   goto out;
               dst += ret;
           }
       } else {
           ret = snprintf(dst, rest(dst, end), "\"\"\n");
           if (ret < 0)
               break;
           dst += ret;
       }
   }
out:
   kfree(key);
 
   return ret < 0 ? ret : dst - (end - size);
}
 
static int __init proc_boot_config_init(void)
{
   int len;
 
   len = copy_xbc_key_value_list(NULL, 0);
   if (len < 0)
       return len;
 
   if (len > 0) {
       saved_boot_config = kzalloc(len + 1, GFP_KERNEL);
       if (!saved_boot_config)
           return -ENOMEM;
 
       len = copy_xbc_key_value_list(saved_boot_config, len + 1);
       if (len < 0) {
           kfree(saved_boot_config);
           return len;
       }
   }
 
   proc_create_single("bootconfig", 0, NULL, boot_config_proc_show);
 
   return 0;
}
fs_initcall(proc_boot_config_init);