← Back to branch summary

~ubuntu-branches/ubuntu/edgy/xfsprogs/edgy

« back to all changes in this revision

Viewing changes to db/check.c

  • Committer: Bazaar Package Importer
  • Author(s): Nathan Scott
  • Date: 2005-11-16 16:32:35 UTC
  • Revision ID: james.westby@ubuntu.com-20051116163235-synnef6xjj18ny42
Tags: 2.7.7-1
http://bugs.debian.org/336350
http://bugs.debian.org/249429
http://bugs.debian.org/338207
* New upstream release.
* Add support for (optional) ATTR2 format extension (closes: #336350)
* Allow gcc -pedantic option for C++ <xfs.h> users (closes: #249429)
* Fix segv in xfs_db frag command (closes: #338207)

Show diffs side-by-side

added added

removed removed

Lines of Context:
db/check.c
1
1
/*
2
 
 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.  All Rights Reserved.
 
2
 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
 
3
 * All Rights Reserved.
3
4
 *
4
 
 * This program is free software; you can redistribute it and/or modify it
5
 
 * under the terms of version 2 of the GNU General Public License as
 
5
 * This program is free software; you can redistribute it and/or
 
6
 * modify it under the terms of the GNU General Public License as
6
7
 * published by the Free Software Foundation.
7
8
 *
8
 
 * This program is distributed in the hope that it would be useful, but
9
 
 * WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11
 
 *
12
 
 * Further, this software is distributed without any warranty that it is
13
 
 * free of the rightful claim of any third person regarding infringement
14
 
 * or the like.  Any license provided herein, whether implied or
15
 
 * otherwise, applies only to this software file.  Patent licenses, if
16
 
 * any, provided herein do not apply to combinations of this program with
17
 
 * other software, or any other product whatsoever.
18
 
 *
19
 
 * You should have received a copy of the GNU General Public License along
20
 
 * with this program; if not, write the Free Software Foundation, Inc., 59
21
 
 * Temple Place - Suite 330, Boston MA 02111-1307, USA.
22
 
 *
23
 
 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24
 
 * Mountain View, CA  94043, or:
25
 
 *
26
 
 * http://www.sgi.com
27
 
 *
28
 
 * For further information regarding this notice, see:
29
 
 *
30
 
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 
9
 * This program is distributed in the hope that it would be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
 * GNU General Public License for more details.
 
13
 *
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program; if not, write the Free Software Foundation,
 
16
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
31
17
 */
32
18
 
33
19
#include <xfs/libxfs.h>
38
24
#include "command.h"
39
25
#include "io.h"
40
26
#include "type.h"
41
 
#include "fprint.h"    
42
 
#include "faddr.h"     
43
 
#include "field.h"     
 
27
#include "fprint.h"
 
28
#include "faddr.h"
 
29
#include "field.h"
44
30
#include "sb.h"
45
31
#include "output.h"
46
32
#include "init.h"
232
218
static void             blkmap_shrink(blkmap_t *blkmap, blkent_t **entp);
233
219
static int              blockfree_f(int argc, char **argv);
234
220
static int              blockget_f(int argc, char **argv);
235
 
#ifdef DEBUG
236
221
static int              blocktrash_f(int argc, char **argv);
237
 
#endif
238
222
static int              blockuse_f(int argc, char **argv);
239
223
static int              check_blist(xfs_fsblock_t bno);
240
224
static void             check_dbmap(xfs_agnumber_t agno, xfs_agblock_t agbno,
333
317
                                          int *dotdot, inodata_t *id);
334
318
static xfs_ino_t        process_shortform_dir_v1(xfs_dinode_t *dip, int *dot,
335
319
                                                 int *dotdot, inodata_t *id);
336
 
static void             quota_add(xfs_dqid_t p, xfs_dqid_t g, xfs_dqid_t u,
 
320
static void             quota_add(xfs_dqid_t *p, xfs_dqid_t *g, xfs_dqid_t *u,
337
321
                                  int dq, xfs_qcnt_t bc, xfs_qcnt_t ic,
338
322
                                  xfs_qcnt_t rc);
339
323
static void             quota_add1(qdata_t **qt, xfs_dqid_t id, int dq,
386
370
        { "blockget", "check", blockget_f, 0, -1, 0,
387
371
          "[-s|-v] [-n] [-t] [-b bno]... [-i ino] ...",
388
372
          "get block usage and check consistency", NULL };
389
 
#ifdef DEBUG
390
373
static const cmdinfo_t  blocktrash_cmd =
391
374
        { "blocktrash", NULL, blocktrash_f, 0, -1, 0,
392
375
          "[-n count] [-x minlen] [-y maxlen] [-s seed] [-0123] [-t type] ...",
393
376
          "trash randomly selected block(s)", NULL };
394
 
#endif
395
377
static const cmdinfo_t  blockuse_cmd =
396
378
        { "blockuse", NULL, blockuse_f, 0, 3, 0,
397
379
          "[-n] [-c blockcount]",
920
902
        return 0;
921
903
}
922
904
 
923
 
#ifdef DEBUG
924
905
typedef struct ltab {
925
906
        int     min;
926
907
        int     max;
1155
1136
        xfree(lentab);
1156
1137
        return 0;
1157
1138
}
1158
 
#endif
1159
1139
 
1160
1140
int
1161
1141
blockuse_f(
1264
1244
{
1265
1245
        add_command(&blockfree_cmd);
1266
1246
        add_command(&blockget_cmd);
1267
 
#ifdef DEBUG
1268
 
        add_command(&blocktrash_cmd);
1269
 
#endif
 
1247
        if (expert_mode)
 
1248
                add_command(&blocktrash_cmd);
1270
1249
        add_command(&blockuse_cmd);
1271
1250
        add_command(&ncheck_cmd);
1272
1251
}
1355
1334
 
1356
1335
static int
1357
1336
check_range(
1358
 
        xfs_agnumber_t  agno,
1359
 
        xfs_agblock_t   agbno,
1360
 
        xfs_extlen_t    len)
 
1337
        xfs_agnumber_t  agno,
 
1338
        xfs_agblock_t   agbno,
 
1339
        xfs_extlen_t    len)
1361
1340
{
1362
 
        xfs_extlen_t    i;
 
1341
        xfs_extlen_t    i;
 
1342
        xfs_agblock_t   low = 0;
 
1343
        xfs_agblock_t   high = 0;
 
1344
        int             valid_range = 0;
 
1345
        int             cur, prev = 0;
1363
1346
 
1364
1347
        if (agno >= mp->m_sb.sb_agcount ||
1365
1348
            agbno + len - 1 >= mp->m_sb.sb_agblocks) {
1366
1349
                for (i = 0; i < len; i++) {
1367
 
                        if (!sflag || CHECK_BLISTA(agno, agbno + i))
1368
 
                                dbprintf("block %u/%u out of range\n",
1369
 
                                        agno, agbno + i);
 
1350
                        cur = !sflag || CHECK_BLISTA(agno, agbno + i) ? 1 : 0;
 
1351
                        if (cur == 1 && prev == 0) {
 
1352
                                low = high = agbno + i;
 
1353
                                valid_range = 1;
 
1354
                        } else if (cur == 0 && prev == 0) {
 
1355
                                /* Do nothing */
 
1356
                        } else if (cur == 0 && prev == 1) {
 
1357
                                if (low == high) {
 
1358
                                        dbprintf("block %u/%u out of range\n",
 
1359
                                                agno, low);
 
1360
                                } else {
 
1361
                                        dbprintf("blocks %u/%u..%u "
 
1362
                                                "out of range\n",
 
1363
                                                agno, low, high);
 
1364
                                }
 
1365
                                valid_range = 0;
 
1366
                        } else if (cur == 1 && prev == 1) {
 
1367
                                high = agbno + i;
 
1368
                        }
 
1369
                        prev = cur;
 
1370
                }
 
1371
                if (valid_range) {
 
1372
                        if (low == high) {
 
1373
                                dbprintf("block %u/%u out of range\n",
 
1374
                                agno, low);
 
1375
                        } else {
 
1376
                                dbprintf("blocks %u/%u..%u "
 
1377
                                        "out of range\n",
 
1378
                                        agno, low, high);
 
1379
                        }
1370
1380
                }
1371
1381
                error++;
1372
1382
                return 0;
2086
2096
        xfs_bmbt_ptr_t          *pp;
2087
2097
        xfs_bmbt_rec_32_t       *rp;
2088
2098
 
2089
 
        dib = (xfs_bmdr_block_t *)XFS_DFORK_PTR_ARCH(dip, whichfork, ARCH_NOCONVERT);
 
2099
        dib = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork);
2090
2100
        if (INT_GET(dib->bb_level, ARCH_CONVERT) >= XFS_BM_MAXLEVELS(mp, whichfork)) {
2091
2101
                if (!sflag || id->ilist)
2092
2102
                        dbprintf("level for ino %lld %s fork bmap root too "
2098
2108
                return;
2099
2109
        }
2100
2110
        if (INT_GET(dib->bb_numrecs, ARCH_CONVERT) >
2101
 
            XFS_BTREE_BLOCK_MAXRECS(XFS_DFORK_SIZE_ARCH(dip, mp, whichfork, ARCH_NOCONVERT),
 
2111
            XFS_BTREE_BLOCK_MAXRECS(XFS_DFORK_SIZE_HOST(dip, mp, whichfork),
2102
2112
                    xfs_bmdr, INT_GET(dib->bb_level, ARCH_CONVERT) == 0)) {
2103
2113
                if (!sflag || id->ilist)
2104
2114
                        dbprintf("numrecs for ino %lld %s fork bmap root too "
2111
2121
        }
2112
2122
        if (INT_GET(dib->bb_level, ARCH_CONVERT) == 0) {
2113
2123
                rp = (xfs_bmbt_rec_32_t *)XFS_BTREE_REC_ADDR(
2114
 
                        XFS_DFORK_SIZE_ARCH(dip, mp, whichfork, ARCH_NOCONVERT),
 
2124
                        XFS_DFORK_SIZE_HOST(dip, mp, whichfork),
2115
2125
                        xfs_bmdr, dib, 1,
2116
2126
                        XFS_BTREE_BLOCK_MAXRECS(XFS_DFORK_SIZE(dip, mp,
2117
2127
                                        whichfork),
2121
2131
                *nex += INT_GET(dib->bb_numrecs, ARCH_CONVERT);
2122
2132
                return;
2123
2133
        } else {
2124
 
                pp = XFS_BTREE_PTR_ADDR(XFS_DFORK_SIZE_ARCH(dip, mp, whichfork, ARCH_NOCONVERT),
 
2134
                pp = XFS_BTREE_PTR_ADDR(XFS_DFORK_SIZE_HOST(dip, mp, whichfork),
2125
2135
                        xfs_bmdr, dib, 1,
2126
2136
                        XFS_BTREE_BLOCK_MAXRECS(XFS_DFORK_SIZE(dip, mp,
2127
2137
                                                               whichfork),
2134
2144
                                        TYP_BMAPBTD : TYP_BMAPBTA);
2135
2145
        }
2136
2146
        if (*nex <=
2137
 
            XFS_DFORK_SIZE_ARCH(dip, mp, whichfork, ARCH_NOCONVERT) / sizeof(xfs_bmbt_rec_t)) {
 
2147
            XFS_DFORK_SIZE_HOST(dip, mp, whichfork) / sizeof(xfs_bmbt_rec_t)) {
2138
2148
                if (!sflag || id->ilist)
2139
2149
                        dbprintf("extent count for ino %lld %s fork too low "
2140
2150
                                 "(%d) for file format\n",
2197
2207
        ptr = (char *)data->u;
2198
2208
        if (INT_GET(block->hdr.magic, ARCH_CONVERT) == XFS_DIR2_BLOCK_MAGIC) {
2199
2209
                btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
2200
 
                lep = XFS_DIR2_BLOCK_LEAF_P_ARCH(btp, ARCH_CONVERT);
 
2210
                lep = XFS_DIR2_BLOCK_LEAF_P(btp);
2201
2211
                endptr = (char *)lep;
2202
2212
                if (endptr <= ptr || endptr > (char *)btp) {
2203
2213
                        endptr = (char *)data + mp->m_dirblksize;
2245
2255
                        lastfree_err += lastfree != 0;
2246
2256
                        if ((INT_GET(dup->length, ARCH_CONVERT) & (XFS_DIR2_DATA_ALIGN - 1)) ||
2247
2257
                            INT_GET(dup->length, ARCH_CONVERT) == 0 ||
2248
 
                            (char *)(tagp = XFS_DIR2_DATA_UNUSED_TAG_P_ARCH(dup, ARCH_CONVERT)) >=
 
2258
                            (char *)(tagp = XFS_DIR2_DATA_UNUSED_TAG_P(dup)) >=
2249
2259
                            endptr) {
2250
2260
                                if (!sflag || v)
2251
2261
                                        dbprintf("dir %lld block %d bad free "
2474
2484
        inodata_t       *id,
2475
2485
        xfs_ino_t       *parent)
2476
2486
{
2477
 
        if (dip->di_core.di_size <= XFS_DFORK_DSIZE_ARCH(dip, mp, ARCH_NOCONVERT) &&
 
2487
        if (dip->di_core.di_size <= XFS_DFORK_DSIZE_HOST(dip, mp) &&
2478
2488
            dip->di_core.di_format == XFS_DINODE_FMT_LOCAL)
2479
2489
                *parent =
2480
2490
                        process_shortform_dir_v1(dip, dot, dotdot, id);
2510
2520
 
2511
2521
        if (blkmap)
2512
2522
                last = blkmap_last_off(blkmap);
2513
 
        if (dip->di_core.di_size <= XFS_DFORK_DSIZE_ARCH(dip, mp, ARCH_NOCONVERT) &&
 
2523
        if (dip->di_core.di_size <= XFS_DFORK_DSIZE_HOST(dip, mp) &&
2514
2524
            dip->di_core.di_format == XFS_DINODE_FMT_LOCAL)
2515
2525
                *parent = process_sf_dir_v2(dip, dot, dotdot, id);
2516
2526
        else if (last == mp->m_dirblkfsbs &&
2547
2557
{
2548
2558
        xfs_bmbt_rec_32_t       *rp;
2549
2559
 
2550
 
        rp = (xfs_bmbt_rec_32_t *)XFS_DFORK_PTR_ARCH(dip, whichfork, ARCH_NOCONVERT);
2551
 
        *nex = XFS_DFORK_NEXTENTS_ARCH(dip, whichfork, ARCH_NOCONVERT);
 
2560
        rp = (xfs_bmbt_rec_32_t *)XFS_DFORK_PTR(dip, whichfork);
 
2561
        *nex = XFS_DFORK_NEXTENTS_HOST(dip, whichfork);
2552
2562
        if (*nex < 0 ||
2553
2563
            *nex >
2554
 
            XFS_DFORK_SIZE_ARCH(dip, mp, whichfork, ARCH_NOCONVERT) / sizeof(xfs_bmbt_rec_32_t)) {
 
2564
            XFS_DFORK_SIZE_HOST(dip, mp, whichfork) / sizeof(xfs_bmbt_rec_32_t)) {
2555
2565
                if (!sflag || id->ilist)
2556
2566
                        dbprintf("bad number of extents %d for inode %lld\n",
2557
2567
                                *nex, id->ino);
2587
2597
        xfs_qcnt_t              bc = 0;
2588
2598
        xfs_qcnt_t              ic = 0;
2589
2599
        xfs_qcnt_t              rc = 0;
 
2600
        xfs_dqid_t              dqprid;
2590
2601
        static char             okfmts[] = {
2591
2602
                0,                              /* type 0 unused */
2592
2603
                1 << XFS_DINODE_FMT_DEV,        /* FIFO */
2614
2625
        };
2615
2626
 
2616
2627
        /* convert the core, then copy it back into the inode */
2617
 
        libxfs_xlate_dinode_core((xfs_caddr_t)&dip->di_core, &tdic, 1,
2618
 
                                 ARCH_CONVERT);
 
2628
        libxfs_xlate_dinode_core((xfs_caddr_t)&dip->di_core, &tdic, 1);
2619
2629
        memcpy(&dip->di_core, &tdic, sizeof(xfs_dinode_core_t));
2620
2630
        dic=&dip->di_core;
2621
2631
 
2676
2686
                error++;
2677
2687
                return;
2678
2688
        }
2679
 
        if ((unsigned int)XFS_DFORK_ASIZE_ARCH(dip, mp, ARCH_NOCONVERT) >= XFS_LITINO(mp))  {
 
2689
        if ((unsigned int)XFS_DFORK_ASIZE_HOST(dip, mp) >= XFS_LITINO(mp))  {
2680
2690
                if (!sflag || id->ilist)
2681
2691
                        dbprintf("bad fork offset %d for inode %lld\n",
2682
2692
                                dic->di_forkoff, id->ino);
2765
2775
                        &nextents, &blkmap, XFS_DATA_FORK);
2766
2776
                break;
2767
2777
        }
2768
 
        if (XFS_DFORK_Q_ARCH(dip, ARCH_NOCONVERT)) {
 
2778
        if (XFS_DFORK_Q(dip)) {
2769
2779
                sbversion |= XFS_SB_VERSION_ATTRBIT;
2770
2780
                switch (dic->di_aformat) {
2771
2781
                case XFS_DINODE_FMT_LOCAL:
2802
2812
                default:
2803
2813
                        break;
2804
2814
                }
2805
 
                if (ic)
2806
 
                        quota_add(dic->di_projid, dic->di_gid, dic->di_uid,
 
2815
                if (ic) {
 
2816
                        dqprid = dic->di_projid;        /* dquot ID is u32 */
 
2817
                        quota_add(&dqprid, &dic->di_gid, &dic->di_uid,
2807
2818
                                  0, bc, ic, rc);
 
2819
                }
2808
2820
        }
2809
2821
        totblocks = totdblocks + totiblocks + atotdblocks + atotiblocks;
2810
2822
        if (totblocks != dic->di_nblocks) {
2844
2856
                        process_quota(IS_USER_QUOTA, id, blkmap);
2845
2857
                else if (id->ino == mp->m_sb.sb_gquotino &&
2846
2858
                         (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) &&
2847
 
                         (mp->m_sb.sb_qflags & XFS_GQUOTA_CHKD))
 
2859
                         (mp->m_sb.sb_qflags & XFS_OQUOTA_CHKD))
2848
2860
                        process_quota(IS_GROUP_QUOTA, id, blkmap);
2849
2861
                else if (id->ino == mp->m_sb.sb_gquotino &&
2850
2862
                         (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) &&
2851
 
                         (mp->m_sb.sb_qflags & XFS_GQUOTA_CHKD)) /* yep, G */
 
2863
                         (mp->m_sb.sb_qflags & XFS_OQUOTA_CHKD))
2852
2864
                        process_quota(IS_PROJECT_QUOTA, id, blkmap);
2853
2865
        }
2854
2866
        if (blkmap)
2874
2886
        dic = &dip->di_core;
2875
2887
        bno = XFS_INO_TO_FSB(mp, id->ino);
2876
2888
        if (whichfork == XFS_DATA_FORK &&
2877
 
            dic->di_size > XFS_DFORK_DSIZE_ARCH(dip, mp, ARCH_NOCONVERT)) {
 
2889
            dic->di_size > XFS_DFORK_DSIZE_HOST(dip, mp)) {
2878
2890
                if (!sflag || id->ilist || CHECK_BLIST(bno))
2879
2891
                        dbprintf("local inode %lld data is too large (size "
2880
2892
                                 "%lld)\n",
2882
2894
                error++;
2883
2895
        }
2884
2896
        else if (whichfork == XFS_ATTR_FORK) {
2885
 
                asf = (xfs_attr_shortform_t *)XFS_DFORK_PTR_ARCH(dip, whichfork, ARCH_NOCONVERT);
2886
 
                if (INT_GET(asf->hdr.totsize, ARCH_CONVERT) > XFS_DFORK_ASIZE_ARCH(dip, mp, ARCH_NOCONVERT)) {
 
2897
                asf = (xfs_attr_shortform_t *)XFS_DFORK_PTR(dip, whichfork);
 
2898
                if (INT_GET(asf->hdr.totsize, ARCH_CONVERT) > XFS_DFORK_ASIZE_HOST(dip, mp)) {
2887
2899
                        if (!sflag || id->ilist || CHECK_BLIST(bno))
2888
2900
                                dbprintf("local inode %lld attr is too large "
2889
2901
                                         "(size %d)\n",
2958
2970
        entry = &leaf->entries[0];
2959
2971
        for (i = 0; i < INT_GET(leaf->hdr.count, ARCH_CONVERT); entry++, i++) {
2960
2972
                namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT));
2961
 
                lino=DIRINO_GET_ARCH(&namest->inumber, ARCH_CONVERT);
 
2973
                lino = XFS_GET_DIR_INO8(namest->inumber);
2962
2974
                cid = find_inode(lino, 1);
2963
2975
                if (v)
2964
2976
                        dbprintf("dir %lld entry %*.*s %lld\n", id->ino,
3209
3221
                        error++;
3210
3222
                }
3211
3223
                ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
3212
 
                lbp = XFS_DIR2_LEAF_BESTS_P_ARCH(ltp, ARCH_CONVERT);
 
3224
                lbp = XFS_DIR2_LEAF_BESTS_P(ltp);
3213
3225
                for (i = 0; i < INT_GET(ltp->bestcount, ARCH_CONVERT); i++) {
3214
3226
                        if (freetab->nents <= i || freetab->ents[i] != INT_GET(lbp[i], ARCH_CONVERT)) {
3215
3227
                                if (!sflag || v)
3354
3366
        xfs_dqblk_t     *dqb;
3355
3367
        xfs_dqid_t      dqid;
3356
3368
        u_int8_t        exp_flags = 0;
3357
 
        int             i;
3358
 
        int             perblock;
 
3369
        uint            i;
 
3370
        uint            perblock;
3359
3371
        xfs_fileoff_t   qbno;
3360
3372
        char            *s = NULL;
3361
3373
        int             scicb;
3378
3390
                ASSERT(0);
3379
3391
        }
3380
3392
 
3381
 
        perblock = (int)(mp->m_sb.sb_blocksize / sizeof(*dqb));
 
3393
        perblock = (uint)(mp->m_sb.sb_blocksize / sizeof(*dqb));
3382
3394
        dqid = 0;
3383
3395
        qbno = NULLFILEOFF;
3384
3396
        while ((qbno = blkmap_next_off(blkmap, qbno, &t)) !=
3402
3414
                }
3403
3415
                for (i = 0; i < perblock; i++, dqid++, dqb++) {
3404
3416
                        if (verbose || id->ilist || cb)
3405
 
                                dbprintf("%s dqblk %lld entry %d id %d bc "
 
3417
                                dbprintf("%s dqblk %lld entry %d id %u bc "
3406
3418
                                         "%lld ic %lld rc %lld\n",
3407
3419
                                        s, (xfs_dfiloff_t)qbno, i, dqid,
3408
3420
                                        INT_GET(dqb->dd_diskdq.d_bcount, ARCH_CONVERT),
3411
3423
                        if (INT_GET(dqb->dd_diskdq.d_magic, ARCH_CONVERT) != XFS_DQUOT_MAGIC) {
3412
3424
                                if (scicb)
3413
3425
                                        dbprintf("bad magic number %#x for %s "
3414
 
                                                 "dqblk %lld entry %d id %d\n",
 
3426
                                                 "dqblk %lld entry %d id %u\n",
3415
3427
                                                INT_GET(dqb->dd_diskdq.d_magic, ARCH_CONVERT), s,
3416
3428
                                                (xfs_dfiloff_t)qbno, i, dqid);
3417
3429
                                error++;
3421
3433
                                if (scicb)
3422
3434
                                        dbprintf("bad version number %#x for "
3423
3435
                                                 "%s dqblk %lld entry %d id "
3424
 
                                                 "%d\n",
 
3436
                                                 "%u\n",
3425
3437
                                                INT_GET(dqb->dd_diskdq.d_version, ARCH_CONVERT), s,
3426
3438
                                                (xfs_dfiloff_t)qbno, i, dqid);
3427
3439
                                error++;
3430
3442
                        if (INT_GET(dqb->dd_diskdq.d_flags, ARCH_CONVERT) != exp_flags) {
3431
3443
                                if (scicb)
3432
3444
                                        dbprintf("bad flags %#x for %s dqblk "
3433
 
                                                 "%lld entry %d id %d\n",
 
3445
                                                 "%lld entry %d id %u\n",
3434
3446
                                                INT_GET(dqb->dd_diskdq.d_flags, ARCH_CONVERT), s,
3435
3447
                                                (xfs_dfiloff_t)qbno, i, dqid);
3436
3448
                                error++;
3438
3450
                        }
3439
3451
                        if (INT_GET(dqb->dd_diskdq.d_id, ARCH_CONVERT) != dqid) {
3440
3452
                                if (scicb)
3441
 
                                        dbprintf("bad id %d for %s dqblk %lld "
3442
 
                                                 "entry %d id %d\n",
 
3453
                                        dbprintf("bad id %u for %s dqblk %lld "
 
3454
                                                 "entry %d id %u\n",
3443
3455
                                                INT_GET(dqb->dd_diskdq.d_id, ARCH_CONVERT), s,
3444
3456
                                                (xfs_dfiloff_t)qbno, i, dqid);
3445
3457
                                error++;
3446
3458
                                continue;
3447
3459
                        }
3448
 
                        quota_add((qtype == IS_PROJECT_QUOTA) ? dqid : -1,
3449
 
                                  (qtype == IS_GROUP_QUOTA) ? dqid : -1,
3450
 
                                  (qtype == IS_USER_QUOTA) ? dqid : -1,
 
3460
                        quota_add((qtype == IS_PROJECT_QUOTA) ? &dqid : NULL,
 
3461
                                  (qtype == IS_GROUP_QUOTA) ? &dqid : NULL,
 
3462
                                  (qtype == IS_USER_QUOTA) ? &dqid : NULL,
3451
3463
                                  1,
3452
3464
                                  INT_GET(dqb->dd_diskdq.d_bcount, ARCH_CONVERT),
3453
3465
                                  INT_GET(dqb->dd_diskdq.d_icount, ARCH_CONVERT),
3610
3622
                        error++;
3611
3623
                        break;
3612
3624
                }
3613
 
                lino = XFS_DIR2_SF_GET_INUMBER_ARCH(sf, XFS_DIR2_SF_INUMBERP(sfe), ARCH_CONVERT);
 
3625
                lino = XFS_DIR2_SF_GET_INUMBER(sf, XFS_DIR2_SF_INUMBERP(sfe));
3614
3626
                if (lino > XFS_DIR2_MAX_SHORT_INUM)
3615
3627
                        i8++;
3616
3628
                cid = find_inode(lino, 1);
3630
3642
                if (v)
3631
3643
                        dbprintf("dir %lld entry %*.*s offset %d %lld\n",
3632
3644
                                id->ino, sfe->namelen, sfe->namelen, sfe->name,
3633
 
                                XFS_DIR2_SF_GET_OFFSET_ARCH(sfe, ARCH_CONVERT), lino);
3634
 
                if (XFS_DIR2_SF_GET_OFFSET_ARCH(sfe, ARCH_CONVERT) < offset) {
 
3645
                                XFS_DIR2_SF_GET_OFFSET(sfe), lino);
 
3646
                if (XFS_DIR2_SF_GET_OFFSET(sfe) < offset) {
3635
3647
                        if (!sflag)
3636
3648
                                dbprintf("dir %lld entry %*.*s bad offset %d\n",
3637
3649
                                        id->ino, sfe->namelen, sfe->namelen,
3638
 
                                        sfe->name, XFS_DIR2_SF_GET_OFFSET_ARCH(sfe, ARCH_CONVERT));
 
3650
                                        sfe->name, XFS_DIR2_SF_GET_OFFSET(sfe));
3639
3651
                        error++;
3640
3652
                }
3641
3653
                offset =
3642
 
                        XFS_DIR2_SF_GET_OFFSET_ARCH(sfe, ARCH_CONVERT) +
 
3654
                        XFS_DIR2_SF_GET_OFFSET(sfe) +
3643
3655
                        XFS_DIR2_DATA_ENTSIZE(sfe->namelen);
3644
3656
                sfe = XFS_DIR2_SF_NEXTENTRY(sf, sfe);
3645
3657
        }
3656
3668
                        dbprintf("dir %llu offsets too high\n", id->ino);
3657
3669
                error++;
3658
3670
        }
3659
 
        lino = XFS_DIR2_SF_GET_INUMBER_ARCH(sf, &sf->hdr.parent, ARCH_CONVERT);
 
3671
        lino = XFS_DIR2_SF_GET_INUMBER(sf, &sf->hdr.parent);
3660
3672
        if (lino > XFS_DIR2_MAX_SHORT_INUM)
3661
3673
                i8++;
3662
3674
        cid = find_inode(lino, 1);
3703
3715
        (*dot)++;
3704
3716
        sfe = &sf->list[0];
3705
3717
        for (i = INT_GET(sf->hdr.count, ARCH_CONVERT) - 1; i >= 0; i--) {
3706
 
                lino = DIRINO_GET_ARCH(&sfe->inumber, ARCH_CONVERT);
 
3718
                lino = XFS_GET_DIR_INO8(sfe->inumber);
3707
3719
                cid = find_inode(lino, 1);
3708
3720
                if (cid == NULL) {
3709
3721
                        if (!sflag)
3727
3739
                dbprintf("dir %llu size is %lld, should be %d\n",
3728
3740
                        id->ino, dip->di_core.di_size,
3729
3741
                        (int)((char *)sfe - (char *)sf));
3730
 
        lino=DIRINO_GET_ARCH(&sf->hdr.parent, ARCH_CONVERT);
 
3742
        lino = XFS_GET_DIR_INO8(sf->hdr.parent);
3731
3743
        cid = find_inode(lino, 1);
3732
3744
        if (cid)
3733
3745
                addlink_inode(cid);
3745
3757
 
3746
3758
static void
3747
3759
quota_add(
3748
 
        xfs_dqid_t      prjid,
3749
 
        xfs_dqid_t      grpid,
3750
 
        xfs_dqid_t      usrid,
 
3760
        xfs_dqid_t      *prjid,
 
3761
        xfs_dqid_t      *grpid,
 
3762
        xfs_dqid_t      *usrid,
3751
3763
        int             dq,
3752
3764
        xfs_qcnt_t      bc,
3753
3765
        xfs_qcnt_t      ic,
3754
3766
        xfs_qcnt_t      rc)
3755
3767
{
3756
 
        if (qudo && usrid != -1)
3757
 
                quota_add1(qudata, usrid, dq, bc, ic, rc);
3758
 
        if (qgdo && grpid != -1)
3759
 
                quota_add1(qgdata, grpid, dq, bc, ic, rc);
3760
 
        if (qpdo && prjid != -1)
3761
 
                quota_add1(qpdata, prjid, dq, bc, ic, rc);
 
3768
        if (qudo && usrid != NULL)
 
3769
                quota_add1(qudata, *usrid, dq, bc, ic, rc);
 
3770
        if (qgdo && grpid != NULL)
 
3771
                quota_add1(qgdata, *grpid, dq, bc, ic, rc);
 
3772
        if (qpdo && prjid != NULL)
 
3773
                quota_add1(qpdata, *prjid, dq, bc, ic, rc);
3762
3774
}
3763
3775
 
3764
3776
static void
3774
3786
        int             qh;
3775
3787
        qinfo_t         *qi;
3776
3788
 
3777
 
        qh = (int)((__uint32_t)id % QDATA_HASH_SIZE);
 
3789
        qh = (int)(id % QDATA_HASH_SIZE);
3778
3790
        qe = qt[qh];
3779
3791
        while (qe) {
3780
3792
                if (qe->id == id) {
3815
3827
                            qp->count.ic != qp->dq.ic ||
3816
3828
                            qp->count.rc != qp->dq.rc) {
3817
3829
                                if (!sflag) {
3818
 
                                        dbprintf("%s quota id %d, have/exp",
 
3830
                                        dbprintf("%s quota id %u, have/exp",
3819
3831
                                                s, qp->id);
3820
3832
                                        if (qp->count.bc != qp->dq.bc)
3821
3833
                                                dbprintf(" bc %lld/%lld",
3850
3862
        qgdo = mp->m_sb.sb_gquotino != 0 &&
3851
3863
               mp->m_sb.sb_gquotino != NULLFSINO &&
3852
3864
               (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) &&
3853
 
               (mp->m_sb.sb_qflags & XFS_GQUOTA_CHKD);
 
3865
               (mp->m_sb.sb_qflags & XFS_OQUOTA_CHKD);
3854
3866
        qpdo = mp->m_sb.sb_gquotino != 0 &&
3855
3867
               mp->m_sb.sb_gquotino != NULLFSINO &&
3856
3868
               (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) &&
3857
 
               (mp->m_sb.sb_qflags & XFS_GQUOTA_CHKD);  /* yep, G */
 
3869
               (mp->m_sb.sb_qflags & XFS_OQUOTA_CHKD);
3858
3870
        if (qudo)
3859
3871
                qudata = xcalloc(QDATA_HASH_SIZE, sizeof(qdata_t *));
3860
3872
        if (qgdo)
3887
3899
                return;
3888
3900
        }
3889
3901
 
3890
 
        libxfs_xlate_sb(iocur_top->data, sb, 1, ARCH_CONVERT, XFS_SB_ALL_BITS);
 
3902
        libxfs_xlate_sb(iocur_top->data, sb, 1, XFS_SB_ALL_BITS);
3891
3903
 
3892
3904
        if (sb->sb_magicnum != XFS_SB_MAGIC) {
3893
3905
                if (!sflag)
4418
4430
                                continue;
4419
4431
                        }
4420
4432
                        for (j = 0, nfree = 0; j < XFS_INODES_PER_CHUNK; j++) {
4421
 
                                if ((isfree = XFS_INOBT_IS_FREE(&rp[i], j, ARCH_CONVERT)))
 
4433
                                if ((isfree = XFS_INOBT_IS_FREE_DISK(&rp[i], j)))
4422
4434
                                        nfree++;
4423
4435
                                process_inode(agf, agino + j,
4424
4436
                                        (xfs_dinode_t *)((char *)iocur_top->data + ((off + j) << mp->m_sb.sb_inodelog)),