[Haiku-commits] r31306 - haiku/trunk/src/add-ons/kernel/file_systems/fat
mmlr at mail.berlios.de
mmlr at mail.berlios.de
Mon Jun 29 01:41:50 CEST 2009
Author: mmlr
Date: 2009-06-29 01:41:48 +0200 (Mon, 29 Jun 2009)
New Revision: 31306
ViewCVS: http://svn.berlios.de/viewcvs/haiku?rev=31306&view=rev
Modified:
haiku/trunk/src/add-ons/kernel/file_systems/fat/fat.c
Log:
* Big cleanup, remove dead code, some renaming, line lengths, spacing,
use B_* error codes, print most numbers as normal decimals or at least prefix
them with 0x where appropriate.
* When counting free clusters for FAT32 correctly ignore the uppermost 4 bits
when checking for free entries. Shouldn't matter, as those should always be
0 anyway.
Modified: haiku/trunk/src/add-ons/kernel/file_systems/fat/fat.c
===================================================================
--- haiku/trunk/src/add-ons/kernel/file_systems/fat/fat.c 2009-06-28 21:53:53 UTC (rev 31305)
+++ haiku/trunk/src/add-ons/kernel/file_systems/fat/fat.c 2009-06-28 23:41:48 UTC (rev 31306)
@@ -22,7 +22,7 @@
#define DPRINTF(a,b) if (debug_fat > (a)) dprintf b
static status_t
-mirror_fats(nspace *vol, uint32 sector, uint8 *buffer, int32 tid)
+mirror_fats(nspace *vol, uint32 sector, uint8 *buffer, int32 transactionID)
{
uint32 i;
char *buf = buffer;
@@ -32,14 +32,16 @@
sector -= vol->active_fat * vol->sectors_per_fat;
- for (i=0;i<vol->fat_count;i++) {
+ for (i = 0; i < vol->fat_count; i++) {
char *blockData;
if (i == vol->active_fat)
continue;
- blockData = block_cache_get_writable_etc(vol->fBlockCache, sector + i*vol->sectors_per_fat, 0, 1, tid);
+
+ blockData = block_cache_get_writable_etc(vol->fBlockCache, sector
+ + i * vol->sectors_per_fat, 0, 1, transactionID);
memcpy(blockData, buf, vol->bytes_per_sector);
buf += vol->bytes_per_sector;
- block_cache_put(vol->fBlockCache, sector + i*vol->sectors_per_fat);
+ block_cache_put(vol->fBlockCache, sector + i * vol->sectors_per_fat);
}
return B_OK;
@@ -57,15 +59,15 @@
cur_sector = vol->reserved_sectors + vol->active_fat * vol->sectors_per_fat;
- for(fat_sector = 0; fat_sector < vol->sectors_per_fat; fat_sector++) {
+ for (fat_sector = 0; fat_sector < vol->sectors_per_fat; fat_sector++) {
block = (uint8 *)block_cache_get(vol->fBlockCache, cur_sector);
- if(block == NULL) {
- return EIO;
- }
+ if(block == NULL)
+ return B_IO_ERROR;
- for(i=0; i < vol->bytes_per_sector; i += sizeof(uint32)) {
+ for (i = 0; i < vol->bytes_per_sector; i += sizeof(uint32)) {
uint32 val = read32(block, i);
- if(val == 0) count++;
+ if ((val & 0x0fffffff) == 0)
+ count++;
}
block_cache_put(vol->fBlockCache, cur_sector);
@@ -80,7 +82,12 @@
// set_entry: cluster #, value. returns int32 status
// allocate: # clusters in N, returns int32 status/starting cluster
-enum { _IOCTL_COUNT_FREE_, _IOCTL_GET_ENTRY_, _IOCTL_SET_ENTRY_, _IOCTL_ALLOCATE_N_ENTRIES_ };
+enum {
+ _IOCTL_COUNT_FREE_,
+ _IOCTL_GET_ENTRY_,
+ _IOCTL_SET_ENTRY_,
+ _IOCTL_ALLOCATE_N_ENTRIES_
+};
static int32
_fat_ioctl_(nspace *vol, uint32 action, uint32 cluster, int32 N, int32 _tid)
@@ -89,18 +96,23 @@
uint32 n = 0, first = 0, last = 0;
uint32 i;
uint32 sector;
- uint32 off, val = 0; /* quiet warning */
+ uint32 offset, value = 0; /* quiet warning */
uint8 *block1, *block2 = NULL; /* quiet warning */
- int32 tid = _tid;
+ int32 transactionID = _tid;
+ bool readOnly
+ = action != _IOCTL_SET_ENTRY_ && action != _IOCTL_ALLOCATE_N_ENTRIES_;
// mark end of chain for allocations
- uint32 V = (action == _IOCTL_SET_ENTRY_) ? N : 0x0fffffff;
+ uint32 endOfChainMarker = (action == _IOCTL_SET_ENTRY_) ? N : 0x0fffffff;
- ASSERT((action >= _IOCTL_COUNT_FREE_) && (action <= _IOCTL_ALLOCATE_N_ENTRIES_));
+ ASSERT((action >= _IOCTL_COUNT_FREE_)
+ && (action <= _IOCTL_ALLOCATE_N_ENTRIES_));
- if (check_nspace_magic(vol, "_fat_ioctl_")) return EINVAL;
+ if (check_nspace_magic(vol, "_fat_ioctl_"))
+ return B_BAD_VALUE;
- DPRINTF(3, ("_fat_ioctl_: action %lx, cluster %lx, N %lx\n", action, cluster, N));
+ DPRINTF(3, ("_fat_ioctl_: action %lx, cluster %ld, N %ld\n", action,
+ cluster, N));
if (action == _IOCTL_COUNT_FREE_) {
if(vol->fat_bits == 32)
@@ -115,137 +127,143 @@
if (action != _IOCTL_COUNT_FREE_) {
if (!IS_DATA_CLUSTER(cluster)) {
- DPRINTF(0, ("_fat_ioctl_ called with invalid cluster (%lx)\n", cluster));
- return EINVAL;
+ DPRINTF(0, ("_fat_ioctl_ called with invalid cluster (%ld)\n",
+ cluster));
+ return B_BAD_VALUE;
}
}
- off = cluster * vol->fat_bits / 8;
+ offset = cluster * vol->fat_bits / 8;
sector = vol->reserved_sectors + vol->active_fat * vol->sectors_per_fat +
- off / vol->bytes_per_sector;
- off %= vol->bytes_per_sector;
+ offset / vol->bytes_per_sector;
+ offset %= vol->bytes_per_sector;
- if (action != _IOCTL_SET_ENTRY_ && action != _IOCTL_ALLOCATE_N_ENTRIES_) {
+ if (readOnly) {
block1 = (uint8 *)block_cache_get(vol->fBlockCache, sector);
} else {
- if (tid == -1)
- tid = cache_start_transaction(vol->fBlockCache);
- block1 = (uint8 *)block_cache_get_writable(vol->fBlockCache, sector, tid);
+ if (transactionID == -1)
+ transactionID = cache_start_transaction(vol->fBlockCache);
+
+ block1 = (uint8 *)block_cache_get_writable(vol->fBlockCache, sector,
+ transactionID);
}
if (block1 == NULL) {
- DPRINTF(0, ("_fat_ioctl_: error reading fat (sector %lx)\n", sector));
- return EIO;
+ DPRINTF(0, ("_fat_ioctl_: error reading fat (sector %ld)\n", sector));
+ return B_IO_ERROR;
}
- for (i=0;i<vol->total_clusters;i++) {
+ for (i = 0; i < vol->total_clusters; i++) {
ASSERT(IS_DATA_CLUSTER(cluster));
- ASSERT(off == ((cluster * vol->fat_bits / 8) % vol->bytes_per_sector));
+ ASSERT(offset == ((cluster * vol->fat_bits / 8)
+ % vol->bytes_per_sector));
if (vol->fat_bits == 12) {
- if (off == vol->bytes_per_sector - 1) {
- if (action != _IOCTL_SET_ENTRY_ && action != _IOCTL_ALLOCATE_N_ENTRIES_)
- block2 = (uint8 *)block_cache_get(vol->fBlockCache, ++sector);
- else
- block2 = (uint8 *)block_cache_get_writable(vol->fBlockCache, ++sector, tid);
+ if (offset == vol->bytes_per_sector - 1) {
+ if (readOnly) {
+ block2 = (uint8 *)block_cache_get(vol->fBlockCache,
+ ++sector);
+ } else {
+ block2 = (uint8 *)block_cache_get_writable(vol->fBlockCache,
+ ++sector, transactionID);
+ }
if (block2 == NULL) {
- DPRINTF(0, ("_fat_ioctl_: error reading fat (sector %lx)\n", sector));
- result = EIO;
+ DPRINTF(0, ("_fat_ioctl_: error reading fat (sector %ld)\n",
+ sector));
+ result = B_IO_ERROR;
sector--;
goto bi;
}
}
+
if (action != _IOCTL_SET_ENTRY_) {
- if (off == vol->bytes_per_sector - 1) {
- val = block1[off] + 0x100*block2[0];
- } else
- val = block1[off] + 0x100*block1[off+1];
- if (cluster & 1) {
- val >>= 4;
- } else {
- val &= 0xfff;
- }
- if (val > 0xff0) val |= 0x0ffff000;
+ if (offset == vol->bytes_per_sector - 1)
+ value = block1[offset] + 0x100 * block2[0];
+ else
+ value = block1[offset] + 0x100 * block1[offset + 1];
+
+ if (cluster & 1)
+ value >>= 4;
+ else
+ value &= 0xfff;
+
+ if (value > 0xff0)
+ value |= 0x0ffff000;
}
- if (((action == _IOCTL_ALLOCATE_N_ENTRIES_) && (val == 0)) ||
- (action == _IOCTL_SET_ENTRY_)) {
+
+ if (((action == _IOCTL_ALLOCATE_N_ENTRIES_) && (value == 0))
+ || action == _IOCTL_SET_ENTRY_) {
uint32 andmask, ormask;
if (cluster & 1) {
- ormask = (V & 0xfff) << 4;
+ ormask = (endOfChainMarker & 0xfff) << 4;
andmask = 0xf;
} else {
- ormask = V & 0xfff;
+ ormask = endOfChainMarker & 0xfff;
andmask = 0xf000;
}
- block1[off] &= (andmask & 0xff);
- block1[off] |= (ormask & 0xff);
- if (off == vol->bytes_per_sector - 1) {
- //mark_blocks_dirty(vol->fd, sector - 1, 1);
- mirror_fats(vol, sector - 1, block1, tid);
+
+ block1[offset] &= (andmask & 0xff);
+ block1[offset] |= (ormask & 0xff);
+ if (offset == vol->bytes_per_sector - 1) {
+ mirror_fats(vol, sector - 1, block1, transactionID);
block2[0] &= (andmask >> 8);
block2[0] |= (ormask >> 8);
} else {
- block1[off+1] &= (andmask >> 8);
- block1[off+1] |= (ormask >> 8);
+ block1[offset + 1] &= (andmask >> 8);
+ block1[offset + 1] |= (ormask >> 8);
}
}
- if (off == vol->bytes_per_sector - 1) {
- off = (cluster & 1) ? 1 : 0;
+ if (offset == vol->bytes_per_sector - 1) {
+ offset = (cluster & 1) ? 1 : 0;
block_cache_put(vol->fBlockCache, sector - 1);
block1 = block2;
- } else {
- off += (cluster & 1) ? 2 : 1;
- }
+ } else
+ offset += (cluster & 1) ? 2 : 1;
+
} else if (vol->fat_bits == 16) {
if (action != _IOCTL_SET_ENTRY_) {
- val = read16(block1, off);
-// val = block1[off] + 0x100*block1[off+1];
- if (val > 0xfff0) val |= 0x0fff0000;
+ value = read16(block1, offset);
+ if (value > 0xfff0)
+ value |= 0x0fff0000;
}
- if (((action == _IOCTL_ALLOCATE_N_ENTRIES_) && (val == 0)) ||
- (action == _IOCTL_SET_ENTRY_)) {
- *(uint16 *)&block1[off] = B_HOST_TO_LENDIAN_INT16(V);
-// block1[off] = V & 0xff;
-// block1[off+1] = (V >> 8) & 0xff;
+
+ if (((action == _IOCTL_ALLOCATE_N_ENTRIES_) && (value == 0))
+ || action == _IOCTL_SET_ENTRY_) {
+ *(uint16 *)&block1[offset]
+ = B_HOST_TO_LENDIAN_INT16(endOfChainMarker);
}
- off += 2;
+
+ offset += 2;
} else if (vol->fat_bits == 32) {
- if (action != _IOCTL_SET_ENTRY_) {
- val = read32(block1, off) & 0x0fffffff;
-// val = block1[off] + 0x100*block1[off+1] +
-// 0x10000*block1[off+2] + 0x1000000*(block1[off+3]&0x0f);
-// if (val > 0x0ffffff0) val |= 0x00000000;
+ if (action != _IOCTL_SET_ENTRY_)
+ value = read32(block1, offset) & 0x0fffffff;
+
+ if (((action == _IOCTL_ALLOCATE_N_ENTRIES_) && (value == 0))
+ || action == _IOCTL_SET_ENTRY_) {
+ ASSERT((endOfChainMarker & 0xf0000000) == 0);
+ *(uint32 *)&block1[offset]
+ = B_HOST_TO_LENDIAN_INT32(endOfChainMarker);
}
- if (((action == _IOCTL_ALLOCATE_N_ENTRIES_) && (val == 0)) ||
- (action == _IOCTL_SET_ENTRY_)) {
- ASSERT((V & 0xf0000000) == 0);
- *(uint32 *)&block1[off] = B_HOST_TO_LENDIAN_INT32(V);
-// block1[off] = V & 0xff;
-// block1[off+1] = (V >> 8) & 0xff;
-// block1[off+2] = (V >> 16) & 0xff;
-// block1[off+3] = (V >> 24) & 0x0f;
-// ASSERT(V == (block1[off] + 0x100*block1[off+1] + 0x10000*block1[off+2] + 0x1000000*block1[off+3]));
- }
- off += 4;
+
+ offset += 4;
} else
ASSERT(0);
if (action == _IOCTL_COUNT_FREE_) {
- if (val == 0)
+ if (value == 0)
result++;
} else if (action == _IOCTL_GET_ENTRY_) {
- result = val;
+ result = value;
goto bi;
} else if (action == _IOCTL_SET_ENTRY_) {
- //mark_blocks_dirty(vol->fd, sector, 1);
- mirror_fats(vol, sector, block1, tid);
+ mirror_fats(vol, sector, block1, transactionID);
goto bi;
- } else if ((action == _IOCTL_ALLOCATE_N_ENTRIES_) && (val == 0)) {
+ } else if (action == _IOCTL_ALLOCATE_N_ENTRIES_ && value == 0) {
vol->free_clusters--;
- //mark_blocks_dirty(vol->fd, sector, 1);
- mirror_fats(vol, sector, block1, tid);
+ mirror_fats(vol, sector, block1, transactionID);
+
if (n == 0) {
ASSERT(first == 0);
first = last = cluster;
@@ -254,7 +272,8 @@
ASSERT(IS_DATA_CLUSTER(last));
// set last cluster to point to us
- if ((result = _fat_ioctl_(vol,_IOCTL_SET_ENTRY_,last,cluster, tid)) < 0) {
+ if ((result = _fat_ioctl_(vol, _IOCTL_SET_ENTRY_, last, cluster,
+ transactionID)) < 0) {
ASSERT(0);
goto bi;
}
@@ -271,49 +290,59 @@
block_cache_put(vol->fBlockCache, sector);
cluster = 2;
- off = 2 * vol->fat_bits / 8;
- sector = vol->reserved_sectors + vol->active_fat * vol->sectors_per_fat;
+ offset = cluster * vol->fat_bits / 8;
+ sector = vol->reserved_sectors + vol->active_fat
+ * vol->sectors_per_fat;
- if (action != _IOCTL_SET_ENTRY_ && action != _IOCTL_ALLOCATE_N_ENTRIES_)
+ if (readOnly)
block1 = (uint8 *)block_cache_get(vol->fBlockCache, sector);
- else
- block1 = (uint8 *)block_cache_get_writable(vol->fBlockCache, sector, tid);
+ else {
+ block1 = (uint8 *)block_cache_get_writable(vol->fBlockCache,
+ sector, transactionID);
+ }
}
- if (off >= vol->bytes_per_sector) {
+ if (offset >= vol->bytes_per_sector) {
block_cache_put(vol->fBlockCache, sector);
- off -= vol->bytes_per_sector;
sector++;
- ASSERT(sector < vol->reserved_sectors + (vol->active_fat + 1) * vol->sectors_per_fat);
+ offset -= vol->bytes_per_sector;
+ ASSERT(sector < vol->reserved_sectors + (vol->active_fat + 1)
+ * vol->sectors_per_fat);
- if (action != _IOCTL_SET_ENTRY_ && action != _IOCTL_ALLOCATE_N_ENTRIES_)
+ if (readOnly)
block1 = (uint8 *)block_cache_get(vol->fBlockCache, sector);
- else
- block1 = (uint8 *)block_cache_get_writable(vol->fBlockCache, sector, tid);
+ else {
+ block1 = (uint8 *)block_cache_get_writable(vol->fBlockCache,
+ sector, transactionID);
+ }
}
if (block1 == NULL) {
- DPRINTF(0, ("_fat_ioctl_: error reading fat (sector %lx)\n", sector));
- result = EIO;
+ DPRINTF(0, ("_fat_ioctl_: error reading fat (sector %ld)\n", sector));
+ result = B_IO_ERROR;
goto bi;
}
}
bi:
- if (block1)
+ if (block1 != NULL)
block_cache_put(vol->fBlockCache, sector);
- if (_tid == -1 && tid > 0)
- cache_end_transaction(vol->fBlockCache, tid, NULL, NULL);
+ if (_tid == -1 && transactionID > 0)
+ cache_end_transaction(vol->fBlockCache, transactionID, NULL, NULL);
+
if (action == _IOCTL_ALLOCATE_N_ENTRIES_) {
if (result < 0) {
- DPRINTF(0, ("pooh. there is a problem. clearing chain (%lx)\n", first));
- if (first != 0) clear_fat_chain(vol, first);
+ DPRINTF(0, ("pooh. there is a problem. clearing chain (%ld)\n",
+ first));
+ if (first != 0)
+ clear_fat_chain(vol, first);
} else if (n != N) {
- DPRINTF(0, ("not enough free entries (%lx/%lx found)\n", n, N));
- if (first != 0) clear_fat_chain(vol, first);
- result = ENOSPC;
+ DPRINTF(0, ("not enough free entries (%ld/%ld found)\n", n, N));
+ if (first != 0)
+ clear_fat_chain(vol, first);
+ result = B_DEVICE_FULL;
} else if (result == 0) {
vol->last_allocated = cluster;
result = first;
@@ -322,8 +351,10 @@
}
if (result < B_OK) {
- DPRINTF(0, ("_fat_ioctl_ error: action = %lx cluster = %lx N = %lx (%s)\n", action, cluster, N, strerror(result)));
+ DPRINTF(0, ("_fat_ioctl_ error: action = %lx cluster = %ld N = %ld "
+ "(%s)\n", action, cluster, N, strerror(result)));
}
+
return result;
}
@@ -352,7 +383,7 @@
if (value > 0x0ffffff0)
return BAD_FAT_ENTRY;
- DPRINTF(0, ("invalid fat entry: %lx\n", value));
+ DPRINTF(0, ("invalid fat entry: 0x%08lx\n", value));
return BAD_FAT_ENTRY;
}
@@ -368,7 +399,8 @@
int32
get_nth_fat_entry(nspace *vol, int32 cluster, uint32 n)
{
- if (check_nspace_magic(vol, "get_nth_fat_entry")) return EINVAL;
+ if (check_nspace_magic(vol, "get_nth_fat_entry"))
+ return B_BAD_VALUE;
while (n--) {
cluster = get_fat_entry(vol, cluster);
@@ -378,7 +410,6 @@
}
ASSERT(cluster != 0);
-
return cluster;
}
@@ -391,13 +422,15 @@
{
int32 count = 0;
- DPRINTF(2, ("count_clusters %lx\n", cluster));
+ DPRINTF(2, ("count_clusters %ld\n", cluster));
- if (check_nspace_magic(vol, "count_clusters")) return 0;
+ if (check_nspace_magic(vol, "count_clusters"))
+ return 0;
// not intended for use on root directory
if (!IS_DATA_CLUSTER(cluster)) {
- DPRINTF(0, ("count_clusters called on invalid cluster (%lx)\n", cluster));
+ DPRINTF(0, ("count_clusters called on invalid cluster (%ld)\n",
+ cluster));
return 0;
}
@@ -411,14 +444,13 @@
cluster = get_fat_entry(vol, cluster);
}
- DPRINTF(2, ("count_clusters %lx = %lx\n", cluster, count));
+ DPRINTF(2, ("count_clusters %ld = %ld\n", cluster, count));
if (cluster == END_FAT_ENTRY)
return count;
- dprintf("cluster = %lx\n", cluster);
+ dprintf("cluster = %ld\n", cluster);
ASSERT(0);
-
return 0;
}
@@ -430,30 +462,37 @@
status_t result;
if (!IS_DATA_CLUSTER(cluster)) {
- DPRINTF(0, ("clear_fat_chain called on invalid cluster (%lx)\n", cluster));
- return EINVAL;
+ DPRINTF(0, ("clear_fat_chain called on invalid cluster (%ld)\n",
+ cluster));
+ return B_BAD_VALUE;
}
ASSERT(count_clusters(vol, cluster) != 0);
- DPRINTF(2, ("clearing fat chain: %lx", cluster));
+ DPRINTF(2, ("clearing fat chain: %ld", cluster));
while (IS_DATA_CLUSTER(cluster)) {
if ((c = get_fat_entry(vol, cluster)) < 0) {
- DPRINTF(0, ("clear_fat_chain: error clearing fat entry for cluster %lx (%s)\n", cluster, strerror(c)));
+ DPRINTF(0, ("clear_fat_chain: error clearing fat entry for cluster "
+ "%ld (%s)\n", cluster, strerror(c)));
return c;
}
+
if ((result = set_fat_entry(vol, cluster, 0)) != B_OK) {
- DPRINTF(0, ("clear_fat_chain: error clearing fat entry for cluster %lx (%s)\n", cluster, strerror(result)));
+ DPRINTF(0, ("clear_fat_chain: error clearing fat entry for cluster "
+ "%ld (%s)\n", cluster, strerror(result)));
return result;
}
+
vol->free_clusters++;
cluster = c;
- DPRINTF(2, (", %lx", cluster));
+ DPRINTF(2, (", %ld", cluster));
}
DPRINTF(2, ("\n"));
- if (cluster != END_FAT_ENTRY)
- dprintf("clear_fat_chain: fat chain terminated improperly with %lx\n", cluster);
+ if (cluster != END_FAT_ENTRY) {
+ dprintf("clear_fat_chain: fat chain terminated improperly with %ld\n",
+ cluster);
+ }
return 0;
}
@@ -466,7 +505,7 @@
ASSERT(n > 0);
- DPRINTF(2, ("allocating %lx fat entries\n", n));
+ DPRINTF(2, ("allocating %ld fat entries\n", n));
c = _fat_ioctl_(vol, _IOCTL_ALLOCATE_N_ENTRIES_, 0, n, -1);
if (c < 0)
@@ -475,7 +514,7 @@
ASSERT(IS_DATA_CLUSTER(c));
ASSERT(count_clusters(vol, c) == n);
- DPRINTF(2, ("allocated %lx fat entries at %lx\n", n, c));
+ DPRINTF(2, ("allocated %ld fat entries at %ld\n", n, c));
*start = c;
return 0;
@@ -488,27 +527,32 @@
status_t result;
int32 i, c, n;
- DPRINTF(1, ("set_fat_chain_length: %Lx to %lx clusters (%lx)\n", node->vnid, clusters, node->cluster));
+ DPRINTF(1, ("set_fat_chain_length: %Lx to %ld clusters (%ld)\n", node->vnid,
+ clusters, node->cluster));
- if (IS_FIXED_ROOT(node->cluster) || (!IS_DATA_CLUSTER(node->cluster) && (node->cluster != 0))) {
- DPRINTF(0, ("set_fat_chain_length called on invalid cluster (%lx)\n", node->cluster));
- return EINVAL;
+ if (IS_FIXED_ROOT(node->cluster)
+ || (!IS_DATA_CLUSTER(node->cluster) && (node->cluster != 0))) {
+ DPRINTF(0, ("set_fat_chain_length called on invalid cluster (%ld)\n",
+ node->cluster));
+ return B_BAD_VALUE;
}
if (clusters == 0) {
DPRINTF(1, ("truncating node to zero bytes\n"));
if (node->cluster == 0)
return B_OK;
+
c = node->cluster;
if ((result = clear_fat_chain(vol, c)) != B_OK)
return result;
+
node->cluster = 0;
node->end_cluster = 0;
- // XXX: don't have to do this this way -- can clean up nicely
+ // TODO: don't have to do this this way -- can clean up nicely
do {
result = vcache_set_entry(vol, node->vnid,
- GENERATE_DIR_INDEX_VNID(node->dir_vnid, node->sindex));
+ GENERATE_DIR_INDEX_VNID(node->dir_vnid, node->sindex));
// repeat until memory is freed up
if (result != B_OK)
snooze(5000LL);
@@ -516,22 +560,22 @@
/* write to disk so that get_next_dirent doesn't barf */
write_vnode_entry(vol, node);
-
return result;
}
if (node->cluster == 0) {
- DPRINTF(1, ("node has no clusters. adding %lx clusters\n", clusters));
+ DPRINTF(1, ("node has no clusters. adding %ld clusters\n", clusters));
if ((result = allocate_n_fat_entries(vol, clusters, &n)) != B_OK)
return result;
+
node->cluster = n;
node->end_cluster = get_nth_fat_entry(vol, n, clusters - 1);
- // XXX: don't have to do this this way -- can clean up nicely
+ // TODO: don't have to do this this way -- can clean up nicely
do {
result = vcache_set_entry(vol, node->vnid,
- GENERATE_DIR_CLUSTER_VNID(node->dir_vnid, node->cluster));
+ GENERATE_DIR_CLUSTER_VNID(node->dir_vnid, node->cluster));
// repeat until memory is freed up
if (result != B_OK)
snooze(5000LL);
@@ -539,17 +583,17 @@
/* write to disk so that get_next_dirent doesn't barf */
write_vnode_entry(vol, node);
-
return result;
}
- i = (node->st_size + vol->bytes_per_sector * vol->sectors_per_cluster - 1) /
- vol->bytes_per_sector / vol->sectors_per_cluster;
- if (i == clusters) return B_OK;
+ i = (node->st_size + vol->bytes_per_sector * vol->sectors_per_cluster - 1)
+ / vol->bytes_per_sector / vol->sectors_per_cluster;
+ if (i == clusters)
+ return B_OK;
if (clusters > i) {
// add new fat entries
- DPRINTF(1, ("adding %lx new fat entries\n", clusters - i));
+ DPRINTF(1, ("adding %ld new fat entries\n", clusters - i));
if ((result = allocate_n_fat_entries(vol, clusters - i, &n)) != B_OK)
return result;
@@ -562,30 +606,37 @@
}
node->end_cluster = get_nth_fat_entry(vol, n, clusters - i - 1);
-
return result;
}
// traverse fat chain
c = node->cluster;
- n = get_fat_entry(vol,c);
- for (i=1;i<clusters;i++) {
+ n = get_fat_entry(vol, c);
+ for (i = 1; i < clusters; i++) {
if (!IS_DATA_CLUSTER(n))
break;
+
c = n;
- n = get_fat_entry(vol,c);
+ n = get_fat_entry(vol, c);
}
- ASSERT(i == clusters); ASSERT(n != END_FAT_ENTRY);
- if ((i == clusters) && (n == END_FAT_ENTRY)) return B_OK;
+ ASSERT(i == clusters);
+ ASSERT(n != END_FAT_ENTRY);
- if (n < 0) return n;
- if ((n != END_FAT_ENTRY) && !IS_DATA_CLUSTER(n)) return EINVAL;
+ if (i == clusters && n == END_FAT_ENTRY)
+ return B_OK;
+ if (n < 0)
+ return n;
+
+ if (n != END_FAT_ENTRY && !IS_DATA_CLUSTER(n))
+ return B_BAD_VALUE;
+
// clear trailing fat entries
DPRINTF(1, ("clearing trailing fat entries\n"));
if ((result = set_fat_entry(vol, c, 0x0fffffff)) != B_OK)
return result;
+
node->end_cluster = c;
return clear_fat_chain(vol, n);
}
@@ -594,11 +645,12 @@
void
dump_fat_chain(nspace *vol, uint32 cluster)
{
- dprintf("fat chain: %lx", cluster);
+ dprintf("fat chain: %ld", cluster);
while (IS_DATA_CLUSTER(cluster)) {
cluster = get_fat_entry(vol, cluster);
- dprintf(" %lx", cluster);
+ dprintf(" %ld", cluster);
}
+
dprintf("\n");
}
More information about the Haiku-commits
mailing list