static int _MsApi_BrickTerminator_Recover_NonReserve ()
{
char cmd[CMD_BUF] = {};
const char* BOOT_RECOVER_BRICK_BACKUP_VOLUME = "brickbackup";
const char* BOOT_RECOVER_BRICK_BACKUP_FILE = "/MstarUpgrade_backup.bin";
vfs_umount();
if(0 == vfs_mount((char*)BOOT_RECOVER_BRICK_BACKUP_VOLUME))
{
sprintf(cmd, "bstar %s", BOOT_RECOVER_BRICK_BACKUP_FILE);
UBOOT_ERROR("%s: ERROR: VFS failed, at %d\n", __func__, __LINE__);
UBOOT_DEBUG("%s: DO BRICK RESERVE RECOVER, at %d\n", __func__, __LINE__);
//NOTE: do partition recover
run_command(cmd, 0);
vfs_umount();
}
return 0;
}
static int _MsApi_BrickTerminator_Recover_Reserve ()
{
MS_BOOL bNeedReburn = TRUE;
U32 u32PathSize = 0;
const char* BOOT_RECOVER_BRICK_RESERVE_VOLUME = "brickreserve";
const char* BOOT_RECOVER_BRICK_BACKUP_VOLUME = "brickbackup";
const char* BOOT_RECOVER_BRICK_RESERVE_FILE = "/.ready";
const char* BOOT_RECOVER_BRICK_BACKUP_FILE = "/MstarUpgrade_reserve.bin";
if(0 == vfs_mount((char*)BOOT_RECOVER_BRICK_RESERVE_VOLUME))
{
u32PathSize = vfs_getsize((char*)BOOT_RECOVER_BRICK_RESERVE_FILE);
if(0 < u32PathSize)
{
bNeedReburn = FALSE;
UBOOT_DEBUG("%s: u32PathSize: %u, at %d\n", __func__, u32PathSize, __LINE__); // DBG
}
else // TODO: remove after debug
{
UBOOT_ERROR("%s: ERROR: vfs_getsize failed, at %d\n", __func__, __LINE__);
}
}
if(TRUE == bNeedReburn)
{
char cmd[CMD_BUF] = {};
vfs_umount();
if(0 == vfs_mount((char*)BOOT_RECOVER_BRICK_BACKUP_VOLUME))
{
sprintf(cmd, "bstar %s", BOOT_RECOVER_BRICK_BACKUP_FILE);
UBOOT_ERROR("%s: ERROR: VFS failed, at %d\n", __func__, __LINE__);
UBOOT_DEBUG("%s: DO BRICK RESERVE RECOVER, at %d\n", __func__, __LINE__);
//NOTE: do partition recover
run_command(cmd, 0);
vfs_umount();
}
}
else
{
UBOOT_DEBUG("%s: '%s' is ok, no need to re-burn, at %d\n", __func__, BOOT_RECOVER_BRICK_RESERVE_VOLUME, __LINE__);
vfs_umount();
}
return 0;
}
int sys_umount(const char* dev) {
if((current_task->uid != TASK_ROOT_UID) && (current_task->gid != TASK_ROOT_GID)) {
errno = EPERM;
return -1;
}
inode_t* dev_ino = NULL;
int devfd = sys_open(dev, O_RDONLY, 0);
if(devfd >= 0) {
dev_ino = current_task->fd[devfd].inode;
sys_close(devfd);
}
return vfs_umount(dev_ino);
});
/*Unmount a device*/
void umount(int i) {
char *args = (char *)i;
char output[MAX_PATH+1];
if(! args) {
goto out_usage;
}
while(*args && isspace(*args) ) ++args;
if(! *args) {
out_usage:
printf("usage: umount mountpoint\n");
goto out;
}
trim_file_separator(args,output,sizeof(output)-1);
vfs_umount(output);
out:;
}
int LoadMMAP(void)
{
UBOOT_TRACE("IN\n");
if(vfs_mount(CONFIG)!=0)
{
UBOOT_ERROR("mount %s fail\n",CONFIG);
return -1;
}
mmap_buffer_size=vfs_getsize(MMAP_FILE_NAME);
if(mmap_buffer_size==0)
{
UBOOT_ERROR("get the file size of %s fail\n",MMAP_FILE_NAME);
return -1;
}
mmap_buffer=malloc(mmap_buffer_size);
UBOOT_DEBUG("mmmap_buffer at 0x%x\n",(unsigned int)mmap_buffer);
if(mmap_buffer==NULL)
{
UBOOT_ERROR("malloc for mmap_buffer fail\n");
return NULL;
}
if(vfs_read((char *)mmap_buffer,MMAP_FILE_NAME,0,mmap_buffer_size)!=0)
{
free(mmap_buffer);
mmap_buffer=NULL;
UBOOT_ERROR("read %s fail\n",MMAP_FILE_NAME);
return -1;
}
vfs_umount();
UBOOT_TRACE("OK\n");
return 0;
}
int vfs_mount(char *volume)
{
char *buffer=NULL;
char *pEnv=NULL;
char *pStr=NULL;
char *pStart=NULL;
char *pEnd=NULL;
int ret=-1;
UBOOT_TRACE("IN\n");
if(volume==NULL)
{
bVfsReady=FALSE;
UBOOT_ERROR("Input parameter 'volume' is a null pointer\n");
return -1;
}
buffer=malloc(CMD_BUF);
if(buffer==NULL)
{
bVfsReady=FALSE;
UBOOT_ERROR("malloc buffer fail\n");
return -1;
}
ret=vfs_umount();
if(ret==-1)
{
free(buffer);
bVfsReady=FALSE;
UBOOT_ERROR("umount previous filesystem fail\n");
return -1;
}
//Assume this volume is in UBI partition
memset(buffer,0,CMD_BUF);
snprintf(buffer,CMD_BUF,"ubi part %s",UBIPART);
ret=run_command(buffer,0);
if(ret!=-1)
{
memset(buffer,0,CMD_BUF);
snprintf(buffer,CMD_BUF,"ubifsmount %s",volume);
UBOOT_DEBUG("cmd=%s\n",buffer);
ret=run_command(buffer,0);
if(ret==-1)
{
UBOOT_ERROR("ubifsmount fail (Assume this volume is in UBI(or ubi) partition)\n");
}
else
{
free(buffer);
bVfsReady=TRUE;
UBOOT_TRACE("OK\n");
return ret;
}
}
//Check ever partition
pEnv=getenv("mtdparts");
if(pEnv==NULL)
{
free(buffer);
bVfsReady=FALSE;
UBOOT_ERROR("No MTD partition\n");
return ret;
}
else
{
pStr=malloc(strlen(pEnv)+1);
if(pStr==NULL)
{
free(buffer);
bVfsReady=FALSE;
UBOOT_ERROR("malloc fail\n");
return ret;
}
memset(pStr,0,strlen(pEnv)+1);
memcpy(pStr,pEnv,strlen(pEnv));
pStart=pStr;
while(1)
{
pStart=strchr(pStart,'(');
if(pStart==NULL)
{
free(buffer);
bVfsReady=FALSE;
UBOOT_ERROR("error partition symbol\n");
return -1;
}
else
{
UBOOT_DEBUG("pStart=%s\n",pStart);
pEnd=strchr(pStart,')');
if(pEnd==NULL)
{
free(buffer);
bVfsReady=FALSE;
UBOOT_ERROR("error partition symbol\n");
return -1;
}
else
{
UBOOT_DEBUG("pEnd=%s\n",pEnd);
*pEnd='\0';
memset(buffer,0,CMD_BUF);
snprintf(buffer,CMD_BUF,"ubi part %s",pStart+1);
UBOOT_DEBUG("cmd=%s\n",buffer);
ret=run_command(buffer,0);
if(ret!=-1)
{
memset(buffer,0,CMD_BUF);
snprintf(buffer,CMD_BUF,"ubifsmount %s",volume);
UBOOT_DEBUG("cmd=%s\n",buffer);
ret=run_command(buffer,0);
if(ret!=-1)
{
break;
}
}
pStart=pEnd+1;
}
}
}
}
free(buffer);
bVfsReady=TRUE;
UBOOT_TRACE("OK\n");
return 0;
}
