← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/fsp/fsp0fsp.c

  • Committer: Brian Aker
  • Date: 2010-10-21 05:03:11 UTC
  • mto: (1866.1.1 merge)
  • mto: This revision was merged to the branch mainline in revision 1867.
  • Revision ID: brian@tangent.org-20101021050311-gmobtsn3cgp8tz0b
Add a catalog() command.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/fsp/fsp0fsp.c
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (c) 1995, 2010, Innobase Oy. All Rights Reserved.
 
3
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
127
127
 
128
128
#define FSEG_ARR_OFFSET         (FSEG_PAGE_DATA + FLST_NODE_SIZE)
129
129
/*-------------------------------------*/
130
 
#define FSEG_ID                 0       /* 8 bytes of segment id: if this is 0,
131
 
                                        it means that the header is unused */
 
130
#define FSEG_ID                 0       /* 8 bytes of segment id: if this is
 
131
                                        ut_dulint_zero, it means that the
 
132
                                        header is unused */
132
133
#define FSEG_NOT_FULL_N_USED    8
133
134
                                        /* number of used segment pages in
134
135
                                        the FSEG_NOT_FULL list */
385
386
ibool
386
387
xdes_get_bit(
387
388
/*=========*/
388
 
        const xdes_t*   descr,  /*!< in: descriptor */
389
 
        ulint           bit,    /*!< in: XDES_FREE_BIT or XDES_CLEAN_BIT */
390
 
        ulint           offset, /*!< in: page offset within extent:
391
 
                                0 ... FSP_EXTENT_SIZE - 1 */
392
 
        mtr_t*          mtr)    /*!< in: mtr */
 
389
        xdes_t* descr,  /*!< in: descriptor */
 
390
        ulint   bit,    /*!< in: XDES_FREE_BIT or XDES_CLEAN_BIT */
 
391
        ulint   offset, /*!< in: page offset within extent:
 
392
                        0 ... FSP_EXTENT_SIZE - 1 */
 
393
        mtr_t*  mtr)    /*!< in: mtr */
393
394
{
394
395
        ulint   index;
395
396
        ulint   byte_index;
526
527
ulint
527
528
xdes_get_n_used(
528
529
/*============*/
529
 
        const xdes_t*   descr,  /*!< in: descriptor */
530
 
        mtr_t*          mtr)    /*!< in: mtr */
 
530
        xdes_t* descr,  /*!< in: descriptor */
 
531
        mtr_t*  mtr)    /*!< in: mtr */
531
532
{
532
533
        ulint   i;
533
534
        ulint   count   = 0;
550
551
ibool
551
552
xdes_is_free(
552
553
/*=========*/
553
 
        const xdes_t*   descr,  /*!< in: descriptor */
554
 
        mtr_t*          mtr)    /*!< in: mtr */
 
554
        xdes_t* descr,  /*!< in: descriptor */
 
555
        mtr_t*  mtr)    /*!< in: mtr */
