pal_fileSystem.c

00001 /*******************************************************************************
00002  * Copyright 2016, 2017 ARM Ltd.
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  *******************************************************************************/
00016 /*
00017  * 2.c
00018  *
00019  *  Created on: 22 Jan 2017
00020  *      Author: alonof01
00021  */
00022 
00023 #include "pal.h"
00024 #include "pal_fileSystem.h"
00025 #include "pal_plat_fileSystem.h"
00026 
00027 #define TRACE_GROUP "PAL"
00028 
00029 PAL_PRIVATE char* g_RootFolder[PAL_FS_PARTITION_LAST] = { NULL , NULL };      //!< global var that holds the  root folder
00030 PAL_PRIVATE bool g_RootFolderIsSet[PAL_FS_PARTITION_LAST] = { false, false };    //!< global var that holds the state root folder
00031 
00032 
00033 void pal_fsCleanup()
00034 {
00035     if (NULL != g_RootFolder[PAL_FS_PARTITION_PRIMARY])
00036     {
00037         free(g_RootFolder[PAL_FS_PARTITION_PRIMARY]);
00038         g_RootFolder[PAL_FS_PARTITION_PRIMARY] = NULL;
00039     }
00040 
00041     if (NULL != g_RootFolder[PAL_FS_PARTITION_SECONDARY])
00042     {
00043         free(g_RootFolder[PAL_FS_PARTITION_SECONDARY]);
00044         g_RootFolder[PAL_FS_PARTITION_SECONDARY] = NULL;
00045     }
00046 
00047     g_RootFolder[PAL_FS_PARTITION_SECONDARY] = NULL;
00048     g_RootFolderIsSet[PAL_FS_PARTITION_PRIMARY] = false;
00049     g_RootFolderIsSet[PAL_FS_PARTITION_SECONDARY] = false;
00050 }
00051 
00052 
00053 
00054 palStatus_t pal_fsMkDir(const char *pathName)
00055 {
00056     palStatus_t ret = PAL_SUCCESS;
00057     PAL_VALIDATE_CONDITION_WITH_ERROR((pathName == NULL), PAL_ERR_FS_INVALID_FILE_NAME)
00058     PAL_VALIDATE_CONDITION_WITH_ERROR((pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FOLDER_DEPTH_CHAR), PAL_ERR_FS_FILENAME_LENGTH)
00059 
00060     ret = pal_plat_fsMkdir(pathName);
00061     if ((PAL_SUCCESS != ret) && (PAL_ERR_FS_NAME_ALREADY_EXIST != ret))
00062     {
00063         PAL_LOG_ERR("Failed to create folder, was the storage properly initialized?");
00064     }
00065 
00066     return ret;
00067 }
00068 
00069 
00070 
00071 palStatus_t pal_fsRmDir(const char *pathName)
00072 {
00073     palStatus_t ret = PAL_SUCCESS;
00074     PAL_VALIDATE_CONDITION_WITH_ERROR((pathName == NULL), PAL_ERR_FS_INVALID_FILE_NAME)
00075     PAL_VALIDATE_CONDITION_WITH_ERROR((pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FOLDER_DEPTH_CHAR), PAL_ERR_FS_FILENAME_LENGTH)
00076 
00077     ret = pal_plat_fsRmdir(pathName);
00078     return ret;
00079 }
00080 
00081 palStatus_t pal_fsFopen(const char *pathName, pal_fsFileMode_t mode, palFileDescriptor_t *fd)
00082 {
00083     palStatus_t ret = PAL_SUCCESS;
00084 
00085     PAL_VALIDATE_CONDITION_WITH_ERROR((fd == NULL), PAL_ERR_FS_INVALID_ARGUMENT)
00086     PAL_VALIDATE_CONDITION_WITH_ERROR((pathName == NULL), PAL_ERR_FS_INVALID_FILE_NAME)
00087     PAL_VALIDATE_CONDITION_WITH_ERROR((pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FOLDER_DEPTH_CHAR), PAL_ERR_FS_FILENAME_LENGTH)
00088     PAL_VALIDATE_CONDITION_WITH_ERROR((!((mode > PAL_FS_FLAG_KEEP_FIRST) && (mode < PAL_FS_FLAG_KEEP_LAST))), PAL_ERR_FS_INVALID_OPEN_FLAGS)
00089 
00090     ret = pal_plat_fsFopen(pathName,  mode, fd);
00091     if (ret != PAL_SUCCESS)
00092     {
00093         *fd = 0;
00094     }
00095     return ret;
00096 }
00097 
00098 
00099 palStatus_t pal_fsFclose(palFileDescriptor_t *fd)
00100 {
00101     palStatus_t ret = PAL_SUCCESS;
00102     PAL_VALIDATE_CONDITION_WITH_ERROR((fd == NULL), PAL_ERR_FS_INVALID_ARGUMENT)
00103     PAL_VALIDATE_CONDITION_WITH_ERROR((*fd == 0), PAL_ERR_FS_BAD_FD)
00104 
00105     ret = pal_plat_fsFclose(fd);
00106     *fd = 0;
00107     return ret;
00108 }
00109 
00110 
00111 palStatus_t pal_fsFread(palFileDescriptor_t *fd, void * buffer, size_t numOfBytes, size_t *numberOfBytesRead)
00112 {
00113     palStatus_t ret = PAL_SUCCESS;
00114     *numberOfBytesRead = 0;
00115     PAL_VALIDATE_CONDITION_WITH_ERROR((*fd == 0), PAL_ERR_FS_BAD_FD)
00116     PAL_VALIDATE_CONDITION_WITH_ERROR((buffer == NULL), PAL_ERR_FS_BUFFER_ERROR)
00117 
00118     ret = pal_plat_fsFread(fd, buffer, numOfBytes, numberOfBytesRead);
00119     return ret;
00120 }
00121 
00122 
00123 palStatus_t pal_fsFwrite(palFileDescriptor_t *fd, const void * buffer, size_t numOfBytes, size_t *numberOfBytesWritten)
00124 {
00125     palStatus_t ret = PAL_SUCCESS;
00126     *numberOfBytesWritten = 0;
00127     PAL_VALIDATE_CONDITION_WITH_ERROR((*fd == 0), PAL_ERR_FS_BAD_FD)
00128     PAL_VALIDATE_CONDITION_WITH_ERROR((numOfBytes == 0), PAL_ERR_FS_LENGTH_ERROR)
00129     PAL_VALIDATE_CONDITION_WITH_ERROR((buffer == NULL), PAL_ERR_FS_BUFFER_ERROR)
00130 
00131     ret = pal_plat_fsFwrite(fd, buffer, numOfBytes, numberOfBytesWritten);
00132     return ret;
00133 }
00134 
00135 
00136 palStatus_t pal_fsFseek(palFileDescriptor_t *fd, int32_t offset, pal_fsOffset_t whence)
00137 {
00138     palStatus_t ret = PAL_SUCCESS;
00139     PAL_VALIDATE_CONDITION_WITH_ERROR((*fd == 0), PAL_ERR_FS_BAD_FD)
00140     PAL_VALIDATE_CONDITION_WITH_ERROR((!((whence < PAL_FS_OFFSET_KEEP_LAST) && (whence > PAL_FS_OFFSET_KEEP_FIRST))), PAL_ERR_FS_OFFSET_ERROR)
00141 
00142     ret = pal_plat_fsFseek(fd, offset, whence);
00143     return ret;
00144 }
00145 
00146 
00147 palStatus_t pal_fsFtell(palFileDescriptor_t *fd, int32_t *pos)
00148 {
00149     palStatus_t ret = PAL_SUCCESS;
00150     PAL_VALIDATE_CONDITION_WITH_ERROR((*fd == 0), PAL_ERR_FS_BAD_FD)
00151 
00152     ret = pal_plat_fsFtell(fd, pos);
00153     return ret;
00154 }
00155 
00156 palStatus_t pal_fsUnlink(const char *pathName)
00157 {
00158     palStatus_t ret = PAL_SUCCESS;
00159     PAL_VALIDATE_CONDITION_WITH_ERROR((pathName == NULL), PAL_ERR_FS_INVALID_FILE_NAME)
00160     PAL_VALIDATE_CONDITION_WITH_ERROR((pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FULL_FILE_NAME), PAL_ERR_FS_FILENAME_LENGTH)
00161 
00162     ret = pal_plat_fsUnlink(pathName);
00163     return ret;
00164 }
00165 
00166 
00167 
00168 palStatus_t pal_fsRmFiles(const char *pathName)
00169 {
00170     palStatus_t ret = PAL_SUCCESS;
00171     PAL_VALIDATE_CONDITION_WITH_ERROR((pathName == NULL), PAL_ERR_FS_INVALID_FILE_NAME)
00172     PAL_VALIDATE_CONDITION_WITH_ERROR((pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FOLDER_DEPTH_CHAR), PAL_ERR_FS_FILENAME_LENGTH)
00173 
00174     ret = pal_plat_fsRmFiles(pathName);
00175     return ret;
00176 }
00177 
00178 
00179 palStatus_t pal_fsCpFolder(const char *pathNameSrc,  char *pathNameDest)
00180 {
00181     palStatus_t ret = PAL_SUCCESS;
00182     PAL_VALIDATE_CONDITION_WITH_ERROR(((pathNameSrc == NULL) || ((pathNameDest == NULL))), PAL_ERR_FS_INVALID_FILE_NAME)
00183     PAL_VALIDATE_CONDITION_WITH_ERROR(((pal_plat_fsSizeCheck(pathNameSrc) >= PAL_MAX_FOLDER_DEPTH_CHAR) || (pal_plat_fsSizeCheck(pathNameDest) >= PAL_MAX_FOLDER_DEPTH_CHAR)), PAL_ERR_FS_FILENAME_LENGTH)
00184 
00185     ret = pal_plat_fsCpFolder(pathNameSrc, pathNameDest);
00186     return ret;
00187 }
00188 
00189 
00190 
00191 palStatus_t pal_fsSetMountPoint(pal_fsStorageID_t dataID, const char *path)
00192 {
00193     palStatus_t ret = PAL_SUCCESS;
00194     PAL_VALIDATE_CONDITION_WITH_ERROR(((dataID >= PAL_FS_PARTITION_LAST) || (NULL == path)), PAL_ERR_FS_INVALID_FILE_NAME)
00195     PAL_VALIDATE_CONDITION_WITH_ERROR((pal_plat_fsSizeCheck(path) >= PAL_MAX_FOLDER_DEPTH_CHAR), PAL_ERR_FS_FILENAME_LENGTH)
00196 
00197     if (g_RootFolderIsSet[dataID])
00198     {
00199         ret = PAL_ERR_FS_ERROR;
00200     }
00201     else
00202     {
00203         if (NULL == g_RootFolder[dataID])
00204         {
00205             g_RootFolder[dataID] = (char*)malloc(PAL_MAX_FOLDER_DEPTH_CHAR);
00206             if (NULL == g_RootFolder[dataID])
00207             {
00208                 return PAL_ERR_NO_MEMORY ;
00209             }
00210             g_RootFolder[dataID][0] = 0;
00211         }
00212         strncat( g_RootFolder[dataID], path, PAL_MAX_FOLDER_DEPTH_CHAR - pal_plat_fsSizeCheck(g_RootFolder[dataID]));// same buffer is used for active backup root dirs using indexing
00213         g_RootFolderIsSet[dataID] = true;
00214     }
00215     return ret;
00216 }
00217 
00218 palStatus_t pal_fsGetMountPoint(pal_fsStorageID_t dataID, size_t length, char *path)
00219 {
00220     palStatus_t ret = PAL_SUCCESS;
00221 
00222     PAL_VALIDATE_CONDITION_WITH_ERROR((dataID >= PAL_FS_PARTITION_LAST), PAL_ERR_INVALID_ARGUMENT )
00223     PAL_VALIDATE_CONDITION_WITH_ERROR((length < PAL_MAX_FOLDER_DEPTH_CHAR), PAL_ERR_FS_LENGTH_ERROR)
00224 
00225     if (path)
00226     {
00227         if (false == g_RootFolderIsSet[dataID])
00228         {
00229             strncpy(path, pal_plat_fsGetDefaultRootFolder(dataID), length);
00230         }
00231         else 
00232         {
00233             strncpy(path, g_RootFolder[dataID], length); // same buffer is used for active backup root dirs using indexing
00234         }
00235         
00236     }
00237     else
00238     {
00239         ret = PAL_ERR_FS_BUFFER_ERROR;
00240     }
00241     return ret;
00242 }
00243 
00244 
00245 palStatus_t pal_fsFormat(pal_fsStorageID_t dataID)
00246 {
00247     palStatus_t ret = PAL_SUCCESS;
00248     PAL_VALIDATE_CONDITION_WITH_ERROR((((int32_t)dataID < PAL_FS_PARTITION_PRIMARY) || ((int32_t)dataID >= PAL_FS_PARTITION_LAST)), PAL_ERR_INVALID_ARGUMENT )
00249 
00250 #if PAL_SIMULATOR_FS_RM_INSTEAD_OF_FORMAT //Simulator    
00251     char rootFolder[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0};
00252     ret = pal_fsGetMountPoint(dataID, PAL_MAX_FILE_AND_FOLDER_LENGTH, rootFolder);
00253     if (PAL_SUCCESS == ret)
00254     {
00255         ret = pal_plat_fsRmFiles(rootFolder);
00256         if (PAL_SUCCESS != ret)
00257         {
00258             PAL_LOG_ERR("(%s:%d) pal_plat_fsRmFiles  failed ",__FILE__,__LINE__);
00259         }
00260     }
00261 #else //Real life scenario
00262     ret = pal_plat_fsFormat(dataID);
00263 #endif        
00264     
00265     return ret;
00266 }
00267 
00268 
00269 
00270 
00271 bool pal_fsIsPrivatePartition(pal_fsStorageID_t dataID)
00272 {
00273     bool isPrivate;
00274     if (PAL_FS_PARTITION_PRIMARY == dataID)
00275     {
00276         isPrivate = PAL_PRIMARY_PARTITION_PRIVATE;
00277     }
00278     else
00279     {
00280         isPrivate = PAL_SECONDARY_PARTITION_PRIVATE;
00281     }
00282     return isPrivate;
00283 }