Пример #1
0
int std_fseek(FILE *handle, long int offset, int whence) {
//	consolePrintf("fseek %d %d ", offset, whence);

	if (DS::isGBAMPAvailable()) {
		return FAT_fseek((FAT_FILE *) handle, offset, whence);
	}

	switch (whence) {
	case SEEK_CUR:
		handle->pos += offset;
		break;
	case SEEK_SET:
		handle->pos = offset;
		break;
	case SEEK_END:
		handle->pos = handle->size + offset;
		break;
	default:
		handle->pos = offset;
		break;
	}

	return 0;
}
Пример #2
0
uint TestDir10(void)
{
  tIORes res;
  uint result = 1;
  uint i, cnt;
  char name[12+1+13];
  tReadDirState ReadDirState;
  tFATDirectoryEntry DirEntry;
  tFATFSStatus FSStatus1, FSStatus2;
  tFATFile file;
  uint32 FreeSpace1, FreeSpace2;
  int subtest;

  // tbd: allocate almost all free space to big file(s), leave 1 free cluster
  // create directory ending up with disk full, create empty files in it
  // until it needs to grow and fails
  
  FAT_statvfs (&stdio_FATFS, &res, "\\", &FSStatus1);
  CHK(res == ior_OK);

  FAT_mkdir (&stdio_FATFS, &res, "level1", mt_S_IWUSR);
  CHK(res == ior_OK);

  for (subtest = 0; subtest < 2; subtest++)
  {
    FAT_fopen (&stdio_FATFS, &res, &file, "huge0000", "wb");
    CHK(res == ior_OK);

    FAT_statvfs (&stdio_FATFS, &res, "\\", &FSStatus2);
    CHK(res == ior_OK);

    FreeSpace1 = FSStatus2.TotalFreeClusterCount * FSStatus2.ClusterSize;
    CHK(FreeSpace1 / FSStatus2.TotalFreeClusterCount ==
        FSStatus2.ClusterSize);
    CHK(FreeSpace1 >= 2 * FSStatus2.ClusterSize);

    if (!subtest)
    {
      FreeSpace2 = 0;
    }
    else
    {
      FreeSpace1 -= FSStatus2.ClusterSize;
      FreeSpace2 = FSStatus2.ClusterSize;
    }

    FAT_fseek (&stdio_FATFS, &res, &file, FreeSpace1);
    CHK(res == ior_OK);

    FAT_fclose (&stdio_FATFS, &res, &file);
    CHK(res == ior_OK);

    FAT_fopen (&stdio_FATFS, &res, &file, "huge0001", "wb");
    CHK(res == ior_OK);

    FAT_fseek (&stdio_FATFS, &res, &file, FreeSpace2);
    CHK(res == ior_OK);

    FAT_fclose (&stdio_FATFS, &res, &file);
    CHK(res == ior_OK);

    if (subtest)
    {
      int idx;
      for (idx = 0; idx < 2; idx++)
      {
        FAT_unlink (&stdio_FATFS, &res, "huge0000");
        CHK(res == ior_OK);

        FAT_fopen (&stdio_FATFS, &res, &file, "huge0000", "wb");
        CHK(res == ior_OK);

        FAT_fseek (&stdio_FATFS, &res, &file, FreeSpace1);
        CHK(res == ior_OK);

        FAT_fclose (&stdio_FATFS, &res, &file);
        CHK(res == ior_OK);
      }
    }

    for (cnt = i = 0; i < UINT_MAX; i++)
    {
      strcpy (name, "level1\\");
      sprintf (name + strlen(name), "%u", i);
      FAT_fopen (&stdio_FATFS, &res, &file, name, "wb");
      CHK((res == ior_OK) || (res == ior_NO_SPACE));
      if (res == ior_OK)
      {
        FAT_fclose (&stdio_FATFS, &res, &file);
        CHK(res == ior_OK);
        cnt++;
      }
      else
        break;
    }

    CHK(cnt == 16 - 2);

    FAT_opendir (&stdio_FATFS, &res, "level1", &ReadDirState);
    CHK(res == ior_OK);

    for (i = 0; i < cnt; i++)
    {
      char s[13];
      sprintf (name, "%u", i);
lSkipDotEntries:
      FAT_readdir (&stdio_FATFS, &res, &ReadDirState, &DirEntry);
      CHK(res == ior_OK);
      CHK(DirEntryNameToASCIIZ (&DirEntry, s) == s);
      if (s[0] ==  '.') goto lSkipDotEntries;
      CHK(!strcmp (name, s));
    }

    FAT_readdir (&stdio_FATFS, &res, &ReadDirState, &DirEntry);
    CHK(res == ior_NO_MORE_FILES);

    FAT_closedir (&stdio_FATFS, &res, &ReadDirState);
    CHK(res == ior_OK);

    for (i = 0; i < cnt; i++)
    {
      strcpy (name, "level1\\");
      sprintf (name + strlen(name), "%u", i);
      FAT_unlink (&stdio_FATFS, &res, name);
      CHK(res == ior_OK);
    }

    FAT_unlink (&stdio_FATFS, &res, "huge0001");
    CHK(res == ior_OK);

    FAT_unlink (&stdio_FATFS, &res, "huge0000");
    CHK(res == ior_OK);
  }

  FAT_rmdir (&stdio_FATFS, &res, "level1");
  CHK(res == ior_OK);

  FAT_statvfs (&stdio_FATFS, &res, "\\", &FSStatus2);
  CHK(res == ior_OK);
  CHK(FSStatus2.TotalFreeClusterCount == FSStatus1.TotalFreeClusterCount);

  result = 0;

lend:
  return result;
}
Пример #3
0
uint TestFile4(void)
{
  tIORes res;
  uint result = 1;
  tFATFile file;
  tFATFSStatus FSStatus1, FSStatus2;
  uint32 aFileSize[]=
  {0, 1,                                                  // ~= 0
   FAT_SECTOR_SIZE-1, FAT_SECTOR_SIZE, FAT_SECTOR_SIZE+1, // ~= sector
   -1, 0, 1,                                              // ~= cluster
   -1, 0, 1,                                              // ~= 2 clusters
   -1, 0, 1};                                             // ~= 4 clusters
  int FileSizeCount = 5;
  int FileSizeIndex = 0;
  int CloseIndex;
  int ReadSizeIndex = 0;

  FAT_statvfs (&stdio_FATFS, &res, "\\", &FSStatus1);
  CHK(res == ior_OK);

  if (FSStatus1.ClusterSize != FAT_SECTOR_SIZE)
  {
    aFileSize[FileSizeCount++] = FSStatus1.ClusterSize - 1;
    aFileSize[FileSizeCount++] = FSStatus1.ClusterSize;
    aFileSize[FileSizeCount++] = FSStatus1.ClusterSize + 1;
  }
  aFileSize[FileSizeCount++] = 2 * FSStatus1.ClusterSize - 1;
  aFileSize[FileSizeCount++] = 2 * FSStatus1.ClusterSize;
  aFileSize[FileSizeCount++] = 2 * FSStatus1.ClusterSize + 1;

  aFileSize[FileSizeCount++] = 4 * FSStatus1.ClusterSize - 1;
  aFileSize[FileSizeCount++] = 4 * FSStatus1.ClusterSize;
  aFileSize[FileSizeCount++] = 4 * FSStatus1.ClusterSize + 1;

  for (CloseIndex = 0; CloseIndex <= 1; CloseIndex++)
  {
    for (FileSizeIndex = 0; FileSizeIndex < FileSizeCount; FileSizeIndex++)
    {
      for (ReadSizeIndex = 0; ReadSizeIndex < FileSizeCount; ReadSizeIndex++)
      {
        uint32 size, pos=0, ReadPos;
        size_t ReadSize;

        size = (size_t)aFileSize[FileSizeIndex];
        ReadSize = aFileSize[ReadSizeIndex];

        CreateTestFile (&res, &file, "file1",
                        size, CloseIndex);
        CHK(res == ior_OK);

        if (!CloseIndex)
        {
          FAT_rewind (&stdio_FATFS, &res, &file);
          CHK(res == ior_OK);
        }
        else
        {
          FAT_fopen (&stdio_FATFS, &res, &file, "file1", "rb");
          CHK(res == ior_OK);
        }

        FAT_ftell (&stdio_FATFS, &res, &file, &ReadPos);
        CHK(res == ior_OK);
        CHK(pos == ReadPos);

        while (pos < size)
        {
          FAT_fseek (&stdio_FATFS, &res, &file, pos);
          CHK(res == ior_OK);

          FAT_ftell (&stdio_FATFS, &res, &file, &ReadPos);
          CHK(res == ior_OK);
          CHK(pos == ReadPos);

          pos += MIN(size - pos, ReadSize);

          if (!ReadSize)
            break;
        }

        FAT_fseek (&stdio_FATFS, &res, &file, 0);
        CHK(res == ior_OK);

        FAT_ftell (&stdio_FATFS, &res, &file, &ReadPos);
        CHK(res == ior_OK);
        CHK(ReadPos == 0);

        FAT_fseek (&stdio_FATFS, &res, &file, size);
        CHK(res == ior_OK);

        FAT_ftell (&stdio_FATFS, &res, &file, &ReadPos);
        CHK(res == ior_OK);
        CHK(ReadPos == size);

        if (CloseIndex)
        {
          FAT_fseek (&stdio_FATFS, &res, &file, size + 1);
          CHK(res == ior_ARGUMENT_OUT_OF_RANGE);

          FAT_ftell (&stdio_FATFS, &res, &file, &ReadPos);
          CHK(res == ior_OK);
          CHK(ReadPos == size);
        }

        FAT_fsize (&stdio_FATFS, &res, &file, &ReadPos);
        CHK(res == ior_OK);
        CHK(size == ReadPos);

        FAT_fclose (&stdio_FATFS, &res, &file);
        CHK(res == ior_OK);

        FAT_unlink (&stdio_FATFS, &res, "file1");
        CHK(res == ior_OK);
      }
    }
  }

  FAT_statvfs (&stdio_FATFS, &res, "\\", &FSStatus2);
  CHK(res == ior_OK);
  CHK(FSStatus2.TotalFreeClusterCount == FSStatus1.TotalFreeClusterCount);

  result = 0;

lend:
  return result;
}