555
556
{
556
557
        if (0 == xdes_get_n_used(descr, mtr)) {
557
558
 
568
569
ibool
569
570
xdes_is_full(
570
571
/*=========*/
571
 
        const xdes_t*   descr,  /*!< in: descriptor */
572
 
        mtr_t*          mtr)    /*!< in: mtr */
 
572
        xdes_t* descr,  /*!< in: descriptor */
 
573
        mtr_t*  mtr)    /*!< in: mtr */
573
574
{
574
575
        if (FSP_EXTENT_SIZE == xdes_get_n_used(descr, mtr)) {
575
576
 
585
586
void
586
587
xdes_set_state(
587
588
/*===========*/
588
 
        xdes_t* descr,  /*!< in/out: descriptor */
 
589
        xdes_t* descr,  /*!< in: descriptor */
589
590
        ulint   state,  /*!< in: state to set */
590
591
        mtr_t*  mtr)    /*!< in: mtr handle */
591
592
{
604
605
ulint
605
606
xdes_get_state(
606
607
/*===========*/
607
 
        const xdes_t*   descr,  /*!< in: descriptor */
608
 
        mtr_t*          mtr)    /*!< in: mtr handle */
 
608
        xdes_t* descr,  /*!< in: descriptor */
 
609
        mtr_t*  mtr)    /*!< in: mtr handle */
609
610
{
610
611
        ulint   state;
611
612
 
704
705
xdes_t*
705
706
xdes_get_descriptor_with_space_hdr(
706
707
/*===============================*/
707
 
        fsp_header_t*   sp_header,/*!< in/out: space header, x-latched */
 
708
        fsp_header_t*   sp_header,/*!< in: space header, x-latched */
708
709
        ulint           space,  /*!< in: space id */
709
710
        ulint           offset, /*!< in: page offset;
710
711
                                if equal to the free limit,
868
869
                return;
869
870
        }
870
871
 
871
 
        memset(page, 0, UNIV_PAGE_SIZE);
 
872
#ifdef UNIV_BASIC_LOG_DEBUG
 
873
        memset(page, 0xff, UNIV_PAGE_SIZE);
 
874
#endif
872
875
        mach_write_to_4(page + FIL_PAGE_OFFSET, buf_block_get_page_no(block));
 
876
        memset(page + FIL_PAGE_LSN, 0, 8);
873
877
        mach_write_to_4(page + FIL_PAGE_ARCH_LOG_NO_OR_SPACE_ID,
874
878
                        buf_block_get_space(block));
 
879
        memset(page + UNIV_PAGE_SIZE - FIL_PAGE_END_LSN_OLD_CHKSUM, 0, 8);
875
880
}
876
881
 
877
882
#ifndef UNIV_HOTBACKUP
998
1003
        flst_init(header + FSP_SEG_INODES_FULL, mtr);
999
1004
        flst_init(header + FSP_SEG_INODES_FREE, mtr);
1000
1005
 
1001
 
        mlog_write_ull(header + FSP_SEG_ID, 1, mtr);
 
1006
        mlog_write_dulint(header + FSP_SEG_ID, ut_dulint_create(0, 1), mtr);
1002
1007
        if (space == 0) {
1003
1008
                fsp_fill_free_list(FALSE, space, header, mtr);
1004
1009
                btr_create(DICT_CLUSTERED | DICT_UNIVERSAL | DICT_IBUF,
1005
 
                           0, 0, DICT_IBUF_ID_MIN + space,
 
1010
                           0, 0, ut_dulint_add(DICT_IBUF_ID_MIN, space),
1006
1011
                           dict_ind_redundant, mtr);
1007
1012
        } else {
1008
1013
                fsp_fill_free_list(TRUE, space, header, mtr);
1337
1342
                                        descriptor page and ibuf bitmap page;
1338
1343
                                        then we do not allocate more extents */
1339
1344
        ulint           space,          /*!< in: space */
1340
 
        fsp_header_t*   header,         /*!< in/out: space header */
 
1345
        fsp_header_t*   header,         /*!< in: space header */
1341
1346
        mtr_t*          mtr)            /*!< in: mtr */
1342
1347
{
1343
1348
        ulint   limit;
1840
1845
                inode = fsp_seg_inode_page_get_nth_inode(
1841
1846
                        page, i, zip_size, mtr);
1842
1847
 
1843
 
                if (mach_read_from_8(inode + FSEG_ID)) {
 
1848
                if (!ut_dulint_is_zero(mach_read_from_8(inode + FSEG_ID))) {
1844
1849
                        /* This is used */
1845
1850
 
1846
1851
                        ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N)
1871
1876
                inode = fsp_seg_inode_page_get_nth_inode(
1872
1877
                        page, i, zip_size, mtr);
1873
1878
 
1874
 
                if (!mach_read_from_8(inode + FSEG_ID)) {
 
1879
                if (ut_dulint_is_zero(mach_read_from_8(inode + FSEG_ID))) {
1875
1880
                        /* This is unused */
1876
1881
 
1877
1882
                        return(i);
1930
1935
                inode = fsp_seg_inode_page_get_nth_inode(page, i,
1931
1936
                                                         zip_size, mtr);
1932
1937
 
1933
 
                mlog_write_ull(inode + FSEG_ID, 0, mtr);
 
1938
                mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, mtr);
1934
1939
        }
1935
1940
 
1936
1941
        flst_add_last(space_header + FSP_SEG_INODES_FREE,
1997
2002
                              page + FSEG_INODE_PAGE_NODE, mtr);
1998
2003
        }
1999
2004
 
2000
 
        ut_ad(!mach_read_from_8(inode + FSEG_ID)
 
2005
        ut_ad(ut_dulint_is_zero(mach_read_from_8(inode + FSEG_ID))
2001
2006
              || mach_read_from_4(inode + FSEG_MAGIC_N) == FSEG_MAGIC_N_VALUE);
2002
2007
        return(inode);
2003
2008
}
2035
2040
                              page + FSEG_INODE_PAGE_NODE, mtr);
2036
2041
        }
2037
2042
 
2038
 
        mlog_write_ull(inode + FSEG_ID, 0, mtr);
 
2043
        mlog_write_dulint(inode + FSEG_ID, ut_dulint_zero, mtr);
2039
2044
        mlog_write_ulint(inode + FSEG_MAGIC_N, 0xfa051ce3, MLOG_4BYTES, mtr);
2040
2045
 
2041
2046
        if (ULINT_UNDEFINED
2072
2077
 
2073
2078
        inode = fut_get_ptr(space, zip_size, inode_addr, RW_X_LATCH, mtr);
2074
2079
 
2075
 
        if (UNIV_UNLIKELY(!mach_read_from_8(inode + FSEG_ID))) {
 
2080
        if (UNIV_UNLIKELY
 
2081
            (ut_dulint_is_zero(mach_read_from_8(inode + FSEG_ID)))) {
2076
2082
 
2077
2083
                inode = NULL;
2078
2084
        } else {
2247
2253
        ulint           zip_size;
2248
2254
        fsp_header_t*   space_header;
2249
2255
        fseg_inode_t*   inode;
2250
 
        ib_id_t         seg_id;
 
2256
        dulint          seg_id;
2251
2257
        buf_block_t*    block   = 0; /* remove warning */
2252
2258
        fseg_header_t*  header  = 0; /* remove warning */
2253
2259
        rw_lock_t*      latch;
2301
2307
        /* Read the next segment id from space header and increment the
2302
2308
        value in space header */
2303
2309
 
2304
 
        seg_id = mach_read_from_8(space_header + FSP_SEG_ID);
2305
 
 
2306
 
        mlog_write_ull(space_header + FSP_SEG_ID, seg_id + 1, mtr);
2307
 
 
2308
 
        mlog_write_ull(inode + FSEG_ID, seg_id, mtr);
 
2310
        seg_id = mtr_read_dulint(space_header + FSP_SEG_ID, mtr);
 
2311
 
 
2312
        mlog_write_dulint(space_header + FSP_SEG_ID, ut_dulint_add(seg_id, 1),
 
2313
                          mtr);
 
2314
 
 
2315
        mlog_write_dulint(inode + FSEG_ID, seg_id, mtr);
2309
2316
        mlog_write_ulint(inode + FSEG_NOT_FULL_N_USED, 0, MLOG_4BYTES, mtr);
2310
2317
 
2311
2318
        flst_init(inode + FSEG_FREE, mtr);
2457
2464
{
2458
2465
        xdes_t* descr;
2459
2466
        ulint   i;
2460
 
        ib_id_t seg_id;
 
2467
        dulint  seg_id;
2461
2468
        ulint   reserved;
2462
2469
        ulint   used;
2463
2470
 
2494
2501
 
2495
2502
                xdes_set_state(descr, XDES_FSEG, mtr);
2496
2503
 
2497
 
                seg_id = mach_read_from_8(inode + FSEG_ID);
 
2504
                seg_id = mtr_read_dulint(inode + FSEG_ID, mtr);
2498
2505
                ut_ad(mach_read_from_4(inode + FSEG_MAGIC_N)
2499
2506
                      == FSEG_MAGIC_N_VALUE);
2500
 
                mlog_write_ull(descr + XDES_ID, seg_id, mtr);
 
2507
                mlog_write_dulint(descr + XDES_ID, seg_id, mtr);
2501
2508
 
2502
2509
                flst_add_last(inode + FSEG_FREE, descr + XDES_FLST_NODE, mtr);
2503
2510
                hint += FSP_EXTENT_SIZE;
2521
2528
        mtr_t*          mtr)    /*!< in: mtr */
2522
2529
{
2523
2530
        xdes_t*         descr;
2524
 
        ib_id_t         seg_id;
 
2531
        dulint          seg_id;
2525
2532
        fil_addr_t      first;
2526
2533
 
2527
2534
        ut_ad(!((page_offset(inode) - FSEG_ARR_OFFSET) % FSEG_INODE_SIZE));
2542
2549
                        return(NULL);
2543
2550
                }
2544
2551
 
2545
 
                seg_id = mach_read_from_8(inode + FSEG_ID);
 
2552
                seg_id = mtr_read_dulint(inode + FSEG_ID, mtr);
2546
2553
 
2547
2554
                xdes_set_state(descr, XDES_FSEG, mtr);
2548
 
                mlog_write_ull(descr + XDES_ID, seg_id, mtr);
 
2555
                mlog_write_dulint(descr + XDES_ID, seg_id, mtr);
2549
2556
                flst_add_last(inode + FSEG_FREE, descr + XDES_FLST_NODE, mtr);
2550
2557
 
2551
2558
                /* Try to fill the segment free list */
2580
2587
{
2581
2588
        fsp_header_t*   space_header;
2582
2589
        ulint           space_size;
2583
 
        ib_id_t         seg_id;
 
2590
        dulint          seg_id;
2584
2591
        ulint           used;
2585
2592
        ulint           reserved;
2586
2593
        xdes_t*         descr;          /*!< extent of the hinted page */
2596
2603
        ut_ad(mach_read_from_4(seg_inode + FSEG_MAGIC_N)
2597
2604
              == FSEG_MAGIC_N_VALUE);
2598
2605
        ut_ad(!((page_offset(seg_inode) - FSEG_ARR_OFFSET) % FSEG_INODE_SIZE));
2599
 
        seg_id = mach_read_from_8(seg_inode + FSEG_ID);
 
2606
        seg_id = mtr_read_dulint(seg_inode + FSEG_ID, mtr);
2600
2607
 
2601
 
        ut_ad(seg_id);
 
2608
        ut_ad(!ut_dulint_is_zero(seg_id));
2602
2609
 
2603
2610
        reserved = fseg_n_reserved_pages_low(seg_inode, &used, mtr);
2604
2611
 
2616
2623
        /* In the big if-else below we look for ret_page and ret_descr */
2617
2624
        /*-------------------------------------------------------------*/
2618
2625
        if ((xdes_get_state(descr, mtr) == XDES_FSEG)
2619
 
            && mach_read_from_8(descr + XDES_ID) == seg_id
 
2626
            && (0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID,
 
2627
                                                   mtr), seg_id))
2620
2628
            && (xdes_get_bit(descr, XDES_FREE_BIT,
2621
2629
                             hint % FSP_EXTENT_SIZE, mtr) == TRUE)) {
2622
2630
 
2638
2646
                ut_a(ret_descr == descr);
2639
2647
 
2640
2648
                xdes_set_state(ret_descr, XDES_FSEG, mtr);
2641
 
                mlog_write_ull(ret_descr + XDES_ID, seg_id, mtr);
 
2649
                mlog_write_dulint(ret_descr + XDES_ID, seg_id, mtr);
2642
2650
                flst_add_last(seg_inode + FSEG_FREE,
2643
2651
                              ret_descr + XDES_FLST_NODE, mtr);
2644
2652
 
2667
2675
                }
2668
2676
                /*-----------------------------------------------------------*/
2669
2677
        } else if ((xdes_get_state(descr, mtr) == XDES_FSEG)
2670
 
                   && mach_read_from_8(descr + XDES_ID) == seg_id
 
2678
                   && (0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID,
 
2679
                                                          mtr), seg_id))
2671
2680
                   && (!xdes_is_full(descr, mtr))) {
2672
2681
 
2673
2682
                /* 4. We can take the page from the same extent as the
3238
3247
        xdes_t* descr;
3239
3248
        ulint   not_full_n_used;
3240
3249
        ulint   state;
3241
 
        ib_id_t descr_id;
3242
 
        ib_id_t seg_id;
 
3250
        dulint  descr_id;
 
3251
        dulint  seg_id;
3243
3252
        ulint   i;
3244
3253
 
3245
3254
        ut_ad(seg_inode && mtr);
3298
3307
 
3299
3308
        /* If we get here, the page is in some extent of the segment */
3300
3309
 
3301
 
        descr_id = mach_read_from_8(descr + XDES_ID);
3302
 
        seg_id = mach_read_from_8(seg_inode + FSEG_ID);
 
3310
        descr_id = mtr_read_dulint(descr + XDES_ID, mtr);
 
3311
        seg_id = mtr_read_dulint(seg_inode + FSEG_ID, mtr);
3303
3312
#if 0
3304
3313
        fprintf(stderr,
3305
3314
                "InnoDB: InnoDB is freeing space %lu page %lu,\n"
3306
 
                "InnoDB: which belongs to descr seg %llu\n"
3307
 
                "InnoDB: segment %llu.\n",
 
3315
                "InnoDB: which belongs to descr seg %lu %lu\n"
 
3316
                "InnoDB: segment %lu %lu.\n",
3308
3317
                (ulong) space, (ulong) page,
3309
 
                (ullint) descr_id,
3310
 
                (ullint) seg_id);
 
3318
                (ulong) ut_dulint_get_high(descr_id),
 
3319
                (ulong) ut_dulint_get_low(descr_id),
 
3320
                (ulong) ut_dulint_get_high(seg_id),
 
3321
                (ulong) ut_dulint_get_low(seg_id));
3311
3322
#endif /* 0 */
3312
 
        if (UNIV_UNLIKELY(descr_id != seg_id)) {
 
3323
        if (0 != ut_dulint_cmp(descr_id, seg_id)) {
3313
3324
                fputs("InnoDB: Dump of the tablespace extent descriptor: ",
3314
3325
                      stderr);
3315
3326
                ut_print_buf(stderr, descr, 40);
3321
3332
                        "InnoDB: Serious error: InnoDB is trying to"
3322
3333
                        " free space %lu page %lu,\n"
3323
3334
                        "InnoDB: which does not belong to"
3324
 
                        " segment %llu but belongs\n"
3325
 
                        "InnoDB: to segment %llu.\n",
 
3335
                        " segment %lu %lu but belongs\n"
 
3336
                        "InnoDB: to segment %lu %lu.\n",
3326
3337
                        (ulong) space, (ulong) page,
3327
 
                        (ullint) descr_id,
3328
 
                        (ullint) seg_id);
 
3338
                        (ulong) ut_dulint_get_high(descr_id),
 
3339
                        (ulong) ut_dulint_get_low(descr_id),
 
3340
                        (ulong) ut_dulint_get_high(seg_id),
 
3341
                        (ulong) ut_dulint_get_low(seg_id));
3329
3342
                goto crash;
3330
3343
        }
3331
3344
 
3414
3427
        descr = xdes_get_descriptor(space, zip_size, page, mtr);
3415
3428
 
3416
3429
        ut_a(xdes_get_state(descr, mtr) == XDES_FSEG);
3417
 
        ut_a(!memcmp(descr + XDES_ID, seg_inode + FSEG_ID, 8));
 
3430
        ut_a(0 == ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID, mtr),
 
3431
                                mtr_read_dulint(seg_inode + FSEG_ID, mtr)));
