#
PKG_MAJOR=2
PKG_MINOR=5
-PKG_REVISION=8
+PKG_REVISION=9
PKG_BUILD=0
if (verbose || id->ilist || CHECK_BLIST(bno))
dbprintf("inode %lld mode %#o fmt %s "
"afmt %s "
- "nex %d anex %d nblk %lld sz %lld%s%s\n",
+ "nex %d anex %d nblk %lld sz %lld%s%s%s%s%s%s%s\n",
id->ino, dic->di_mode, fmtnames[(int)dic->di_format],
fmtnames[(int)dic->di_aformat],
dic->di_nextents,
dic->di_anextents,
dic->di_nblocks, dic->di_size,
dic->di_flags & XFS_DIFLAG_REALTIME ? " rt" : "",
- dic->di_flags & XFS_DIFLAG_PREALLOC ? " pre" : ""
- );
+ dic->di_flags & XFS_DIFLAG_PREALLOC ? " pre" : "",
+ dic->di_flags & XFS_DIFLAG_IMMUTABLE? " imm" : "",
+ dic->di_flags & XFS_DIFLAG_APPEND ? " app" : "",
+ dic->di_flags & XFS_DIFLAG_SYNC ? " syn" : "",
+ dic->di_flags & XFS_DIFLAG_NOATIME ? " noa" : "",
+ dic->di_flags & XFS_DIFLAG_NODUMP ? " nod" : "");
security = 0;
switch (dic->di_mode & IFMT) {
case IFDIR:
{ "realtime", FLDT_UINT1,
OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_REALTIME_BIT - 1), C1,
0, TYP_NONE },
+ { "immutable", FLDT_UINT1,
+ OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_IMMUTABLE_BIT-1), C1,
+ 0, TYP_NONE },
+ { "append", FLDT_UINT1,
+ OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_APPEND_BIT - 1), C1,
+ 0, TYP_NONE },
+ { "sync", FLDT_UINT1,
+ OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_SYNC_BIT - 1), C1,
+ 0, TYP_NONE },
+ { "noatime", FLDT_UINT1,
+ OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NOATIME_BIT - 1), C1,
+ 0, TYP_NONE },
+ { "nodump", FLDT_UINT1,
+ OI(COFF(flags) + bitsz(__uint16_t) - XFS_DIFLAG_NODUMP_BIT - 1), C1,
+ 0, TYP_NONE },
{ "gen", FLDT_UINT32D, OI(COFF(gen)), C1, 0, TYP_NONE },
{ NULL }
};
-xfsprogs (2.5.8-1) unstable; urgency=low
+xfsprogs (2.5.9-1) unstable; urgency=low
* New upstream release.
- -- Nathan Scott <nathans@debian.org> Fri, 12 Sep 2003 13:49:46 +1000
+ -- Nathan Scott <nathans@debian.org> Fri, 19 Sep 2003 14:15:16 +1000
xfsprogs (2.5.6-1) unstable; urgency=low
+xfsprogs-2.5.9 (19 September 2003)
+ - Sync up user/kernel source in libxfs, libxlog and headers.
+ - Add new inode flags into xfs_db too.
+
xfsprogs-2.5.8 (12 September 2003)
- Add missing options to xfs_db frag command one-line summary.
- Add xfs_io commands for setting and clearing new inode flags
ENABLE_READLINE = @enable_readline@
HAVE_ZIPPED_MANPAGES = @have_zipped_manpages@
-LCFLAGS += -DXFS_BIG_FILES=1 -DXFS_BIG_FILESYSTEMS=1
-
ifeq ($(PKG_PLATFORM),linux)
PCFLAGS = -D_GNU_SOURCE -D_FILE_OFFSET_BITS=64
endif
#ifndef __LIBXFS_H__
#define __LIBXFS_H__
+#define XFS_BIG_INUMS 1
+#define XFS_BIG_BLKNOS 1
+
#include <xfs/platform_defs.h>
#include <xfs/xfs_fs.h>
#ifndef __XFS_ARCH_H__
#define __XFS_ARCH_H__
-#ifndef XFS_BIG_FILESYSTEMS
-#error XFS_BIG_FILESYSTEMS must be defined true or false
+#ifndef XFS_BIG_INUMS
+# error XFS_BIG_INUMS must be defined true or false
#endif
#ifdef __KERNEL__
#include <asm/byteorder.h>
#ifdef __LITTLE_ENDIAN
-#define __BYTE_ORDER __LITTLE_ENDIAN
+# define __BYTE_ORDER __LITTLE_ENDIAN
#endif
#ifdef __BIG_ENDIAN
-#define __BYTE_ORDER __BIG_ENDIAN
+# define __BYTE_ORDER __BIG_ENDIAN
#endif
#endif /* __KERNEL__ */
/* generic swapping macros */
-#ifndef HAVE_SWABMACROS
#define INT_SWAP16(type,var) ((typeof(type))(__swab16((__u16)(var))))
#define INT_SWAP32(type,var) ((typeof(type))(__swab32((__u32)(var))))
#define INT_SWAP64(type,var) ((typeof(type))(__swab64((__u64)(var))))
-#endif
#define INT_SWAP(type, var) \
((sizeof(type) == 8) ? INT_SWAP64(type,var) : \
(INT_GET_UNALIGNED_32_BE(pointer)) \
)
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
#define DIRINO_GET_ARCH(pointer,arch) \
( ((arch) == ARCH_NOCONVERT) \
? \
* Values and macros for delayed-allocation startblock fields.
*/
#define STARTBLOCKVALBITS 17
-#define STARTBLOCKMASKBITS (15 + XFS_BIG_FILESYSTEMS * 20)
+#define STARTBLOCKMASKBITS (15 + XFS_BIG_BLKNOS * 20)
#define DSTARTBLOCKMASKBITS (15 + 20)
#define STARTBLOCKMASK \
(((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
* There should be a one-to-one correspondence between these flags and the
* XFS_XFLAG_s.
*/
-#define XFS_DIFLAG_REALTIME_BIT 0 /* file's blocks come from rt area */
-#define XFS_DIFLAG_PREALLOC_BIT 1 /* file space has been preallocated */
-#define XFS_DIFLAG_NEWRTBM_BIT 2 /* for rtbitmap inode, new format */
-#define XFS_DIFLAG_REALTIME (1 << XFS_DIFLAG_REALTIME_BIT)
-#define XFS_DIFLAG_PREALLOC (1 << XFS_DIFLAG_PREALLOC_BIT)
-#define XFS_DIFLAG_NEWRTBM (1 << XFS_DIFLAG_NEWRTBM_BIT)
-#define XFS_DIFLAG_ALL \
- (XFS_DIFLAG_REALTIME|XFS_DIFLAG_PREALLOC|XFS_DIFLAG_NEWRTBM)
+#define XFS_DIFLAG_REALTIME_BIT 0 /* file's blocks come from rt area */
+#define XFS_DIFLAG_PREALLOC_BIT 1 /* file space has been preallocated */
+#define XFS_DIFLAG_NEWRTBM_BIT 2 /* for rtbitmap inode, new format */
+#define XFS_DIFLAG_IMMUTABLE_BIT 3 /* inode is immutable */
+#define XFS_DIFLAG_APPEND_BIT 4 /* inode is append-only */
+#define XFS_DIFLAG_SYNC_BIT 5 /* inode is written synchronously */
+#define XFS_DIFLAG_NOATIME_BIT 6 /* do not update atime */
+#define XFS_DIFLAG_NODUMP_BIT 7 /* do not dump */
+#define XFS_DIFLAG_REALTIME (1 << XFS_DIFLAG_REALTIME_BIT)
+#define XFS_DIFLAG_PREALLOC (1 << XFS_DIFLAG_PREALLOC_BIT)
+#define XFS_DIFLAG_NEWRTBM (1 << XFS_DIFLAG_NEWRTBM_BIT)
+#define XFS_DIFLAG_IMMUTABLE (1 << XFS_DIFLAG_IMMUTABLE_BIT)
+#define XFS_DIFLAG_APPEND (1 << XFS_DIFLAG_APPEND_BIT)
+#define XFS_DIFLAG_SYNC (1 << XFS_DIFLAG_SYNC_BIT)
+#define XFS_DIFLAG_NOATIME (1 << XFS_DIFLAG_NOATIME_BIT)
+#define XFS_DIFLAG_NODUMP (1 << XFS_DIFLAG_NODUMP_BIT)
#endif /* __XFS_DINODE_H__ */
sema_t i_flock; /* inode flush lock */
atomic_t i_pincount; /* inode pin count */
wait_queue_head_t i_ipin_wait; /* inode pinning wait queue */
- struct xfs_inode **i_refcache; /* ptr to entry in ref cache */
- struct xfs_inode *i_release; /* inode to unref */
/* I/O state */
xfs_iocore_t i_iocore; /* I/O core */
/*
- * Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
+ * Copyright (c) 2000-2003 Silicon Graphics, Inc. All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of version 2 of the GNU General Public License as
* Used in some places where having 64-bits in the 32-bit kernels
* costs too much.
*/
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
typedef xfs_ino_t xfs_intino_t;
#else
typedef __uint32_t xfs_intino_t;
((xfs_agino_t)(((b) << XFS_INO_OFFSET_BITS(mp)) | (o)))
#endif
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
#define XFS_MAXINUMBER ((xfs_ino_t)((1ULL << 56) - 1ULL))
#define XFS_INO64_OFFSET ((xfs_ino_t)(1ULL << 32))
#else
* endian issues in treating two 32 bit numbers as one 64 bit number
*/
static
-#if defined(__GNUC__) && (__GNUC__ == 2) && ( (__GNUC_MINOR__ == 95) || (__GNUC_MINOR__ == 96))
-__attribute__((unused)) /* gcc 2.95, 2.96 miscompile this when inlined */
+#if defined(__GNUC__) && (__GNUC__ == 2) && (__GNUC_MINOR__ == 95)
+__attribute__((unused)) /* gcc 2.95 miscompiles this when inlined */
#else
__inline__
#endif
__uint64_t m_maxioffset; /* maximum inode offset */
__uint64_t m_resblks; /* total reserved blocks */
__uint64_t m_resblks_avail;/* available reserved blocks */
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
xfs_ino_t m_inoadd; /* add value for ino64_offset */
#endif
int m_dalign; /* stripe unit */
#define XFS_MOUNT_WSYNC 0x00000001 /* for nfs - all metadata ops
must be synchronous except
for space allocations */
-#if XFS_BIG_FILESYSTEMS
#define XFS_MOUNT_INO64 0x00000002
-#endif
/* 0x00000004 -- currently unused */
/* 0x00000008 -- currently unused */
#define XFS_MOUNT_FS_SHUTDOWN 0x00000010 /* atomic stop of all filesystem
#define XFS_MOUNT_DFLT_IOSIZE 0x00001000 /* set default i/o size */
#define XFS_MOUNT_OSYNCISOSYNC 0x00002000 /* o_sync is REALLY o_sync */
/* osyncisdsync is now default*/
-#define XFS_MOUNT_NOUUID 0x00004000 /* ignore uuid during mount */
-#define XFS_MOUNT_32BITINODES 0x00008000 /* do not create inodes above
+#define XFS_MOUNT_32BITINODES 0x00004000 /* do not create inodes above
* 32 bits in size */
-#define XFS_MOUNT_NOLOGFLUSH 0x00010000
+#define XFS_MOUNT_32BITINOOPT 0x00008000 /* saved mount option state */
+#define XFS_MOUNT_NOUUID 0x00010000 /* ignore uuid during mount */
+#define XFS_MOUNT_NOLOGFLUSH 0x00020000
/*
* Default minimum read and write sizes.
#define XFS_RTLOBIT(w) xfs_lowbit32(w)
#define XFS_RTHIBIT(w) xfs_highbit32(w)
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_BLKNOS
#define XFS_RTBLOCKLOG(b) xfs_highbit64(b)
#else
#define XFS_RTBLOCKLOG(b) xfs_highbit32(b)
#error BITS_PER_LONG must be 32 or 64
#endif
-#endif /* __KERNEL__ */
-
/*
- * Some types are conditional based on the selected configuration.
- * Set XFS_BIG_FILESYSTEMS=1 or 0 depending on the desired configuration.
- * XFS_BIG_FILESYSTEMS needs daddr_t to be 64 bits
- *
- * On linux right now we are limited to 2^32 512 byte blocks in a
- * filesystem, Once this limit is changed, setting this to 1
- * will allow XFS to go larger. With BIG_FILESYSTEMS set to 0
- * a 4K block filesystem could still theoretically be 16Gbytes
- * long, so on an ia32 box the 32 bit page index will then be
- * the limiting factor.
+ * Some types are conditional depending on the target system.
+ * XFS_BIG_BLKNOS needs block layer disk addresses to be 64 bits.
+ * XFS_BIG_INUMS needs the VFS inode number to be 64 bits, as well
+ * as requiring XFS_BIG_BLKNOS to be set.
*/
-
#if defined(CONFIG_LBD) || (defined(HAVE_SECTOR_T) && (BITS_PER_LONG == 64))
-# ifndef XFS_BIG_FILESYSTEMS
-# define XFS_BIG_FILESYSTEMS 1
-# endif
+# define XFS_BIG_BLKNOS 1
+# if BITS_PER_LONG == 64
+# define XFS_BIG_INUMS 1
+# else
+# define XFS_BIG_INUMS 0
+# endif
#else
-# ifndef XFS_BIG_FILESYSTEMS
-# define XFS_BIG_FILESYSTEMS 0
-# endif
+# define XFS_BIG_BLKNOS 0
+# define XFS_BIG_INUMS 0
#endif
+#endif /* __KERNEL__ */
+
typedef __uint32_t xfs_agblock_t; /* blockno in alloc. group */
typedef __uint32_t xfs_extlen_t; /* extent length in blocks */
typedef __uint32_t xfs_agnumber_t; /* allocation group number */
/*
* Memory based types are conditional.
*/
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_BLKNOS
typedef __uint64_t xfs_fsblock_t; /* blockno in filesystem (agno|agbno) */
typedef __uint64_t xfs_rfsblock_t; /* blockno in filesystem (raw) */
typedef __uint64_t xfs_rtblock_t; /* extent (block) in realtime area */
#define XFS_MKDEV(major,minor) ((xfs_dev_t)(((major)<<XFS_DEV_BITSMINOR) \
| (minor&XFS_DEV_MAXMIN)))
-#define XFS_DEV_TO_KDEVT(dev) mk_kdev(XFS_DEV_MAJOR(dev),XFS_DEV_MINOR(dev))
+#define XFS_DEV_TO_KDEVT(dev) MKDEV(XFS_DEV_MAJOR(dev),XFS_DEV_MINOR(dev))
-#endif /* !__XFS_TYPES_H */
+#endif /* __XFS_TYPES_H__ */
}
#define XFS_MOUNT_32BITINODES 0x1
+#define XFS_MOUNT_32BITINOOPT 0x2
/*
* Mount structure initialization, provides a filled-in xfs_mount_t
* such that the numerous XFS_* macros can be used. If dev is zero,
mp->m_dev = dev;
mp->m_rtdev = rtdev;
mp->m_logdev = logdev;
- mp->m_flags = XFS_MOUNT_32BITINODES;
+ mp->m_flags = (XFS_MOUNT_32BITINODES|XFS_MOUNT_32BITINOOPT);
mp->m_sb = *sb;
sbp = &(mp->m_sb);
manage_zones(0);
#define XFS_MOUNT_WSYNC 0 /* ignored in userspace */
#define XFS_MOUNT_NOALIGN 0 /* ignored in userspace */
#define XFS_MOUNT_32BITINODES 0x1 /* enforce in userspace */
+#define XFS_MOUNT_32BITINOOPT 0x2 /* enforce in userspace */
#define XFS_ILOCK_EXCL 0
#define down_read(a) ((void) 0)
#define up_read(a) ((void) 0)
ext_flag = (int)(l0 >> (64 - BMBT_EXNTFLAG_BITLEN));
s->br_startoff = ((xfs_fileoff_t)l0 &
XFS_MASK64LO(64 - BMBT_EXNTFLAG_BITLEN)) >> 9;
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_BLKNOS
s->br_startblock = (((xfs_fsblock_t)l0 & XFS_MASK64LO(9)) << 43) |
(((xfs_fsblock_t)l1) >> 21);
#else
#else /* !DEBUG */
s->br_startblock = (xfs_fsblock_t)(((xfs_dfsbno_t)l1) >> 21);
#endif /* DEBUG */
-#endif /* XFS_BIG_FILESYSTEMS */
+#endif /* XFS_BIG_BLKNOS */
s->br_blockcount = (xfs_filblks_t)(l1 & XFS_MASK64LO(21));
/* This is xfs_extent_state() in-line */
if (ext_flag) {
xfs_bmbt_get_startblock(
xfs_bmbt_rec_t *r)
{
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_BLKNOS
return (((xfs_fsblock_t)r->l0 & XFS_MASK64LO(9)) << 43) |
(((xfs_fsblock_t)r->l1) >> 21);
#else
#else /* !DEBUG */
return (xfs_fsblock_t)(((xfs_dfsbno_t)r->l1) >> 21);
#endif /* DEBUG */
-#endif /* XFS_BIG_FILESYSTEMS */
+#endif /* XFS_BIG_BLKNOS */
}
/*
xfs_bmbt_disk_get_startblock(
xfs_bmbt_rec_t *r)
{
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_BLKNOS
return (((xfs_fsblock_t)INT_GET(r->l0, ARCH_CONVERT) & XFS_MASK64LO(9)) << 43) |
(((xfs_fsblock_t)INT_GET(r->l1, ARCH_CONVERT)) >> 21);
#else
#else /* !DEBUG */
return (xfs_fsblock_t)(((xfs_dfsbno_t)INT_GET(r->l1, ARCH_CONVERT)) >> 21);
#endif /* DEBUG */
-#endif /* XFS_BIG_FILESYSTEMS */
+#endif /* XFS_BIG_BLKNOS */
}
/*
extent_flag = (s->br_state == XFS_EXT_NORM) ? 0 : 1;
ASSERT((s->br_startoff & XFS_MASK64HI(9)) == 0);
ASSERT((s->br_blockcount & XFS_MASK64HI(43)) == 0);
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_BLKNOS
ASSERT((s->br_startblock & XFS_MASK64HI(12)) == 0);
-#endif /* XFS_BIG_FILESYSTEMS */
-#if XFS_BIG_FILESYSTEMS
r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
((xfs_bmbt_rec_base_t)s->br_startoff << 9) |
((xfs_bmbt_rec_base_t)s->br_startblock >> 43);
r->l1 = ((xfs_bmbt_rec_base_t)s->br_startblock << 21) |
((xfs_bmbt_rec_base_t)s->br_blockcount &
(xfs_bmbt_rec_base_t)XFS_MASK64LO(21));
-#else /* !XFS_BIG_FILESYSTEMS */
+#else /* !XFS_BIG_BLKNOS */
if (ISNULLSTARTBLOCK(s->br_startblock)) {
r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
((xfs_bmbt_rec_base_t)s->br_startoff << 9) |
((xfs_bmbt_rec_base_t)s->br_blockcount &
(xfs_bmbt_rec_base_t)XFS_MASK64LO(21));
}
-#endif /* XFS_BIG_FILESYSTEMS */
+#endif /* XFS_BIG_BLKNOS */
}
/*
extent_flag = (v == XFS_EXT_NORM) ? 0 : 1;
ASSERT((o & XFS_MASK64HI(64-BMBT_STARTOFF_BITLEN)) == 0);
ASSERT((c & XFS_MASK64HI(64-BMBT_BLOCKCOUNT_BITLEN)) == 0);
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_BLKNOS
ASSERT((b & XFS_MASK64HI(64-BMBT_STARTBLOCK_BITLEN)) == 0);
-#endif /* XFS_BIG_FILESYSTEMS */
-#if XFS_BIG_FILESYSTEMS
r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
((xfs_bmbt_rec_base_t)o << 9) |
((xfs_bmbt_rec_base_t)b >> 43);
r->l1 = ((xfs_bmbt_rec_base_t)b << 21) |
((xfs_bmbt_rec_base_t)c &
(xfs_bmbt_rec_base_t)XFS_MASK64LO(21));
-#else /* !XFS_BIG_FILESYSTEMS */
+#else /* !XFS_BIG_BLKNOS */
if (ISNULLSTARTBLOCK(b)) {
r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
((xfs_bmbt_rec_base_t)o << 9) |
((xfs_bmbt_rec_base_t)c &
(xfs_bmbt_rec_base_t)XFS_MASK64LO(21));
}
-#endif /* XFS_BIG_FILESYSTEMS */
+#endif /* XFS_BIG_BLKNOS */
}
#if ARCH_CONVERT != ARCH_NOCONVERT
extent_flag = (s->br_state == XFS_EXT_NORM) ? 0 : 1;
ASSERT((s->br_startoff & XFS_MASK64HI(9)) == 0);
ASSERT((s->br_blockcount & XFS_MASK64HI(43)) == 0);
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_BLKNOS
ASSERT((s->br_startblock & XFS_MASK64HI(12)) == 0);
-#endif /* XFS_BIG_FILESYSTEMS */
-#if XFS_BIG_FILESYSTEMS
INT_SET(r->l0, ARCH_CONVERT, ((xfs_bmbt_rec_base_t)extent_flag << 63) |
((xfs_bmbt_rec_base_t)s->br_startoff << 9) |
((xfs_bmbt_rec_base_t)s->br_startblock >> 43));
INT_SET(r->l1, ARCH_CONVERT, ((xfs_bmbt_rec_base_t)s->br_startblock << 21) |
((xfs_bmbt_rec_base_t)s->br_blockcount &
(xfs_bmbt_rec_base_t)XFS_MASK64LO(21)));
-#else /* !XFS_BIG_FILESYSTEMS */
+#else /* !XFS_BIG_BLKNOS */
if (ISNULLSTARTBLOCK(s->br_startblock)) {
INT_SET(r->l0, ARCH_CONVERT, ((xfs_bmbt_rec_base_t)extent_flag << 63) |
((xfs_bmbt_rec_base_t)s->br_startoff << 9) |
((xfs_bmbt_rec_base_t)s->br_blockcount &
(xfs_bmbt_rec_base_t)XFS_MASK64LO(21)));
}
-#endif /* XFS_BIG_FILESYSTEMS */
+#endif /* XFS_BIG_BLKNOS */
}
/*
extent_flag = (v == XFS_EXT_NORM) ? 0 : 1;
ASSERT((o & XFS_MASK64HI(64-BMBT_STARTOFF_BITLEN)) == 0);
ASSERT((c & XFS_MASK64HI(64-BMBT_BLOCKCOUNT_BITLEN)) == 0);
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_BLKNOS
ASSERT((b & XFS_MASK64HI(64-BMBT_STARTBLOCK_BITLEN)) == 0);
-#endif /* XFS_BIG_FILESYSTEMS */
-#if XFS_BIG_FILESYSTEMS
INT_SET(r->l0, ARCH_CONVERT, ((xfs_bmbt_rec_base_t)extent_flag << 63) |
((xfs_bmbt_rec_base_t)o << 9) |
((xfs_bmbt_rec_base_t)b >> 43));
INT_SET(r->l1, ARCH_CONVERT, ((xfs_bmbt_rec_base_t)b << 21) |
((xfs_bmbt_rec_base_t)c &
(xfs_bmbt_rec_base_t)XFS_MASK64LO(21)));
-#else /* !XFS_BIG_FILESYSTEMS */
+#else /* !XFS_BIG_BLKNOS */
if (ISNULLSTARTBLOCK(b)) {
INT_SET(r->l0, ARCH_CONVERT, ((xfs_bmbt_rec_base_t)extent_flag << 63) |
((xfs_bmbt_rec_base_t)o << 9) |
((xfs_bmbt_rec_base_t)c &
(xfs_bmbt_rec_base_t)XFS_MASK64LO(21)));
}
-#endif /* XFS_BIG_FILESYSTEMS */
+#endif /* XFS_BIG_BLKNOS */
}
#endif
xfs_bmbt_rec_t *r,
xfs_fsblock_t v)
{
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_BLKNOS
ASSERT((v & XFS_MASK64HI(12)) == 0);
-#endif /* XFS_BIG_FILESYSTEMS */
-#if XFS_BIG_FILESYSTEMS
r->l0 = (r->l0 & (xfs_bmbt_rec_base_t)XFS_MASK64HI(55)) |
(xfs_bmbt_rec_base_t)(v >> 43);
r->l1 = (r->l1 & (xfs_bmbt_rec_base_t)XFS_MASK64LO(21)) |
(xfs_bmbt_rec_base_t)(v << 21);
-#else /* !XFS_BIG_FILESYSTEMS */
+#else /* !XFS_BIG_BLKNOS */
if (ISNULLSTARTBLOCK(v)) {
r->l0 |= (xfs_bmbt_rec_base_t)XFS_MASK64LO(9);
r->l1 = (xfs_bmbt_rec_base_t)XFS_MASK64HI(11) |
r->l1 = ((xfs_bmbt_rec_base_t)v << 21) |
(r->l1 & (xfs_bmbt_rec_base_t)XFS_MASK64LO(21));
}
-#endif /* XFS_BIG_FILESYSTEMS */
+#endif /* XFS_BIG_BLKNOS */
}
/*
isdotdot =
dep->namelen == 2 &&
dep->name[0] == '.' && dep->name[1] == '.';
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
if (!isdot)
i8count += INT_GET(dep->inumber, ARCH_CONVERT) > XFS_DIR2_MAX_SHORT_INUM;
#endif
*/
add_entsize = XFS_DIR2_SF_ENTSIZE_BYNAME(sfp, args->namelen);
incr_isize = add_entsize;
-#if XFS_BIG_FILESYSTEMS
+ objchange = 0;
+#if XFS_BIG_INUMS
/*
* Do we have to change to 8 byte inodes?
*/
((uint)sizeof(xfs_dir2_ino8_t) -
(uint)sizeof(xfs_dir2_ino4_t));
objchange = 1;
- } else
- objchange = 0;
-#else
- objchange = 0;
+ }
#endif
old_isize = (int)dp->i_d.di_size;
new_isize = old_isize + incr_isize;
*/
else {
ASSERT(pick == 2);
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
if (objchange)
xfs_dir2_sf_toino8(args);
#endif
* Update the header and inode.
*/
sfp->hdr.count++;
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
if (args->inumber > XFS_DIR2_MAX_SHORT_INUM)
sfp->hdr.i8count++;
#endif
XFS_DIR2_SF_PUT_INUMBER_ARCH(sfp, &args->inumber,
XFS_DIR2_SF_INUMBERP(sfep), ARCH_CONVERT);
sfp->hdr.count++;
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
if (args->inumber > XFS_DIR2_MAX_SHORT_INUM && !objchange)
sfp->hdr.i8count++;
#endif
/*
* If changing the inode number size, do it the hard way.
*/
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
if (objchange) {
return 2;
}
XFS_DIR2_DATA_ENTSIZE(sfep->namelen);
}
ASSERT(i8count == sfp->hdr.i8count);
-#if !XFS_BIG_FILESYSTEMS
- ASSERT(i8count == 0);
-#endif
+ ASSERT(XFS_BIG_INUMS || i8count == 0);
ASSERT((char *)sfep - (char *)sfp == dp->i_d.di_size);
ASSERT(offset +
(sfp->hdr.count + 2) * (uint)sizeof(xfs_dir2_leaf_entry_t) +
*/
xfs_idata_realloc(dp, newsize - oldsize, XFS_DATA_FORK);
sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
/*
* Are we changing inode number size?
*/
{
xfs_inode_t *dp; /* incore directory inode */
int i; /* entry index */
-#if XFS_BIG_FILESYSTEMS || defined(DEBUG)
+#if XFS_BIG_INUMS || defined(DEBUG)
xfs_ino_t ino=0; /* entry old inode number */
#endif
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
int i8elevated; /* sf_toino8 set i8count=1 */
#endif
xfs_dir2_sf_entry_t *sfep; /* shortform directory entry */
ASSERT(dp->i_df.if_u1.if_data != NULL);
sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
ASSERT(dp->i_d.di_size >= XFS_DIR2_SF_HDR_SIZE(sfp->hdr.i8count));
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
/*
* New inode number is large, and need to convert to 8-byte inodes.
*/
*/
if (args->namelen == 2 &&
args->name[0] == '.' && args->name[1] == '.') {
-#if XFS_BIG_FILESYSTEMS || defined(DEBUG)
+#if XFS_BIG_INUMS || defined(DEBUG)
ino = XFS_DIR2_SF_GET_INUMBER_ARCH(sfp, &sfp->hdr.parent, ARCH_CONVERT);
ASSERT(args->inumber != ino);
#endif
if (sfep->namelen == args->namelen &&
sfep->name[0] == args->name[0] &&
memcmp(args->name, sfep->name, args->namelen) == 0) {
-#if XFS_BIG_FILESYSTEMS || defined(DEBUG)
+#if XFS_BIG_INUMS || defined(DEBUG)
ino = XFS_DIR2_SF_GET_INUMBER_ARCH(sfp,
XFS_DIR2_SF_INUMBERP(sfep), ARCH_CONVERT);
ASSERT(args->inumber != ino);
*/
if (i == sfp->hdr.count) {
ASSERT(args->oknoent);
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
if (i8elevated)
xfs_dir2_sf_toino4(args);
#endif
return XFS_ERROR(ENOENT);
}
}
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
/*
* See if the old number was large, the new number is small.
*/
return 0;
}
-#if XFS_BIG_FILESYSTEMS
+#if XFS_BIG_INUMS
/*
* Convert from 8-byte inode numbers to 4-byte inode numbers.
* The last 8-byte inode number is gone, but the count is still 1.
dp->i_d.di_size = newsize;
xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
}
-#endif /* XFS_BIG_FILESYSTEMS */
+#endif /* XFS_BIG_INUMS */
entry_d = &leaf_d->entries[start_d];
for (i = 0; i < count; entry_s++, entry_d++, i++) {
ASSERT(INT_GET(entry_s->nameidx, ARCH_CONVERT) >= INT_GET(hdr_s->firstused, ARCH_CONVERT));
- ASSERT(entry_s->namelen < MAXNAMELEN);
tmp = XFS_DIR_LEAF_ENTSIZE_BYENTRY(entry_s);
INT_MOD(hdr_d->firstused, ARCH_CONVERT, -(tmp));
entry_d->hashval = entry_s->hashval; /* INT_: direct copy */
ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino);
/* Clear the mount flag if no inode can overflow 32 bits
- * on this filesystem.
+ * on this filesystem, or if specifically requested..
*/
- if (ino <= max_inum) {
+ if ((mp->m_flags & XFS_MOUNT_32BITINOOPT) && ino > max_inum) {
+ mp->m_flags |= XFS_MOUNT_32BITINODES;
+ } else {
mp->m_flags &= ~XFS_MOUNT_32BITINODES;
}
{
xlog_recover_item_t *item;
- item = kmem_zalloc(sizeof(xlog_recover_item_t), 0);
+ item = kmem_zalloc(sizeof(xlog_recover_item_t), KM_SLEEP);
xlog_recover_insert_item_backq(itemq, item);
}
item->ri_total = in_f->ilf_size;
ASSERT(item->ri_total <= XLOG_MAX_REGIONS_IN_ITEM);
item->ri_buf = kmem_zalloc((item->ri_total *
- sizeof(xfs_log_iovec_t)), 0);
+ sizeof(xfs_log_iovec_t)), KM_SLEEP);
}
ASSERT(item->ri_total > item->ri_cnt);
/* Description region is ri_buf[0] */
projects / thirdparty / xfsprogs-dev.git / commitdiff
