p71924506
/
kernel_liteos_a
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
kernel_liteos_a/fs/rootfs/los_rootfs.c

374 lines
12 KiB
C
Raw Blame History

/*
* Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
* Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this list of
* conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
* of conditions and the following disclaimer in the documentation and/or other materials
* provided with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its contributors may be used
* to endorse or promote products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "los_rootfs.h"
#include "los_bootargs.h"
#include "los_base.h"
#include "string.h"
#include "sys/mount.h"
#include "sys/stat.h"
#include "sys/types.h"
#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND) || defined(LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7)
#include "mtd_list.h"
#include "mtd_partition.h"
#endif
#ifdef LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7
#include "cfiflash.h"
#endif
#ifdef LOSCFG_STORAGE_EMMC
#include "disk.h"
#include "ff.h"
#endif
#ifdef LOSCFG_STORAGE_EMMC
struct disk_divide_info *StorageBlockGetEmmc(void);
struct block_operations *StorageBlockGetMmcOps(void);
char *StorageBlockGetEmmcNodeName(void *block);
STATIC INT32 AddEmmcParts(INT32 rootAddr, INT32 rootSize, INT32 userAddr, INT32 userSize)
{
INT32 ret;
los_disk *emmcDisk = los_get_mmcdisk_bytype(EMMC);
if (emmcDisk == NULL) {
PRINT_ERR("Get EMMC disk failed!\n");
return LOS_NOK;
}
void *block = ((struct drv_data *)emmcDisk->dev->data)->priv;
const char *node_name = StorageBlockGetEmmcNodeName(block);
if (los_disk_deinit(emmcDisk->disk_id) != ENOERR) {
PRINT_ERR("Failed to deinit emmc disk!\n");
return LOS_NOK;
}
struct disk_divide_info *emmc = StorageBlockGetEmmc();
ret = add_mmc_partition(emmc, rootAddr / EMMC_SEC_SIZE, rootSize / EMMC_SEC_SIZE);
if (ret != LOS_OK) {
PRINT_ERR("Failed to add mmc root partition!\n");
return LOS_NOK;
}
#ifdef LOSCFG_PLATFORM_PATCHFS
UINT64 patchStartCnt = userAddr / EMMC_SEC_SIZE;
UINT64 patchSizeCnt = PATCH_SIZE / EMMC_SEC_SIZE;
ret = add_mmc_partition(emmc, patchStartCnt, patchSizeCnt);
if (ret != LOS_OK) {
PRINT_ERR("Failed to add mmc patch partition!\n");
return LOS_NOK;
}
userAddr += PATCH_SIZE;
#endif
UINT64 storageStartCnt = userAddr / EMMC_SEC_SIZE;
UINT64 storageSizeCnt = userSize / EMMC_SEC_SIZE;
UINT64 userdataStartCnt = storageStartCnt + storageSizeCnt;
UINT64 userdataSizeCnt = emmcDisk->sector_count - userdataStartCnt;
ret = add_mmc_partition(emmc, storageStartCnt, storageSizeCnt);
if (ret != LOS_OK) {
PRINT_ERR("Failed to add mmc storage partition!\n");
return LOS_NOK;
}
ret = add_mmc_partition(emmc, userdataStartCnt, userdataSizeCnt);
if (ret != LOS_OK) {
PRINT_ERR("Failed to add mmc userdata partition!\n");
return LOS_NOK;
}
LOS_Msleep(10); /* 100, sleep time. waiting for device identification */
INT32 diskId = los_alloc_diskid_byname(node_name);
if (diskId < 0) {
PRINT_ERR("Failed to alloc disk %s!\n", node_name);
return LOS_NOK;
}
if (los_disk_init(node_name, StorageBlockGetMmcOps(), block, diskId, emmc) != ENOERR) {
PRINT_ERR("Failed to init emmc disk!\n");
return LOS_NOK;
}
return LOS_OK;
}
#endif
STATIC INT32 AddPartitions(CHAR *dev, UINT64 rootAddr, UINT64 rootSize, UINT64 userAddr, UINT64 userSize)
{
#ifdef LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7
if ((strcmp(dev, "cfi-flash") == 0) && (rootAddr != CFIFLASH_ROOT_ADDR)) {
PRINT_ERR("Error rootAddr, must be %#0x!\n", CFIFLASH_ROOT_ADDR);
return LOS_NOK;
}
#endif
#if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND) || defined(LOSCFG_PLATFORM_QEMU_ARM_VIRT_CA7)
INT32 ret;
INT32 blk0 = 0;
INT32 blk2 = 2;
if (strcmp(dev, "flash") == 0 || strcmp(dev, FLASH_TYPE) == 0) {
ret = add_mtd_partition(FLASH_TYPE, rootAddr, rootSize, blk0);
if (ret != LOS_OK) {
PRINT_ERR("Failed to add mtd root partition!\n");
return LOS_NOK;
}
ret = add_mtd_partition(FLASH_TYPE, userAddr, userSize, blk2);
if (ret != LOS_OK) {
PRINT_ERR("Failed to add mtd storage partition!\n");
return LOS_NOK;
}
return LOS_OK;
}
#endif
#ifdef LOSCFG_STORAGE_EMMC
if (strcmp(dev, "emmc") == 0) {
return AddEmmcParts(rootAddr, rootSize, userAddr, userSize);
}
#endif
PRINT_ERR("Unsupport dev type: %s\n", dev);
return LOS_NOK;
}
STATIC INT32 ParseRootArgs(CHAR **dev, CHAR **fstype, UINT64 *rootAddr, UINT64 *rootSize, UINT32 *mountFlags)
{
INT32 ret;
CHAR *rootAddrStr = NULL;
CHAR *rootSizeStr = NULL;
CHAR *rwTag = NULL;
ret = LOS_GetArgValue("root", dev);
if (ret != LOS_OK) {
PRINT_ERR("Cannot find root!");
return ret;
}
ret = LOS_GetArgValue("fstype", fstype);
if (ret != LOS_OK) {
PRINT_ERR("Cannot find fstype!");
return ret;
}
ret = LOS_GetArgValue("rootaddr", &rootAddrStr);
if (ret != LOS_OK) {
*rootAddr = ROOTFS_ADDR;
} else {
*rootAddr = LOS_SizeStrToNum(rootAddrStr);
}
ret = LOS_GetArgValue("rootsize", &rootSizeStr);
if (ret != LOS_OK) {
*rootSize = ROOTFS_SIZE;
} else {
*rootSize = LOS_SizeStrToNum(rootSizeStr);
}
ret = LOS_GetArgValue("ro", &rwTag);
if (ret == LOS_OK) {
*mountFlags = MS_RDONLY;
} else {
*mountFlags = 0;
}
return LOS_OK;
}
STATIC INT32 ParseUserArgs(UINT64 rootAddr, UINT64 rootSize, UINT64 *userAddr, UINT64 *userSize)
{
INT32 ret;
CHAR *userAddrStr = NULL;
CHAR *userSizeStr = NULL;
ret = LOS_GetArgValue("useraddr", &userAddrStr);
if (ret != LOS_OK) {
*userAddr = rootAddr + rootSize;
} else {
*userAddr = LOS_SizeStrToNum(userAddrStr);
}
ret = LOS_GetArgValue("usersize", &userSizeStr);
if (ret != LOS_OK) {
*userSize = USERFS_SIZE;
} else {
*userSize = LOS_SizeStrToNum(userSizeStr);
}
return LOS_OK;
}
STATIC INT32 MountPartitions(CHAR *fsType, UINT32 mountFlags)
{
INT32 ret;
INT32 err;
/* Mount rootfs */
ret = mount(ROOT_DEV_NAME, ROOT_DIR_NAME, fsType, mountFlags, NULL);
if (ret != LOS_OK) {
err = get_errno();
PRINT_ERR("Failed to mount %s, rootDev %s, errno %d: %s\n", ROOT_DIR_NAME, ROOT_DEV_NAME, err, strerror(err));
return ret;
}
#ifdef LOSCFG_STORAGE_EMMC
#ifdef LOSCFG_PLATFORM_PATCHFS
/* Mount patch */
ret = mkdir(PATCH_DIR_NAME, DEFAULT_MOUNT_DIR_MODE);
if ((ret != LOS_OK) && ((err = get_errno()) != EEXIST)) {
PRINT_ERR("Failed to mkdir %s, errno %d: %s\n", PATCH_DIR_NAME, err, strerror(err));
return ret;
}
ret = mount(PATCH_DEV_NAME, PATCH_DIR_NAME, fsType, 0, DEFAULT_MOUNT_DATA);
if ((ret != LOS_OK) && ((err = get_errno()) == ENOTSUP)) {
ret = format(PATCH_DEV_NAME, 0, FM_FAT32);
if (ret != LOS_OK) {
PRINT_ERR("Failed to format %s\n", PATCH_DEV_NAME);
return ret;
}
ret = mount(PATCH_DEV_NAME, PATCH_DIR_NAME, fsType, 0, DEFAULT_MOUNT_DATA);
if (ret != LOS_OK) {
err = get_errno();
}
}
if (ret != LOS_OK) {
PRINT_ERR("Failed to mount %s, errno %d: %s\n", PATCH_DIR_NAME, err, strerror(err));
return ret;
}
#endif
#endif
/* Mount userfs */
ret = mkdir(STORAGE_DIR_NAME, DEFAULT_MOUNT_DIR_MODE);
if ((ret != LOS_OK) && ((err = get_errno()) != EEXIST)) {
PRINT_ERR("Failed to mkdir %s, errno %d: %s\n", STORAGE_DIR_NAME, err, strerror(err));
return ret;
}
ret = mount(USER_DEV_NAME, STORAGE_DIR_NAME, fsType, 0, DEFAULT_MOUNT_DATA);
if (ret != LOS_OK) {
err = get_errno();
PRINT_ERR("Failed to mount %s, errno %d: %s\n", STORAGE_DIR_NAME, err, strerror(err));
return ret;
}
#ifdef LOSCFG_STORAGE_EMMC
/* Mount userdata */
ret = mkdir(USERDATA_DIR_NAME, DEFAULT_MOUNT_DIR_MODE);
if ((ret != LOS_OK) && ((err = get_errno()) != EEXIST)) {
PRINT_ERR("Failed to mkdir %s, errno %d: %s\n", USERDATA_DIR_NAME, err, strerror(err));
return ret;
}
ret = mount(USERDATA_DEV_NAME, USERDATA_DIR_NAME, fsType, 0, DEFAULT_MOUNT_DATA);
if ((ret != LOS_OK) && ((err = get_errno()) == ENOTSUP)) {
ret = format(USERDATA_DEV_NAME, 0, FM_FAT32);
if (ret != LOS_OK) {
PRINT_ERR("Failed to format %s\n", USERDATA_DEV_NAME);
return ret;
}
ret = mount(USERDATA_DEV_NAME, USERDATA_DIR_NAME, fsType, 0, DEFAULT_MOUNT_DATA);
if (ret != LOS_OK) {
err = get_errno();
}
}
if (ret != LOS_OK) {
PRINT_ERR("Failed to mount %s, errno %d: %s\n", USERDATA_DIR_NAME, err, strerror(err));
return ret;
}
#endif
return LOS_OK;
}
STATIC INT32 CheckValidation(UINT64 rootAddr, UINT64 rootSize, UINT64 userAddr, UINT64 userSize)
{
UINT64 alignSize = LOS_GetAlignsize();
if (alignSize == 0) {
return LOS_OK;
}
if ((rootAddr & (alignSize - 1)) || (rootSize & (alignSize - 1)) ||
(userAddr & (alignSize - 1)) || (userSize & (alignSize - 1))) {
PRINT_ERR("The address or size value should be 0x%x aligned!\n", alignSize);
return LOS_NOK;
}
return LOS_OK;
}
INT32 OsMountRootfs()
{
INT32 ret;
CHAR *dev = NULL;
CHAR *fstype = NULL;
UINT64 rootAddr;
UINT64 rootSize;
UINT64 userAddr;
UINT64 userSize;
UINT32 mountFlags;
ret = ParseRootArgs(&dev, &fstype, &rootAddr, &rootSize, &mountFlags);
if (ret != LOS_OK) {
return ret;
}
ret = ParseUserArgs(rootAddr, rootSize, &userAddr, &userSize);
if (ret != LOS_OK) {
return ret;
}
ret = CheckValidation(rootAddr, rootSize, userAddr, userSize);
if (ret != LOS_OK) {
return ret;
}
ret = AddPartitions(dev, rootAddr, rootSize, userAddr, userSize);
if (ret != LOS_OK) {
return ret;
}
ret = MountPartitions(fstype, mountFlags);
if (ret != LOS_OK) {
return ret;
}
return LOS_OK;
}
Reference in New Issue View Git Blame Copy Permalink