1 /*
2 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
3 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without modification,
6 * are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice, this list of
9 * conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
12 * of conditions and the following disclaimer in the documentation and/or other materials
13 * provided with the distribution.
14 *
15 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
16 * to endorse or promote products derived from this software without specific prior written
17 * permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
29 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include "los_rootfs.h"
33 #include "los_bootargs.h"
34 #include "los_base.h"
35 #include "string.h"
36 #include "sys/mount.h"
37 #include "sys/stat.h"
38 #include "sys/types.h"
39
40 #if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND)
41 #include "mtd_list.h"
42 #include "mtd_partition.h"
43 #endif
44
45 #ifdef LOSCFG_STORAGE_EMMC
46 #include "disk.h"
47 #include "ff.h"
48 #endif
49
50
51 #ifdef LOSCFG_STORAGE_EMMC
52 struct disk_divide_info *StorageBlockGetEmmc(void);
53 struct block_operations *StorageBlockGetMmcOps(void);
54 char *StorageBlockGetEmmcNodeName(void *block);
55
AddEmmcParts(INT32 rootAddr,INT32 rootSize,INT32 userAddr,INT32 userSize)56 STATIC INT32 AddEmmcParts(INT32 rootAddr, INT32 rootSize, INT32 userAddr, INT32 userSize)
57 {
58 INT32 ret;
59
60 los_disk *emmcDisk = los_get_mmcdisk_bytype(EMMC);
61 if (emmcDisk == NULL) {
62 PRINT_ERR("Get EMMC disk failed!\n");
63 return LOS_NOK;
64 }
65
66 void *block = ((struct drv_data *)emmcDisk->dev->data)->priv;
67 const char *node_name = StorageBlockGetEmmcNodeName(block);
68 if (los_disk_deinit(emmcDisk->disk_id) != ENOERR) {
69 PRINT_ERR("Failed to deinit emmc disk!\n");
70 return LOS_NOK;
71 }
72
73 struct disk_divide_info *emmc = StorageBlockGetEmmc();
74 ret = add_mmc_partition(emmc, rootAddr / EMMC_SEC_SIZE, rootSize / EMMC_SEC_SIZE);
75 if (ret != LOS_OK) {
76 PRINT_ERR("Failed to add mmc root partition!\n");
77 return LOS_NOK;
78 }
79
80 #ifdef LOSCFG_PLATFORM_PATCHFS
81 UINT64 patchStartCnt = userAddr / EMMC_SEC_SIZE;
82 UINT64 patchSizeCnt = PATCH_SIZE / EMMC_SEC_SIZE;
83 ret = add_mmc_partition(emmc, patchStartCnt, patchSizeCnt);
84 if (ret != LOS_OK) {
85 PRINT_ERR("Failed to add mmc patch partition!\n");
86 return LOS_NOK;
87 }
88 userAddr += PATCH_SIZE;
89 #endif
90
91 UINT64 storageStartCnt = userAddr / EMMC_SEC_SIZE;
92 UINT64 storageSizeCnt = userSize / EMMC_SEC_SIZE;
93 UINT64 userdataStartCnt = storageStartCnt + storageSizeCnt;
94 UINT64 userdataSizeCnt = emmcDisk->sector_count - userdataStartCnt;
95 ret = add_mmc_partition(emmc, storageStartCnt, storageSizeCnt);
96 if (ret != LOS_OK) {
97 PRINT_ERR("Failed to add mmc storage partition!\n");
98 return LOS_NOK;
99 }
100
101 ret = add_mmc_partition(emmc, userdataStartCnt, userdataSizeCnt);
102 if (ret != LOS_OK) {
103 PRINT_ERR("Failed to add mmc userdata partition!\n");
104 return LOS_NOK;
105 }
106
107 LOS_Msleep(10); /* 100, sleep time. waiting for device identification */
108
109 INT32 diskId = los_alloc_diskid_byname(node_name);
110 if (diskId < 0) {
111 PRINT_ERR("Failed to alloc disk %s!\n", node_name);
112 return LOS_NOK;
113 }
114
115 if (los_disk_init(node_name, StorageBlockGetMmcOps(), block, diskId, emmc) != ENOERR) {
116 PRINT_ERR("Failed to init emmc disk!\n");
117 return LOS_NOK;
118 }
119
120 return LOS_OK;
121 }
122 #endif
123
124
AddPartitions(CHAR * dev,UINT64 rootAddr,UINT64 rootSize,UINT64 userAddr,UINT64 userSize)125 STATIC INT32 AddPartitions(CHAR *dev, UINT64 rootAddr, UINT64 rootSize, UINT64 userAddr, UINT64 userSize)
126 {
127 #if defined(LOSCFG_STORAGE_SPINOR) || defined(LOSCFG_STORAGE_SPINAND)
128 INT32 ret;
129 INT32 blk0 = 0;
130 INT32 blk2 = 2;
131 if (strcmp(dev, "flash") == 0 || strcmp(dev, FLASH_TYPE) == 0) {
132 ret = add_mtd_partition(FLASH_TYPE, rootAddr, rootSize, blk0);
133 if (ret != LOS_OK) {
134 PRINT_ERR("Failed to add mtd root partition!\n");
135 return LOS_NOK;
136 }
137
138 ret = add_mtd_partition(FLASH_TYPE, userAddr, userSize, blk2);
139 if (ret != LOS_OK) {
140 PRINT_ERR("Failed to add mtd storage partition!\n");
141 return LOS_NOK;
142 }
143
144 return LOS_OK;
145 }
146 #endif
147
148 #ifdef LOSCFG_STORAGE_EMMC
149 if (strcmp(dev, "emmc") == 0) {
150 return AddEmmcParts(rootAddr, rootSize, userAddr, userSize);
151 }
152 #endif
153
154 PRINT_ERR("Unsupport dev type: %s\n", dev);
155 return LOS_NOK;
156 }
157
158
ParseRootArgs(CHAR ** dev,CHAR ** fstype,UINT64 * rootAddr,UINT64 * rootSize,UINT32 * mountFlags)159 STATIC INT32 ParseRootArgs(CHAR **dev, CHAR **fstype, UINT64 *rootAddr, UINT64 *rootSize, UINT32 *mountFlags)
160 {
161 INT32 ret;
162 CHAR *rootAddrStr = NULL;
163 CHAR *rootSizeStr = NULL;
164 CHAR *rwTag = NULL;
165
166 ret = LOS_GetArgValue("root", dev);
167 if (ret != LOS_OK) {
168 PRINT_ERR("Cannot find root!");
169 return ret;
170 }
171
172 ret = LOS_GetArgValue("fstype", fstype);
173 if (ret != LOS_OK) {
174 PRINT_ERR("Cannot find fstype!");
175 return ret;
176 }
177
178 ret = LOS_GetArgValue("rootaddr", &rootAddrStr);
179 if (ret != LOS_OK) {
180 *rootAddr = ROOTFS_ADDR;
181 } else {
182 *rootAddr = LOS_SizeStrToNum(rootAddrStr);
183 }
184
185 ret = LOS_GetArgValue("rootsize", &rootSizeStr);
186 if (ret != LOS_OK) {
187 *rootSize = ROOTFS_SIZE;
188 } else {
189 *rootSize = LOS_SizeStrToNum(rootSizeStr);
190 }
191
192 ret = LOS_GetArgValue("ro", &rwTag);
193 if (ret == LOS_OK) {
194 *mountFlags = MS_RDONLY;
195 } else {
196 *mountFlags = 0;
197 }
198
199 return LOS_OK;
200 }
201
ParseUserArgs(UINT64 rootAddr,UINT64 rootSize,UINT64 * userAddr,UINT64 * userSize)202 STATIC INT32 ParseUserArgs(UINT64 rootAddr, UINT64 rootSize, UINT64 *userAddr, UINT64 *userSize)
203 {
204 INT32 ret;
205 CHAR *userAddrStr = NULL;
206 CHAR *userSizeStr = NULL;
207
208 ret = LOS_GetArgValue("useraddr", &userAddrStr);
209 if (ret != LOS_OK) {
210 *userAddr = rootAddr + rootSize;
211 } else {
212 *userAddr = LOS_SizeStrToNum(userAddrStr);
213 }
214
215 ret = LOS_GetArgValue("usersize", &userSizeStr);
216 if (ret != LOS_OK) {
217 *userSize = USERFS_SIZE;
218 } else {
219 *userSize = LOS_SizeStrToNum(userSizeStr);
220 }
221
222 return LOS_OK;
223 }
224
MountPartitions(CHAR * fsType,UINT32 mountFlags)225 STATIC INT32 MountPartitions(CHAR *fsType, UINT32 mountFlags)
226 {
227 INT32 ret;
228 INT32 err;
229
230 /* Mount rootfs */
231 ret = mount(ROOT_DEV_NAME, ROOT_DIR_NAME, fsType, mountFlags, NULL);
232 if (ret != LOS_OK) {
233 err = get_errno();
234 PRINT_ERR("Failed to mount %s, rootDev %s, errno %d: %s\n", ROOT_DIR_NAME, ROOT_DEV_NAME, err, strerror(err));
235 return ret;
236 }
237
238 #ifdef LOSCFG_STORAGE_EMMC
239 #ifdef LOSCFG_PLATFORM_PATCHFS
240 /* Mount patch */
241 ret = mkdir(PATCH_DIR_NAME, DEFAULT_MOUNT_DIR_MODE);
242 if ((ret != LOS_OK) && ((err = get_errno()) != EEXIST)) {
243 PRINT_ERR("Failed to mkdir %s, errno %d: %s\n", PATCH_DIR_NAME, err, strerror(err));
244 return ret;
245 }
246
247 ret = mount(PATCH_DEV_NAME, PATCH_DIR_NAME, fsType, 0, DEFAULT_MOUNT_DATA);
248 if ((ret != LOS_OK) && ((err = get_errno()) == ENOTSUP)) {
249 ret = format(PATCH_DEV_NAME, 0, FM_FAT32);
250 if (ret != LOS_OK) {
251 PRINT_ERR("Failed to format %s\n", PATCH_DEV_NAME);
252 return ret;
253 }
254
255 ret = mount(PATCH_DEV_NAME, PATCH_DIR_NAME, fsType, 0, DEFAULT_MOUNT_DATA);
256 if (ret != LOS_OK) {
257 err = get_errno();
258 }
259 }
260 if (ret != LOS_OK) {
261 PRINT_ERR("Failed to mount %s, errno %d: %s\n", PATCH_DIR_NAME, err, strerror(err));
262 return ret;
263 }
264 #endif
265 #endif
266
267 /* Mount userfs */
268 ret = mkdir(STORAGE_DIR_NAME, DEFAULT_MOUNT_DIR_MODE);
269 if ((ret != LOS_OK) && ((err = get_errno()) != EEXIST)) {
270 PRINT_ERR("Failed to mkdir %s, errno %d: %s\n", STORAGE_DIR_NAME, err, strerror(err));
271 return ret;
272 }
273
274 ret = mount(USER_DEV_NAME, STORAGE_DIR_NAME, fsType, 0, DEFAULT_MOUNT_DATA);
275 if (ret != LOS_OK) {
276 err = get_errno();
277 PRINT_ERR("Failed to mount %s, errno %d: %s\n", STORAGE_DIR_NAME, err, strerror(err));
278 return ret;
279 }
280
281 #ifdef LOSCFG_STORAGE_EMMC
282 /* Mount userdata */
283 ret = mkdir(USERDATA_DIR_NAME, DEFAULT_MOUNT_DIR_MODE);
284 if ((ret != LOS_OK) && ((err = get_errno()) != EEXIST)) {
285 PRINT_ERR("Failed to mkdir %s, errno %d: %s\n", USERDATA_DIR_NAME, err, strerror(err));
286 return ret;
287 }
288
289 ret = mount(USERDATA_DEV_NAME, USERDATA_DIR_NAME, fsType, 0, DEFAULT_MOUNT_DATA);
290 if ((ret != LOS_OK) && ((err = get_errno()) == ENOTSUP)) {
291 ret = format(USERDATA_DEV_NAME, 0, FM_FAT32);
292 if (ret != LOS_OK) {
293 PRINT_ERR("Failed to format %s\n", USERDATA_DEV_NAME);
294 return ret;
295 }
296
297 ret = mount(USERDATA_DEV_NAME, USERDATA_DIR_NAME, fsType, 0, DEFAULT_MOUNT_DATA);
298 if (ret != LOS_OK) {
299 err = get_errno();
300 }
301 }
302 if (ret != LOS_OK) {
303 PRINT_ERR("Failed to mount %s, errno %d: %s\n", USERDATA_DIR_NAME, err, strerror(err));
304 return ret;
305 }
306 #endif
307 return LOS_OK;
308 }
309
CheckValidation(UINT64 rootAddr,UINT64 rootSize,UINT64 userAddr,UINT64 userSize)310 STATIC INT32 CheckValidation(UINT64 rootAddr, UINT64 rootSize, UINT64 userAddr, UINT64 userSize)
311 {
312 UINT64 alignSize = LOS_GetAlignsize();
313 if (alignSize == 0) {
314 return LOS_OK;
315 }
316
317 if ((rootAddr & (alignSize - 1)) || (rootSize & (alignSize - 1)) ||
318 (userAddr & (alignSize - 1)) || (userSize & (alignSize - 1))) {
319 PRINT_ERR("The address or size value should be 0x%llx aligned!\n", alignSize);
320 return LOS_NOK;
321 }
322
323 return LOS_OK;
324 }
325
OsMountRootfs()326 INT32 OsMountRootfs()
327 {
328 INT32 ret;
329 CHAR *dev = NULL;
330 CHAR *fstype = NULL;
331 UINT64 rootAddr;
332 UINT64 rootSize;
333 UINT64 userAddr;
334 UINT64 userSize;
335 UINT32 mountFlags;
336
337 ret = ParseRootArgs(&dev, &fstype, &rootAddr, &rootSize, &mountFlags);
338 if (ret != LOS_OK) {
339 return ret;
340 }
341
342 ret = ParseUserArgs(rootAddr, rootSize, &userAddr, &userSize);
343 if (ret != LOS_OK) {
344 return ret;
345 }
346
347 ret = CheckValidation(rootAddr, rootSize, userAddr, userSize);
348 if (ret != LOS_OK) {
349 return ret;
350 }
351
352 ret = AddPartitions(dev, rootAddr, rootSize, userAddr, userSize);
353 if (ret != LOS_OK) {
354 return ret;
355 }
356
357 ret = MountPartitions(fstype, mountFlags);
358 if (ret != LOS_OK) {
359 return ret;
360 }
361
362 return LOS_OK;
363 }
364