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
, ssize_t
*ecc_notice_size
,
448 struct pstore_info
*psi
)
450 struct oops_log_info
*oops_hdr
;
451 unsigned int err_type
, id_no
, size
= 0;
452 struct nvram_os_partition
*part
= NULL
;
459 switch (nvram_type_ids
[read_type
]) {
460 case PSTORE_TYPE_DMESG
:
461 part
= &oops_log_partition
;
462 *type
= PSTORE_TYPE_DMESG
;
464 case PSTORE_TYPE_PPC_COMMON
:
466 part
= &common_partition
;
467 *type
= PSTORE_TYPE_PPC_COMMON
;
468 *id
= PSTORE_TYPE_PPC_COMMON
;
472 #ifdef CONFIG_PPC_PSERIES
473 case PSTORE_TYPE_PPC_RTAS
:
474 part
= &rtas_log_partition
;
475 *type
= PSTORE_TYPE_PPC_RTAS
;
476 time
->tv_sec
= last_rtas_event
;
479 case PSTORE_TYPE_PPC_OF
:
481 part
= &of_config_partition
;
482 *type
= PSTORE_TYPE_PPC_OF
;
483 *id
= PSTORE_TYPE_PPC_OF
;
488 #ifdef CONFIG_PPC_POWERNV
489 case PSTORE_TYPE_PPC_OPAL
:
491 part
= &skiboot_partition
;
492 *type
= PSTORE_TYPE_PPC_OPAL
;
493 *id
= PSTORE_TYPE_PPC_OPAL
;
502 if (!part
->os_partition
) {
503 p
= nvram_find_partition(part
->name
, sig
, &size
);
505 pr_err("nvram: Failed to find partition %s, "
506 "err %d\n", part
->name
, (int)p
);
513 buff
= kmalloc(part
->size
, GFP_KERNEL
);
518 if (nvram_read_partition(part
, buff
, part
->size
, &err_type
, &id_no
)) {
525 if (part
->os_partition
)
528 if (nvram_type_ids
[read_type
] == PSTORE_TYPE_DMESG
) {
529 size_t length
, hdr_size
;
531 oops_hdr
= (struct oops_log_info
*)buff
;
532 if (be16_to_cpu(oops_hdr
->version
) < OOPS_HDR_VERSION
) {
533 /* Old format oops header had 2-byte record size */
534 hdr_size
= sizeof(u16
);
535 length
= be16_to_cpu(oops_hdr
->version
);
539 hdr_size
= sizeof(*oops_hdr
);
540 length
= be16_to_cpu(oops_hdr
->report_length
);
541 time
->tv_sec
= be64_to_cpu(oops_hdr
->timestamp
);
544 *buf
= kmemdup(buff
+ hdr_size
, length
, GFP_KERNEL
);
549 *ecc_notice_size
= 0;
550 if (err_type
== ERR_TYPE_KERNEL_PANIC_GZ
)
561 static struct pstore_info nvram_pstore_info
= {
562 .owner
= THIS_MODULE
,
564 .open
= nvram_pstore_open
,
565 .read
= nvram_pstore_read
,
566 .write
= nvram_pstore_write
,
569 static int nvram_pstore_init(void)
573 if (machine_is(pseries
)) {
574 nvram_type_ids
[2] = PSTORE_TYPE_PPC_RTAS
;
575 nvram_type_ids
[3] = PSTORE_TYPE_PPC_OF
;
577 nvram_type_ids
[2] = PSTORE_TYPE_PPC_OPAL
;
579 nvram_pstore_info
.buf
= oops_data
;
580 nvram_pstore_info
.bufsize
= oops_data_sz
;
582 spin_lock_init(&nvram_pstore_info
.buf_lock
);
584 rc
= pstore_register(&nvram_pstore_info
);
585 if (rc
&& (rc
!= -EPERM
))
586 /* Print error only when pstore.backend == nvram */
587 pr_err("nvram: pstore_register() failed, returned %d. "
588 "Defaults to kmsg_dump\n", rc
);
593 static int nvram_pstore_init(void)
599 void __init
nvram_init_oops_partition(int rtas_partition_exists
)
603 rc
= nvram_init_os_partition(&oops_log_partition
);
605 #ifdef CONFIG_PPC_PSERIES
606 if (!rtas_partition_exists
) {
607 pr_err("nvram: Failed to initialize oops partition!");
610 pr_notice("nvram: Using %s partition to log both"
611 " RTAS errors and oops/panic reports\n",
612 rtas_log_partition
.name
);
613 memcpy(&oops_log_partition
, &rtas_log_partition
,
614 sizeof(rtas_log_partition
));
616 pr_err("nvram: Failed to initialize oops partition!");
620 oops_buf
= kmalloc(oops_log_partition
.size
, GFP_KERNEL
);
622 pr_err("nvram: No memory for %s partition\n",
623 oops_log_partition
.name
);
626 oops_data
= oops_buf
+ sizeof(struct oops_log_info
);
627 oops_data_sz
= oops_log_partition
.size
- sizeof(struct oops_log_info
);
629 rc
= nvram_pstore_init();
635 * Figure compression (preceded by elimination of each line's <n>
636 * severity prefix) will reduce the oops/panic report to at most
637 * 45% of its original size.
639 big_oops_buf_sz
= (oops_data_sz
* 100) / 45;
640 big_oops_buf
= kmalloc(big_oops_buf_sz
, GFP_KERNEL
);
642 stream
.workspace
= kmalloc(zlib_deflate_workspacesize(
643 WINDOW_BITS
, MEM_LEVEL
), GFP_KERNEL
);
644 if (!stream
.workspace
) {
645 pr_err("nvram: No memory for compression workspace; "
646 "skipping compression of %s partition data\n",
647 oops_log_partition
.name
);
652 pr_err("No memory for uncompressed %s data; "
653 "skipping compression\n", oops_log_partition
.name
);
654 stream
.workspace
= NULL
;
657 rc
= kmsg_dump_register(&nvram_kmsg_dumper
);
659 pr_err("nvram: kmsg_dump_register() failed; returned %d\n", rc
);
662 kfree(stream
.workspace
);
667 * This is our kmsg_dump callback, called after an oops or panic report
668 * has been written to the printk buffer. We want to capture as much
669 * of the printk buffer as possible. First, capture as much as we can
670 * that we think will compress sufficiently to fit in the lnx,oops-log
671 * partition. If that's too much, go back and capture uncompressed text.
673 static void oops_to_nvram(struct kmsg_dumper
*dumper
,
674 enum kmsg_dump_reason reason
)
676 struct oops_log_info
*oops_hdr
= (struct oops_log_info
*)oops_buf
;
677 static unsigned int oops_count
= 0;
678 static bool panicking
= false;
679 static DEFINE_SPINLOCK(lock
);
682 unsigned int err_type
= ERR_TYPE_KERNEL_PANIC_GZ
;
686 case KMSG_DUMP_RESTART
:
688 case KMSG_DUMP_POWEROFF
:
689 /* These are almost always orderly shutdowns. */
693 case KMSG_DUMP_PANIC
:
696 case KMSG_DUMP_EMERG
:
698 /* Panic report already captured. */
702 pr_err("%s: ignoring unrecognized KMSG_DUMP_* reason %d\n",
703 __func__
, (int) reason
);
707 if (clobbering_unread_rtas_event())
710 if (!spin_trylock_irqsave(&lock
, flags
))
714 kmsg_dump_get_buffer(dumper
, false,
715 big_oops_buf
, big_oops_buf_sz
, &text_len
);
716 rc
= zip_oops(text_len
);
719 kmsg_dump_rewind(dumper
);
720 kmsg_dump_get_buffer(dumper
, false,
721 oops_data
, oops_data_sz
, &text_len
);
722 err_type
= ERR_TYPE_KERNEL_PANIC
;
723 oops_hdr
->version
= cpu_to_be16(OOPS_HDR_VERSION
);
724 oops_hdr
->report_length
= cpu_to_be16(text_len
);
725 oops_hdr
->timestamp
= cpu_to_be64(ktime_get_real_seconds());
728 (void) nvram_write_os_partition(&oops_log_partition
, oops_buf
,
729 (int) (sizeof(*oops_hdr
) + text_len
), err_type
,
732 spin_unlock_irqrestore(&lock
, flags
);
735 static loff_t
dev_nvram_llseek(struct file
*file
, loff_t offset
, int origin
)
737 if (ppc_md
.nvram_size
== NULL
)
739 return generic_file_llseek_size(file
, offset
, origin
, MAX_LFS_FILESIZE
,
740 ppc_md
.nvram_size());
744 static ssize_t
dev_nvram_read(struct file
*file
, char __user
*buf
,
745 size_t count
, loff_t
*ppos
)
751 if (!ppc_md
.nvram_size
) {
756 size
= ppc_md
.nvram_size();
767 count
= min_t(size_t, count
, size
- *ppos
);
768 count
= min(count
, PAGE_SIZE
);
770 tmp
= kmalloc(count
, GFP_KERNEL
);
776 ret
= ppc_md
.nvram_read(tmp
, count
, ppos
);
780 if (copy_to_user(buf
, tmp
, ret
))
789 static ssize_t
dev_nvram_write(struct file
*file
, const char __user
*buf
,
790 size_t count
, loff_t
*ppos
)
797 if (!ppc_md
.nvram_size
)
801 size
= ppc_md
.nvram_size();
802 if (*ppos
>= size
|| size
< 0)
805 count
= min_t(size_t, count
, size
- *ppos
);
806 count
= min(count
, PAGE_SIZE
);
809 tmp
= kmalloc(count
, GFP_KERNEL
);
814 if (copy_from_user(tmp
, buf
, count
))
817 ret
= ppc_md
.nvram_write(tmp
, count
, ppos
);
825 static long dev_nvram_ioctl(struct file
*file
, unsigned int cmd
,
829 #ifdef CONFIG_PPC_PMAC
830 case OBSOLETE_PMAC_NVRAM_GET_OFFSET
:
831 printk(KERN_WARNING
"nvram: Using obsolete PMAC_NVRAM_GET_OFFSET ioctl\n");
832 case IOC_NVRAM_GET_OFFSET
: {
835 if (!machine_is(powermac
))
837 if (copy_from_user(&part
, (void __user
*)arg
, sizeof(part
)) != 0)
839 if (part
< pmac_nvram_OF
|| part
> pmac_nvram_NR
)
841 offset
= pmac_get_partition(part
);
844 if (copy_to_user((void __user
*)arg
, &offset
, sizeof(offset
)) != 0)
848 #endif /* CONFIG_PPC_PMAC */
854 static const struct file_operations nvram_fops
= {
855 .owner
= THIS_MODULE
,
856 .llseek
= dev_nvram_llseek
,
857 .read
= dev_nvram_read
,
858 .write
= dev_nvram_write
,
859 .unlocked_ioctl
= dev_nvram_ioctl
,
862 static struct miscdevice nvram_dev
= {
870 static void __init
nvram_print_partitions(char * label
)
872 struct nvram_partition
* tmp_part
;
874 printk(KERN_WARNING
"--------%s---------\n", label
);
875 printk(KERN_WARNING
"indx\t\tsig\tchks\tlen\tname\n");
876 list_for_each_entry(tmp_part
, &nvram_partitions
, partition
) {
877 printk(KERN_WARNING
"%4d \t%02x\t%02x\t%d\t%12.12s\n",
878 tmp_part
->index
, tmp_part
->header
.signature
,
879 tmp_part
->header
.checksum
, tmp_part
->header
.length
,
880 tmp_part
->header
.name
);
886 static int __init
nvram_write_header(struct nvram_partition
* part
)
890 struct nvram_header phead
;
892 memcpy(&phead
, &part
->header
, NVRAM_HEADER_LEN
);
893 phead
.length
= cpu_to_be16(phead
.length
);
895 tmp_index
= part
->index
;
896 rc
= ppc_md
.nvram_write((char *)&phead
, NVRAM_HEADER_LEN
, &tmp_index
);
902 static unsigned char __init
nvram_checksum(struct nvram_header
*p
)
904 unsigned int c_sum
, c_sum2
;
905 unsigned short *sp
= (unsigned short *)p
->name
; /* assume 6 shorts */
906 c_sum
= p
->signature
+ p
->length
+ sp
[0] + sp
[1] + sp
[2] + sp
[3] + sp
[4] + sp
[5];
908 /* The sum may have spilled into the 3rd byte. Fold it back. */
909 c_sum
= ((c_sum
& 0xffff) + (c_sum
>> 16)) & 0xffff;
910 /* The sum cannot exceed 2 bytes. Fold it into a checksum */
911 c_sum2
= (c_sum
>> 8) + (c_sum
<< 8);
912 c_sum
= ((c_sum
+ c_sum2
) >> 8) & 0xff;
917 * Per the criteria passed via nvram_remove_partition(), should this
918 * partition be removed? 1=remove, 0=keep
920 static int nvram_can_remove_partition(struct nvram_partition
*part
,
921 const char *name
, int sig
, const char *exceptions
[])
923 if (part
->header
.signature
!= sig
)
926 if (strncmp(name
, part
->header
.name
, 12))
928 } else if (exceptions
) {
930 for (except
= exceptions
; *except
; except
++) {
931 if (!strncmp(*except
, part
->header
.name
, 12))
939 * nvram_remove_partition - Remove one or more partitions in nvram
940 * @name: name of the partition to remove, or NULL for a
941 * signature only match
942 * @sig: signature of the partition(s) to remove
943 * @exceptions: When removing all partitions with a matching signature,
947 int __init
nvram_remove_partition(const char *name
, int sig
,
948 const char *exceptions
[])
950 struct nvram_partition
*part
, *prev
, *tmp
;
953 list_for_each_entry(part
, &nvram_partitions
, partition
) {
954 if (!nvram_can_remove_partition(part
, name
, sig
, exceptions
))
957 /* Make partition a free partition */
958 part
->header
.signature
= NVRAM_SIG_FREE
;
959 memset(part
->header
.name
, 'w', 12);
960 part
->header
.checksum
= nvram_checksum(&part
->header
);
961 rc
= nvram_write_header(part
);
963 printk(KERN_ERR
"nvram_remove_partition: nvram_write failed (%d)\n", rc
);
968 /* Merge contiguous ones */
970 list_for_each_entry_safe(part
, tmp
, &nvram_partitions
, partition
) {
971 if (part
->header
.signature
!= NVRAM_SIG_FREE
) {
976 prev
->header
.length
+= part
->header
.length
;
977 prev
->header
.checksum
= nvram_checksum(&prev
->header
);
978 rc
= nvram_write_header(prev
);
980 printk(KERN_ERR
"nvram_remove_partition: nvram_write failed (%d)\n", rc
);
983 list_del(&part
->partition
);
993 * nvram_create_partition - Create a partition in nvram
994 * @name: name of the partition to create
995 * @sig: signature of the partition to create
996 * @req_size: size of data to allocate in bytes
997 * @min_size: minimum acceptable size (0 means req_size)
999 * Returns a negative error code or a positive nvram index
1000 * of the beginning of the data area of the newly created
1001 * partition. If you provided a min_size smaller than req_size
1002 * you need to query for the actual size yourself after the
1003 * call using nvram_partition_get_size().
1005 loff_t __init
nvram_create_partition(const char *name
, int sig
,
1006 int req_size
, int min_size
)
1008 struct nvram_partition
*part
;
1009 struct nvram_partition
*new_part
;
1010 struct nvram_partition
*free_part
= NULL
;
1011 static char nv_init_vals
[16];
1016 /* Convert sizes from bytes to blocks */
1017 req_size
= _ALIGN_UP(req_size
, NVRAM_BLOCK_LEN
) / NVRAM_BLOCK_LEN
;
1018 min_size
= _ALIGN_UP(min_size
, NVRAM_BLOCK_LEN
) / NVRAM_BLOCK_LEN
;
1020 /* If no minimum size specified, make it the same as the
1024 min_size
= req_size
;
1025 if (min_size
> req_size
)
1028 /* Now add one block to each for the header */
1032 /* Find a free partition that will give us the maximum needed size
1033 If can't find one that will give us the minimum size needed */
1034 list_for_each_entry(part
, &nvram_partitions
, partition
) {
1035 if (part
->header
.signature
!= NVRAM_SIG_FREE
)
1038 if (part
->header
.length
>= req_size
) {
1043 if (part
->header
.length
> size
&&
1044 part
->header
.length
>= min_size
) {
1045 size
= part
->header
.length
;
1052 /* Create our OS partition */
1053 new_part
= kmalloc(sizeof(*new_part
), GFP_KERNEL
);
1055 pr_err("%s: kmalloc failed\n", __func__
);
1059 new_part
->index
= free_part
->index
;
1060 new_part
->header
.signature
= sig
;
1061 new_part
->header
.length
= size
;
1062 strncpy(new_part
->header
.name
, name
, 12);
1063 new_part
->header
.checksum
= nvram_checksum(&new_part
->header
);
1065 rc
= nvram_write_header(new_part
);
1067 pr_err("%s: nvram_write_header failed (%d)\n", __func__
, rc
);
1071 list_add_tail(&new_part
->partition
, &free_part
->partition
);
1073 /* Adjust or remove the partition we stole the space from */
1074 if (free_part
->header
.length
> size
) {
1075 free_part
->index
+= size
* NVRAM_BLOCK_LEN
;
1076 free_part
->header
.length
-= size
;
1077 free_part
->header
.checksum
= nvram_checksum(&free_part
->header
);
1078 rc
= nvram_write_header(free_part
);
1080 pr_err("%s: nvram_write_header failed (%d)\n",
1085 list_del(&free_part
->partition
);
1089 /* Clear the new partition */
1090 for (tmp_index
= new_part
->index
+ NVRAM_HEADER_LEN
;
1091 tmp_index
< ((size
- 1) * NVRAM_BLOCK_LEN
);
1092 tmp_index
+= NVRAM_BLOCK_LEN
) {
1093 rc
= ppc_md
.nvram_write(nv_init_vals
, NVRAM_BLOCK_LEN
, &tmp_index
);
1095 pr_err("%s: nvram_write failed (%d)\n",
1101 return new_part
->index
+ NVRAM_HEADER_LEN
;
1105 * nvram_get_partition_size - Get the data size of an nvram partition
1106 * @data_index: This is the offset of the start of the data of
1107 * the partition. The same value that is returned by
1108 * nvram_create_partition().
1110 int nvram_get_partition_size(loff_t data_index
)
1112 struct nvram_partition
*part
;
1114 list_for_each_entry(part
, &nvram_partitions
, partition
) {
1115 if (part
->index
+ NVRAM_HEADER_LEN
== data_index
)
1116 return (part
->header
.length
- 1) * NVRAM_BLOCK_LEN
;
1123 * nvram_find_partition - Find an nvram partition by signature and name
1124 * @name: Name of the partition or NULL for any name
1125 * @sig: Signature to test against
1126 * @out_size: if non-NULL, returns the size of the data part of the partition
1128 loff_t
nvram_find_partition(const char *name
, int sig
, int *out_size
)
1130 struct nvram_partition
*p
;
1132 list_for_each_entry(p
, &nvram_partitions
, partition
) {
1133 if (p
->header
.signature
== sig
&&
1134 (!name
|| !strncmp(p
->header
.name
, name
, 12))) {
1136 *out_size
= (p
->header
.length
- 1) *
1138 return p
->index
+ NVRAM_HEADER_LEN
;
1144 int __init
nvram_scan_partitions(void)
1146 loff_t cur_index
= 0;
1147 struct nvram_header phead
;
1148 struct nvram_partition
* tmp_part
;
1149 unsigned char c_sum
;
1154 if (ppc_md
.nvram_size
== NULL
|| ppc_md
.nvram_size() <= 0)
1156 total_size
= ppc_md
.nvram_size();
1158 header
= kmalloc(NVRAM_HEADER_LEN
, GFP_KERNEL
);
1160 printk(KERN_ERR
"nvram_scan_partitions: Failed kmalloc\n");
1164 while (cur_index
< total_size
) {
1166 err
= ppc_md
.nvram_read(header
, NVRAM_HEADER_LEN
, &cur_index
);
1167 if (err
!= NVRAM_HEADER_LEN
) {
1168 printk(KERN_ERR
"nvram_scan_partitions: Error parsing "
1169 "nvram partitions\n");
1173 cur_index
-= NVRAM_HEADER_LEN
; /* nvram_read will advance us */
1175 memcpy(&phead
, header
, NVRAM_HEADER_LEN
);
1177 phead
.length
= be16_to_cpu(phead
.length
);
1180 c_sum
= nvram_checksum(&phead
);
1181 if (c_sum
!= phead
.checksum
) {
1182 printk(KERN_WARNING
"WARNING: nvram partition checksum"
1183 " was %02x, should be %02x!\n",
1184 phead
.checksum
, c_sum
);
1185 printk(KERN_WARNING
"Terminating nvram partition scan\n");
1188 if (!phead
.length
) {
1189 printk(KERN_WARNING
"WARNING: nvram corruption "
1190 "detected: 0-length partition\n");
1193 tmp_part
= kmalloc(sizeof(struct nvram_partition
), GFP_KERNEL
);
1196 printk(KERN_ERR
"nvram_scan_partitions: kmalloc failed\n");
1200 memcpy(&tmp_part
->header
, &phead
, NVRAM_HEADER_LEN
);
1201 tmp_part
->index
= cur_index
;
1202 list_add_tail(&tmp_part
->partition
, &nvram_partitions
);
1204 cur_index
+= phead
.length
* NVRAM_BLOCK_LEN
;
1209 nvram_print_partitions("NVRAM Partitions");
1217 static int __init
nvram_init(void)
1221 BUILD_BUG_ON(NVRAM_BLOCK_LEN
!= 16);
1223 if (ppc_md
.nvram_size
== NULL
|| ppc_md
.nvram_size() <= 0)
1226 rc
= misc_register(&nvram_dev
);
1228 printk(KERN_ERR
"nvram_init: failed to register device\n");
1234 device_initcall(nvram_init
);