mirror of
https://github.com/torvalds/linux.git
synced 2026-04-18 06:44:00 -04:00
0b2600f81c
On 32-bit architectures, unsigned long is only 32 bits wide, which causes 64-bit inode numbers to be silently truncated. Several filesystems (NFS, XFS, BTRFS, etc.) can generate inode numbers that exceed 32 bits, and this truncation can lead to inode number collisions and other subtle bugs on 32-bit systems. Change the type of inode->i_ino from unsigned long to u64 to ensure that inode numbers are always represented as 64-bit values regardless of architecture. Update all format specifiers treewide from %lu/%lx to %llu/%llx to match the new type, along with corresponding local variable types. This is the bulk treewide conversion. Earlier patches in this series handled trace events separately to allow trace field reordering for better struct packing on 32-bit. Signed-off-by: Jeff Layton <jlayton@kernel.org> Link: https://patch.msgid.link/20260304-iino-u64-v3-12-2257ad83d372@kernel.org Acked-by: Damien Le Moal <dlemoal@kernel.org> Reviewed-by: Christoph Hellwig <hch@lst.de> Reviewed-by: Jan Kara <jack@suse.cz> Reviewed-by: Chuck Lever <chuck.lever@oracle.com> Signed-off-by: Christian Brauner <brauner@kernel.org>
272 lines
6.5 KiB
C
272 lines
6.5 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Copyright (c) 2000-2001 Christoph Hellwig.
|
|
*/
|
|
|
|
/*
|
|
* Veritas filesystem driver - filesystem to disk block mapping.
|
|
*/
|
|
#include <linux/fs.h>
|
|
#include <linux/buffer_head.h>
|
|
#include <linux/kernel.h>
|
|
|
|
#include "vxfs.h"
|
|
#include "vxfs_inode.h"
|
|
#include "vxfs_extern.h"
|
|
|
|
|
|
#ifdef DIAGNOSTIC
|
|
static void
|
|
vxfs_typdump(struct vxfs_typed *typ)
|
|
{
|
|
printk(KERN_DEBUG "type=%Lu ", typ->vt_hdr >> VXFS_TYPED_TYPESHIFT);
|
|
printk("offset=%Lx ", typ->vt_hdr & VXFS_TYPED_OFFSETMASK);
|
|
printk("block=%x ", typ->vt_block);
|
|
printk("size=%x\n", typ->vt_size);
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* vxfs_bmap_ext4 - do bmap for ext4 extents
|
|
* @ip: pointer to the inode we do bmap for
|
|
* @bn: logical block.
|
|
*
|
|
* Description:
|
|
* vxfs_bmap_ext4 performs the bmap operation for inodes with
|
|
* ext4-style extents (which are much like the traditional UNIX
|
|
* inode organisation).
|
|
*
|
|
* Returns:
|
|
* The physical block number on success, else Zero.
|
|
*/
|
|
static daddr_t
|
|
vxfs_bmap_ext4(struct inode *ip, long bn)
|
|
{
|
|
struct super_block *sb = ip->i_sb;
|
|
struct vxfs_inode_info *vip = VXFS_INO(ip);
|
|
struct vxfs_sb_info *sbi = VXFS_SBI(sb);
|
|
unsigned long bsize = sb->s_blocksize;
|
|
u32 indsize = fs32_to_cpu(sbi, vip->vii_ext4.ve4_indsize);
|
|
int i;
|
|
|
|
if (indsize > sb->s_blocksize)
|
|
goto fail_size;
|
|
|
|
for (i = 0; i < VXFS_NDADDR; i++) {
|
|
struct direct *d = vip->vii_ext4.ve4_direct + i;
|
|
if (bn >= 0 && bn < fs32_to_cpu(sbi, d->size))
|
|
return (bn + fs32_to_cpu(sbi, d->extent));
|
|
bn -= fs32_to_cpu(sbi, d->size);
|
|
}
|
|
|
|
if ((bn / (indsize * indsize * bsize / 4)) == 0) {
|
|
struct buffer_head *buf;
|
|
daddr_t bno;
|
|
__fs32 *indir;
|
|
|
|
buf = sb_bread(sb,
|
|
fs32_to_cpu(sbi, vip->vii_ext4.ve4_indir[0]));
|
|
if (!buf || !buffer_mapped(buf))
|
|
goto fail_buf;
|
|
|
|
indir = (__fs32 *)buf->b_data;
|
|
bno = fs32_to_cpu(sbi, indir[(bn / indsize) % (indsize * bn)]) +
|
|
(bn % indsize);
|
|
|
|
brelse(buf);
|
|
return bno;
|
|
} else
|
|
printk(KERN_WARNING "no matching indir?");
|
|
|
|
return 0;
|
|
|
|
fail_size:
|
|
printk("vxfs: indirect extent too big!\n");
|
|
fail_buf:
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* vxfs_bmap_indir - recursion for vxfs_bmap_typed
|
|
* @ip: pointer to the inode we do bmap for
|
|
* @indir: indirect block we start reading at
|
|
* @size: size of the typed area to search
|
|
* @block: partially result from further searches
|
|
*
|
|
* Description:
|
|
* vxfs_bmap_indir reads a &struct vxfs_typed at @indir
|
|
* and performs the type-defined action.
|
|
*
|
|
* Returns:
|
|
* The physical block number on success, else Zero.
|
|
*
|
|
* Note:
|
|
* Kernelstack is rare. Unrecurse?
|
|
*/
|
|
static daddr_t
|
|
vxfs_bmap_indir(struct inode *ip, long indir, int size, long block)
|
|
{
|
|
struct vxfs_sb_info *sbi = VXFS_SBI(ip->i_sb);
|
|
struct buffer_head *bp = NULL;
|
|
daddr_t pblock = 0;
|
|
int i;
|
|
|
|
for (i = 0; i < size * VXFS_TYPED_PER_BLOCK(ip->i_sb); i++) {
|
|
struct vxfs_typed *typ;
|
|
int64_t off;
|
|
|
|
bp = sb_bread(ip->i_sb,
|
|
indir + (i / VXFS_TYPED_PER_BLOCK(ip->i_sb)));
|
|
if (!bp || !buffer_mapped(bp))
|
|
return 0;
|
|
|
|
typ = ((struct vxfs_typed *)bp->b_data) +
|
|
(i % VXFS_TYPED_PER_BLOCK(ip->i_sb));
|
|
off = fs64_to_cpu(sbi, typ->vt_hdr) & VXFS_TYPED_OFFSETMASK;
|
|
|
|
if (block < off) {
|
|
brelse(bp);
|
|
continue;
|
|
}
|
|
|
|
switch ((u_int32_t)(fs64_to_cpu(sbi, typ->vt_hdr) >>
|
|
VXFS_TYPED_TYPESHIFT)) {
|
|
case VXFS_TYPED_INDIRECT:
|
|
pblock = vxfs_bmap_indir(ip,
|
|
fs32_to_cpu(sbi, typ->vt_block),
|
|
fs32_to_cpu(sbi, typ->vt_size),
|
|
block - off);
|
|
if (pblock == -2)
|
|
break;
|
|
goto out;
|
|
case VXFS_TYPED_DATA:
|
|
if ((block - off) >= fs32_to_cpu(sbi, typ->vt_size))
|
|
break;
|
|
pblock = fs32_to_cpu(sbi, typ->vt_block) + block - off;
|
|
goto out;
|
|
case VXFS_TYPED_INDIRECT_DEV4:
|
|
case VXFS_TYPED_DATA_DEV4: {
|
|
struct vxfs_typed_dev4 *typ4 =
|
|
(struct vxfs_typed_dev4 *)typ;
|
|
|
|
printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n");
|
|
printk(KERN_INFO "block: %llu\tsize: %lld\tdev: %d\n",
|
|
fs64_to_cpu(sbi, typ4->vd4_block),
|
|
fs64_to_cpu(sbi, typ4->vd4_size),
|
|
fs32_to_cpu(sbi, typ4->vd4_dev));
|
|
goto fail;
|
|
}
|
|
default:
|
|
printk(KERN_ERR "%s:%d vt_hdr %llu\n", __func__,
|
|
__LINE__, fs64_to_cpu(sbi, typ->vt_hdr));
|
|
BUG();
|
|
}
|
|
brelse(bp);
|
|
}
|
|
|
|
fail:
|
|
pblock = 0;
|
|
out:
|
|
brelse(bp);
|
|
return (pblock);
|
|
}
|
|
|
|
/**
|
|
* vxfs_bmap_typed - bmap for typed extents
|
|
* @ip: pointer to the inode we do bmap for
|
|
* @iblock: logical block
|
|
*
|
|
* Description:
|
|
* Performs the bmap operation for typed extents.
|
|
*
|
|
* Returns:
|
|
* The physical block number on success, else Zero.
|
|
*/
|
|
static daddr_t
|
|
vxfs_bmap_typed(struct inode *ip, long iblock)
|
|
{
|
|
struct vxfs_inode_info *vip = VXFS_INO(ip);
|
|
struct vxfs_sb_info *sbi = VXFS_SBI(ip->i_sb);
|
|
daddr_t pblock = 0;
|
|
int i;
|
|
|
|
for (i = 0; i < VXFS_NTYPED; i++) {
|
|
struct vxfs_typed *typ = vip->vii_org.typed + i;
|
|
u64 hdr = fs64_to_cpu(sbi, typ->vt_hdr);
|
|
int64_t off = (hdr & VXFS_TYPED_OFFSETMASK);
|
|
|
|
#ifdef DIAGNOSTIC
|
|
vxfs_typdump(typ);
|
|
#endif
|
|
if (iblock < off)
|
|
continue;
|
|
switch ((u32)(hdr >> VXFS_TYPED_TYPESHIFT)) {
|
|
case VXFS_TYPED_INDIRECT:
|
|
pblock = vxfs_bmap_indir(ip,
|
|
fs32_to_cpu(sbi, typ->vt_block),
|
|
fs32_to_cpu(sbi, typ->vt_size),
|
|
iblock - off);
|
|
if (pblock == -2)
|
|
break;
|
|
return (pblock);
|
|
case VXFS_TYPED_DATA:
|
|
if ((iblock - off) < fs32_to_cpu(sbi, typ->vt_size))
|
|
return (fs32_to_cpu(sbi, typ->vt_block) +
|
|
iblock - off);
|
|
break;
|
|
case VXFS_TYPED_INDIRECT_DEV4:
|
|
case VXFS_TYPED_DATA_DEV4: {
|
|
struct vxfs_typed_dev4 *typ4 =
|
|
(struct vxfs_typed_dev4 *)typ;
|
|
|
|
printk(KERN_INFO "\n\nTYPED_DEV4 detected!\n");
|
|
printk(KERN_INFO "block: %llu\tsize: %lld\tdev: %d\n",
|
|
fs64_to_cpu(sbi, typ4->vd4_block),
|
|
fs64_to_cpu(sbi, typ4->vd4_size),
|
|
fs32_to_cpu(sbi, typ4->vd4_dev));
|
|
return 0;
|
|
}
|
|
default:
|
|
BUG();
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* vxfs_bmap1 - vxfs-internal bmap operation
|
|
* @ip: pointer to the inode we do bmap for
|
|
* @iblock: logical block
|
|
*
|
|
* Description:
|
|
* vxfs_bmap1 perfoms a logical to physical block mapping
|
|
* for vxfs-internal purposes.
|
|
*
|
|
* Returns:
|
|
* The physical block number on success, else Zero.
|
|
*/
|
|
daddr_t
|
|
vxfs_bmap1(struct inode *ip, long iblock)
|
|
{
|
|
struct vxfs_inode_info *vip = VXFS_INO(ip);
|
|
|
|
if (VXFS_ISEXT4(vip))
|
|
return vxfs_bmap_ext4(ip, iblock);
|
|
if (VXFS_ISTYPED(vip))
|
|
return vxfs_bmap_typed(ip, iblock);
|
|
if (VXFS_ISNONE(vip))
|
|
goto unsupp;
|
|
if (VXFS_ISIMMED(vip))
|
|
goto unsupp;
|
|
|
|
printk(KERN_WARNING "vxfs: inode %llu has no valid orgtype (%x)\n",
|
|
ip->i_ino, vip->vii_orgtype);
|
|
BUG();
|
|
|
|
unsupp:
|
|
printk(KERN_WARNING "vxfs: inode %llu has an unsupported orgtype (%x)\n",
|
|
ip->i_ino, vip->vii_orgtype);
|
|
return 0;
|
|
}
|