1 /* 2 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 #include "FileSystemTest.h" 16 #include <stdio.h> 17 #include <string.h> 18 #include <stdlib.h> 19 20 #include <sys/stat.h> 21 #include <sys/types.h> 22 #include <sys/statvfs.h> 23 #include <fcntl.h> 24 #include <unistd.h> 25 #include <dirent.h> 26 #include <ftw.h> 27 #include <libgen.h> 28 29 #include <gtest/gtest.h> 30 31 #include "utils.h" 32 #include "log.h" 33 #include "KernelConstants.h" 34 #include "libfs.h" 35 36 using namespace testing::ext; 37 38 #if defined(LITE_FS_NFS) || defined(LITE_FS_VFAT) 39 /** 40 * @tc.number SUB_KERNEL_FS_FCNTL_0100 41 * @tc.name basic function test : Test fcntl, use F_DUPFD to copy 42 * @tc.desc [C- SOFTWARE -0200] 43 */ 44 HWTEST_F(FileSystemTest, testFcntl, Function | MediumTest | Level3) 45 { 46 int fd = 0; 47 EXPECT_NE((fd = open(FILE0, O_CREAT | O_RDWR, 0777)), -1) << "> open faild errno = " << errno; 48 WriteCloseTest(fd); 49 50 // F_DUPFD 51 int fdNew = 0; 52 EXPECT_NE((fd = open(FILE0, O_RDONLY, 0777)), -1) << "> open faild errno = " << errno; 53 // openharmony not support F_DUPFD, after support change to NE 54 EXPECT_EQ((fdNew = fcntl(fd, F_DUPFD)), -1) << "> fcntl errno = " << errno; 55 if (fdNew != -1) { 56 ReadCloseTest(fdNew); 57 } 58 EXPECT_NE(close(fd), -1) << "> close errno = " << errno; 59 } 60 #endif 61 62 /** 63 * @tc.number SUB_KERNEL_FS_FCNTL_0110 64 * @tc.name basic function test : Test fcntl with F_GETFL 65 * @tc.desc [C- SOFTWARE -0200] 66 */ 67 HWTEST_F(FileSystemTest, testFcntlFgetfl, Function | MediumTest | Level3) 68 { 69 int fd = 0; 70 EXPECT_NE((fd = open(FILE0, O_CREAT | O_RDWR, 0777)), -1) << "> open faild errno = " << errno; 71 WriteCloseTest(fd); 72 73 int flagReadWrite = GetRandom(3) - 1; // 0 is O_RDONLY, 1 is O_WRONLY, 2 is O_RDWR 74 EXPECT_NE((fd = open(FILE0, flagReadWrite, 0777)), -1) << "> open faild errno = " << errno; 75 76 // F_GETFL 77 int flagGet = 0; 78 EXPECT_NE((flagGet = fcntl(fd, F_GETFL)), -1) << "> fcntl errno = " << errno; 79 EXPECT_EQ(flagReadWrite, (flagGet & O_ACCMODE)) << "> flagReadWrite != (flagGet & O_ACCMODE)"; 80 EXPECT_NE(close(fd), -1) << "> close errno = " << errno; 81 } 82 83 /** 84 * @tc.number SUB_KERNEL_FS_FCNTL_0120 85 * @tc.name basic function test : Test fcntl with F_SETFL 86 * @tc.desc [C- SOFTWARE -0200] 87 */ 88 HWTEST_F(FileSystemTest, testFcntlFsetfl, Function | MediumTest | Level3) 89 { 90 int fd = 0; 91 EXPECT_NE((fd = open(FILE0, O_CREAT | O_RDWR, 0777)), -1) << "> open faild errno = " << errno; 92 WriteCloseTest(fd); 93 94 int flagReadWrite = GetRandom(3) - 1; // 0 is O_RDONLY, 1 is O_WRONLY, 2 is O_RDWR 95 EXPECT_NE((fd = open(FILE0, flagReadWrite, 0777)), -1) << "> open faild errno = " << errno; 96 97 // F_SETFL 98 int flagSet = fcntl(fd, F_GETFL) | O_APPEND | O_NONBLOCK; 99 EXPECT_NE(fcntl(fd, F_SETFL, flagSet), -1) << "> fcntl errno = " << errno; 100 101 // use F_GETFL check 102 int flagGet = fcntl(fd, F_GETFL); 103 EXPECT_NE(flagGet, -1) << "> fcntl errno = " << errno; 104 EXPECT_EQ(flagGet & O_APPEND, O_APPEND) << "> O_APPEND faild"; 105 EXPECT_EQ(flagGet & O_NONBLOCK, O_NONBLOCK) << "> O_NONBLOCK faild"; 106 EXPECT_NE(close(fd), -1) << "> close errno = " << errno; 107 } 108 109 /** 110 * @tc.number SUB_KERNEL_FS_FCNTL_0200 111 * @tc.name basic function test : test lseek with SEEK_CUR 112 * @tc.desc [C- SOFTWARE -0200] 113 */ 114 HWTEST_F(FileSystemTest, testLseek, Function | MediumTest | Level3) 115 { 116 int reLseek; 117 int fd = 0; 118 char writeBuf[100]; 119 for (int i = 0; i < 100; i++) { 120 writeBuf[i] = '1'; 121 } 122 123 fd = open(FILE0, O_CREAT | O_RDWR, 0777); 124 EXPECT_NE(fd, -1) << "> open faild errno = " << errno; 125 EXPECT_NE(write(fd, writeBuf, 20), -1) << "> write errno = " << errno; 126 127 // reLseek 0 -> 20 128 reLseek = lseek(fd, 0, SEEK_CUR); 129 EXPECT_NE(reLseek, -1) << "> lseek errno = " << errno; 130 EXPECT_EQ(reLseek, 20) << "> reLseek = " << reLseek; 131 132 // reLseek 20 -> 40 133 EXPECT_NE(write(fd, writeBuf, 20), -1) << "> write errno = " << errno; 134 reLseek = lseek(fd, 0, SEEK_CUR); 135 EXPECT_NE(reLseek, -1) << "> lseek errno = " << errno; 136 EXPECT_EQ(reLseek, 40) << "> reLseek = " << reLseek; 137 138 EXPECT_NE(close(fd), -1) << "> close errno = " << errno; 139 } 140 141 /** 142 * @tc.number SUB_KERNEL_FS_FCNTL_0210 143 * @tc.name basic function test : test lseek wioth SEEK_SET 144 * @tc.desc [C- SOFTWARE -0200] 145 */ 146 HWTEST_F(FileSystemTest, testLseekSeekSet, Function | MediumTest | Level3) 147 { 148 int reLseek; 149 int fd = 0; 150 char writeBuf[100]; 151 for (int i = 0; i < 100; i++) { 152 writeBuf[i] = '1'; 153 } 154 155 fd = open(FILE0, O_CREAT | O_RDWR, 0777); 156 EXPECT_NE(fd, -1) << "> open faild errno = " << errno; 157 EXPECT_NE(write(fd, writeBuf, 20), -1) << "> write errno = " << errno; 158 159 // reLseek 20 -> 0 160 reLseek = lseek(fd, 0, SEEK_SET); 161 EXPECT_NE(reLseek, -1) << "> lseek errno = " << errno; 162 EXPECT_EQ(reLseek, 0) << "> reLseek = " << reLseek; 163 164 // reLseek 0 -> 10 165 reLseek = lseek(fd, 10, SEEK_SET); 166 EXPECT_NE(reLseek, -1) << "> lseek errno = " << errno; 167 EXPECT_EQ(reLseek, 10) << "> reLseek = " << reLseek; 168 169 EXPECT_NE(close(fd), -1) << "> close errno = " << errno; 170 } 171 172 /** 173 * @tc.number SUB_KERNEL_FS_FCNTL_0220 174 * @tc.name basic function test : test lseek wioth SEEK_END 175 * @tc.desc [C- SOFTWARE -0200] 176 */ 177 HWTEST_F(FileSystemTest, testLseekSeekEnd, Function | MediumTest | Level3) 178 { 179 int reLseek; 180 int fd = 0; 181 char writeBuf[100]; 182 for (int i = 0; i < 100; i++) { 183 writeBuf[i] = '1'; 184 } 185 186 fd = open(FILE0, O_CREAT | O_RDWR, 0777); 187 EXPECT_NE(fd, -1) << "> open faild errno = " << errno; 188 EXPECT_NE(write(fd, writeBuf, 20), -1) << "> write errno = " << errno; 189 190 // reLseek 20 -> 10 191 reLseek = lseek(fd, -10, SEEK_END); 192 EXPECT_NE(reLseek, -1) << "> lseek errno = " << errno; 193 EXPECT_EQ(reLseek, 10) << "> reLseek = " << reLseek; 194 195 EXPECT_NE(close(fd), -1) << "> close errno = " << errno; 196 } 197 198 #if defined(LITE_FS_VFAT) 199 /** 200 * @tc.number SUB_KERNEL_FS_FCNTL_0300 201 * @tc.name basic function test : Use the fallocate function to pre-allocate large space to the file 202 * @tc.desc [C- SOFTWARE -0200] 203 */ 204 HWTEST_F(FileSystemTest, testFallocate, Function | MediumTest | Level2) 205 { 206 char writeBuf[] = "123456789ABCDE"; 207 208 unsigned int file_size; 209 file_size = GetRandom(1024) * 102400 + 20; // >20 210 LOG("> GetRandom = %u", file_size); 211 212 struct statvfs vfsBufOld; 213 statvfs(".", &vfsBufOld); // old system info. 214 LOG("> vfsBufOld.f_bfree = %lu", vfsBufOld.f_bfree); 215 216 int fd = open(FILE0, O_RDWR | O_CREAT | O_EXCL, 0777); 217 ASSERT_NE(fd, -1) << "> open faild errno = " << errno; 218 EXPECT_NE(write(fd, writeBuf, sizeof(writeBuf)), -1) << "> write errno = " << errno; 219 220 int reInt = fallocate(fd, FALLOC_FL_KEEP_SIZE, 0, file_size); 221 EXPECT_EQ(reInt, 0) << "> fallocate errno = " << errno; 222 EXPECT_NE(close(fd), -1) << "> close errno = " << errno; 223 224 // expect not changed 225 struct stat statbuf; 226 EXPECT_NE(stat(FILE0, &statbuf), -1) << "> fstat errno = " << errno; 227 EXPECT_TRUE(statbuf.st_size == sizeof(writeBuf)); 228 229 struct statvfs vfsBufNew; 230 statvfs(".", &vfsBufNew); // new system info. 231 LOG("> vfsBufNew.f_bfree = %lu", vfsBufNew.f_bfree); 232 233 int ret = strcmp(TOP_DIR, "sdcard"); 234 if(ret = 0) { 235 int bNumExpect = file_size / vfsBufNew.f_bsize; 236 int bNum = vfsBufOld.f_bfree - vfsBufNew.f_bfree; 237 LOG("> bNumExpect = %d", bNumExpect); 238 LOG("> bNum = %d", bNum); 239 EXPECT_GE(bNum, bNumExpect); 240 } 241 } 242 #endif 243 244 #if defined(LITE_FS_VFAT) 245 /** 246 * @tc.number SUB_KERNEL_FS_FCNTL_0310 247 * @tc.name basic function test : Use the fallocate function to pre-allocate a small space to the file, 248 * @tc.desc [C- SOFTWARE -0200] 249 */ 250 HWTEST_F(FileSystemTest, testFallocateSmallSize, Function | MediumTest | Level2) 251 { 252 char writeBuf[] = "123456789ABCDE"; 253 254 unsigned int file_size; 255 file_size = GetRandom(1024) + 20; // >20 256 LOG("> GetRandom = %u", file_size); 257 258 struct statvfs vfsBufOld; 259 statvfs(".", &vfsBufOld); // old system info. 260 LOG("> vfsBufOld.f_bfree = %lu", vfsBufOld.f_bfree); 261 262 int fd = open(FILE0, O_RDWR | O_CREAT | O_EXCL, 0777); 263 ASSERT_NE(fd, -1) << "> open faild errno = " << errno; 264 EXPECT_NE(write(fd, writeBuf, sizeof(writeBuf)), -1) << "> write errno = " << errno; 265 266 int reInt = fallocate(fd, FALLOC_FL_KEEP_SIZE, 0, file_size); 267 EXPECT_EQ(reInt, 0) << "> fallocate errno = " << errno; 268 EXPECT_NE(close(fd), -1) << "> close errno = " << errno; 269 270 // expect not changed 271 struct stat statbuf; 272 EXPECT_NE(stat(FILE0, &statbuf), -1) << "> fstat errno = " << errno; 273 EXPECT_TRUE(statbuf.st_size == sizeof(writeBuf)); 274 275 struct statvfs vfsBufNew; 276 statvfs(".", &vfsBufNew); // new system info. 277 LOG("> vfsBufNew.f_bfree = %lu", vfsBufNew.f_bfree); 278 279 int ret = strcmp(TOP_DIR, "sdcard"); 280 if (ret = 0) { 281 int bNumExpect = file_size / vfsBufNew.f_bsize; 282 int bNum = vfsBufOld.f_bfree - vfsBufNew.f_bfree; 283 LOG("> bNumExpect = %d", bNumExpect); 284 LOG("> bNum = %d", bNum); 285 EXPECT_GE(bNum, bNumExpect); 286 } 287 } 288 #endif 289 290 /** 291 * @tc.number SUB_KERNEL_FS_FCNTL_0400 292 * @tc.name basic function test : test open with O_RDWR O_CREAT O_EXCL when the file does not exist 293 * @tc.desc [C- SOFTWARE -0200] 294 */ 295 HWTEST_F(FileSystemTest, testOpen, Function | MediumTest | Level2) 296 { 297 int fd = open(FILE0, O_RDWR | O_CREAT | O_EXCL, 0777); 298 EXPECT_NE(fd, -1) << "> open faild errno = " << errno; 299 EXPECT_NE(close(fd), -1) << "> close errno = " << errno; 300 } 301 302 /** 303 * @tc.number SUB_KERNEL_FS_FCNTL_0410 304 * @tc.name basic function test : test open with error number EEXIST 305 * @tc.desc [C- SOFTWARE -0200] 306 */ 307 HWTEST_F(FileSystemTest, testOpenEexist, Function | MediumTest | Level2) 308 { 309 int fd = 0; 310 fd = creat(FILE0, 0777); 311 EXPECT_NE(fd, -1) << "> creat faild errno = " << errno; 312 EXPECT_NE(close(fd), -1) << "> close errno = " << errno; 313 314 fd = open(FILE0, O_RDWR | O_CREAT | O_EXCL, 0777); 315 EXPECT_EQ(fd, -1) << "> Should open failed"; 316 EXPECT_EQ(errno, EEXIST); 317 close(fd); 318 } 319 320 /** 321 * @tc.number SUB_KERNEL_FS_FCNTL_0420 322 * @tc.name basic function test : test open with error number EISDIR 323 * @tc.desc [C- SOFTWARE -0200] 324 */ 325 HWTEST_F(FileSystemTest, testOpenEisdir, Function | MediumTest | Level2) 326 { 327 int fd = 0; 328 CreateTestFolder(); 329 330 fd = open(DIR0, O_RDWR, 0777); 331 if (fd != -1) { 332 EXPECT_EQ(errno, EISDIR); 333 close(fd); 334 } 335 } 336 337 /** 338 * @tc.number SUB_KERNEL_FS_FCNTL_0430 339 * @tc.name basic function test : test open with error number ENOENT 340 * @tc.desc [C- SOFTWARE -0200] 341 */ 342 HWTEST_F(FileSystemTest, testOpenEnoent, Function | MediumTest | Level2) 343 { 344 int fd = 0; 345 346 fd = open(FILE0, O_RDWR, 0777); 347 EXPECT_EQ(fd, -1) << "> Should open failed"; 348 EXPECT_EQ(errno, ENOENT); 349 close(fd); 350 } 351 352 /** 353 * @tc.number SUB_KERNEL_FS_FCNTL_0440 354 * @tc.name basic function test : test open with error number ENAMETOOLONG 355 * @tc.desc [C- SOFTWARE -0200] 356 */ 357 HWTEST_F(FileSystemTest, testOpenEnametoolong, Function | MediumTest | Level2) 358 { 359 int fd = 0; 360 const char *fileName = "12345678901234567890123456789012345678901234567890\ 361 12345678901234567890123456789012345678901234567890\ 362 12345678901234567890123456789012345678901234567890\ 363 12345678901234567890123456789012345678901234567890\ 364 12345678901234567890123456789012345678901234567890\ 365 12345678901234567890123456789012345678901234567890\ 366 12345678901234567890123456789012345678901234567890\ 367 12345678901234567890123456789012345678901234567890"; 368 369 fd = open(fileName, O_RDWR | O_CREAT | O_EXCL, 0777); 370 EXPECT_EQ(fd, -1) << "> Should open failed"; 371 EXPECT_EQ(errno, ENAMETOOLONG); 372 close(fd); 373 }