3418
3432
        ut_ad(mach_read_from_4(seg_inode + FSEG_MAGIC_N)
3419
3433
              == FSEG_MAGIC_N_VALUE);
3420
3434
 
3674
3688
        mtr_t*          mtr2)   /*!< in: mtr */
3675
3689
{
3676
3690
        ulint           space;
3677
 
        ib_id_t         seg_id;
 
3691
        dulint          seg_id;
3678
3692
        mtr_t           mtr;
3679
3693
        xdes_t*         descr;
3680
3694
        fil_addr_t      node_addr;
3686
3700
 
3687
3701
        space = page_get_space_id(page_align(inode));
3688
3702
 
3689
 
        seg_id = mach_read_from_8(inode + FSEG_ID);
 
3703
        seg_id = mtr_read_dulint(inode + FSEG_ID, mtr2);
3690
3704
        n_used = mtr_read_ulint(inode + FSEG_NOT_FULL_N_USED,
3691
3705
                                MLOG_4BYTES, mtr2);
3692
3706
        flst_validate(inode + FSEG_FREE, mtr2);
3709
3723
 
3710
3724
                ut_a(xdes_get_n_used(descr, &mtr) == 0);
3711
3725
                ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG);
3712
 
                ut_a(mach_read_from_8(descr + XDES_ID) == seg_id);
 
