// SPDX-License-Identifier: GPL-2.0-or-later/* * c 2001 PPC 64 Team, IBM Corp * * /proc/powerpc/rtas/firmware_flash interface * * This file implements a firmware_flash interface to pump a firmware * image into the kernel. At reboot time rtas_restart() will see the * firmware image and flash it as it reboots (see rtas.c). */ #include <linux/module.h>#include <linux/init.h>#include <linux/slab.h>#include <linux/proc_fs.h>#include <linux/reboot.h>#include <asm/delay.h>#include <linux/uaccess.h>#include <asm/rtas.h> #define MODULE_VERS "1.0"#define MODULE_NAME "rtas_flash" #define FIRMWARE_FLASH_NAME "firmware_flash" #define FIRMWARE_UPDATE_NAME "firmware_update"#define MANAGE_FLASH_NAME "manage_flash"#define VALIDATE_FLASH_NAME "validate_flash" /* General RTAS Status Codes */#define RTAS_RC_SUCCESS 0#define RTAS_RC_HW_ERR -1#define RTAS_RC_BUSY -2 /* Flash image status values */#define FLASH_AUTH -9002 /* RTAS Not Service Authority Partition */#define FLASH_NO_OP -1099 /* No operation initiated by user */ #define FLASH_IMG_SHORT -1005 /* Flash image shorter than expected */#define FLASH_IMG_BAD_LEN -1004 /* Bad length value in flash list block */#define FLASH_IMG_NULL_DATA -1003 /* Bad data value in flash list block */#define FLASH_IMG_READY 0 /* Firmware img ready for flash on reboot */ /* Manage image status values */#define MANAGE_AUTH -9002 /* RTAS Not Service Authority Partition */#define MANAGE_ACTIVE_ERR -9001 /* RTAS Cannot Overwrite Active Img */#define MANAGE_NO_OP -1099 /* No operation initiated by user */#define MANAGE_PARAM_ERR -3 /* RTAS Parameter Error */#define MANAGE_HW_ERR -1 /* RTAS Hardware Error */ /* Validate image status values */#define VALIDATE_AUTH -9002 /* RTAS Not Service Authority Partition */#define VALIDATE_NO_OP -1099 /* No operation initiated by the user */#define VALIDATE_INCOMPLETE -1002 /* User copied < VALIDATE_BUF_SIZE */#define VALIDATE_READY -1001 /* Firmware image ready for validation */#define VALIDATE_PARAM_ERR -3 /* RTAS Parameter Error */#define VALIDATE_HW_ERR -1 /* RTAS Hardware Error */ /* ibm,validate-flash-image update result tokens */#define VALIDATE_TMP_UPDATE 0 /* T side will be updated */#define VALIDATE_FLASH_AUTH 1 /* Partition does not have authority */#define VALIDATE_INVALID_IMG 2 /* Candidate image is not valid */#define VALIDATE_CUR_UNKNOWN 3 /* Current fixpack level is unknown *//* * Current T side will be committed to P side before being replace with new * image, and the new image is downlevel from current image */#define VALIDATE_TMP_COMMIT_DL 4/* * Current T side will be committed to P side before being replaced with new * image */#define VALIDATE_TMP_COMMIT 5/* * T side will be updated with a downlevel image */#define VALIDATE_TMP_UPDATE_DL 6/* * The candidate image's release date is later than the system's firmware * service entitlement date - service warranty period has expired */#define VALIDATE_OUT_OF_WRNTY 7 /* ibm,manage-flash-image operation tokens */#define RTAS_REJECT_TMP_IMG 0#define RTAS_COMMIT_TMP_IMG 1 /* Array sizes */#define VALIDATE_BUF_SIZE 4096 #define VALIDATE_MSG_LEN 256#define RTAS_MSG_MAXLEN 64 /* Quirk - RTAS requires 4k list length and block size */#define RTAS_BLKLIST_LENGTH 4096#define RTAS_BLK_SIZE 4096 struct flash_block { char *data; unsigned long length;}; /* This struct is very similar but not identical to * that needed by the rtas flash update. * All we need to do for rtas is rewrite num_blocks * into a version/length and translate the pointers * to absolute. */#define FLASH_BLOCKS_PER_NODE ((RTAS_BLKLIST_LENGTH - 16) / sizeof(struct flash_block))struct flash_block_list { unsigned long num_blocks; struct flash_block_list *next; struct flash_block blocks[FLASH_BLOCKS_PER_NODE];}; static struct flash_block_list *rtas_firmware_flash_list; /* Use slab cache to guarantee 4k alignment */static struct kmem_cache *flash_block_cache = NULL; #define FLASH_BLOCK_LIST_VERSION (1UL) /* * Local copy of the flash block list. * * The rtas_firmware_flash_list variable will be * set once the data is fully read. * * For convenience as we build the list we use virtual addrs, * we do not fill in the version number, and the length field * is treated as the number of entries currently in the block * (i.e. not a byte count). This is all fixed when calling * the flash routine. */ /* Status int must be first member of struct */struct rtas_update_flash_t{ int status; /* Flash update status */ struct flash_block_list *flist; /* Local copy of flash block list */}; /* Status int must be first member of struct */struct rtas_manage_flash_t{ int status; /* Returned status */}; /* Status int must be first member of struct */struct rtas_validate_flash_t{ int status; /* Returned status */ char *buf; /* Candidate image buffer */ unsigned int buf_size; /* Size of image buf */ unsigned int update_results; /* Update results token */}; static struct rtas_update_flash_t rtas_update_flash_data;static struct rtas_manage_flash_t rtas_manage_flash_data;static struct rtas_validate_flash_t rtas_validate_flash_data;static DEFINE_MUTEX(rtas_update_flash_mutex);static DEFINE_MUTEX(rtas_manage_flash_mutex);static DEFINE_MUTEX(rtas_validate_flash_mutex); /* Do simple sanity checks on the flash image. */static int flash_list_valid(struct flash_block_list *flist){ struct flash_block_list *f; int i; unsigned long block_size, image_size; /* Paranoid self test here. We also collect the image size. */ image_size = 0; for (f = flist; f; f = f->next) { for (i = 0; i < f->num_blocks; i++) { if (f->blocks[i].data == NULL) { return FLASH_IMG_NULL_DATA; } block_size = f->blocks[i].length; if (block_size <= 0 || block_size > RTAS_BLK_SIZE) { return FLASH_IMG_BAD_LEN; } image_size += block_size; } } if (image_size < (256 << 10)) { if (image_size < 2) return FLASH_NO_OP; } printk(KERN_INFO "FLASH: flash image with %ld bytes stored for hardware flash on reboot\n", image_size); return FLASH_IMG_READY;} static void free_flash_list(struct flash_block_list *f){ struct flash_block_list *next; int i; while (f) { for (i = 0; i < f->num_blocks; i++) kmem_cache_free(flash_block_cache, f->blocks[i].data); next = f->next; kmem_cache_free(flash_block_cache, f); f = next; }} static int rtas_flash_release(struct inode *inode, struct file *file){ struct rtas_update_flash_t *const uf = &rtas_update_flash_data; mutex_lock(&rtas_update_flash_mutex); if (uf->flist) { /* File was opened in write mode for a new flash attempt */ /* Clear saved list */ if (rtas_firmware_flash_list) { free_flash_list(rtas_firmware_flash_list); rtas_firmware_flash_list = NULL; } if (uf->status != FLASH_AUTH) uf->status = flash_list_valid(uf->flist); if (uf->status == FLASH_IMG_READY) rtas_firmware_flash_list = uf->flist; else free_flash_list(uf->flist); uf->flist = NULL; } mutex_unlock(&rtas_update_flash_mutex); return 0;} static size_t get_flash_status_msg(int status, char *buf){ const char *msg; size_t len; switch (status) { case FLASH_AUTH: msg = "error: this partition does not have service authority\n"; break; case FLASH_NO_OP: msg = "info: no firmware image for flash\n"; break; case FLASH_IMG_SHORT: msg = "error: flash image short\n"; break; case FLASH_IMG_BAD_LEN: msg = "error: internal error bad length\n"; break; case FLASH_IMG_NULL_DATA: msg = "error: internal error null data\n"; break; case FLASH_IMG_READY: msg = "ready: firmware image ready for flash on reboot\n"; break; default: return sprintf(buf, "error: unexpected status value %d\n", status); } len = strlen(msg); memcpy(buf, msg, len + 1); return len;} /* Reading the proc file will show status (not the firmware contents) */static ssize_t rtas_flash_read_msg(struct file *file, char __user *buf, size_t count, loff_t *ppos){ struct rtas_update_flash_t *const uf = &rtas_update_flash_data; char msg[RTAS_MSG_MAXLEN]; size_t len; int status; mutex_lock(&rtas_update_flash_mutex); status = uf->status; mutex_unlock(&rtas_update_flash_mutex); /* Read as text message */ len = get_flash_status_msg(status, msg); return simple_read_from_buffer(buf, count, ppos, msg, len);} static ssize_t rtas_flash_read_num(struct file *file, char __user *buf, size_t count, loff_t *ppos){ struct rtas_update_flash_t *const uf = &rtas_update_flash_data; char msg[RTAS_MSG_MAXLEN]; int status; mutex_lock(&rtas_update_flash_mutex); status = uf->status; mutex_unlock(&rtas_update_flash_mutex); /* Read as number */ sprintf(msg, "%d\n", status); return simple_read_from_buffer(buf, count, ppos, msg, strlen(msg));} /* We could be much more efficient here. But to keep this function * simple we allocate a page to the block list no matter how small the * count is. If the system is low on memory it will be just as well * that we fail.... */static ssize_t rtas_flash_write(struct file *file, const char __user *buffer, size_t count, loff_t *off){ struct rtas_update_flash_t *const uf = &rtas_update_flash_data; char *p; int next_free; struct flash_block_list *fl; guard(mutex)(&rtas_update_flash_mutex); if (uf->status == FLASH_AUTH || count == 0) return count; /* discard data */ /* In the case that the image is not ready for flashing, the memory * allocated for the block list will be freed upon the release of the * proc file */ if (uf->flist == NULL) { uf->flist = kmem_cache_zalloc(flash_block_cache, GFP_KERNEL); if (!uf->flist) return -ENOMEM; } fl = uf->flist; while (fl->next) fl = fl->next; /* seek to last block_list for append */ next_free = fl->num_blocks; if (next_free == FLASH_BLOCKS_PER_NODE) { /* Need to allocate another block_list */ fl->next = kmem_cache_zalloc(flash_block_cache, GFP_KERNEL); if (!fl->next) return -ENOMEM; fl = fl->next; next_free = 0; } if (count > RTAS_BLK_SIZE) count = RTAS_BLK_SIZE; p = kmem_cache_zalloc(flash_block_cache, GFP_KERNEL); if (!p) return -ENOMEM; if(copy_from_user(p, buffer, count)) { kmem_cache_free(flash_block_cache, p); return -EFAULT; } fl->blocks[next_free].data = p; fl->blocks[next_free].length = count; fl->num_blocks++; return count;} /* * Flash management routines. */static void manage_flash(struct rtas_manage_flash_t *args_buf, unsigned int op){ s32 rc; do { rc = rtas_call(rtas_function_token(RTAS_FN_IBM_MANAGE_FLASH_IMAGE), 1, 1, NULL, op); } while (rtas_busy_delay(rc)); args_buf->status = rc;} static ssize_t manage_flash_read(struct file *file, char __user *buf, size_t count, loff_t *ppos){ struct rtas_manage_flash_t *const args_buf = &rtas_manage_flash_data; char msg[RTAS_MSG_MAXLEN]; int msglen, status; mutex_lock(&rtas_manage_flash_mutex); status = args_buf->status; mutex_unlock(&rtas_manage_flash_mutex); msglen = sprintf(msg, "%d\n", status); return simple_read_from_buffer(buf, count, ppos, msg, msglen);} static ssize_t manage_flash_write(struct file *file, const char __user *buf, size_t count, loff_t *off){ struct rtas_manage_flash_t *const args_buf = &rtas_manage_flash_data; unsigned int op; char cmd; guard(mutex)(&rtas_manage_flash_mutex); if ((args_buf->status == MANAGE_AUTH) || (count == 0)) return count; if (get_user(cmd, buf)) return -EFAULT; if (cmd == '0') op = RTAS_REJECT_TMP_IMG; else if (cmd == '1') op = RTAS_COMMIT_TMP_IMG; else return -EINVAL; manage_flash(args_buf, op); return count;} /* * Validation routines. */static void validate_flash(struct rtas_validate_flash_t *args_buf){ int token = rtas_function_token(RTAS_FN_IBM_VALIDATE_FLASH_IMAGE); int update_results; s32 rc; rc = 0; do { spin_lock(&rtas_data_buf_lock); memcpy(rtas_data_buf, args_buf->buf, VALIDATE_BUF_SIZE); rc = rtas_call(token, 2, 2, &update_results, (u32) __pa(rtas_data_buf), args_buf->buf_size); memcpy(args_buf->buf, rtas_data_buf, VALIDATE_BUF_SIZE); spin_unlock(&rtas_data_buf_lock); } while (rtas_busy_delay(rc)); args_buf->status = rc; args_buf->update_results = update_results;} static int get_validate_flash_msg(struct rtas_validate_flash_t *args_buf, char *msg, int msglen){ int n; if (args_buf->status >= VALIDATE_TMP_UPDATE) { n = sprintf(msg, "%d\n", args_buf->update_results); if ((args_buf->update_results >= VALIDATE_CUR_UNKNOWN) || (args_buf->update_results == VALIDATE_TMP_UPDATE)) n += snprintf(msg + n, msglen - n, "%s\n", args_buf->buf); } else { n = sprintf(msg, "%d\n", args_buf->status); } return n;} static ssize_t validate_flash_read(struct file *file, char __user *buf, size_t count, loff_t *ppos){ struct rtas_validate_flash_t *const args_buf = &rtas_validate_flash_data; char msg[VALIDATE_MSG_LEN]; int msglen; mutex_lock(&rtas_validate_flash_mutex); msglen = get_validate_flash_msg(args_buf, msg, VALIDATE_MSG_LEN); mutex_unlock(&rtas_validate_flash_mutex); return simple_read_from_buffer(buf, count, ppos, msg, msglen);} static ssize_t validate_flash_write(struct file *file, const char __user *buf, size_t count, loff_t *off){ struct rtas_validate_flash_t *const args_buf = &rtas_validate_flash_data; guard(mutex)(&rtas_validate_flash_mutex); /* We are only interested in the first 4K of the * candidate image */ if ((*off >= VALIDATE_BUF_SIZE) || (args_buf->status == VALIDATE_AUTH)) { *off += count; return count; } if (*off + count >= VALIDATE_BUF_SIZE) { count = VALIDATE_BUF_SIZE - *off; args_buf->status = VALIDATE_READY; } else { args_buf->status = VALIDATE_INCOMPLETE; } if (!access_ok(buf, count)) return -EFAULT; if (copy_from_user(args_buf->buf + *off, buf, count))Lines 1–500 of 746. Load more
// SPDX-License-Identifier: GPL-2.0-or-later /* * c 2001 PPC 64 Team, IBM Corp * * /proc/powerpc/rtas/firmware_flash interface * * This file implements a firmware_flash interface to pump a firmware * image into the kernel. At reboot time rtas_restart() will see the * firmware image and flash it as it reboots (see rtas.c). */ #include <linux/module.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/proc_fs.h> #include <linux/reboot.h> #include <asm/delay.h> #include <linux/uaccess.h> #include <asm/rtas.h> #define MODULE_VERS "1.0" #define MODULE_NAME "rtas_flash" #define FIRMWARE_FLASH_NAME "firmware_flash" #define FIRMWARE_UPDATE_NAME "firmware_update" #define MANAGE_FLASH_NAME "manage_flash" #define VALIDATE_FLASH_NAME "validate_flash" /* General RTAS Status Codes */ #define RTAS_RC_SUCCESS 0 #define RTAS_RC_HW_ERR -1 #define RTAS_RC_BUSY -2 /* Flash image status values */ #define FLASH_AUTH -9002 /* RTAS Not Service Authority Partition */ #define FLASH_NO_OP -1099 /* No operation initiated by user */ #define FLASH_IMG_SHORT -1005 /* Flash image shorter than expected */ #define FLASH_IMG_BAD_LEN -1004 /* Bad length value in flash list block */ #define FLASH_IMG_NULL_DATA -1003 /* Bad data value in flash list block */ #define FLASH_IMG_READY 0 /* Firmware img ready for flash on reboot */ /* Manage image status values */ #define MANAGE_AUTH -9002 /* RTAS Not Service Authority Partition */ #define MANAGE_ACTIVE_ERR -9001 /* RTAS Cannot Overwrite Active Img */ #define MANAGE_NO_OP -1099 /* No operation initiated by user */ #define MANAGE_PARAM_ERR -3 /* RTAS Parameter Error */ #define MANAGE_HW_ERR -1 /* RTAS Hardware Error */ /* Validate image status values */ #define VALIDATE_AUTH -9002 /* RTAS Not Service Authority Partition */ #define VALIDATE_NO_OP -1099 /* No operation initiated by the user */ #define VALIDATE_INCOMPLETE -1002 /* User copied < VALIDATE_BUF_SIZE */ #define VALIDATE_READY -1001 /* Firmware image ready for validation */ #define VALIDATE_PARAM_ERR -3 /* RTAS Parameter Error */ #define VALIDATE_HW_ERR -1 /* RTAS Hardware Error */ /* ibm,validate-flash-image update result tokens */ #define VALIDATE_TMP_UPDATE 0 /* T side will be updated */ #define VALIDATE_FLASH_AUTH 1 /* Partition does not have authority */ #define VALIDATE_INVALID_IMG 2 /* Candidate image is not valid */ #define VALIDATE_CUR_UNKNOWN 3 /* Current fixpack level is unknown */ /* * Current T side will be committed to P side before being replace with new * image, and the new image is downlevel from current image */ #define VALIDATE_TMP_COMMIT_DL 4 /* * Current T side will be committed to P side before being replaced with new * image */ #define VALIDATE_TMP_COMMIT 5 /* * T side will be updated with a downlevel image */ #define VALIDATE_TMP_UPDATE_DL 6 /* * The candidate image's release date is later than the system's firmware * service entitlement date - service warranty period has expired */ #define VALIDATE_OUT_OF_WRNTY 7 /* ibm,manage-flash-image operation tokens */ #define RTAS_REJECT_TMP_IMG 0 #define RTAS_COMMIT_TMP_IMG 1 /* Array sizes */ #define VALIDATE_BUF_SIZE 4096 #define VALIDATE_MSG_LEN 256 #define RTAS_MSG_MAXLEN 64 /* Quirk - RTAS requires 4k list length and block size */ #define RTAS_BLKLIST_LENGTH 4096 #define RTAS_BLK_SIZE 4096 struct flash_block { char *data; unsigned long length; }; /* This struct is very similar but not identical to * that needed by the rtas flash update. * All we need to do for rtas is rewrite num_blocks * into a version/length and translate the pointers * to absolute. */ #define FLASH_BLOCKS_PER_NODE ((RTAS_BLKLIST_LENGTH - 16) / sizeof(struct flash_block)) struct flash_block_list { unsigned long num_blocks; struct flash_block_list *next; struct flash_block blocks[FLASH_BLOCKS_PER_NODE]; }; static struct flash_block_list *rtas_firmware_flash_list; /* Use slab cache to guarantee 4k alignment */ static struct kmem_cache *flash_block_cache = NULL; #define FLASH_BLOCK_LIST_VERSION (1UL) /* * Local copy of the flash block list. * * The rtas_firmware_flash_list variable will be * set once the data is fully read. * * For convenience as we build the list we use virtual addrs, * we do not fill in the version number, and the length field * is treated as the number of entries currently in the block * (i.e. not a byte count). This is all fixed when calling * the flash routine. */ /* Status int must be first member of struct */ struct rtas_update_flash_t { int status; /* Flash update status */ struct flash_block_list *flist; /* Local copy of flash block list */ }; /* Status int must be first member of struct */ struct rtas_manage_flash_t { int status; /* Returned status */ }; /* Status int must be first member of struct */ struct rtas_validate_flash_t { int status; /* Returned status */ char *buf; /* Candidate image buffer */ unsigned int buf_size; /* Size of image buf */ unsigned int update_results; /* Update results token */ }; static struct rtas_update_flash_t rtas_update_flash_data; static struct rtas_manage_flash_t rtas_manage_flash_data; static struct rtas_validate_flash_t rtas_validate_flash_data; static DEFINE_MUTEX(rtas_update_flash_mutex); static DEFINE_MUTEX(rtas_manage_flash_mutex); static DEFINE_MUTEX(rtas_validate_flash_mutex); /* Do simple sanity checks on the flash image. */ static int flash_list_valid(struct flash_block_list *flist) { struct flash_block_list *f; int i; unsigned long block_size, image_size; /* Paranoid self test here. We also collect the image size. */ image_size = 0; for (f = flist; f; f = f->next) { for (i = 0; i < f->num_blocks; i++) { if (f->blocks[i].data == NULL) { return FLASH_IMG_NULL_DATA; } block_size = f->blocks[i].length; if (block_size <= 0 || block_size > RTAS_BLK_SIZE) { return FLASH_IMG_BAD_LEN; } image_size += block_size; } } if (image_size < (256 << 10)) { if (image_size < 2) return FLASH_NO_OP; } printk(KERN_INFO "FLASH: flash image with %ld bytes stored for hardware flash on reboot\n", image_size); return FLASH_IMG_READY; } static void free_flash_list(struct flash_block_list *f) { struct flash_block_list *next; int i; while (f) { for (i = 0; i < f->num_blocks; i++) kmem_cache_free(flash_block_cache, f->blocks[i].data); next = f->next; kmem_cache_free(flash_block_cache, f); f = next; } } static int rtas_flash_release(struct inode *inode, struct file *file) { struct rtas_update_flash_t *const uf = &rtas_update_flash_data; mutex_lock(&rtas_update_flash_mutex); if (uf->flist) { /* File was opened in write mode for a new flash attempt */ /* Clear saved list */ if (rtas_firmware_flash_list) { free_flash_list(rtas_firmware_flash_list); rtas_firmware_flash_list = NULL; } if (uf->status != FLASH_AUTH) uf->status = flash_list_valid(uf->flist); if (uf->status == FLASH_IMG_READY) rtas_firmware_flash_list = uf->flist; else free_flash_list(uf->flist); uf->flist = NULL; } mutex_unlock(&rtas_update_flash_mutex); return 0; } static size_t get_flash_status_msg(int status, char *buf) { const char *msg; size_t len; switch (status) { case FLASH_AUTH: msg = "error: this partition does not have service authority\n"; break; case FLASH_NO_OP: msg = "info: no firmware image for flash\n"; break; case FLASH_IMG_SHORT: msg = "error: flash image short\n"; break; case FLASH_IMG_BAD_LEN: msg = "error: internal error bad length\n"; break; case FLASH_IMG_NULL_DATA: msg = "error: internal error null data\n"; break; case FLASH_IMG_READY: msg = "ready: firmware image ready for flash on reboot\n"; break; default: return sprintf(buf, "error: unexpected status value %d\n", status); } len = strlen(msg); memcpy(buf, msg, len + 1); return len; } /* Reading the proc file will show status (not the firmware contents) */ static ssize_t rtas_flash_read_msg(struct file *file, char __user *buf, size_t count, loff_t *ppos) { struct rtas_update_flash_t *const uf = &rtas_update_flash_data; char msg[RTAS_MSG_MAXLEN]; size_t len; int status; mutex_lock(&rtas_update_flash_mutex); status = uf->status; mutex_unlock(&rtas_update_flash_mutex); /* Read as text message */ len = get_flash_status_msg(status, msg); return simple_read_from_buffer(buf, count, ppos, msg, len); } static ssize_t rtas_flash_read_num(struct file *file, char __user *buf, size_t count, loff_t *ppos) { struct rtas_update_flash_t *const uf = &rtas_update_flash_data; char msg[RTAS_MSG_MAXLEN]; int status; mutex_lock(&rtas_update_flash_mutex); status = uf->status; mutex_unlock(&rtas_update_flash_mutex); /* Read as number */ sprintf(msg, "%d\n", status); return simple_read_from_buffer(buf, count, ppos, msg, strlen(msg)); } /* We could be much more efficient here. But to keep this function * simple we allocate a page to the block list no matter how small the * count is. If the system is low on memory it will be just as well * that we fail.... */ static ssize_t rtas_flash_write(struct file *file, const char __user *buffer, size_t count, loff_t *off) { struct rtas_update_flash_t *const uf = &rtas_update_flash_data; char *p; int next_free; struct flash_block_list *fl; guard(mutex)(&rtas_update_flash_mutex); if (uf->status == FLASH_AUTH || count == 0) return count; /* discard data */ /* In the case that the image is not ready for flashing, the memory * allocated for the block list will be freed upon the release of the * proc file */ if (uf->flist == NULL) { uf->flist = kmem_cache_zalloc(flash_block_cache, GFP_KERNEL); if (!uf->flist) return -ENOMEM; } fl = uf->flist; while (fl->next) fl = fl->next; /* seek to last block_list for append */ next_free = fl->num_blocks; if (next_free == FLASH_BLOCKS_PER_NODE) { /* Need to allocate another block_list */ fl->next = kmem_cache_zalloc(flash_block_cache, GFP_KERNEL); if (!fl->next) return -ENOMEM; fl = fl->next; next_free = 0; } if (count > RTAS_BLK_SIZE) count = RTAS_BLK_SIZE; p = kmem_cache_zalloc(flash_block_cache, GFP_KERNEL); if (!p) return -ENOMEM; if(copy_from_user(p, buffer, count)) { kmem_cache_free(flash_block_cache, p); return -EFAULT; } fl->blocks[next_free].data = p; fl->blocks[next_free].length = count; fl->num_blocks++; return count; } /* * Flash management routines. */ static void manage_flash(struct rtas_manage_flash_t *args_buf, unsigned int op) { s32 rc; do { rc = rtas_call(rtas_function_token(RTAS_FN_IBM_MANAGE_FLASH_IMAGE), 1, 1, NULL, op); } while (rtas_busy_delay(rc)); args_buf->status = rc; } static ssize_t manage_flash_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) { struct rtas_manage_flash_t *const args_buf = &rtas_manage_flash_data; char msg[RTAS_MSG_MAXLEN]; int msglen, status; mutex_lock(&rtas_manage_flash_mutex); status = args_buf->status; mutex_unlock(&rtas_manage_flash_mutex); msglen = sprintf(msg, "%d\n", status); return simple_read_from_buffer(buf, count, ppos, msg, msglen); } static ssize_t manage_flash_write(struct file *file, const char __user *buf, size_t count, loff_t *off) { struct rtas_manage_flash_t *const args_buf = &rtas_manage_flash_data; unsigned int op; char cmd; guard(mutex)(&rtas_manage_flash_mutex); if ((args_buf->status == MANAGE_AUTH) || (count == 0)) return count; if (get_user(cmd, buf)) return -EFAULT; if (cmd == '0') op = RTAS_REJECT_TMP_IMG; else if (cmd == '1') op = RTAS_COMMIT_TMP_IMG; else return -EINVAL; manage_flash(args_buf, op); return count; } /* * Validation routines. */ static void validate_flash(struct rtas_validate_flash_t *args_buf) { int token = rtas_function_token(RTAS_FN_IBM_VALIDATE_FLASH_IMAGE); int update_results; s32 rc; rc = 0; do { spin_lock(&rtas_data_buf_lock); memcpy(rtas_data_buf, args_buf->buf, VALIDATE_BUF_SIZE); rc = rtas_call(token, 2, 2, &update_results, (u32) __pa(rtas_data_buf), args_buf->buf_size); memcpy(args_buf->buf, rtas_data_buf, VALIDATE_BUF_SIZE); spin_unlock(&rtas_data_buf_lock); } while (rtas_busy_delay(rc)); args_buf->status = rc; args_buf->update_results = update_results; } static int get_validate_flash_msg(struct rtas_validate_flash_t *args_buf, char *msg, int msglen) { int n; if (args_buf->status >= VALIDATE_TMP_UPDATE) { n = sprintf(msg, "%d\n", args_buf->update_results); if ((args_buf->update_results >= VALIDATE_CUR_UNKNOWN) || (args_buf->update_results == VALIDATE_TMP_UPDATE)) n += snprintf(msg + n, msglen - n, "%s\n", args_buf->buf); } else { n = sprintf(msg, "%d\n", args_buf->status); } return n; } static ssize_t validate_flash_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) { struct rtas_validate_flash_t *const args_buf = &rtas_validate_flash_data; char msg[VALIDATE_MSG_LEN]; int msglen; mutex_lock(&rtas_validate_flash_mutex); msglen = get_validate_flash_msg(args_buf, msg, VALIDATE_MSG_LEN); mutex_unlock(&rtas_validate_flash_mutex); return simple_read_from_buffer(buf, count, ppos, msg, msglen); } static ssize_t validate_flash_write(struct file *file, const char __user *buf, size_t count, loff_t *off) { struct rtas_validate_flash_t *const args_buf = &rtas_validate_flash_data; guard(mutex)(&rtas_validate_flash_mutex); /* We are only interested in the first 4K of the * candidate image */ if ((*off >= VALIDATE_BUF_SIZE) || (args_buf->status == VALIDATE_AUTH)) { *off += count; return count; } if (*off + count >= VALIDATE_BUF_SIZE) { count = VALIDATE_BUF_SIZE - *off; args_buf->status = VALIDATE_READY; } else { args_buf->status = VALIDATE_INCOMPLETE; } if (!access_ok(buf, count)) return -EFAULT; if (copy_from_user(args_buf->buf + *off, buf, count))