inodata_t *id, int v,
xfs_dablk_t dabno,
freetab_t **freetabp);
-static xfs_dir2_data_free_t
- *process_data_dir_v2_freefind(xfs_dir2_data_t *data,
- xfs_dir2_data_unused_t *dup);
+static xfs_dir2_data_free_t *process_data_dir_v2_freefind(
+ struct xfs_dir2_data_hdr *data,
+ struct xfs_dir2_data_unused *dup);
static void process_dir(xfs_dinode_t *dip, blkmap_t *blkmap,
inodata_t *id);
static int process_dir_v2(xfs_dinode_t *dip, blkmap_t *blkmap,
xfs_dir2_dataptr_t addr;
xfs_dir2_data_free_t *bf;
int bf_err;
- xfs_dir2_block_t *block;
+ struct xfs_dir2_data_hdr *block;
xfs_dir2_block_tail_t *btp = NULL;
inodata_t *cid;
int count;
- xfs_dir2_data_t *data;
+ struct xfs_dir2_data_hdr *data;
xfs_dir2_db_t db;
xfs_dir2_data_entry_t *dep;
xfs_dir2_data_free_t *dfp;
data = iocur_top->data;
block = iocur_top->data;
- if (be32_to_cpu(block->hdr.magic) != XFS_DIR2_BLOCK_MAGIC &&
- be32_to_cpu(data->hdr.magic) != XFS_DIR2_DATA_MAGIC) {
+ if (be32_to_cpu(block->magic) != XFS_DIR2_BLOCK_MAGIC &&
+ be32_to_cpu(data->magic) != XFS_DIR2_DATA_MAGIC) {
if (!sflag || v)
dbprintf(_("bad directory data magic # %#x for dir ino "
"%lld block %d\n"),
- be32_to_cpu(data->hdr.magic), id->ino, dabno);
+ be32_to_cpu(data->magic), id->ino, dabno);
error++;
return NULLFSINO;
}
db = xfs_dir2_da_to_db(mp, dabno);
- bf = data->hdr.bestfree;
- ptr = (char *)data->u;
- if (be32_to_cpu(block->hdr.magic) == XFS_DIR2_BLOCK_MAGIC) {
- btp = xfs_dir2_block_tail_p(mp, &block->hdr);
+ bf = xfs_dir3_data_bestfree_p(data);
+ ptr = (char *)xfs_dir3_data_unused_p(data);
+ if (be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC) {
+ btp = xfs_dir2_block_tail_p(mp, block);
lep = xfs_dir2_block_leaf_p(btp);
endptr = (char *)lep;
if (endptr <= ptr || endptr > (char *)btp) {
(*dot)++;
}
}
- if (be32_to_cpu(data->hdr.magic) == XFS_DIR2_BLOCK_MAGIC) {
+ if (be32_to_cpu(data->magic) == XFS_DIR2_BLOCK_MAGIC) {
endptr = (char *)data + mp->m_dirblksize;
for (i = stale = 0; lep && i < be32_to_cpu(btp->count); i++) {
if ((char *)&lep[i] >= endptr) {
id->ino, dabno);
error++;
}
- if (be32_to_cpu(data->hdr.magic) == XFS_DIR2_BLOCK_MAGIC &&
- count != be32_to_cpu(btp->count) -
- be32_to_cpu(btp->stale)) {
+ if (be32_to_cpu(data->magic) == XFS_DIR2_BLOCK_MAGIC &&
+ count != be32_to_cpu(btp->count) - be32_to_cpu(btp->stale)) {
if (!sflag || v)
dbprintf(_("dir %lld block %d bad block tail count %d "
"(stale %d)\n"),
be32_to_cpu(btp->stale));
error++;
}
- if (be32_to_cpu(data->hdr.magic) == XFS_DIR2_BLOCK_MAGIC &&
+ if (be32_to_cpu(data->magic) == XFS_DIR2_BLOCK_MAGIC &&
stale != be32_to_cpu(btp->stale)) {
if (!sflag || v)
dbprintf(_("dir %lld block %d bad stale tail count %d\n"),
static xfs_dir2_data_free_t *
process_data_dir_v2_freefind(
- xfs_dir2_data_t *data,
+ struct xfs_dir2_data_hdr *data,
xfs_dir2_data_unused_t *dup)
{
- xfs_dir2_data_free_t *dfp;
+ struct xfs_dir2_data_free *bf;
+ struct xfs_dir2_data_free *dfp;
xfs_dir2_data_aoff_t off;
off = (xfs_dir2_data_aoff_t)((char *)dup - (char *)data);
- if (be16_to_cpu(dup->length) < be16_to_cpu(data->hdr.
- bestfree[XFS_DIR2_DATA_FD_COUNT - 1].length))
+ bf = xfs_dir3_data_bestfree_p(data);
+ if (be16_to_cpu(dup->length) <
+ be16_to_cpu(bf[XFS_DIR2_DATA_FD_COUNT - 1].length))
return NULL;
- for (dfp = &data->hdr.bestfree[0]; dfp < &data->hdr.
- bestfree[XFS_DIR2_DATA_FD_COUNT]; dfp++) {
+ for (dfp = bf; dfp < &bf[XFS_DIR2_DATA_FD_COUNT]; dfp++) {
if (be16_to_cpu(dfp->offset) == 0)
return NULL;
if (be16_to_cpu(dfp->offset) == off)
int i8;
xfs_ino_t lino;
int offset;
- xfs_dir2_sf_t *sf;
+ struct xfs_dir2_sf_hdr *sf;
xfs_dir2_sf_entry_t *sfe;
int v;
- sf = (xfs_dir2_sf_t *)XFS_DFORK_DPTR(dip);
+ sf = (struct xfs_dir2_sf_hdr *)XFS_DFORK_DPTR(dip);
addlink_inode(id);
v = verbose || id->ilist;
if (v)
dbprintf(_("dir %lld entry . %lld\n"), id->ino, id->ino);
(*dot)++;
- sfe = xfs_dir2_sf_firstentry(&sf->hdr);
+ sfe = xfs_dir2_sf_firstentry(sf);
offset = XFS_DIR3_DATA_FIRST_OFFSET(mp);
- for (i = sf->hdr.count - 1, i8 = 0; i >= 0; i--) {
- if ((__psint_t)sfe + xfs_dir2_sf_entsize(&sf->hdr,sfe->namelen) -
+ for (i = sf->count - 1, i8 = 0; i >= 0; i--) {
+ if ((__psint_t)sfe + xfs_dir2_sf_entsize(sf, sfe->namelen) -
(__psint_t)sf > be64_to_cpu(dip->di_size)) {
if (!sflag)
dbprintf(_("dir %llu bad size in entry at %d\n"),
error++;
break;
}
- lino = xfs_dir2_sfe_get_ino(&sf->hdr, sfe);
+ lino = xfs_dir2_sfe_get_ino(sf, sfe);
if (lino > XFS_DIR2_MAX_SHORT_INUM)
i8++;
cid = find_inode(lino, 1);
}
offset =
xfs_dir2_sf_get_offset(sfe) +
- xfs_dir2_sf_entsize(&sf->hdr, sfe->namelen);
- sfe = xfs_dir2_sf_nextentry(&sf->hdr, sfe);
+ xfs_dir2_sf_entsize(sf, sfe->namelen);
+ sfe = xfs_dir2_sf_nextentry(sf, sfe);
}
if (i < 0 && (__psint_t)sfe - (__psint_t)sf !=
be64_to_cpu(dip->di_size)) {
(uint)((char *)sfe - (char *)sf));
error++;
}
- if (offset + (sf->hdr.count + 2) * sizeof(xfs_dir2_leaf_entry_t) +
+ if (offset + (sf->count + 2) * sizeof(xfs_dir2_leaf_entry_t) +
sizeof(xfs_dir2_block_tail_t) > mp->m_dirblksize) {
if (!sflag)
dbprintf(_("dir %llu offsets too high\n"), id->ino);
error++;
}
- lino = xfs_dir2_sf_get_parent_ino(&sf->hdr);
+ lino = xfs_dir2_sf_get_parent_ino(sf);
if (lino > XFS_DIR2_MAX_SHORT_INUM)
i8++;
cid = find_inode(lino, 1);
}
if (v)
dbprintf(_("dir %lld entry .. %lld\n"), id->ino, lino);
- if (i8 != sf->hdr.i8count) {
+ if (i8 != sf->i8count) {
if (!sflag)
dbprintf(_("dir %lld i8count mismatch is %d should be "
"%d\n"),
- id->ino, sf->hdr.i8count, i8);
+ id->ino, sf->i8count, i8);
error++;
}
(*dotdot)++;
{ NULL }
};
-#define BOFF(f) bitize(offsetof(xfs_dir2_block_t, f))
-#define DOFF(f) bitize(offsetof(xfs_dir2_data_t, f))
-#define FOFF(f) bitize(offsetof(xfs_dir2_free_t, f))
-#define LOFF(f) bitize(offsetof(xfs_dir2_leaf_t, f))
-#define NOFF(f) bitize(offsetof(xfs_da_intnode_t, f))
+#define BOFF(f) bitize(offsetof(struct xfs_dir2_data_hdr, f))
+#define DOFF(f) bitize(offsetof(struct xfs_dir2_data_hdr, f))
+#define FOFF(f) bitize(offsetof(struct xfs_dir2_free, f))
+#define LOFF(f) bitize(offsetof(struct xfs_dir2_leaf, f))
+#define NOFF(f) bitize(offsetof(struct xfs_da_intnode, f))
const field_t dir2_flds[] = {
- { "bhdr", FLDT_DIR2_DATA_HDR, OI(BOFF(hdr)), dir2_block_hdr_count,
+ { "bhdr", FLDT_DIR2_DATA_HDR, OI(BOFF(magic)), dir2_block_hdr_count,
FLD_COUNT, TYP_NONE },
{ "bu", FLDT_DIR2_DATA_UNION, dir2_block_u_offset, dir2_block_u_count,
FLD_ARRAY|FLD_OFFSET|FLD_COUNT, TYP_NONE },
dir2_block_leaf_count, FLD_ARRAY|FLD_OFFSET|FLD_COUNT, TYP_NONE },
{ "btail", FLDT_DIR2_BLOCK_TAIL, dir2_block_tail_offset,
dir2_block_tail_count, FLD_OFFSET|FLD_COUNT, TYP_NONE },
- { "dhdr", FLDT_DIR2_DATA_HDR, OI(DOFF(hdr)), dir2_data_hdr_count,
+ { "dhdr", FLDT_DIR2_DATA_HDR, OI(DOFF(magic)), dir2_data_hdr_count,
FLD_COUNT, TYP_NONE },
{ "du", FLDT_DIR2_DATA_UNION, dir2_data_u_offset, dir2_data_u_count,
FLD_ARRAY|FLD_OFFSET|FLD_COUNT, TYP_NONE },
{ NULL }
};
-/*ARGSUSED*/
static int
dir2_block_hdr_count(
void *obj,
int startoff)
{
- xfs_dir2_block_t *block;
+ struct xfs_dir2_data_hdr *block;
ASSERT(startoff == 0);
block = obj;
- return be32_to_cpu(block->hdr.magic) == XFS_DIR2_BLOCK_MAGIC;
+ return be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC;
}
-/*ARGSUSED*/
static int
dir2_block_leaf_count(
void *obj,
int startoff)
{
- xfs_dir2_block_t *block;
- xfs_dir2_block_tail_t *btp;
+ struct xfs_dir2_data_hdr *block;
+ struct xfs_dir2_block_tail *btp;
ASSERT(startoff == 0);
block = obj;
- if (be32_to_cpu(block->hdr.magic) != XFS_DIR2_BLOCK_MAGIC)
+ if (be32_to_cpu(block->magic) != XFS_DIR2_BLOCK_MAGIC)
return 0;
- btp = xfs_dir2_block_tail_p(mp, &block->hdr);
+ btp = xfs_dir2_block_tail_p(mp, block);
return be32_to_cpu(btp->count);
}
-/*ARGSUSED*/
static int
dir2_block_leaf_offset(
void *obj,
int startoff,
int idx)
{
- xfs_dir2_block_t *block;
- xfs_dir2_block_tail_t *btp;
- xfs_dir2_leaf_entry_t *lep;
+ struct xfs_dir2_data_hdr *block;
+ struct xfs_dir2_block_tail *btp;
+ struct xfs_dir2_leaf_entry *lep;
ASSERT(startoff == 0);
block = obj;
- ASSERT(be32_to_cpu(block->hdr.magic) == XFS_DIR2_BLOCK_MAGIC);
- btp = xfs_dir2_block_tail_p(mp, &block->hdr);
+ ASSERT(be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC);
+ btp = xfs_dir2_block_tail_p(mp, block);
lep = xfs_dir2_block_leaf_p(btp) + idx;
return bitize((int)((char *)lep - (char *)block));
}
-/*ARGSUSED*/
static int
dir2_block_tail_count(
void *obj,
int startoff)
{
- xfs_dir2_block_t *block;
+ struct xfs_dir2_data_hdr *block;
ASSERT(startoff == 0);
block = obj;
- return be32_to_cpu(block->hdr.magic) == XFS_DIR2_BLOCK_MAGIC;
+ return be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC;
}
/*ARGSUSED*/
int startoff,
int idx)
{
- xfs_dir2_block_t *block;
- xfs_dir2_block_tail_t *btp;
+ struct xfs_dir2_data_hdr *block;
+ struct xfs_dir2_block_tail *btp;
ASSERT(startoff == 0);
ASSERT(idx == 0);
block = obj;
- ASSERT(be32_to_cpu(block->hdr.magic) == XFS_DIR2_BLOCK_MAGIC);
- btp = xfs_dir2_block_tail_p(mp, &block->hdr);
+ ASSERT(be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC);
+ btp = xfs_dir2_block_tail_p(mp, block);
return bitize((int)((char *)btp - (char *)block));
}
void *obj,
int startoff)
{
- xfs_dir2_block_t *block;
- xfs_dir2_block_tail_t *btp;
- xfs_dir2_data_entry_t *dep;
- xfs_dir2_data_unused_t *dup;
+ struct xfs_dir2_data_hdr *block;
+ struct xfs_dir2_block_tail *btp;
char *endptr;
int i;
char *ptr;
ASSERT(startoff == 0);
block = obj;
- if (be32_to_cpu(block->hdr.magic) != XFS_DIR2_BLOCK_MAGIC)
+ if (be32_to_cpu(block->magic) != XFS_DIR2_BLOCK_MAGIC)
return 0;
- btp = xfs_dir2_block_tail_p(mp, &block->hdr);
- ptr = (char *)block->u;
+ btp = xfs_dir2_block_tail_p(mp, block);
+ ptr = (char *)xfs_dir3_data_unused_p(block);
endptr = (char *)xfs_dir2_block_leaf_p(btp);
for (i = 0; ptr < endptr; i++) {
+ struct xfs_dir2_data_entry *dep;
+ struct xfs_dir2_data_unused *dup;
+
dup = (xfs_dir2_data_unused_t *)ptr;
if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG)
ptr += be16_to_cpu(dup->length);
int startoff,
int idx)
{
- xfs_dir2_block_t *block;
- xfs_dir2_block_tail_t *btp;
- xfs_dir2_data_entry_t *dep;
- xfs_dir2_data_unused_t *dup;
+ struct xfs_dir2_data_hdr *block;
+ struct xfs_dir2_block_tail *btp;
char *endptr;
int i;
char *ptr;
ASSERT(startoff == 0);
block = obj;
- ASSERT(be32_to_cpu(block->hdr.magic) == XFS_DIR2_BLOCK_MAGIC);
- btp = xfs_dir2_block_tail_p(mp, &block->hdr);
- ptr = (char *)block->u;
+ ASSERT(be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC);
+ btp = xfs_dir2_block_tail_p(mp, block);
+ ptr = (char *)xfs_dir3_data_unused_p(block);
endptr = (char *)xfs_dir2_block_leaf_p(btp);
for (i = 0; i < idx; i++) {
+ struct xfs_dir2_data_entry *dep;
+ struct xfs_dir2_data_unused *dup;
+
ASSERT(ptr < endptr);
dup = (xfs_dir2_data_unused_t *)ptr;
if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG)
void *obj,
int startoff)
{
- xfs_dir2_data_t *data;
+ struct xfs_dir2_data_hdr *data;
ASSERT(startoff == 0);
data = obj;
- return be32_to_cpu(data->hdr.magic) == XFS_DIR2_DATA_MAGIC;
+ return be32_to_cpu(data->magic) == XFS_DIR2_DATA_MAGIC;
}
/*ARGSUSED*/
void *obj,
int startoff)
{
- xfs_dir2_data_t *data;
- xfs_dir2_data_entry_t *dep;
- xfs_dir2_data_unused_t *dup;
+ struct xfs_dir2_data_hdr *data;
char *endptr;
int i;
char *ptr;
ASSERT(startoff == 0);
data = obj;
- if (be32_to_cpu(data->hdr.magic) != XFS_DIR2_DATA_MAGIC)
+ if (be32_to_cpu(data->magic) != XFS_DIR2_DATA_MAGIC)
return 0;
- ptr = (char *)data->u;
+ ptr = (char *)xfs_dir3_data_unused_p(data);
endptr = (char *)data + mp->m_dirblksize;
for (i = 0; ptr < endptr; i++) {
+ struct xfs_dir2_data_entry *dep;
+ struct xfs_dir2_data_unused *dup;
+
dup = (xfs_dir2_data_unused_t *)ptr;
if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG)
ptr += be16_to_cpu(dup->length);
int startoff,
int idx)
{
- xfs_dir2_data_t *data;
- xfs_dir2_data_entry_t *dep;
- xfs_dir2_data_unused_t *dup;
- /*REFERENCED*/
+ struct xfs_dir2_data_hdr *data;
char *endptr;
int i;
char *ptr;
ASSERT(startoff == 0);
data = obj;
- ASSERT(be32_to_cpu(data->hdr.magic) == XFS_DIR2_DATA_MAGIC);
- ptr = (char *)data->u;
+ ASSERT(be32_to_cpu(data->magic) == XFS_DIR2_DATA_MAGIC);
+ ptr = (char *)xfs_dir3_data_unused_p(data);
endptr = (char *)data + mp->m_dirblksize;
for (i = 0; i < idx; i++) {
+ struct xfs_dir2_data_entry *dep;
+ struct xfs_dir2_data_unused *dup;
+
ASSERT(ptr < endptr);
dup = (xfs_dir2_data_unused_t *)ptr;
if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG)
void *obj,
int startoff)
{
- xfs_dir2_free_t *free;
+ struct xfs_dir2_free *free;
ASSERT(startoff == 0);
free = obj;
void *obj,
int startoff)
{
- xfs_dir2_free_t *free;
+ struct xfs_dir2_free *free;
ASSERT(startoff == 0);
free = obj;
void *obj,
int startoff)
{
- xfs_dir2_leaf_t *leaf;
- xfs_dir2_leaf_tail_t *ltp;
+ struct xfs_dir2_leaf *leaf;
+ struct xfs_dir2_leaf_tail *ltp;
ASSERT(startoff == 0);
leaf = obj;
int startoff,
int idx)
{
+ struct xfs_dir2_leaf *leaf;
+ struct xfs_dir2_leaf_tail *ltp;
__be16 *lbp;
- xfs_dir2_leaf_t *leaf;
- xfs_dir2_leaf_tail_t *ltp;
ASSERT(startoff == 0);
leaf = obj;
void *obj,
int startoff)
{
- xfs_dir2_leaf_t *leaf;
+ struct xfs_dir2_leaf *leaf;
ASSERT(startoff == 0);
leaf = obj;
void *obj,
int startoff)
{
- xfs_dir2_leaf_t *leaf;
+ struct xfs_dir2_leaf *leaf;
ASSERT(startoff == 0);
leaf = obj;
void *obj,
int startoff)
{
- xfs_dir2_leaf_t *leaf;
+ struct xfs_dir2_leaf *leaf;
ASSERT(startoff == 0);
leaf = obj;
int startoff,
int idx)
{
- xfs_dir2_leaf_t *leaf;
- xfs_dir2_leaf_tail_t *ltp;
+ struct xfs_dir2_leaf *leaf;
+ struct xfs_dir2_leaf_tail *ltp;
ASSERT(startoff == 0);
ASSERT(idx == 0);
void *obj,
int startoff)
{
- xfs_da_intnode_t *node;
+ struct xfs_da_intnode *node;
ASSERT(startoff == 0);
node = obj;
extern const field_t da_node_entry_flds[];
extern const field_t da_node_hdr_flds[];
-/*
- * generic dir2 structures used by xfs_db
- */
-typedef union {
- xfs_dir2_data_entry_t entry;
- xfs_dir2_data_unused_t unused;
-} xfs_dir2_data_union_t;
-
-typedef struct xfs_dir2_data {
- xfs_dir2_data_hdr_t hdr; /* magic XFS_DIR2_DATA_MAGIC */
- xfs_dir2_data_union_t u[1];
-} xfs_dir2_data_t;
-
-typedef struct xfs_dir2_block {
- xfs_dir2_data_hdr_t hdr; /* magic XFS_DIR2_BLOCK_MAGIC */
- xfs_dir2_data_union_t u[1];
- xfs_dir2_leaf_entry_t leaf[1];
- xfs_dir2_block_tail_t tail;
-} xfs_dir2_block_t;
-
-typedef struct xfs_dir2_sf {
- xfs_dir2_sf_hdr_t hdr; /* shortform header */
- xfs_dir2_sf_entry_t list[1]; /* shortform entries */
-} xfs_dir2_sf_t;
-
static inline xfs_dir2_inou_t *xfs_dir2_sf_inumberp(xfs_dir2_sf_entry_t *sfep)
{
return (xfs_dir2_inou_t *)&(sfep)->name[(sfep)->namelen];
static int dir2_sf_list_count(void *obj, int startoff);
static int dir2_sf_list_offset(void *obj, int startoff, int idx);
-#define OFF(f) bitize(offsetof(xfs_dir2_sf_t, f))
+#define OFF(f) bitize(offsetof(struct xfs_dir2_sf_hdr, f))
const field_t dir2sf_flds[] = {
- { "hdr", FLDT_DIR2_SF_HDR, OI(OFF(hdr)), C1, 0, TYP_NONE },
+ { "hdr", FLDT_DIR2_SF_HDR, OI(OFF(count)), C1, 0, TYP_NONE },
{ "list", FLDT_DIR2_SF_ENTRY, dir2_sf_list_offset, dir2_sf_list_count,
FLD_ARRAY|FLD_COUNT|FLD_OFFSET, TYP_NONE },
{ NULL }
int startoff)
{
struct xfs_dinode *dip = obj;
- xfs_dir2_sf_t *sf;
+ struct xfs_dir2_sf_hdr *sf;
ASSERT(bitoffs(startoff) == 0);
- sf = (xfs_dir2_sf_t *)XFS_DFORK_DPTR(dip);
- return sf->hdr.i8count == 0;
+ sf = (struct xfs_dir2_sf_hdr *)XFS_DFORK_DPTR(dip);
+ return sf->i8count == 0;
}
/*ARGSUSED*/
int startoff)
{
struct xfs_dinode *dip = obj;
- xfs_dir2_sf_t *sf;
+ struct xfs_dir2_sf_hdr *sf;
ASSERT(bitoffs(startoff) == 0);
- sf = (xfs_dir2_sf_t *)XFS_DFORK_DPTR(dip);
- return sf->hdr.i8count != 0;
+ sf = (struct xfs_dir2_sf_hdr *)XFS_DFORK_DPTR(dip);
+ return sf->i8count != 0;
}
/*ARGSUSED*/
int idx)
{
struct xfs_dinode *dip = obj;
- xfs_dir2_sf_t *sf;
+ struct xfs_dir2_sf_hdr *sf;
ASSERT(bitoffs(startoff) == 0);
ASSERT(idx == 0);
- sf = (xfs_dir2_sf_t *)XFS_DFORK_DPTR(dip);
- return bitize(sf->hdr.i8count ?
+ sf = (struct xfs_dir2_sf_hdr *)XFS_DFORK_DPTR(dip);
+ return bitize(sf->i8count ?
(uint)sizeof(xfs_dir2_ino8_t) :
(uint)sizeof(xfs_dir2_ino4_t));
}
{
xfs_dir2_sf_entry_t *e;
int i;
- xfs_dir2_sf_t *sf;
+ struct xfs_dir2_sf_hdr *sf;
ASSERT(bitoffs(startoff) == 0);
- sf = (xfs_dir2_sf_t *)((char *)obj + byteize(startoff));
- e = xfs_dir2_sf_firstentry(&sf->hdr);
+ sf = (struct xfs_dir2_sf_hdr *)((char *)obj + byteize(startoff));
+ e = xfs_dir2_sf_firstentry(sf);
for (i = 0; i < idx; i++)
- e = xfs_dir2_sf_nextentry(&sf->hdr, e);
- return bitize((int)xfs_dir2_sf_entsize(&sf->hdr, e->namelen));
+ e = xfs_dir2_sf_nextentry(sf, e);
+ return bitize((int)xfs_dir2_sf_entsize(sf, e->namelen));
}
/*ARGSUSED*/
int startoff,
int idx)
{
- xfs_dir2_sf_t *sf;
+ struct xfs_dir2_sf_hdr *sf;
ASSERT(bitoffs(startoff) == 0);
ASSERT(idx == 0);
- sf = (xfs_dir2_sf_t *)((char *)obj + byteize(startoff));
- return bitize(xfs_dir2_sf_hdr_size(sf->hdr.i8count));
+ sf = (struct xfs_dir2_sf_hdr *)((char *)obj + byteize(startoff));
+ return bitize(xfs_dir2_sf_hdr_size(sf->i8count));
}
static int
void *obj,
int startoff)
{
- xfs_dir2_sf_t *sf;
+ struct xfs_dir2_sf_hdr *sf;
ASSERT(bitoffs(startoff) == 0);
- sf = (xfs_dir2_sf_t *)((char *)obj + byteize(startoff));
- return sf->hdr.count;
+ sf = (struct xfs_dir2_sf_hdr *)((char *)obj + byteize(startoff));
+ return sf->count;
}
static int
{
xfs_dir2_sf_entry_t *e;
int i;
- xfs_dir2_sf_t *sf;
+ struct xfs_dir2_sf_hdr *sf;
ASSERT(bitoffs(startoff) == 0);
- sf = (xfs_dir2_sf_t *)((char *)obj + byteize(startoff));
- e = xfs_dir2_sf_firstentry(&sf->hdr);
+ sf = (struct xfs_dir2_sf_hdr *)((char *)obj + byteize(startoff));
+ e = xfs_dir2_sf_firstentry(sf);
for (i = 0; i < idx; i++)
- e = xfs_dir2_sf_nextentry(&sf->hdr, e);
+ e = xfs_dir2_sf_nextentry(sf, e);
return bitize((int)((char *)e - (char *)sf));
}
{
xfs_dir2_sf_entry_t *e;
int i;
- xfs_dir2_sf_t *sf;
+ struct xfs_dir2_sf_hdr *sf;
ASSERT(bitoffs(startoff) == 0);
ASSERT(idx == 0);
- sf = (xfs_dir2_sf_t *)((char *)obj + byteize(startoff));
- e = xfs_dir2_sf_firstentry(&sf->hdr);
- for (i = 0; i < sf->hdr.count; i++)
- e = xfs_dir2_sf_nextentry(&sf->hdr, e);
+ sf = (struct xfs_dir2_sf_hdr *)((char *)obj + byteize(startoff));
+ e = xfs_dir2_sf_firstentry(sf);
+ for (i = 0; i < sf->count; i++)
+ e = xfs_dir2_sf_nextentry(sf, e);
return bitize((int)((char *)e - (char *)sf));
}
obfuscate_sf_dir(
xfs_dinode_t *dip)
{
- xfs_dir2_sf_t *sfp;
+ struct xfs_dir2_sf_hdr *sfp;
xfs_dir2_sf_entry_t *sfep;
__uint64_t ino_dir_size;
int i;
- sfp = (xfs_dir2_sf_t *)XFS_DFORK_DPTR(dip);
+ sfp = (struct xfs_dir2_sf_hdr *)XFS_DFORK_DPTR(dip);
ino_dir_size = be64_to_cpu(dip->di_size);
if (ino_dir_size > XFS_DFORK_DSIZE(dip, mp)) {
ino_dir_size = XFS_DFORK_DSIZE(dip, mp);
(long long)cur_ino);
}
- sfep = xfs_dir2_sf_firstentry(&sfp->hdr);
- for (i = 0; (i < sfp->hdr.count) &&
+ sfep = xfs_dir2_sf_firstentry(sfp);
+ for (i = 0; (i < sfp->count) &&
((char *)sfep - (char *)sfp < ino_dir_size); i++) {
/*
if (show_warnings)
print_warning("zero length entry in dir inode "
"%llu", (long long)cur_ino);
- if (i != sfp->hdr.count - 1)
+ if (i != sfp->count - 1)
break;
namelen = ino_dir_size - ((char *)&sfep->name[0] -
(char *)sfp);
} else if ((char *)sfep - (char *)sfp +
- xfs_dir2_sf_entsize(&sfp->hdr, sfep->namelen) >
+ xfs_dir2_sf_entsize(sfp, sfep->namelen) >
ino_dir_size) {
if (show_warnings)
print_warning("entry length in dir inode %llu "
"overflows space", (long long)cur_ino);
- if (i != sfp->hdr.count - 1)
+ if (i != sfp->count - 1)
break;
namelen = ino_dir_size - ((char *)&sfep->name[0] -
(char *)sfp);
}
- generate_obfuscated_name(xfs_dir2_sfe_get_ino(&sfp->hdr, sfep),
+ generate_obfuscated_name(xfs_dir2_sfe_get_ino(sfp, sfep),
namelen, &sfep->name[0]);
sfep = (xfs_dir2_sf_entry_t *)((char *)sfep +
- xfs_dir2_sf_entsize(&sfp->hdr, namelen));
+ xfs_dir2_sf_entsize(sfp, namelen));
}
}
if (dir_data.block_index == 0) {
int wantmagic;
+ struct xfs_dir2_data_hdr *datahdr;
+
+ datahdr = (struct xfs_dir2_data_hdr *)block;
if (offset % mp->m_dirblkfsbs != 0)
return; /* corrupted, leave it alone */
if (is_block_format) {
xfs_dir2_leaf_entry_t *blp;
xfs_dir2_block_tail_t *btp;
- xfs_dir2_block_t *blk;
- blk = (xfs_dir2_block_t *)block;
- btp = xfs_dir2_block_tail_p(mp, &blk->hdr);
+ btp = xfs_dir2_block_tail_p(mp, datahdr);
blp = xfs_dir2_block_leaf_p(btp);
if ((char *)blp > (char *)btp)
blp = (xfs_dir2_leaf_entry_t *)btp;
mp->m_sb.sb_blocklog;
wantmagic = XFS_DIR2_DATA_MAGIC;
}
- dir_data.offset_to_entry = offsetof(xfs_dir2_data_t, u);
+ dir_data.offset_to_entry =
+ xfs_dir3_data_entry_offset(datahdr);
- if (be32_to_cpu(((xfs_dir2_data_hdr_t*)block)->magic) !=
- wantmagic) {
+ if (be32_to_cpu(datahdr->magic) != wantmagic) {
if (show_warnings)
print_warning("invalid magic in dir "
"inode %llu block %ld",
projects / thirdparty / xfsprogs-dev.git / commitdiff