3726
                ut_a(!ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID, &mtr),
 
3727
                                    seg_id));
3713
3728
 
3714
3729
                node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
3715
3730
                mtr_commit(&mtr);
3733
3748
                ut_a(xdes_get_n_used(descr, &mtr) > 0);
3734
3749
                ut_a(xdes_get_n_used(descr, &mtr) < FSP_EXTENT_SIZE);
3735
3750
                ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG);
3736
 
                ut_a(mach_read_from_8(descr + XDES_ID) == seg_id);
 
3751
                ut_a(!ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID, &mtr),
 
3752
                                    seg_id));
3737
3753
 
3738
3754
                n_used2 += xdes_get_n_used(descr, &mtr);
3739
3755
 
3758
3774
 
3759
3775
                ut_a(xdes_get_n_used(descr, &mtr) == FSP_EXTENT_SIZE);
3760
3776
                ut_a(xdes_get_state(descr, &mtr) == XDES_FSEG);
3761
 
                ut_a(mach_read_from_8(descr + XDES_ID) == seg_id);
 
3777
                ut_a(!ut_dulint_cmp(mtr_read_dulint(descr + XDES_ID, &mtr),
 
3778
                                    seg_id));
3762
3779
 
3763
3780
                node_addr = flst_get_next_addr(descr + XDES_FLST_NODE, &mtr);
