#
PKG_MAJOR=2
PKG_MINOR=3
-PKG_REVISION=5
+PKG_REVISION=6
PKG_BUILD=0
#include <libxfs.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
-#include <sys/vfs.h>
int aflag = 0; /* Attribute fork. */
int lflag = 0; /* list number of blocks with each extent */
char *progname;
int dofile(char *);
-__off64_t file_size(int fd, char * fname);
-int numlen(__off64_t);
+off64_t file_size(int fd, char * fname);
+int numlen(off64_t);
int
main(int argc, char **argv)
return(i ? 1 : 0);
}
-__off64_t
+off64_t
file_size(int fd, char *fname)
{
struct stat64 st;
return 1;
}
fstatfs(fd, &buf);
- if (buf.f_type != XFS_SUPER_MAGIC) {
+ if (statfstype(&buf) != XFS_SUPER_MAGIC) {
fprintf(stderr, "%s: "
"specified file [\"%s\"] is not on an XFS filesystem\n",
progname, fname);
#define MINTOT_WIDTH 5
#define max(a,b) (a > b ? a : b)
int agno;
- __off64_t agoff, bbperag;
+ off64_t agoff, bbperag;
int foff_w, boff_w, aoff_w, tot_w, agno_w;
char rbuf[32], bbuf[32], abuf[32];
foff_w = boff_w = aoff_w = MINRANGE_WIDTH;
tot_w = MINTOT_WIDTH;
- bbperag = (__off64_t)fsgeo.agblocks *
- (__off64_t)fsgeo.blocksize / BBSIZE;
+ bbperag = (off64_t)fsgeo.agblocks *
+ (off64_t)fsgeo.blocksize / BBSIZE;
/*
* Go through the extents and figure out the width
}
int
-numlen( __off64_t val)
+numlen(off64_t val)
{
- __off64_t tmp;
+ off64_t tmp;
int len;
for (len=0, tmp=val; tmp > 0; tmp=tmp/10) len++;
while ((c = getopt(argc, argv, "b:i:npsv")) != EOF) {
switch (c) {
case 'b':
- bno = atoll(optarg);
+ bno = strtoll(optarg, NULL, 10);
add_blist(bno);
break;
case 'i':
- ino = atoll(optarg);
+ ino = strtoll(optarg, NULL, 10);
add_ilist(ino);
break;
case 'n':
while ((c = getopt(argc, argv, "i:s")) != EOF) {
switch (c) {
case 'i':
- ino = atoll(optarg);
+ ino = strtoll(optarg, NULL, 10);
ilist = xrealloc(ilist, (ilist_size + 1) *
sizeof(*ilist));
ilist[ilist_size++] = ino;
ic = 1;
break;
default:
+ break;
}
if (ic)
quota_add(dic->di_gid, dic->di_uid, 0, bc, ic, rc);
return (__uint64_t)val->inooff;
case CT_NONE:
case NCTS:
+ break;
}
/* NOTREACHED */
return 0;
case CT_NONE:
case NCTS:
/* NOTREACHED */
+ break;
}
dbprintf("0x%llx (%llu)\n", v, v);
return 0;
case CT_NONE:
case NCTS:
/* NOTREACHED */
+ break;
}
return 1;
}
xfs_mount_t *mp;
-static void
-compute_maxlevels(
- xfs_mount_t *mp,
- int whichfork)
-{
- int level;
- uint maxblocks;
- uint maxleafents;
- int maxrootrecs;
- int minleafrecs;
- int minnoderecs;
- int sz;
-
- maxleafents = (whichfork == XFS_DATA_FORK) ? MAXEXTNUM : MAXAEXTNUM;
- minleafrecs = mp->m_bmap_dmnr[0];
- minnoderecs = mp->m_bmap_dmnr[1];
- sz = mp->m_sb.sb_inodesize;
- maxrootrecs = (int)XFS_BTREE_BLOCK_MAXRECS(sz, xfs_bmdr, 0);
- maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs;
- for (level = 1; maxblocks > 1; level++) {
- if (maxblocks <= maxrootrecs)
- maxblocks = 1;
- else
- maxblocks = (maxblocks + minnoderecs - 1) / minnoderecs;
- }
- mp->m_bm_maxlevels[whichfork] = level;
-}
-
xfs_mount_t *
dbmount(void)
{
void *bufp;
- int i;
xfs_mount_t *mp;
xfs_sb_t *sbp;
libxfs_xlate_sb(bufp, &mp->m_sb, 1, ARCH_CONVERT, XFS_SB_ALL_BITS);
xfree(bufp);
sbp = &mp->m_sb;
-
if (sbp->sb_magicnum != XFS_SB_MAGIC) {
fprintf(stderr,"%s: unexpected XFS SB magic number 0x%08x\n",
progname, sbp->sb_magicnum);
}
- mp->m_blkbit_log = sbp->sb_blocklog + XFS_NBBYLOG;
- mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT;
- mp->m_agno_log = libxfs_highbit32(sbp->sb_agcount - 1) + 1;
- mp->m_agino_log = sbp->sb_inopblog + sbp->sb_agblklog;
- mp->m_litino =
- (int)(sbp->sb_inodesize -
- (sizeof(xfs_dinode_core_t) + sizeof(xfs_agino_t)));
- mp->m_blockmask = sbp->sb_blocksize - 1;
- mp->m_blockwsize = sbp->sb_blocksize >> XFS_WORDLOG;
- mp->m_blockwmask = mp->m_blockwsize - 1;
- for (i = 0; i < 2; i++) {
- mp->m_alloc_mxr[i] =
- (uint)XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize,
- xfs_alloc, i == 0);
- mp->m_alloc_mnr[i] =
- (uint)XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize,
- xfs_alloc, i == 0);
- mp->m_bmap_dmxr[i] =
- (uint)XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize,
- xfs_bmbt, i == 0);
- mp->m_bmap_dmnr[i] =
- (uint)XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize,
- xfs_bmbt, i == 0);
- mp->m_inobt_mxr[i] =
- (uint)XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize,
- xfs_inobt, i == 0);
- mp->m_inobt_mnr[i] =
- (uint)XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize,
- xfs_inobt, i == 0);
- }
- compute_maxlevels(mp, XFS_DATA_FORK);
- compute_maxlevels(mp, XFS_ATTR_FORK);
- mp->m_bsize = XFS_FSB_TO_BB(mp, 1);
- mp->m_ialloc_inos = (int)MAX(XFS_INODES_PER_CHUNK, sbp->sb_inopblock);
- mp->m_ialloc_blks = mp->m_ialloc_inos >> sbp->sb_inopblog;
+
+ libxfs_mount_common(mp, sbp);
+ libxfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
+ libxfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
+ libxfs_ialloc_compute_maxlevels(mp);
+
if (sbp->sb_rblocks) {
mp->m_rsumlevels = sbp->sb_rextslog + 1;
mp->m_rsumsize =
mp->m_rsumsize =
roundup(mp->m_rsumsize, sbp->sb_blocksize);
}
+
if (XFS_SB_VERSION_HASDIRV2(sbp)) {
- mp->m_dirversion = 2;
- mp->m_dirblksize =
- 1 << (sbp->sb_dirblklog + sbp->sb_blocklog);
- mp->m_dirblkfsbs = 1 << sbp->sb_dirblklog;
- mp->m_dirdatablk =
- XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_DATA_FIRSTDB(mp));
- mp->m_dirleafblk =
- XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_LEAF_FIRSTDB(mp));
- mp->m_dirfreeblk =
- XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_FREE_FIRSTDB(mp));
+ libxfs_dir2_mount(mp);
} else {
- mp->m_dirversion = 1;
- mp->m_dirblksize = sbp->sb_blocksize;
- mp->m_dirblkfsbs = 1;
+ libxfs_dir_mount(mp);
}
return mp;
}
+xfsprogs (2.3.6-1) unstable; urgency=low
+
+ * New upstream release
+
+ -- Nathan Scott <nathans@debian.org> Thu, 31 Oct 2002 17:26:44 +1100
+
xfsprogs (2.3.5-1) unstable; urgency=low
* New upstream release
+xfsprogs-2.3.6 (31 October 2002)
+ - Sync up user/kernel source in lib{xfs,xlog} and headers.
+ - Fix several warnings from newer (3.2) versions of gcc.
+ - Minor header file shuffling.
+
xfsprogs-2.3.5 (10 October 2002)
- Sync up user/kernel source in lib{xfs,xlog} and headers.
- Fix mkfs (libxfs) bug when using BLKFLSBUF ioctl - we passed
#include <libxfs.h>
#include <sys/ioctl.h>
-#include <sys/vfs.h>
char *progname;
return 1;
}
fstatfs(ffd, &buf);
- if (buf.f_type != XFS_SUPER_MAGIC) {
+ if (statfstype(&buf) != XFS_SUPER_MAGIC) {
fprintf(stderr,
"%s: specified file is not on an XFS filesystem\n",
progname);
#include <libxfs.h>
#include <sys/ioctl.h>
-#include <sys/vfs.h>
int main(int argc, char **argv)
{
return 1;
}
fstatfs(fd, &buf);
- if (buf.f_type != XFS_SUPER_MAGIC) {
+ if (statfstype(&buf) != XFS_SUPER_MAGIC) {
fprintf(stderr, "%s: "
"specified file [\"%s\"] is not on an XFS filesystem\n",
progname, name);
uint m_flags; /* global mount flags */
uint m_qflags; /* quota status flags */
uint m_attroffset; /* inode attribute offset */
- int m_da_node_ents; /* how many entries in danode */
+ uint m_dir_node_ents; /* #entries in a dir danode */
+ uint m_attr_node_ents; /* #entries in attr danode */
int m_ialloc_inos; /* inodes in inode allocation */
int m_ialloc_blks; /* blocks in inode allocation */
int m_litino; /* size of inode union area */
#define __XFS_PLATFORM_DEFS_H__
#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
#include <stdarg.h>
#include <assert.h>
-#include <endian.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
-#include <sys/param.h>
#include <sys/types.h>
+
+#if defined(__linux__)
+
+#include <sys/vfs.h>
+#include <sys/param.h>
#include <uuid/uuid.h>
+#include <linux/types.h>
+#include <malloc.h>
+#include <getopt.h>
+#include <endian.h>
#if defined (__powerpc__) /* ppc fix from: Robert Ramiega (jedi@plukwa.net) */
# define __BYTEORDER_HAS_U64__
#endif
#include <asm/byteorder.h>
-#include <errno.h>
-#include <fcntl.h>
-
#ifndef O_DIRECT
# if defined (__powerpc__)
# define O_DIRECT 0400000
# define constpp char * const *
#endif
+#define ENOATTR ENODATA /* Attribute not found */
+#define EFSCORRUPTED 990 /* Filesystem is corrupted */
+#define statfstype(bp) ((bp)->f_type) /* statfs(2) fstyp */
+
typedef loff_t xfs_off_t;
typedef __uint64_t xfs_ino_t;
typedef __uint32_t xfs_dev_t;
typedef char* xfs_caddr_t;
typedef unsigned char uchar_t;
+typedef enum { B_FALSE,B_TRUE } boolean_t;
+
+#endif
+
/* long and pointer must be either 32 bit or 64 bit */
#undef HAVE_32BIT_LONG
typedef struct xfs_da_node_hdr xfs_da_node_hdr_t;
typedef struct xfs_da_node_entry xfs_da_node_entry_t;
-#define XFS_DA_NODE_ENTSIZE_BYNAME /* space a name uses */ \
- (sizeof(xfs_da_node_entry_t))
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DA_NODE_ENTRIES)
-int xfs_da_node_entries(struct xfs_mount *mp);
-#define XFS_DA_NODE_ENTRIES(mp) xfs_da_node_entries(mp)
-#else
-#define XFS_DA_NODE_ENTRIES(mp) ((mp)->m_da_node_ents)
-#endif
-
#define XFS_DA_MAXHASH ((xfs_dahash_t)-1) /* largest valid hash value */
/*
typedef struct xfs_da_state_blk {
xfs_dabuf_t *bp; /* buffer containing block */
xfs_dablk_t blkno; /* filesystem blkno of buffer */
- xfs_daddr_t disk_blkno; /* on-disk blkno (in BBs) of buffer */
+ xfs_daddr_t disk_blkno; /* on-disk blkno (in BBs) of buffer */
int index; /* relevant index into block */
xfs_dahash_t hashval; /* last hash value in block */
int magic; /* blk's magic number, ie: blk type */
typedef struct xfs_da_state {
xfs_da_args_t *args; /* filename arguments */
struct xfs_mount *mp; /* filesystem mount point */
- int blocksize; /* logical block size */
- int inleaf; /* insert into 1->lf, 0->splf */
+ unsigned int blocksize; /* logical block size */
+ unsigned int node_ents; /* how many entries in danode */
xfs_da_state_path_t path; /* search/split paths */
xfs_da_state_path_t altpath; /* alternate path for join */
- int extravalid; /* T/F: extrablk is in use */
- int extraafter; /* T/F: extrablk is after new */
+ unsigned int inleaf : 1; /* insert into 1->lf, 0->splf */
+ unsigned int extravalid : 1; /* T/F: extrablk is in use */
+ unsigned int extraafter : 1; /* T/F: extrablk is after new */
xfs_da_state_blk_t extrablk; /* for double-splits on leafs */
/* for dirv2 extrablk is data */
} xfs_da_state_t;
uint m_dmevmask; /* DMI events for this FS */
uint m_flags; /* global mount flags */
uint m_attroffset; /* inode attribute offset */
- int m_da_node_ents; /* how many entries in danode */
+ uint m_dir_node_ents; /* #entries in a dir danode */
+ uint m_attr_node_ents; /* #entries in attr danode */
int m_ialloc_inos; /* inodes in inode allocation */
int m_ialloc_blks; /* blocks in inode allocation */
int m_litino; /* size of inode union area */
*/
#include <libxfs.h>
-#include <malloc.h>
#include <xfs_log.h>
#include <xfs_log_priv.h>
/* anything else */
typedef __uint32_t uint_t;
typedef __uint32_t inst_t; /* an instruction */
-typedef enum { B_FALSE, B_TRUE } boolean_t;
typedef struct { dev_t dev; } xfs_buftarg_t;
+#undef MASK
+#define NBPP getpagesize()
#define STATIC
#define ATTR_ROOT 0x0002 /* use attrs in root namespace */
#define ENOATTR ENODATA /* Attribute not found */
n = ((unsigned long) n) / (unsigned) base; \
__res; })
-#include <asm/page.h>
-#define NBPP PAGE_SIZE
-
static inline int atomicIncWithWrap(int *a, int b)
{
int r = *a;
INT_SET(node->btree[1].hashval, ARCH_CONVERT, blk2->hashval);
INT_SET(node->btree[1].before, ARCH_CONVERT, blk2->blkno);
INT_SET(node->hdr.count, ARCH_CONVERT, 2);
- if (XFS_DIR_IS_V2(mp)) {
+
+#ifdef DEBUG
+ if (INT_GET(oldroot->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC) {
ASSERT(blk1->blkno >= mp->m_dirleafblk &&
blk1->blkno < mp->m_dirfreeblk);
ASSERT(blk2->blkno >= mp->m_dirleafblk &&
blk2->blkno < mp->m_dirfreeblk);
}
+#endif
+
/* Header is already logged by xfs_da_node_create */
xfs_da_log_buf(tp, bp,
XFS_DA_LOGRANGE(node, node->btree,
/*
* Do we have to split the node?
*/
- if ((INT_GET(node->hdr.count, ARCH_CONVERT) + newcount) > XFS_DA_NODE_ENTRIES(state->mp)) {
+ if ((INT_GET(node->hdr.count, ARCH_CONVERT) + newcount) > state->node_ents) {
/*
* Allocate a new node, add to the doubly linked chain of
* nodes, then move some of our excess entries into it.
ASSERT(INT_GET(info->magic, ARCH_CONVERT) == XFS_DA_NODE_MAGIC);
node = (xfs_da_intnode_t *)info;
count = INT_GET(node->hdr.count, ARCH_CONVERT);
- if (count > (XFS_DA_NODE_ENTRIES(state->mp) >> 1)) {
+ if (count > (state->node_ents >> 1)) {
*action = 0; /* blk over 50%, dont try to join */
return(0); /* blk over 50%, dont try to join */
}
ASSERT(bp != NULL);
node = (xfs_da_intnode_t *)info;
- count = XFS_DA_NODE_ENTRIES(state->mp);
- count -= XFS_DA_NODE_ENTRIES(state->mp) >> 2;
+ count = state->node_ents;
+ count -= state->node_ents >> 2;
count -= INT_GET(node->hdr.count, ARCH_CONVERT);
node = bp->data;
ASSERT(INT_GET(node->hdr.info.magic, ARCH_CONVERT) == XFS_DA_NODE_MAGIC);
count = shortcount > leafcount ? shortcount : leafcount;
mp->m_dircook_elog = xfs_da_log2_roundup(count + 1);
ASSERT(mp->m_dircook_elog <= mp->m_sb.sb_blocklog);
- mp->m_da_node_ents =
+ mp->m_dir_node_ents = mp->m_attr_node_ents =
(XFS_LBSIZE(mp) - (uint)sizeof(xfs_da_node_hdr_t)) /
(uint)sizeof(xfs_da_node_entry_t);
mp->m_dir_magicpct = (XFS_LBSIZE(mp) * 37) / 100;
state->args = args;
state->mp = args->dp->i_mount;
state->blocksize = state->mp->m_sb.sb_blocksize;
+ state->node_ents = state->mp->m_dir_node_ents;
/*
* Search to see if name already exists, and get back a pointer
state->args = args;
state->mp = args->dp->i_mount;
state->blocksize = state->mp->m_sb.sb_blocksize;
+ state->node_ents = state->mp->m_dir_node_ents;
/*
* Search to see if name exists, and get back a pointer to it.
state->args = args;
state->mp = args->dp->i_mount;
state->blocksize = state->mp->m_sb.sb_blocksize;
+ state->node_ents = state->mp->m_dir_node_ents;
/*
* Search to see if name exists,
state->args = args;
state->mp = args->dp->i_mount;
state->blocksize = state->mp->m_sb.sb_blocksize;
+ state->node_ents = state->mp->m_dir_node_ents;
inum = args->inumber;
/*
mp->m_dirdatablk = XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_DATA_FIRSTDB(mp));
mp->m_dirleafblk = XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_LEAF_FIRSTDB(mp));
mp->m_dirfreeblk = XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_FREE_FIRSTDB(mp));
- mp->m_da_node_ents =
+ mp->m_attr_node_ents =
+ (mp->m_sb.sb_blocksize - (uint)sizeof(xfs_da_node_hdr_t)) /
+ (uint)sizeof(xfs_da_node_entry_t);
+ mp->m_dir_node_ents =
(mp->m_dirblksize - (uint)sizeof(xfs_da_node_hdr_t)) /
(uint)sizeof(xfs_da_node_entry_t);
mp->m_dir_magicpct = (mp->m_dirblksize * 37) / 100;
state->args = args;
state->mp = args->dp->i_mount;
state->blocksize = state->mp->m_dirblksize;
+ state->node_ents = state->mp->m_dir_node_ents;
/*
* Look up the name. We're not supposed to find it, but
* this gives us the insertion point.
state->args = args;
state->mp = args->dp->i_mount;
state->blocksize = state->mp->m_dirblksize;
+ state->node_ents = state->mp->m_dir_node_ents;
/*
* Fill in the path to the entry in the cursor.
*/
state->args = args;
state->mp = args->dp->i_mount;
state->blocksize = state->mp->m_dirblksize;
+ state->node_ents = state->mp->m_dir_node_ents;
/*
* Look up the entry we're deleting, set up the cursor.
*/
state->args = args;
state->mp = args->dp->i_mount;
state->blocksize = state->mp->m_dirblksize;
+ state->node_ents = state->mp->m_dir_node_ents;
inum = args->inumber;
/*
* Lookup the entry to change in the btree.
XFS_AGINO_TO_INO(mp, agno, agino) == ino;
if (XFS_TEST_ERROR(!ino_ok, mp, XFS_ERRTAG_DIR_INO_VALIDATE,
XFS_RANDOM_DIR_INO_VALIDATE)) {
- xfs_fs_cmn_err(CE_WARN, mp, "Invalid inode number 0x%Lx\n",
+ xfs_fs_cmn_err(CE_WARN, mp, "Invalid inode number 0x%Lx",
(unsigned long long) ino);
return XFS_ERROR(EFSCORRUPTED);
}
* mkfs etc write a dummy unmount record to a fresh
* log so we can store the uuid in there
*/
- xlog_warn("XFS: totally zeroed log\n");
+ xlog_warn("XFS: totally zeroed log");
}
return 0;
"XFS: Disregard message if filesystem was created with non-DEBUG kernel");
if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
cmn_err(CE_DEBUG,
- "XFS: LogR this is a LogV2 filesystem\n");
+ "XFS: LogR this is a LogV2 filesystem");
}
log->l_flags |= XLOG_CHKSUM_MISMATCH;
}
*/
#include <libxfs.h>
-#include <malloc.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
-#include <sys/vfs.h>
#include <ctype.h>
#define MAXBUFFERSIZE (256 * 1024)
}
fstatfs(fd, &buf);
- if (buf.f_type != XFS_SUPER_MAGIC) {
+ if (statfstype(&buf) != XFS_SUPER_MAGIC) {
fprintf(stderr, "%s: "
"file [\"%s\"] is not on an XFS filesystem\n",
progname, name);
argv[optind][len-1] = '\0';
}
- size = atoll(argv[optind]) * mult;
+ size = strtoll(argv[optind], NULL, 10) * mult;
optind++;
libxfs_putbuf(bp);
goto error_out;
}
- if (INT_GET(node->hdr.count, ARCH_CONVERT) > XFS_DA_NODE_ENTRIES(mp)) {
+ if (INT_GET(node->hdr.count, ARCH_CONVERT) >
+ mp->m_dir_node_ents) {
do_warn("bad record count in inode %llu, count = %d, max = %d\n",
da_cursor->ino, INT_GET(node->hdr.count, ARCH_CONVERT),
- XFS_DA_NODE_ENTRIES(mp));
+ mp->m_dir_node_ents);
libxfs_putbuf(bp);
goto error_out;
}
bad++;
}
if (INT_GET(newnode->hdr.count, ARCH_CONVERT) >
- XFS_DA_NODE_ENTRIES(mp)) {
+ mp->m_dir_node_ents) {
do_warn("entry count %d too large in block %u (%llu) for "
"directory inode %llu\n",
INT_GET(newnode->hdr.count, ARCH_CONVERT),
goto error_out;
}
if (INT_GET(node->hdr.count, ARCH_CONVERT) >
- XFS_DA_NODE_ENTRIES(mp)) {
+ mp->m_dir_node_ents) {
da_brelse(bp);
do_warn("bad record count in inode %llu, count = %d, "
"max = %d\n", da_cursor->ino,
INT_GET(node->hdr.count, ARCH_CONVERT),
- XFS_DA_NODE_ENTRIES(mp));
+ mp->m_dir_node_ents);
goto error_out;
}
dabno, cursor->ino);
bad++;
}
- if (INT_GET(newnode->hdr.count, ARCH_CONVERT) > XFS_DA_NODE_ENTRIES(mp)) {
+ if (INT_GET(newnode->hdr.count, ARCH_CONVERT) >
+ mp->m_dir_node_ents) {
do_warn("entry count %d too large in block %u for "
"directory inode %llu\n",
INT_GET(newnode->hdr.count, ARCH_CONVERT), dabno, cursor->ino);
*/
#include <libxfs.h>
-#include <malloc.h>
#include "avl.h"
#include "globals.h"
#include "incore.h"
*/
#include <libxfs.h>
-#include <malloc.h>
#include "avl.h"
#include "globals.h"
#include "incore.h"
*/
#include <libxfs.h>
-#include <malloc.h>
#include "globals.h"
#include "agheader.h"
#include "protos.h"
*/
#include <libxfs.h>
-#include <malloc.h>
#include "agheader.h"
#include "globals.h"
#include "protos.h"
*/
#include <libxfs.h>
-#include <malloc.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
projects / thirdparty / xfsprogs-dev.git / commitdiff
