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 PAL_PRIVATE char* g_RootFolder[PAL_FS_PARTITION_LAST] = { NULL , NULL };      //!< global var that holds the  root folder
00028 PAL_PRIVATE bool g_RootFolderIsSet[PAL_FS_PARTITION_LAST] = { false, false };    //!< global var that holds the state root folder
00029 
00030 
00031 void pal_fsCleanup()
00032 {
00033     if (NULL != g_RootFolder[PAL_FS_PARTITION_PRIMARY])
00034     {
00035         free(g_RootFolder[PAL_FS_PARTITION_PRIMARY]);
00036         g_RootFolder[PAL_FS_PARTITION_PRIMARY] = NULL;
00037     }
00038 
00039     if (NULL != g_RootFolder[PAL_FS_PARTITION_SECONDARY])
00040     {
00041         free(g_RootFolder[PAL_FS_PARTITION_SECONDARY]);
00042         g_RootFolder[PAL_FS_PARTITION_SECONDARY] = NULL;
00043     }
00044 
00045     g_RootFolder[PAL_FS_PARTITION_SECONDARY] = NULL;
00046     g_RootFolderIsSet[PAL_FS_PARTITION_PRIMARY] = false;
00047     g_RootFolderIsSet[PAL_FS_PARTITION_SECONDARY] = false;
00048 }
00049 
00050 
00051 
00052 palStatus_t pal_fsMkDir(const char *pathName)
00053 {
00054     palStatus_t ret = PAL_SUCCESS;
00055     PAL_VALIDATE_CONDITION_WITH_ERROR((pathName == NULL), PAL_ERR_FS_INVALID_FILE_NAME)
00056     PAL_VALIDATE_CONDITION_WITH_ERROR((pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FOLDER_DEPTH_CHAR), PAL_ERR_FS_FILENAME_LENGTH)
00057 
00058     ret = pal_plat_fsMkdir(pathName);
00059     if ((PAL_SUCCESS != ret) && (PAL_ERR_FS_NAME_ALREADY_EXIST != ret))
00060     {
00061         PAL_LOG(ERR, "Failed to create folder, was the storage properly initialized?");
00062     }
00063 
00064     return ret;
00065 }
00066 
00067 
00068 
00069 palStatus_t pal_fsRmDir(const char *pathName)
00070 {
00071     palStatus_t ret = PAL_SUCCESS;
00072     PAL_VALIDATE_CONDITION_WITH_ERROR((pathName == NULL), PAL_ERR_FS_INVALID_FILE_NAME)
00073     PAL_VALIDATE_CONDITION_WITH_ERROR((pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FOLDER_DEPTH_CHAR), PAL_ERR_FS_FILENAME_LENGTH)
00074 
00075     ret = pal_plat_fsRmdir(pathName);
00076     return ret;
00077 }
00078 
00079 palStatus_t pal_fsFopen(const char *pathName, pal_fsFileMode_t mode, palFileDescriptor_t *fd)
00080 {
00081     palStatus_t ret = PAL_SUCCESS;
00082 
00083     PAL_VALIDATE_CONDITION_WITH_ERROR((fd == NULL), PAL_ERR_FS_INVALID_ARGUMENT)
00084     PAL_VALIDATE_CONDITION_WITH_ERROR((pathName == NULL), PAL_ERR_FS_INVALID_FILE_NAME)
00085     PAL_VALIDATE_CONDITION_WITH_ERROR((pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FOLDER_DEPTH_CHAR), PAL_ERR_FS_FILENAME_LENGTH)
00086     PAL_VALIDATE_CONDITION_WITH_ERROR((!((mode > PAL_FS_FLAG_KEEP_FIRST) && (mode < PAL_FS_FLAG_KEEP_LAST))), PAL_ERR_FS_INVALID_OPEN_FLAGS)
00087 
00088     ret = pal_plat_fsFopen(pathName,  mode, fd);
00089     if (ret != PAL_SUCCESS)
00090     {
00091         *fd = 0;
00092     }
00093     return ret;
00094 }
00095 
00096 
00097 palStatus_t pal_fsFclose(palFileDescriptor_t *fd)
00098 {
00099     palStatus_t ret = PAL_SUCCESS;
00100     PAL_VALIDATE_CONDITION_WITH_ERROR((fd == NULL), PAL_ERR_FS_INVALID_ARGUMENT)
00101     PAL_VALIDATE_CONDITION_WITH_ERROR((*fd == 0), PAL_ERR_FS_BAD_FD)
00102 
00103     ret = pal_plat_fsFclose(fd);
00104     *fd = 0;
00105     return ret;
00106 }
00107 
00108 
00109 palStatus_t pal_fsFread(palFileDescriptor_t *fd, void * buffer, size_t numOfBytes, size_t *numberOfBytesRead)
00110 {
00111     palStatus_t ret = PAL_SUCCESS;
00112     *numberOfBytesRead = 0;
00113     PAL_VALIDATE_CONDITION_WITH_ERROR((*fd == 0), PAL_ERR_FS_BAD_FD)
00114     PAL_VALIDATE_CONDITION_WITH_ERROR((buffer == NULL), PAL_ERR_FS_BUFFER_ERROR)
00115 
00116     ret = pal_plat_fsFread(fd, buffer, numOfBytes, numberOfBytesRead);
00117     return ret;
00118 }
00119 
00120 
00121 palStatus_t pal_fsFwrite(palFileDescriptor_t *fd, const void * buffer, size_t numOfBytes, size_t *numberOfBytesWritten)
00122 {
00123     palStatus_t ret = PAL_SUCCESS;
00124     *numberOfBytesWritten = 0;
00125     PAL_VALIDATE_CONDITION_WITH_ERROR((*fd == 0), PAL_ERR_FS_BAD_FD)
00126     PAL_VALIDATE_CONDITION_WITH_ERROR((numOfBytes == 0), PAL_ERR_FS_LENGTH_ERROR)
00127     PAL_VALIDATE_CONDITION_WITH_ERROR((buffer == NULL), PAL_ERR_FS_BUFFER_ERROR)
00128 
00129     ret = pal_plat_fsFwrite(fd, buffer, numOfBytes, numberOfBytesWritten);
00130     return ret;
00131 }
00132 
00133 
00134 palStatus_t pal_fsFseek(palFileDescriptor_t *fd, int32_t offset, pal_fsOffset_t whence)
00135 {
00136     palStatus_t ret = PAL_SUCCESS;
00137     PAL_VALIDATE_CONDITION_WITH_ERROR((*fd == 0), PAL_ERR_FS_BAD_FD)
00138     PAL_VALIDATE_CONDITION_WITH_ERROR((!((whence < PAL_FS_OFFSET_KEEP_LAST) && (whence > PAL_FS_OFFSET_KEEP_FIRST))), PAL_ERR_FS_OFFSET_ERROR)
00139 
00140     ret = pal_plat_fsFseek(fd, offset, whence);
00141     return ret;
00142 }
00143 
00144 
00145 palStatus_t pal_fsFtell(palFileDescriptor_t *fd, int32_t *pos)
00146 {
00147     palStatus_t ret = PAL_SUCCESS;
00148     PAL_VALIDATE_CONDITION_WITH_ERROR((*fd == 0), PAL_ERR_FS_BAD_FD)
00149 
00150     ret = pal_plat_fsFtell(fd, pos);
00151     return ret;
00152 }
00153 
00154 palStatus_t pal_fsUnlink(const char *pathName)
00155 {
00156     palStatus_t ret = PAL_SUCCESS;
00157     PAL_VALIDATE_CONDITION_WITH_ERROR((pathName == NULL), PAL_ERR_FS_INVALID_FILE_NAME)
00158     PAL_VALIDATE_CONDITION_WITH_ERROR((pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FULL_FILE_NAME), PAL_ERR_FS_FILENAME_LENGTH)
00159 
00160     ret = pal_plat_fsUnlink(pathName);
00161     return ret;
00162 }
00163 
00164 
00165 
00166 palStatus_t pal_fsRmFiles(const char *pathName)
00167 {
00168     palStatus_t ret = PAL_SUCCESS;
00169     PAL_VALIDATE_CONDITION_WITH_ERROR((pathName == NULL), PAL_ERR_FS_INVALID_FILE_NAME)
00170     PAL_VALIDATE_CONDITION_WITH_ERROR((pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FOLDER_DEPTH_CHAR), PAL_ERR_FS_FILENAME_LENGTH)
00171 
00172     ret = pal_plat_fsRmFiles(pathName);
00173     return ret;
00174 }
00175 
00176 
00177 palStatus_t pal_fsCpFolder(const char *pathNameSrc,  char *pathNameDest)
00178 {
00179     palStatus_t ret = PAL_SUCCESS;
00180     PAL_VALIDATE_CONDITION_WITH_ERROR(((pathNameSrc == NULL) || ((pathNameDest == NULL))), PAL_ERR_FS_INVALID_FILE_NAME)
00181     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)
00182 
00183     ret = pal_plat_fsCpFolder(pathNameSrc, pathNameDest);
00184     return ret;
00185 }
00186 
00187 
00188 
00189 palStatus_t pal_fsSetMountPoint(pal_fsStorageID_t dataID, const char *path)
00190 {
00191     palStatus_t ret = PAL_SUCCESS;
00192     PAL_VALIDATE_CONDITION_WITH_ERROR(((dataID >= PAL_FS_PARTITION_LAST) || (NULL == path)), PAL_ERR_FS_INVALID_FILE_NAME)
00193     PAL_VALIDATE_CONDITION_WITH_ERROR((pal_plat_fsSizeCheck(path) >= PAL_MAX_FOLDER_DEPTH_CHAR), PAL_ERR_FS_FILENAME_LENGTH)
00194 
00195     if (g_RootFolderIsSet[dataID])
00196     {
00197         ret = PAL_ERR_FS_ERROR;
00198     }
00199     else
00200     {
00201         if (NULL == g_RootFolder[dataID])
00202         {
00203             g_RootFolder[dataID] = (char*)malloc(PAL_MAX_FOLDER_DEPTH_CHAR);
00204             if (NULL == g_RootFolder[dataID])
00205             {
00206                 return PAL_ERR_NO_MEMORY ;
00207             }
00208             g_RootFolder[dataID][0] = NULLPTR;
00209         }
00210         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
00211         g_RootFolderIsSet[dataID] = true;
00212     }
00213     return ret;
00214 }
00215 
00216 palStatus_t pal_fsGetMountPoint(pal_fsStorageID_t dataID, size_t length, char *path)
00217 {
00218     palStatus_t ret = PAL_SUCCESS;
00219 
00220     PAL_VALIDATE_CONDITION_WITH_ERROR((dataID >= PAL_FS_PARTITION_LAST), PAL_ERR_INVALID_ARGUMENT )
00221     PAL_VALIDATE_CONDITION_WITH_ERROR((length < PAL_MAX_FOLDER_DEPTH_CHAR), PAL_ERR_FS_LENGTH_ERROR)
00222 
00223     if (path)
00224     {
00225         if (false == g_RootFolderIsSet[dataID])
00226         {
00227             strncpy(path, pal_plat_fsGetDefaultRootFolder(dataID), length);
00228         }
00229         else 
00230         {
00231             strncpy(path, g_RootFolder[dataID], length); // same buffer is used for active backup root dirs using indexing
00232         }
00233         
00234     }
00235     else
00236     {
00237         ret = PAL_ERR_FS_BUFFER_ERROR;
00238     }
00239     return ret;
00240 }
00241 
00242 
00243 palStatus_t pal_fsFormat(pal_fsStorageID_t dataID)
00244 {
00245     palStatus_t ret = PAL_SUCCESS;
00246     PAL_VALIDATE_CONDITION_WITH_ERROR((((int32_t)dataID < PAL_FS_PARTITION_PRIMARY) || ((int32_t)dataID >= PAL_FS_PARTITION_LAST)), PAL_ERR_INVALID_ARGUMENT )
00247 
00248 #if PAL_SIMULATOR_FS_RM_INSTEAD_OF_FORMAT //Simulator    
00249     char rootFolder[PAL_MAX_FILE_AND_FOLDER_LENGTH] = {0};
00250     ret = pal_fsGetMountPoint(dataID, PAL_MAX_FILE_AND_FOLDER_LENGTH, rootFolder);
00251     if (PAL_SUCCESS == ret)
00252     {
00253         ret = pal_plat_fsRmFiles(rootFolder);
00254         if (PAL_SUCCESS != ret)
00255         {
00256             PAL_LOG(ERR,"(%s:%d) pal_plat_fsRmFiles  failed ",__FILE__,__LINE__);
00257         }
00258     }
00259 #else //Real life scenario
00260     ret = pal_plat_fsFormat(dataID);
00261 #endif        
00262     
00263     return ret;
00264 }
00265 
00266 
00267 
00268 
00269 bool pal_fsIsPrivatePartition(pal_fsStorageID_t dataID)
00270 {
00271     bool isPrivate;
00272     if (PAL_FS_PARTITION_PRIMARY == dataID)
00273     {
00274         isPrivate = PAL_PRIMARY_PARTITION_PRIVATE;
00275     }
00276     else
00277     {
00278         isPrivate = PAL_SECONDARY_PARTITION_PRIVATE;
00279     }
00280     return isPrivate;
00281 }