This makes those 0x200 far clearer.
Signed-off-by: Clément Chigot <chi...@adacore.com>
---
block/vvfat.c | 60 ++++++++++++++++++++++++++++-----------------------
1 file changed, 33 insertions(+), 27 deletions(-)
diff --git a/block/vvfat.c b/block/vvfat.c
index 91e4ad3158..6b6d158a18 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -75,6 +75,8 @@ static void checkpoint(void);
*/
#define BOOTSECTOR_OEM_NAME "MSWIN4.1"
+#define SECTOR_SIZE 0x200
+
#define DIR_DELETED 0xe5
#define DIR_KANJI DIR_DELETED
#define DIR_KANJI_FAKE 0x05
@@ -300,7 +302,7 @@ static void print_mapping(const struct mapping_t* mapping);
typedef struct BDRVVVFATState {
CoMutex lock;
BlockDriverState* bs; /* pointer to parent */
- unsigned char first_sectors[0x40*0x200];
+ unsigned char first_sectors[0x40 * SECTOR_SIZE];
int fat_type; /* 16 or 32 */
array_t fat,directory,mapping;
@@ -689,11 +691,11 @@ static inline void init_fat(BDRVVVFATState* s)
if (s->fat_type == 12) {
array_init(&(s->fat),1);
array_ensure_allocated(&(s->fat),
- s->sectors_per_fat * 0x200 * 3 / 2 - 1);
+ s->sectors_per_fat * SECTOR_SIZE * 3 / 2 - 1);
} else {
array_init(&(s->fat),(s->fat_type==32?4:2));
array_ensure_allocated(&(s->fat),
- s->sectors_per_fat * 0x200 / s->fat.item_size - 1);
+ s->sectors_per_fat * SECTOR_SIZE / s->fat.item_size - 1);
}
memset(s->fat.pointer,0,s->fat.size);
@@ -901,19 +903,19 @@ static int init_directories(BDRVVVFATState* s,
unsigned int i;
unsigned int cluster;
- memset(&(s->first_sectors[0]),0,0x40*0x200);
+ memset(&(s->first_sectors[0]), 0 , 0x40 * SECTOR_SIZE);
- s->cluster_size=s->sectors_per_cluster*0x200;
+ s->cluster_size = s->sectors_per_cluster * SECTOR_SIZE;
s->cluster_buffer=g_malloc(s->cluster_size);
/*
- * The formula: sc = spf+1+spf*spc*(512*8/fat_type),
+ * The formula: sc = spf+1+spf*spc*(SECTOR_SIZE*8/fat_type),
* where sc is sector_count,
* spf is sectors_per_fat,
* spc is sectors_per_clusters, and
* fat_type = 12, 16 or 32.
*/
- i = 1+s->sectors_per_cluster*0x200*8/s->fat_type;
+ i = 1 + s->sectors_per_cluster * SECTOR_SIZE * 8 / s->fat_type;
s->sectors_per_fat=(s->sector_count+i)/i; /* round up */
s->offset_to_fat = s->offset_to_bootsector + 1;
@@ -1011,12 +1013,12 @@ static int init_directories(BDRVVVFATState* s,
s->current_mapping = NULL;
bootsector = (bootsector_t *)(s->first_sectors
- + s->offset_to_bootsector * 0x200);
+ + s->offset_to_bootsector * SECTOR_SIZE);
bootsector->jump[0]=0xeb;
bootsector->jump[1]=0x3e;
bootsector->jump[2]=0x90;
memcpy(bootsector->name, BOOTSECTOR_OEM_NAME, 8);
- bootsector->sector_size=cpu_to_le16(0x200);
+ bootsector->sector_size = cpu_to_le16(SECTOR_SIZE);
bootsector->sectors_per_cluster=s->sectors_per_cluster;
bootsector->reserved_sectors=cpu_to_le16(1);
bootsector->number_of_fats=0x2; /* number of FATs */
@@ -1513,7 +1515,7 @@ vvfat_read(BlockDriverState *bs, int64_t sector_num,
uint8_t *buf, int nb_sector
" allocated\n", sector_num,
n >> BDRV_SECTOR_BITS));
if (bdrv_co_pread(s->qcow, sector_num * BDRV_SECTOR_SIZE, n,
- buf + i * 0x200, 0) < 0) {
+ buf + i * SECTOR_SIZE, 0) < 0) {
return -1;
}
i += (n >> BDRV_SECTOR_BITS) - 1;
@@ -1525,19 +1527,19 @@ vvfat_read(BlockDriverState *bs, int64_t sector_num,
uint8_t *buf, int nb_sector
}
if (sector_num < s->offset_to_root_dir) {
if (sector_num < s->offset_to_fat) {
- memcpy(buf + i * 0x200,
- &(s->first_sectors[sector_num * 0x200]),
- 0x200);
+ memcpy(buf + i * SECTOR_SIZE,
+ &(s->first_sectors[sector_num * SECTOR_SIZE]),
+ SECTOR_SIZE);
} else if (sector_num < s->offset_to_fat + s->sectors_per_fat) {
- memcpy(buf + i * 0x200,
+ memcpy(buf + i * SECTOR_SIZE,
&(s->fat.pointer[(sector_num
- - s->offset_to_fat) * 0x200]),
- 0x200);
+ - s->offset_to_fat) * SECTOR_SIZE]),
+ SECTOR_SIZE);
} else if (sector_num < s->offset_to_root_dir) {
- memcpy(buf + i * 0x200,
+ memcpy(buf + i * SECTOR_SIZE,
&(s->fat.pointer[(sector_num - s->offset_to_fat
- - s->sectors_per_fat) * 0x200]),
- 0x200);
+ - s->sectors_per_fat) * SECTOR_SIZE]),
+ SECTOR_SIZE);
}
} else {
uint32_t sector = sector_num - s->offset_to_root_dir,
@@ -1545,10 +1547,12 @@ vvfat_read(BlockDriverState *bs, int64_t sector_num,
uint8_t *buf, int nb_sector
cluster_num=sector/s->sectors_per_cluster;
if(cluster_num > s->cluster_count || read_cluster(s, cluster_num)
!= 0) {
/* LATER TODO: strict: return -1; */
- memset(buf+i*0x200,0,0x200);
+ memset(buf + i * SECTOR_SIZE, 0, SECTOR_SIZE);
continue;
}
-
memcpy(buf+i*0x200,s->cluster+sector_offset_in_cluster*0x200,0x200);
+ memcpy(buf + i * SECTOR_SIZE,
+ s->cluster + sector_offset_in_cluster * SECTOR_SIZE,
+ SECTOR_SIZE);
}
}
return 0;
@@ -2176,7 +2180,7 @@ DLOG(checkpoint());
* - if all is fine, return number of used clusters
*/
if (s->fat2 == NULL) {
- int size = 0x200 * s->sectors_per_fat;
+ int size = SECTOR_SIZE * s->sectors_per_fat;
s->fat2 = g_malloc(size);
memcpy(s->fat2, s->fat.pointer, size);
}
@@ -2573,7 +2577,8 @@ commit_one_file(BDRVVVFATState* s, int dir_index,
uint32_t offset)
(size > offset && c >=2 && !fat_eof(s, c)));
ret = vvfat_read(s->bs, cluster2sector(s, c),
- (uint8_t*)cluster, DIV_ROUND_UP(rest_size, 0x200));
+ (uint8_t *)cluster,
+ DIV_ROUND_UP(rest_size, SECTOR_SIZE));
if (ret < 0) {
qemu_close(fd);
@@ -2952,7 +2957,7 @@ static int coroutine_fn GRAPH_RDLOCK
do_commit(BDRVVVFATState* s)
}
/* copy FAT (with bdrv_pread) */
- memcpy(s->fat.pointer, s->fat2, 0x200 * s->sectors_per_fat);
+ memcpy(s->fat.pointer, s->fat2, SECTOR_SIZE * s->sectors_per_fat);
/* recurse direntries from root (using bs->bdrv_pread) */
ret = commit_direntries(s, 0, -1);
@@ -3016,14 +3021,14 @@ DLOG(checkpoint());
* used to mark volume dirtiness
*/
unsigned char *bootsector = s->first_sectors
- + s->offset_to_bootsector * 0x200;
+ + s->offset_to_bootsector * SECTOR_SIZE;
/*
* LATER TODO: if FAT32, this is wrong (see init_directories(),
* which always creates a FAT16 bootsector)
*/
const int reserved1_offset = offsetof(bootsector_t, u.fat16.reserved1);
- for (i = 0; i < 0x200; i++) {
+ for (i = 0; i < SECTOR_SIZE; i++) {
if (i != reserved1_offset && bootsector[i] != buf[i]) {
fprintf(stderr, "Tried to write to protected bootsector\n");
return -1;
@@ -3078,7 +3083,8 @@ DLOG(checkpoint());
end = sector_num + nb_sectors;
dir_index = mapping->dir_index +
0x10 * (begin - mapping->begin * s->sectors_per_cluster);
- direntries = (direntry_t*)(buf + 0x200 * (begin - sector_num));
+ direntries =
+ (direntry_t *)(buf + SECTOR_SIZE * (begin - sector_num));
for (k = 0; k < (end - begin) * 0x10; k++) {
/* no access to the direntry of a read-only file */
--
2.34.1