3764
3781
                mtr_commit(&mtr);
3809
3826
        mtr_t*          mtr)    /*!< in: mtr */
3810
3827
{
3811
3828
        ulint   space;
 
3829
        ulint   seg_id_low;
 
3830
        ulint   seg_id_high;
3812
3831
        ulint   n_used;
3813
3832
        ulint   n_frag;
3814
3833
        ulint   n_free;
3817
3836
        ulint   reserved;
3818
3837
        ulint   used;
3819
3838
        ulint   page_no;
3820
 
        ib_id_t seg_id;
 
3839
        dulint   d_var;
3821
3840
 
3822
3841
        ut_ad(mtr_memo_contains_page(mtr, inode, MTR_MEMO_PAGE_X_FIX));
3823
3842
        space = page_get_space_id(page_align(inode));
3825
3844
 
3826
3845
        reserved = fseg_n_reserved_pages_low(inode, &used, mtr);
3827
3846
 
3828
 
        seg_id = mach_read_from_8(inode + FSEG_ID);
 
3847
        d_var = mtr_read_dulint(inode + FSEG_ID, mtr);
 
3848
 
 
3849
        seg_id_low = ut_dulint_get_low(d_var);
 
3850
        seg_id_high = ut_dulint_get_high(d_var);
3829
3851
 
3830
3852
        n_used = mtr_read_ulint(inode + FSEG_NOT_FULL_N_USED,
3831
3853
                                MLOG_4BYTES, mtr);
3835
3857
        n_full = flst_get_len(inode + FSEG_FULL, mtr);
3836
3858
 
3837
3859
        fprintf(stderr,
3838
 
                "SEGMENT id %llu space %lu; page %lu;"
 
3860
                "SEGMENT id %lu %lu space %lu; page %lu;"
3839
3861
                " res %lu used %lu; full ext %lu\n"
3840
3862
                "fragm pages %lu; free extents %lu;"
3841
3863
                " not full extents %lu: pages %lu\n",
3842
 
                (ullint) seg_id,
 
3864
                (ulong) seg_id_high, (ulong) seg_id_low,
3843
3865
                (ulong) space, (ulong) page_no,
3844
3866
                (ulong) reserved, (ulong) used, (ulong) n_full,
3845
3867
                (ulong) n_frag, (ulong) n_free, (ulong) n_not_full,
4041
4063
 
4042
4064
                        seg_inode = fsp_seg_inode_page_get_nth_inode(
4043
4065
                                seg_inode_page, n, zip_size, &mtr);
4044
 
                        ut_a(mach_read_from_8(seg_inode + FSEG_ID) != 0);
 
4066
                        ut_a(!ut_dulint_is_zero(
 
4067
                                     mach_read_from_8(seg_inode + FSEG_ID)));
4045
4068
                        fseg_validate_low(seg_inode, &mtr);
4046
4069
 
4047
4070
                        descr_count += flst_get_len(seg_inode + FSEG_FREE,
4086
4109
 
4087
4110
                        seg_inode = fsp_seg_inode_page_get_nth_inode(
4088
4111
                                seg_inode_page, n, zip_size, &mtr);
4089
 
                        if (mach_read_from_8(seg_inode + FSEG_ID)) {
 
4112
                        if (!ut_dulint_is_zero(
 
4113
                                    mach_read_from_8(seg_inode + FSEG_ID))) {
4090
4114
                                fseg_validate_low(seg_inode, &mtr);
4091
4115
 
4092
4116
                                descr_count += flst_get_len(
4148
4172
        ulint           n_free;
4149
4173
        ulint           n_free_frag;
4150
4174
        ulint           n_full_frag;
4151
 
        ib_id_t         seg_id;
 
4175
        ulint           seg_id_low;
 
4176
        ulint           seg_id_high;
4152
4177
        ulint           n;
4153
4178
        ulint           n_segs          = 0;
 
4179
        dulint          d_var;
4154
4180
        mtr_t           mtr;
4155
4181
        mtr_t           mtr2;
4156
4182
 
4180
4206
        n_free_frag = flst_get_len(header + FSP_FREE_FRAG, &mtr);
4181
4207
        n_full_frag = flst_get_len(header + FSP_FULL_FRAG, &mtr);
4182
4208
 
4183
 
        seg_id = mach_read_from_8(header + FSP_SEG_ID);
 
4209
        d_var = mtr_read_dulint(header + FSP_SEG_ID, &mtr);
 
4210
 
 
4211
        seg_id_low = ut_dulint_get_low(d_var);
 
4212
        seg_id_high = ut_dulint_get_high(d_var);
4184
4213
 
4185
4214
        fprintf(stderr,
4186
4215
                "FILE SPACE INFO: id %lu\n"
4187
4216
                "size %lu, free limit %lu, free extents %lu\n"
4188
4217
                "not full frag extents %lu: used pages %lu,"
4189
4218
                " full frag extents %lu\n"
4190
 
                "first seg id not used %llu\n",
 
4219
                "first seg id not used %lu %lu\n",
4191
4220
                (ulong) space,
4192
4221
                (ulong) size, (ulong) free_limit, (ulong) n_free,
4193
4222
                (ulong) n_free_frag, (ulong) frag_n_used, (ulong) n_full_frag,
4194
 
                (ullint) seg_id);
 
4223
                (ulong) seg_id_high, (ulong) seg_id_low);
4195
4224
 
4196
4225
        mtr_commit(&mtr);
4197
4226
 
4221
4250
 
4222
4251
                        seg_inode = fsp_seg_inode_page_get_nth_inode(
4223
4252
                                seg_inode_page, n, zip_size, &mtr);
4224
 
                        ut_a(mach_read_from_8(seg_inode + FSEG_ID) != 0);
 
4253
                        ut_a(!ut_dulint_is_zero(
 
4254
                                     mach_read_from_8(seg_inode + FSEG_ID)));
4225
4255
                        fseg_print_low(seg_inode, &mtr);
4226
4256
 
4227
4257
                        n_segs++;
4258
4288
 
4259
4289
                        seg_inode = fsp_seg_inode_page_get_nth_inode(
4260
4290
                                seg_inode_page, n, zip_size, &mtr);
4261
 
                        if (mach_read_from_8(seg_inode + FSEG_ID)) {
 
4291
                        if (!ut_dulint_is_zero(
 
4292
                                    mach_read_from_8(seg_inode + FSEG_ID))) {
4262
4293
 
4263
4294
                                fseg_print_low(seg_inode, &mtr);
4264
4295
                                n_segs++;