mirrors/u-boot
1
0
Fork 0
mirror of https://source.denx.de/u-boot/u-boot.git synced 2025-12-19 16:31:27 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

fs: exfat: Remove pointless variable uoffset

Browse Source 
In exfat_generic_pread and exfat_generic_pwrite offset is passed in as a
off_t type which is defined as 'unsigned long long' so there is no need
to create the variable uoffset as a uint64_t as this is just a direct
copy of offset. Also remove the impossible test of 'offset < 0' as this
is always false due to offset being unsigned.

This issue found by Smatch.

Signed-off-by: Andrew Goodbody <andrew.goodbody@linaro.org>
This commit is contained in:
Andrew Goodbody 2025-07-08 12:16:42 +01:00 committed by Tom Rini
parent 505e273475
commit dd4693136b
1 changed files with 17 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
fs/exfat/io.c
View File

@ -479,43 +479,40 @@ ssize_t exfat_pwrite(struct exfat_dev* dev, const void* buffer, size_t size,
ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node, ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
void* buffer, size_t size, off_t offset) void* buffer, size_t size, off_t offset)
{ {
uint64_t uoffset = offset;
cluster_t cluster; cluster_t cluster;
char* bufp = buffer; char* bufp = buffer;
off_t lsize, loffset, remainder; off_t lsize, loffset, remainder;
if (offset < 0) if (offset >= node->size)
return -EINVAL;
if (uoffset >= node->size)
return 0; return 0;
if (size == 0) if (size == 0)
return 0; return 0;
if (uoffset + size > node->valid_size) if (offset + size > node->valid_size)
{ {
ssize_t bytes = 0; ssize_t bytes = 0;
if (uoffset < node->valid_size) if (offset < node->valid_size)
{ {
bytes = exfat_generic_pread(ef, node, buffer, bytes = exfat_generic_pread(ef, node, buffer,
node->valid_size - uoffset, offset); node->valid_size - offset, offset);
if (bytes < 0 || (size_t) bytes < node->valid_size - uoffset) if (bytes < 0 || (size_t)bytes < node->valid_size - offset)
return bytes; return bytes;
} }
memset(buffer + bytes, 0, memset(buffer + bytes, 0,
MIN(size - bytes, node->size - node->valid_size)); MIN(size - bytes, node->size - node->valid_size));
return MIN(size, node->size - uoffset); return MIN(size, node->size - offset);
} }
cluster = exfat_advance_cluster(ef, node, uoffset / CLUSTER_SIZE(*ef->sb)); cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
if (CLUSTER_INVALID(*ef->sb, cluster)) if (CLUSTER_INVALID(*ef->sb, cluster))
{ {
exfat_error("invalid cluster 0x%x while reading", cluster); exfat_error("invalid cluster 0x%x while reading", cluster);
return -EIO; return -EIO;
} }
loffset = uoffset % CLUSTER_SIZE(*ef->sb); loffset = offset % CLUSTER_SIZE(*ef->sb);
remainder = MIN(size, node->size - uoffset); remainder = MIN(size, node->size - offset);
while (remainder > 0) while (remainder > 0)
{ {
if (CLUSTER_INVALID(*ef->sb, cluster)) if (CLUSTER_INVALID(*ef->sb, cluster))
@ -537,43 +534,40 @@ ssize_t exfat_generic_pread(const struct exfat* ef, struct exfat_node* node,
} }
if (!(node->attrib & EXFAT_ATTRIB_DIR) && !ef->ro && !ef->noatime) if (!(node->attrib & EXFAT_ATTRIB_DIR) && !ef->ro && !ef->noatime)
exfat_update_atime(node); exfat_update_atime(node);
return MIN(size, node->size - uoffset) - remainder; return MIN(size, node->size - offset) - remainder;
} }
ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node, ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
const void* buffer, size_t size, off_t offset) const void* buffer, size_t size, off_t offset)
{ {
uint64_t uoffset = offset;
int rc; int rc;
cluster_t cluster; cluster_t cluster;
const char* bufp = buffer; const char* bufp = buffer;
off_t lsize, loffset, remainder; off_t lsize, loffset, remainder;
if (offset < 0) if (offset > node->size)
return -EINVAL;
if (uoffset > node->size)
{ {
rc = exfat_truncate(ef, node, uoffset, true); rc = exfat_truncate(ef, node, offset, true);
if (rc != 0) if (rc != 0)
return rc; return rc;
} }
if (uoffset + size > node->size) if (offset + size > node->size)
{ {
rc = exfat_truncate(ef, node, uoffset + size, false); rc = exfat_truncate(ef, node, offset + size, false);
if (rc != 0) if (rc != 0)
return rc; return rc;
} }
if (size == 0) if (size == 0)
return 0; return 0;
cluster = exfat_advance_cluster(ef, node, uoffset / CLUSTER_SIZE(*ef->sb)); cluster = exfat_advance_cluster(ef, node, offset / CLUSTER_SIZE(*ef->sb));
if (CLUSTER_INVALID(*ef->sb, cluster)) if (CLUSTER_INVALID(*ef->sb, cluster))
{ {
exfat_error("invalid cluster 0x%x while writing", cluster); exfat_error("invalid cluster 0x%x while writing", cluster);
return -EIO; return -EIO;
} }
loffset = uoffset % CLUSTER_SIZE(*ef->sb); loffset = offset % CLUSTER_SIZE(*ef->sb);
remainder = size; remainder = size;
while (remainder > 0) while (remainder > 0)
{ {
@ -592,7 +586,7 @@ ssize_t exfat_generic_pwrite(struct exfat* ef, struct exfat_node* node,
bufp += lsize; bufp += lsize;
loffset = 0; loffset = 0;
remainder -= lsize; remainder -= lsize;
node->valid_size = MAX(node->valid_size, uoffset + size - remainder); node->valid_size = MAX(node->valid_size, offset + size - remainder);
cluster = exfat_next_cluster(ef, node, cluster); cluster = exfat_next_cluster(ef, node, cluster);
} }
if (!(node->attrib & EXFAT_ATTRIB_DIR)) if (!(node->attrib & EXFAT_ATTRIB_DIR))