2 * c 2001 PPC 64 Team, IBM Corp
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
9 * /dev/nvram driver for PPC64
11 * This perhaps should live in drivers/char
13 * TODO: Split the /dev/nvram part (that one can use
14 * drivers/char/generic_nvram.c) from the arch & partition
18 #include <linux/types.h>
19 #include <linux/errno.h>
21 #include <linux/miscdevice.h>
22 #include <linux/fcntl.h>
23 #include <linux/nvram.h>
24 #include <linux/init.h>
25 #include <linux/slab.h>
26 #include <linux/spinlock.h>
27 #include <linux/kmsg_dump.h>
28 #include <linux/pagemap.h>
29 #include <linux/pstore.h>
30 #include <linux/zlib.h>
31 #include <asm/uaccess.h>
32 #include <asm/nvram.h>
35 #include <asm/machdep.h>
39 #define NVRAM_HEADER_LEN sizeof(struct nvram_header)
40 #define NVRAM_BLOCK_LEN NVRAM_HEADER_LEN
42 /* If change this size, then change the size of NVNAME_LEN */
44 unsigned char signature
;
45 unsigned char checksum
;
46 unsigned short length
;
47 /* Terminating null required only for names < 12 chars. */
51 struct nvram_partition
{
52 struct list_head partition
;
53 struct nvram_header header
;
57 static LIST_HEAD(nvram_partitions
);
59 #ifdef CONFIG_PPC_PSERIES
60 struct nvram_os_partition rtas_log_partition
= {
61 .name
= "ibm,rtas-log",
69 struct nvram_os_partition oops_log_partition
= {
70 .name
= "lnx,oops-log",
77 static const char *nvram_os_partitions
[] = {
78 #ifdef CONFIG_PPC_PSERIES
85 static void oops_to_nvram(struct kmsg_dumper
*dumper
,
86 enum kmsg_dump_reason reason
);
88 static struct kmsg_dumper nvram_kmsg_dumper
= {
93 * For capturing and compressing an oops or panic report...
95 * big_oops_buf[] holds the uncompressed text we're capturing.
97 * oops_buf[] holds the compressed text, preceded by a oops header.
98 * oops header has u16 holding the version of oops header (to differentiate
99 * between old and new format header) followed by u16 holding the length of
100 * the compressed* text (*Or uncompressed, if compression fails.) and u64
101 * holding the timestamp. oops_buf[] gets written to NVRAM.
103 * oops_log_info points to the header. oops_data points to the compressed text.
108 * +-----------+-----------+-----------+------------------------+
109 * | version | length | timestamp | text |
110 * | (2 bytes) | (2 bytes) | (8 bytes) | (oops_data_sz bytes) |
111 * +-----------+-----------+-----------+------------------------+
115 * We preallocate these buffers during init to avoid kmalloc during oops/panic.
117 static size_t big_oops_buf_sz
;
118 static char *big_oops_buf
, *oops_buf
;
119 static char *oops_data
;
120 static size_t oops_data_sz
;
122 /* Compression parameters */
123 #define COMPR_LEVEL 6
124 #define WINDOW_BITS 12
126 static struct z_stream_s stream
;
129 #ifdef CONFIG_PPC_POWERNV
130 static struct nvram_os_partition skiboot_partition
= {
131 .name
= "ibm,skiboot",
133 .os_partition
= false
137 #ifdef CONFIG_PPC_PSERIES
138 static struct nvram_os_partition of_config_partition
= {
141 .os_partition
= false
145 static struct nvram_os_partition common_partition
= {
148 .os_partition
= false
151 static enum pstore_type_id nvram_type_ids
[] = {
153 PSTORE_TYPE_PPC_COMMON
,
158 static int read_type
;
161 /* nvram_write_os_partition
163 * We need to buffer the error logs into nvram to ensure that we have
164 * the failure information to decode. If we have a severe error there
165 * is no way to guarantee that the OS or the machine is in a state to
166 * get back to user land and write the error to disk. For example if
167 * the SCSI device driver causes a Machine Check by writing to a bad
168 * IO address, there is no way of guaranteeing that the device driver
169 * is in any state that is would also be able to write the error data
170 * captured to disk, thus we buffer it in NVRAM for analysis on the
173 * In NVRAM the partition containing the error log buffer will looks like:
175 * +-----------+----------+--------+------------+------------------+
176 * | signature | checksum | length | name | data |
177 * |0 |1 |2 3|4 15|16 length-1|
178 * +-----------+----------+--------+------------+------------------+
180 * The 'data' section would look like (in bytes):
181 * +--------------+------------+-----------------------------------+
182 * | event_logged | sequence # | error log |
183 * |0 3|4 7|8 error_log_size-1|
184 * +--------------+------------+-----------------------------------+
186 * event_logged: 0 if event has not been logged to syslog, 1 if it has
187 * sequence #: The unique sequence # for each event. (until it wraps)
188 * error log: The error log from event_scan
190 int nvram_write_os_partition(struct nvram_os_partition
*part
,
191 char *buff
, int length
,
192 unsigned int err_type
,
193 unsigned int error_log_cnt
)
197 struct err_log_info info
;
199 if (part
->index
== -1)
202 if (length
> part
->size
)
205 info
.error_type
= cpu_to_be32(err_type
);
206 info
.seq_num
= cpu_to_be32(error_log_cnt
);
208 tmp_index
= part
->index
;
210 rc
= ppc_md
.nvram_write((char *)&info
, sizeof(struct err_log_info
),
213 pr_err("%s: Failed nvram_write (%d)\n", __func__
, rc
);
217 rc
= ppc_md
.nvram_write(buff
, length
, &tmp_index
);
219 pr_err("%s: Failed nvram_write (%d)\n", __func__
, rc
);
226 /* nvram_read_partition
228 * Reads nvram partition for at most 'length'
230 int nvram_read_partition(struct nvram_os_partition
*part
, char *buff
,
231 int length
, unsigned int *err_type
,
232 unsigned int *error_log_cnt
)
236 struct err_log_info info
;
238 if (part
->index
== -1)
241 if (length
> part
->size
)
244 tmp_index
= part
->index
;
246 if (part
->os_partition
) {
247 rc
= ppc_md
.nvram_read((char *)&info
,
248 sizeof(struct err_log_info
),
251 pr_err("%s: Failed nvram_read (%d)\n", __func__
, rc
);
256 rc
= ppc_md
.nvram_read(buff
, length
, &tmp_index
);
258 pr_err("%s: Failed nvram_read (%d)\n", __func__
, rc
);
262 if (part
->os_partition
) {
263 *error_log_cnt
= be32_to_cpu(info
.seq_num
);
264 *err_type
= be32_to_cpu(info
.error_type
);
270 /* nvram_init_os_partition
272 * This sets up a partition with an "OS" signature.
274 * The general strategy is the following:
275 * 1.) If a partition with the indicated name already exists...
276 * - If it's large enough, use it.
277 * - Otherwise, recycle it and keep going.
278 * 2.) Search for a free partition that is large enough.
279 * 3.) If there's not a free partition large enough, recycle any obsolete
280 * OS partitions and try again.
281 * 4.) Will first try getting a chunk that will satisfy the requested size.
282 * 5.) If a chunk of the requested size cannot be allocated, then try finding
283 * a chunk that will satisfy the minum needed.
285 * Returns 0 on success, else -1.
287 int __init
nvram_init_os_partition(struct nvram_os_partition
*part
)
293 p
= nvram_find_partition(part
->name
, NVRAM_SIG_OS
, &size
);
295 /* Found one but too small, remove it */
296 if (p
&& size
< part
->min_size
) {
297 pr_info("nvram: Found too small %s partition,"
298 " removing it...\n", part
->name
);
299 nvram_remove_partition(part
->name
, NVRAM_SIG_OS
, NULL
);
303 /* Create one if we didn't find */
305 p
= nvram_create_partition(part
->name
, NVRAM_SIG_OS
,
306 part
->req_size
, part
->min_size
);
308 pr_info("nvram: No room to create %s partition, "
309 "deleting any obsolete OS partitions...\n",
311 nvram_remove_partition(NULL
, NVRAM_SIG_OS
,
312 nvram_os_partitions
);
313 p
= nvram_create_partition(part
->name
, NVRAM_SIG_OS
,
314 part
->req_size
, part
->min_size
);
319 pr_err("nvram: Failed to find or create %s"
320 " partition, err %d\n", part
->name
, (int)p
);
325 part
->size
= nvram_get_partition_size(p
) - sizeof(struct err_log_info
);
330 /* Derived from logfs_compress() */
331 static int nvram_compress(const void *in
, void *out
, size_t inlen
,
337 err
= zlib_deflateInit2(&stream
, COMPR_LEVEL
, Z_DEFLATED
, WINDOW_BITS
,
338 MEM_LEVEL
, Z_DEFAULT_STRATEGY
);
343 stream
.avail_in
= inlen
;
345 stream
.next_out
= out
;
346 stream
.avail_out
= outlen
;
347 stream
.total_out
= 0;
349 err
= zlib_deflate(&stream
, Z_FINISH
);
350 if (err
!= Z_STREAM_END
)
353 err
= zlib_deflateEnd(&stream
);
357 if (stream
.total_out
>= stream
.total_in
)
360 ret
= stream
.total_out
;
365 /* Compress the text from big_oops_buf into oops_buf. */
366 static int zip_oops(size_t text_len
)
368 struct oops_log_info
*oops_hdr
= (struct oops_log_info
*)oops_buf
;
369 int zipped_len
= nvram_compress(big_oops_buf
, oops_data
, text_len
,
371 if (zipped_len
< 0) {
372 pr_err("nvram: compression failed; returned %d\n", zipped_len
);
373 pr_err("nvram: logging uncompressed oops/panic report\n");
376 oops_hdr
->version
= cpu_to_be16(OOPS_HDR_VERSION
);
377 oops_hdr
->report_length
= cpu_to_be16(zipped_len
);
378 oops_hdr
->timestamp
= cpu_to_be64(ktime_get_real_seconds());
383 static int nvram_pstore_open(struct pstore_info
*psi
)
385 /* Reset the iterator to start reading partitions again */
391 * nvram_pstore_write - pstore write callback for nvram
392 * @type: Type of message logged
393 * @reason: reason behind dump (oops/panic)
394 * @id: identifier to indicate the write performed
395 * @part: pstore writes data to registered buffer in parts,
396 * part number will indicate the same.
397 * @count: Indicates oops count
398 * @compressed: Flag to indicate the log is compressed
399 * @size: number of bytes written to the registered buffer
400 * @psi: registered pstore_info structure
402 * Called by pstore_dump() when an oops or panic report is logged in the
404 * Returns 0 on successful write.
406 static int nvram_pstore_write(enum pstore_type_id type
,
407 enum kmsg_dump_reason reason
,
408 u64
*id
, unsigned int part
, int count
,
409 bool compressed
, size_t size
,
410 struct pstore_info
*psi
)
413 unsigned int err_type
= ERR_TYPE_KERNEL_PANIC
;
414 struct oops_log_info
*oops_hdr
= (struct oops_log_info
*) oops_buf
;
416 /* part 1 has the recent messages from printk buffer */
417 if (part
> 1 || (type
!= PSTORE_TYPE_DMESG
))
420 if (clobbering_unread_rtas_event())
423 oops_hdr
->version
= cpu_to_be16(OOPS_HDR_VERSION
);
424 oops_hdr
->report_length
= cpu_to_be16(size
);
425 oops_hdr
->timestamp
= cpu_to_be64(ktime_get_real_seconds());
428 err_type
= ERR_TYPE_KERNEL_PANIC_GZ
;
430 rc
= nvram_write_os_partition(&oops_log_partition
, oops_buf
,
431 (int) (sizeof(*oops_hdr
) + size
), err_type
, count
);
441 * Reads the oops/panic report, rtas, of-config and common partition.
442 * Returns the length of the data we read from each partition.
443 * Returns 0 if we've been called before.
445 static ssize_t
nvram_pstore_read(u64
*id
, enum pstore_type_id
*type
,
446 int *count
, struct timespec
*time
, char **buf
,
447 bool *compressed
, struct pstore_info
*psi
)
449 struct oops_log_info
*oops_hdr
;
450 unsigned int err_type
, id_no
, size
= 0;
451 struct nvram_os_partition
*part
= NULL
;
458 switch (nvram_type_ids
[read_type
]) {
459 case PSTORE_TYPE_DMESG
:
460 part
= &oops_log_partition
;
461 *type
= PSTORE_TYPE_DMESG
;
463 case PSTORE_TYPE_PPC_COMMON
:
465 part
= &common_partition
;
466 *type
= PSTORE_TYPE_PPC_COMMON
;
467 *id
= PSTORE_TYPE_PPC_COMMON
;
471 #ifdef CONFIG_PPC_PSERIES
472 case PSTORE_TYPE_PPC_RTAS
:
473 part
= &rtas_log_partition
;
474 *type
= PSTORE_TYPE_PPC_RTAS
;
475 time
->tv_sec
= last_rtas_event
;
478 case PSTORE_TYPE_PPC_OF
:
480 part
= &of_config_partition
;
481 *type
= PSTORE_TYPE_PPC_OF
;
482 *id
= PSTORE_TYPE_PPC_OF
;
487 #ifdef CONFIG_PPC_POWERNV
488 case PSTORE_TYPE_PPC_OPAL
:
490 part
= &skiboot_partition
;
491 *type
= PSTORE_TYPE_PPC_OPAL
;
492 *id
= PSTORE_TYPE_PPC_OPAL
;
501 if (!part
->os_partition
) {
502 p
= nvram_find_partition(part
->name
, sig
, &size
);
504 pr_err("nvram: Failed to find partition %s, "
505 "err %d\n", part
->name
, (int)p
);
512 buff
= kmalloc(part
->size
, GFP_KERNEL
);
517 if (nvram_read_partition(part
, buff
, part
->size
, &err_type
, &id_no
)) {
524 if (part
->os_partition
)
527 if (nvram_type_ids
[read_type
] == PSTORE_TYPE_DMESG
) {
528 size_t length
, hdr_size
;
530 oops_hdr
= (struct oops_log_info
*)buff
;
531 if (be16_to_cpu(oops_hdr
->version
) < OOPS_HDR_VERSION
) {
532 /* Old format oops header had 2-byte record size */
533 hdr_size
= sizeof(u16
);
534 length
= be16_to_cpu(oops_hdr
->version
);
538 hdr_size
= sizeof(*oops_hdr
);
539 length
= be16_to_cpu(oops_hdr
->report_length
);
540 time
->tv_sec
= be64_to_cpu(oops_hdr
->timestamp
);
543 *buf
= kmemdup(buff
+ hdr_size
, length
, GFP_KERNEL
);
548 if (err_type
== ERR_TYPE_KERNEL_PANIC_GZ
)
559 static struct pstore_info nvram_pstore_info
= {
560 .owner
= THIS_MODULE
,
562 .open
= nvram_pstore_open
,
563 .read
= nvram_pstore_read
,
564 .write
= nvram_pstore_write
,
567 static int nvram_pstore_init(void)
571 if (machine_is(pseries
)) {
572 nvram_type_ids
[2] = PSTORE_TYPE_PPC_RTAS
;
573 nvram_type_ids
[3] = PSTORE_TYPE_PPC_OF
;
575 nvram_type_ids
[2] = PSTORE_TYPE_PPC_OPAL
;
577 nvram_pstore_info
.buf
= oops_data
;
578 nvram_pstore_info
.bufsize
= oops_data_sz
;
580 spin_lock_init(&nvram_pstore_info
.buf_lock
);
582 rc
= pstore_register(&nvram_pstore_info
);
583 if (rc
&& (rc
!= -EPERM
))
584 /* Print error only when pstore.backend == nvram */
585 pr_err("nvram: pstore_register() failed, returned %d. "
586 "Defaults to kmsg_dump\n", rc
);
591 static int nvram_pstore_init(void)
597 void __init
nvram_init_oops_partition(int rtas_partition_exists
)
601 rc
= nvram_init_os_partition(&oops_log_partition
);
603 #ifdef CONFIG_PPC_PSERIES
604 if (!rtas_partition_exists
) {
605 pr_err("nvram: Failed to initialize oops partition!");
608 pr_notice("nvram: Using %s partition to log both"
609 " RTAS errors and oops/panic reports\n",
610 rtas_log_partition
.name
);
611 memcpy(&oops_log_partition
, &rtas_log_partition
,
612 sizeof(rtas_log_partition
));
614 pr_err("nvram: Failed to initialize oops partition!");
618 oops_buf
= kmalloc(oops_log_partition
.size
, GFP_KERNEL
);
620 pr_err("nvram: No memory for %s partition\n",
621 oops_log_partition
.name
);
624 oops_data
= oops_buf
+ sizeof(struct oops_log_info
);
625 oops_data_sz
= oops_log_partition
.size
- sizeof(struct oops_log_info
);
627 rc
= nvram_pstore_init();
633 * Figure compression (preceded by elimination of each line's <n>
634 * severity prefix) will reduce the oops/panic report to at most
635 * 45% of its original size.
637 big_oops_buf_sz
= (oops_data_sz
* 100) / 45;
638 big_oops_buf
= kmalloc(big_oops_buf_sz
, GFP_KERNEL
);
640 stream
.workspace
= kmalloc(zlib_deflate_workspacesize(
641 WINDOW_BITS
, MEM_LEVEL
), GFP_KERNEL
);
642 if (!stream
.workspace
) {
643 pr_err("nvram: No memory for compression workspace; "
644 "skipping compression of %s partition data\n",
645 oops_log_partition
.name
);
650 pr_err("No memory for uncompressed %s data; "
651 "skipping compression\n", oops_log_partition
.name
);
652 stream
.workspace
= NULL
;
655 rc
= kmsg_dump_register(&nvram_kmsg_dumper
);
657 pr_err("nvram: kmsg_dump_register() failed; returned %d\n", rc
);
660 kfree(stream
.workspace
);
665 * This is our kmsg_dump callback, called after an oops or panic report
666 * has been written to the printk buffer. We want to capture as much
667 * of the printk buffer as possible. First, capture as much as we can
668 * that we think will compress sufficiently to fit in the lnx,oops-log
669 * partition. If that's too much, go back and capture uncompressed text.
671 static void oops_to_nvram(struct kmsg_dumper
*dumper
,
672 enum kmsg_dump_reason reason
)
674 struct oops_log_info
*oops_hdr
= (struct oops_log_info
*)oops_buf
;
675 static unsigned int oops_count
= 0;
676 static bool panicking
= false;
677 static DEFINE_SPINLOCK(lock
);
680 unsigned int err_type
= ERR_TYPE_KERNEL_PANIC_GZ
;
684 case KMSG_DUMP_RESTART
:
686 case KMSG_DUMP_POWEROFF
:
687 /* These are almost always orderly shutdowns. */
691 case KMSG_DUMP_PANIC
:
694 case KMSG_DUMP_EMERG
:
696 /* Panic report already captured. */
700 pr_err("%s: ignoring unrecognized KMSG_DUMP_* reason %d\n",
701 __func__
, (int) reason
);
705 if (clobbering_unread_rtas_event())
708 if (!spin_trylock_irqsave(&lock
, flags
))
712 kmsg_dump_get_buffer(dumper
, false,
713 big_oops_buf
, big_oops_buf_sz
, &text_len
);
714 rc
= zip_oops(text_len
);
717 kmsg_dump_rewind(dumper
);
718 kmsg_dump_get_buffer(dumper
, false,
719 oops_data
, oops_data_sz
, &text_len
);
720 err_type
= ERR_TYPE_KERNEL_PANIC
;
721 oops_hdr
->version
= cpu_to_be16(OOPS_HDR_VERSION
);
722 oops_hdr
->report_length
= cpu_to_be16(text_len
);
723 oops_hdr
->timestamp
= cpu_to_be64(ktime_get_real_seconds());
726 (void) nvram_write_os_partition(&oops_log_partition
, oops_buf
,
727 (int) (sizeof(*oops_hdr
) + text_len
), err_type
,
730 spin_unlock_irqrestore(&lock
, flags
);
733 static loff_t
dev_nvram_llseek(struct file
*file
, loff_t offset
, int origin
)
735 if (ppc_md
.nvram_size
== NULL
)
737 return generic_file_llseek_size(file
, offset
, origin
, MAX_LFS_FILESIZE
,
738 ppc_md
.nvram_size());
742 static ssize_t
dev_nvram_read(struct file
*file
, char __user
*buf
,
743 size_t count
, loff_t
*ppos
)
749 if (!ppc_md
.nvram_size
) {
754 size
= ppc_md
.nvram_size();
765 count
= min_t(size_t, count
, size
- *ppos
);
766 count
= min(count
, PAGE_SIZE
);
768 tmp
= kmalloc(count
, GFP_KERNEL
);
774 ret
= ppc_md
.nvram_read(tmp
, count
, ppos
);
778 if (copy_to_user(buf
, tmp
, ret
))
787 static ssize_t
dev_nvram_write(struct file
*file
, const char __user
*buf
,
788 size_t count
, loff_t
*ppos
)
795 if (!ppc_md
.nvram_size
)
799 size
= ppc_md
.nvram_size();
800 if (*ppos
>= size
|| size
< 0)
803 count
= min_t(size_t, count
, size
- *ppos
);
804 count
= min(count
, PAGE_SIZE
);
807 tmp
= kmalloc(count
, GFP_KERNEL
);
812 if (copy_from_user(tmp
, buf
, count
))
815 ret
= ppc_md
.nvram_write(tmp
, count
, ppos
);
823 static long dev_nvram_ioctl(struct file
*file
, unsigned int cmd
,
827 #ifdef CONFIG_PPC_PMAC
828 case OBSOLETE_PMAC_NVRAM_GET_OFFSET
:
829 printk(KERN_WARNING
"nvram: Using obsolete PMAC_NVRAM_GET_OFFSET ioctl\n");
830 case IOC_NVRAM_GET_OFFSET
: {
833 if (!machine_is(powermac
))
835 if (copy_from_user(&part
, (void __user
*)arg
, sizeof(part
)) != 0)
837 if (part
< pmac_nvram_OF
|| part
> pmac_nvram_NR
)
839 offset
= pmac_get_partition(part
);
842 if (copy_to_user((void __user
*)arg
, &offset
, sizeof(offset
)) != 0)
846 #endif /* CONFIG_PPC_PMAC */
852 const struct file_operations nvram_fops
= {
853 .owner
= THIS_MODULE
,
854 .llseek
= dev_nvram_llseek
,
855 .read
= dev_nvram_read
,
856 .write
= dev_nvram_write
,
857 .unlocked_ioctl
= dev_nvram_ioctl
,
860 static struct miscdevice nvram_dev
= {
868 static void __init
nvram_print_partitions(char * label
)
870 struct nvram_partition
* tmp_part
;
872 printk(KERN_WARNING
"--------%s---------\n", label
);
873 printk(KERN_WARNING
"indx\t\tsig\tchks\tlen\tname\n");
874 list_for_each_entry(tmp_part
, &nvram_partitions
, partition
) {
875 printk(KERN_WARNING
"%4d \t%02x\t%02x\t%d\t%12.12s\n",
876 tmp_part
->index
, tmp_part
->header
.signature
,
877 tmp_part
->header
.checksum
, tmp_part
->header
.length
,
878 tmp_part
->header
.name
);
884 static int __init
nvram_write_header(struct nvram_partition
* part
)
888 struct nvram_header phead
;
890 memcpy(&phead
, &part
->header
, NVRAM_HEADER_LEN
);
891 phead
.length
= cpu_to_be16(phead
.length
);
893 tmp_index
= part
->index
;
894 rc
= ppc_md
.nvram_write((char *)&phead
, NVRAM_HEADER_LEN
, &tmp_index
);
900 static unsigned char __init
nvram_checksum(struct nvram_header
*p
)
902 unsigned int c_sum
, c_sum2
;
903 unsigned short *sp
= (unsigned short *)p
->name
; /* assume 6 shorts */
904 c_sum
= p
->signature
+ p
->length
+ sp
[0] + sp
[1] + sp
[2] + sp
[3] + sp
[4] + sp
[5];
906 /* The sum may have spilled into the 3rd byte. Fold it back. */
907 c_sum
= ((c_sum
& 0xffff) + (c_sum
>> 16)) & 0xffff;
908 /* The sum cannot exceed 2 bytes. Fold it into a checksum */
909 c_sum2
= (c_sum
>> 8) + (c_sum
<< 8);
910 c_sum
= ((c_sum
+ c_sum2
) >> 8) & 0xff;
915 * Per the criteria passed via nvram_remove_partition(), should this
916 * partition be removed? 1=remove, 0=keep
918 static int nvram_can_remove_partition(struct nvram_partition
*part
,
919 const char *name
, int sig
, const char *exceptions
[])
921 if (part
->header
.signature
!= sig
)
924 if (strncmp(name
, part
->header
.name
, 12))
926 } else if (exceptions
) {
928 for (except
= exceptions
; *except
; except
++) {
929 if (!strncmp(*except
, part
->header
.name
, 12))
937 * nvram_remove_partition - Remove one or more partitions in nvram
938 * @name: name of the partition to remove, or NULL for a
939 * signature only match
940 * @sig: signature of the partition(s) to remove
941 * @exceptions: When removing all partitions with a matching signature,
945 int __init
nvram_remove_partition(const char *name
, int sig
,
946 const char *exceptions
[])
948 struct nvram_partition
*part
, *prev
, *tmp
;
951 list_for_each_entry(part
, &nvram_partitions
, partition
) {
952 if (!nvram_can_remove_partition(part
, name
, sig
, exceptions
))
955 /* Make partition a free partition */
956 part
->header
.signature
= NVRAM_SIG_FREE
;
957 strncpy(part
->header
.name
, "wwwwwwwwwwww", 12);
958 part
->header
.checksum
= nvram_checksum(&part
->header
);
959 rc
= nvram_write_header(part
);
961 printk(KERN_ERR
"nvram_remove_partition: nvram_write failed (%d)\n", rc
);
966 /* Merge contiguous ones */
968 list_for_each_entry_safe(part
, tmp
, &nvram_partitions
, partition
) {
969 if (part
->header
.signature
!= NVRAM_SIG_FREE
) {
974 prev
->header
.length
+= part
->header
.length
;
975 prev
->header
.checksum
= nvram_checksum(&part
->header
);
976 rc
= nvram_write_header(part
);
978 printk(KERN_ERR
"nvram_remove_partition: nvram_write failed (%d)\n", rc
);
981 list_del(&part
->partition
);
991 * nvram_create_partition - Create a partition in nvram
992 * @name: name of the partition to create
993 * @sig: signature of the partition to create
994 * @req_size: size of data to allocate in bytes
995 * @min_size: minimum acceptable size (0 means req_size)
997 * Returns a negative error code or a positive nvram index
998 * of the beginning of the data area of the newly created
999 * partition. If you provided a min_size smaller than req_size
1000 * you need to query for the actual size yourself after the
1001 * call using nvram_partition_get_size().
1003 loff_t __init
nvram_create_partition(const char *name
, int sig
,
1004 int req_size
, int min_size
)
1006 struct nvram_partition
*part
;
1007 struct nvram_partition
*new_part
;
1008 struct nvram_partition
*free_part
= NULL
;
1009 static char nv_init_vals
[16];
1014 /* Convert sizes from bytes to blocks */
1015 req_size
= _ALIGN_UP(req_size
, NVRAM_BLOCK_LEN
) / NVRAM_BLOCK_LEN
;
1016 min_size
= _ALIGN_UP(min_size
, NVRAM_BLOCK_LEN
) / NVRAM_BLOCK_LEN
;
1018 /* If no minimum size specified, make it the same as the
1022 min_size
= req_size
;
1023 if (min_size
> req_size
)
1026 /* Now add one block to each for the header */
1030 /* Find a free partition that will give us the maximum needed size
1031 If can't find one that will give us the minimum size needed */
1032 list_for_each_entry(part
, &nvram_partitions
, partition
) {
1033 if (part
->header
.signature
!= NVRAM_SIG_FREE
)
1036 if (part
->header
.length
>= req_size
) {
1041 if (part
->header
.length
> size
&&
1042 part
->header
.length
>= min_size
) {
1043 size
= part
->header
.length
;
1050 /* Create our OS partition */
1051 new_part
= kmalloc(sizeof(*new_part
), GFP_KERNEL
);
1053 pr_err("%s: kmalloc failed\n", __func__
);
1057 new_part
->index
= free_part
->index
;
1058 new_part
->header
.signature
= sig
;
1059 new_part
->header
.length
= size
;
1060 strncpy(new_part
->header
.name
, name
, 12);
1061 new_part
->header
.checksum
= nvram_checksum(&new_part
->header
);
1063 rc
= nvram_write_header(new_part
);
1065 pr_err("%s: nvram_write_header failed (%d)\n", __func__
, rc
);
1069 list_add_tail(&new_part
->partition
, &free_part
->partition
);
1071 /* Adjust or remove the partition we stole the space from */
1072 if (free_part
->header
.length
> size
) {
1073 free_part
->index
+= size
* NVRAM_BLOCK_LEN
;
1074 free_part
->header
.length
-= size
;
1075 free_part
->header
.checksum
= nvram_checksum(&free_part
->header
);
1076 rc
= nvram_write_header(free_part
);
1078 pr_err("%s: nvram_write_header failed (%d)\n",
1083 list_del(&free_part
->partition
);
1087 /* Clear the new partition */
1088 for (tmp_index
= new_part
->index
+ NVRAM_HEADER_LEN
;
1089 tmp_index
< ((size
- 1) * NVRAM_BLOCK_LEN
);
1090 tmp_index
+= NVRAM_BLOCK_LEN
) {
1091 rc
= ppc_md
.nvram_write(nv_init_vals
, NVRAM_BLOCK_LEN
, &tmp_index
);
1093 pr_err("%s: nvram_write failed (%d)\n",
1099 return new_part
->index
+ NVRAM_HEADER_LEN
;
1103 * nvram_get_partition_size - Get the data size of an nvram partition
1104 * @data_index: This is the offset of the start of the data of
1105 * the partition. The same value that is returned by
1106 * nvram_create_partition().
1108 int nvram_get_partition_size(loff_t data_index
)
1110 struct nvram_partition
*part
;
1112 list_for_each_entry(part
, &nvram_partitions
, partition
) {
1113 if (part
->index
+ NVRAM_HEADER_LEN
== data_index
)
1114 return (part
->header
.length
- 1) * NVRAM_BLOCK_LEN
;
1121 * nvram_find_partition - Find an nvram partition by signature and name
1122 * @name: Name of the partition or NULL for any name
1123 * @sig: Signature to test against
1124 * @out_size: if non-NULL, returns the size of the data part of the partition
1126 loff_t
nvram_find_partition(const char *name
, int sig
, int *out_size
)
1128 struct nvram_partition
*p
;
1130 list_for_each_entry(p
, &nvram_partitions
, partition
) {
1131 if (p
->header
.signature
== sig
&&
1132 (!name
|| !strncmp(p
->header
.name
, name
, 12))) {
1134 *out_size
= (p
->header
.length
- 1) *
1136 return p
->index
+ NVRAM_HEADER_LEN
;
1142 int __init
nvram_scan_partitions(void)
1144 loff_t cur_index
= 0;
1145 struct nvram_header phead
;
1146 struct nvram_partition
* tmp_part
;
1147 unsigned char c_sum
;
1152 if (ppc_md
.nvram_size
== NULL
|| ppc_md
.nvram_size() <= 0)
1154 total_size
= ppc_md
.nvram_size();
1156 header
= kmalloc(NVRAM_HEADER_LEN
, GFP_KERNEL
);
1158 printk(KERN_ERR
"nvram_scan_partitions: Failed kmalloc\n");
1162 while (cur_index
< total_size
) {
1164 err
= ppc_md
.nvram_read(header
, NVRAM_HEADER_LEN
, &cur_index
);
1165 if (err
!= NVRAM_HEADER_LEN
) {
1166 printk(KERN_ERR
"nvram_scan_partitions: Error parsing "
1167 "nvram partitions\n");
1171 cur_index
-= NVRAM_HEADER_LEN
; /* nvram_read will advance us */
1173 memcpy(&phead
, header
, NVRAM_HEADER_LEN
);
1175 phead
.length
= be16_to_cpu(phead
.length
);
1178 c_sum
= nvram_checksum(&phead
);
1179 if (c_sum
!= phead
.checksum
) {
1180 printk(KERN_WARNING
"WARNING: nvram partition checksum"
1181 " was %02x, should be %02x!\n",
1182 phead
.checksum
, c_sum
);
1183 printk(KERN_WARNING
"Terminating nvram partition scan\n");
1186 if (!phead
.length
) {
1187 printk(KERN_WARNING
"WARNING: nvram corruption "
1188 "detected: 0-length partition\n");
1191 tmp_part
= kmalloc(sizeof(struct nvram_partition
), GFP_KERNEL
);
1194 printk(KERN_ERR
"nvram_scan_partitions: kmalloc failed\n");
1198 memcpy(&tmp_part
->header
, &phead
, NVRAM_HEADER_LEN
);
1199 tmp_part
->index
= cur_index
;
1200 list_add_tail(&tmp_part
->partition
, &nvram_partitions
);
1202 cur_index
+= phead
.length
* NVRAM_BLOCK_LEN
;
1207 nvram_print_partitions("NVRAM Partitions");
1215 static int __init
nvram_init(void)
1219 BUILD_BUG_ON(NVRAM_BLOCK_LEN
!= 16);
1221 if (ppc_md
.nvram_size
== NULL
|| ppc_md
.nvram_size() <= 0)
1224 rc
= misc_register(&nvram_dev
);
1226 printk(KERN_ERR
"nvram_init: failed to register device\n");
1232 device_initcall(nvram_init
);