[BACK]Return to xfs_log_recover.c CVS log [TXT] [DIR] Up to [OSS] / xfs-linux

Diff for /xfs-linux/xfs_log_recover.c between versions 1.328 and 1.329

version 1.328, 2007/10/02 06:14:55 version 1.329, 2007/10/02 06:15:48
Line 198  xlog_header_check_dump( Line 198  xlog_header_check_dump(
         cmn_err(CE_DEBUG, "    log : uuid = ");          cmn_err(CE_DEBUG, "    log : uuid = ");
         for (b = 0; b < 16; b++)          for (b = 0; b < 16; b++)
                 cmn_err(CE_DEBUG, "%02x",((uchar_t *)&head->h_fs_uuid)[b]);                  cmn_err(CE_DEBUG, "%02x",((uchar_t *)&head->h_fs_uuid)[b]);
         cmn_err(CE_DEBUG, ", fmt = %d\n", INT_GET(head->h_fmt, ARCH_CONVERT));          cmn_err(CE_DEBUG, ", fmt = %d\n", be32_to_cpu(head->h_fmt));
 }  }
 #else  #else
 #define xlog_header_check_dump(mp, head)  #define xlog_header_check_dump(mp, head)
Line 212  xlog_header_check_recover( Line 212  xlog_header_check_recover(
         xfs_mount_t             *mp,          xfs_mount_t             *mp,
         xlog_rec_header_t       *head)          xlog_rec_header_t       *head)
 {  {
         ASSERT(INT_GET(head->h_magicno, ARCH_CONVERT) == XLOG_HEADER_MAGIC_NUM);          ASSERT(be32_to_cpu(head->h_magicno) == XLOG_HEADER_MAGIC_NUM);
   
         /*          /*
          * IRIX doesn't write the h_fmt field and leaves it zeroed           * IRIX doesn't write the h_fmt field and leaves it zeroed
          * (XLOG_FMT_UNKNOWN). This stops us from trying to recover           * (XLOG_FMT_UNKNOWN). This stops us from trying to recover
          * a dirty log created in IRIX.           * a dirty log created in IRIX.
          */           */
         if (unlikely(INT_GET(head->h_fmt, ARCH_CONVERT) != XLOG_FMT)) {          if (unlikely(be32_to_cpu(head->h_fmt) != XLOG_FMT)) {
                 xlog_warn(                  xlog_warn(
         "XFS: dirty log written in incompatible format - can't recover");          "XFS: dirty log written in incompatible format - can't recover");
                 xlog_header_check_dump(mp, head);                  xlog_header_check_dump(mp, head);
Line 245  xlog_header_check_mount( Line 245  xlog_header_check_mount(
         xfs_mount_t             *mp,          xfs_mount_t             *mp,
         xlog_rec_header_t       *head)          xlog_rec_header_t       *head)
 {  {
         ASSERT(INT_GET(head->h_magicno, ARCH_CONVERT) == XLOG_HEADER_MAGIC_NUM);          ASSERT(be32_to_cpu(head->h_magicno) == XLOG_HEADER_MAGIC_NUM);
   
         if (uuid_is_nil(&head->h_fs_uuid)) {          if (uuid_is_nil(&head->h_fs_uuid)) {
                 /*                  /*
Line 447  xlog_find_verify_log_record( Line 447  xlog_find_verify_log_record(
   
                 head = (xlog_rec_header_t *)offset;                  head = (xlog_rec_header_t *)offset;
   
                 if (XLOG_HEADER_MAGIC_NUM ==                  if (XLOG_HEADER_MAGIC_NUM == be32_to_cpu(head->h_magicno))
                     INT_GET(head->h_magicno, ARCH_CONVERT))  
                         break;                          break;
   
                 if (!smallmem)                  if (!smallmem)
Line 480  xlog_find_verify_log_record( Line 479  xlog_find_verify_log_record(
          * record do we update last_blk.           * record do we update last_blk.
          */           */
         if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {          if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
                 uint    h_size = INT_GET(head->h_size, ARCH_CONVERT);                  uint    h_size = be32_to_cpu(head->h_size);
   
                 xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;                  xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;
                 if (h_size % XLOG_HEADER_CYCLE_SIZE)                  if (h_size % XLOG_HEADER_CYCLE_SIZE)
Line 489  xlog_find_verify_log_record( Line 488  xlog_find_verify_log_record(
                 xhdrs = 1;                  xhdrs = 1;
         }          }
   
         if (*last_blk - i + extra_bblks          if (*last_blk - i + extra_bblks !=
                         != BTOBB(INT_GET(head->h_len, ARCH_CONVERT)) + xhdrs)              BTOBB(be32_to_cpu(head->h_len)) + xhdrs)
                 *last_blk = i;                  *last_blk = i;
   
 out:  out:
Line 823  xlog_find_tail( Line 822  xlog_find_tail(
                 if ((error = xlog_bread(log, i, 1, bp)))                  if ((error = xlog_bread(log, i, 1, bp)))
                         goto bread_err;                          goto bread_err;
                 offset = xlog_align(log, i, 1, bp);                  offset = xlog_align(log, i, 1, bp);
                 if (XLOG_HEADER_MAGIC_NUM ==                  if (XLOG_HEADER_MAGIC_NUM == be32_to_cpu(*(__be32 *)offset)) {
                     INT_GET(*(uint *)offset, ARCH_CONVERT)) {  
                         found = 1;                          found = 1;
                         break;                          break;
                 }                  }
Line 841  xlog_find_tail( Line 839  xlog_find_tail(
                                 goto bread_err;                                  goto bread_err;
                         offset = xlog_align(log, i, 1, bp);                          offset = xlog_align(log, i, 1, bp);
                         if (XLOG_HEADER_MAGIC_NUM ==                          if (XLOG_HEADER_MAGIC_NUM ==
                             INT_GET(*(uint*)offset, ARCH_CONVERT)) {                              be32_to_cpu(*(__be32 *)offset)) {
                                 found = 2;                                  found = 2;
                                 break;                                  break;
                         }                          }
Line 855  xlog_find_tail( Line 853  xlog_find_tail(
   
         /* find blk_no of tail of log */          /* find blk_no of tail of log */
         rhead = (xlog_rec_header_t *)offset;          rhead = (xlog_rec_header_t *)offset;
         *tail_blk = BLOCK_LSN(INT_GET(rhead->h_tail_lsn, ARCH_CONVERT));          *tail_blk = BLOCK_LSN(be64_to_cpu(rhead->h_tail_lsn));
   
         /*          /*
          * Reset log values according to the state of the log when we           * Reset log values according to the state of the log when we
Line 869  xlog_find_tail( Line 867  xlog_find_tail(
          */           */
         log->l_prev_block = i;          log->l_prev_block = i;
         log->l_curr_block = (int)*head_blk;          log->l_curr_block = (int)*head_blk;
         log->l_curr_cycle = INT_GET(rhead->h_cycle, ARCH_CONVERT);          log->l_curr_cycle = be32_to_cpu(rhead->h_cycle);
         if (found == 2)          if (found == 2)
                 log->l_curr_cycle++;                  log->l_curr_cycle++;
         log->l_tail_lsn = INT_GET(rhead->h_tail_lsn, ARCH_CONVERT);          log->l_tail_lsn = be64_to_cpu(rhead->h_tail_lsn);
         log->l_last_sync_lsn = INT_GET(rhead->h_lsn, ARCH_CONVERT);          log->l_last_sync_lsn = be64_to_cpu(rhead->h_lsn);
         log->l_grant_reserve_cycle = log->l_curr_cycle;          log->l_grant_reserve_cycle = log->l_curr_cycle;
         log->l_grant_reserve_bytes = BBTOB(log->l_curr_block);          log->l_grant_reserve_bytes = BBTOB(log->l_curr_block);
         log->l_grant_write_cycle = log->l_curr_cycle;          log->l_grant_write_cycle = log->l_curr_cycle;
Line 891  xlog_find_tail( Line 889  xlog_find_tail(
          * unmount record rather than the block after it.           * unmount record rather than the block after it.
          */           */
         if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {          if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
                 int     h_size = INT_GET(rhead->h_size, ARCH_CONVERT);                  int     h_size = be32_to_cpu(rhead->h_size);
                 int     h_version = INT_GET(rhead->h_version, ARCH_CONVERT);                  int     h_version = be32_to_cpu(rhead->h_version);
   
                 if ((h_version & XLOG_VERSION_2) &&                  if ((h_version & XLOG_VERSION_2) &&
                     (h_size > XLOG_HEADER_CYCLE_SIZE)) {                      (h_size > XLOG_HEADER_CYCLE_SIZE)) {
Line 906  xlog_find_tail( Line 904  xlog_find_tail(
                 hblks = 1;                  hblks = 1;
         }          }
         after_umount_blk = (i + hblks + (int)          after_umount_blk = (i + hblks + (int)
                 BTOBB(INT_GET(rhead->h_len, ARCH_CONVERT))) % log->l_logBBsize;                  BTOBB(be32_to_cpu(rhead->h_len))) % log->l_logBBsize;
         tail_lsn = log->l_tail_lsn;          tail_lsn = log->l_tail_lsn;
         if (*head_blk == after_umount_blk &&          if (*head_blk == after_umount_blk &&
             INT_GET(rhead->h_num_logops, ARCH_CONVERT) == 1) {              be32_to_cpu(rhead->h_num_logops) == 1) {
                 umount_data_blk = (i + hblks) % log->l_logBBsize;                  umount_data_blk = (i + hblks) % log->l_logBBsize;
                 if ((error = xlog_bread(log, umount_data_blk, 1, bp))) {                  if ((error = xlog_bread(log, umount_data_blk, 1, bp))) {
                         goto bread_err;                          goto bread_err;
Line 1100  xlog_add_record( Line 1098  xlog_add_record(
         xlog_rec_header_t       *recp = (xlog_rec_header_t *)buf;          xlog_rec_header_t       *recp = (xlog_rec_header_t *)buf;
   
         memset(buf, 0, BBSIZE);          memset(buf, 0, BBSIZE);
         INT_SET(recp->h_magicno, ARCH_CONVERT, XLOG_HEADER_MAGIC_NUM);          recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
         INT_SET(recp->h_cycle, ARCH_CONVERT, cycle);          recp->h_cycle = cpu_to_be32(cycle);
         INT_SET(recp->h_version, ARCH_CONVERT,          recp->h_version = cpu_to_be32(
                         XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb) ? 2 : 1);                          XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb) ? 2 : 1);
         INT_SET(recp->h_lsn, ARCH_CONVERT, xlog_assign_lsn(cycle, block));          recp->h_lsn = cpu_to_be64(xlog_assign_lsn(cycle, block));
         INT_SET(recp->h_tail_lsn, ARCH_CONVERT,          recp->h_tail_lsn = cpu_to_be64(xlog_assign_lsn(tail_cycle, tail_block));
                 xlog_assign_lsn(tail_cycle, tail_block));          recp->h_fmt = cpu_to_be32(XLOG_FMT);
         INT_SET(recp->h_fmt, ARCH_CONVERT, XLOG_FMT);  
         memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));          memcpy(&recp->h_fs_uuid, &log->l_mp->m_sb.sb_uuid, sizeof(uuid_t));
 }  }
   
Line 2214  xlog_recover_do_buffer_trans( Line 2211  xlog_recover_do_buffer_trans(
          * overlap with future reads of those inodes.           * overlap with future reads of those inodes.
          */           */
         if (XFS_DINODE_MAGIC ==          if (XFS_DINODE_MAGIC ==
             INT_GET(*((__uint16_t *)(xfs_buf_offset(bp, 0))), ARCH_CONVERT) &&              be16_to_cpu(*((__be16 *)xfs_buf_offset(bp, 0))) &&
             (XFS_BUF_COUNT(bp) != MAX(log->l_mp->m_sb.sb_blocksize,              (XFS_BUF_COUNT(bp) != MAX(log->l_mp->m_sb.sb_blocksize,
                         (__uint32_t)XFS_INODE_CLUSTER_SIZE(log->l_mp)))) {                          (__uint32_t)XFS_INODE_CLUSTER_SIZE(log->l_mp)))) {
                 XFS_BUF_STALE(bp);                  XFS_BUF_STALE(bp);
Line 2584  xlog_recover_do_dquot_trans( Line 2581  xlog_recover_do_dquot_trans(
         /*          /*
          * This type of quotas was turned off, so ignore this record.           * This type of quotas was turned off, so ignore this record.
          */           */
         type = INT_GET(recddq->d_flags, ARCH_CONVERT) &          type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
                         (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);  
         ASSERT(type);          ASSERT(type);
         if (log->l_quotaoffs_flag & type)          if (log->l_quotaoffs_flag & type)
                 return (0);                  return (0);
Line 2898  xlog_recover_process_data( Line 2894  xlog_recover_process_data(
         unsigned long           hash;          unsigned long           hash;
         uint                    flags;          uint                    flags;
   
         lp = dp + INT_GET(rhead->h_len, ARCH_CONVERT);          lp = dp + be32_to_cpu(rhead->h_len);
         num_logops = INT_GET(rhead->h_num_logops, ARCH_CONVERT);          num_logops = be32_to_cpu(rhead->h_num_logops);
   
         /* check the log format matches our own - else we can't recover */          /* check the log format matches our own - else we can't recover */
         if (xlog_header_check_recover(log->l_mp, rhead))          if (xlog_header_check_recover(log->l_mp, rhead))
Line 2922  xlog_recover_process_data( Line 2918  xlog_recover_process_data(
                 if (trans == NULL) {               /* not found; add new tid */                  if (trans == NULL) {               /* not found; add new tid */
                         if (ohead->oh_flags & XLOG_START_TRANS)                          if (ohead->oh_flags & XLOG_START_TRANS)
                                 xlog_recover_new_tid(&rhash[hash], tid,                                  xlog_recover_new_tid(&rhash[hash], tid,
                                         INT_GET(rhead->h_lsn, ARCH_CONVERT));                                          be64_to_cpu(rhead->h_lsn));
                 } else {                  } else {
                         ASSERT(dp + be32_to_cpu(ohead->oh_len) <= lp);                          ASSERT(dp + be32_to_cpu(ohead->oh_len) <= lp);
                         flags = ohead->oh_flags & ~XLOG_END_TRANS;                          flags = ohead->oh_flags & ~XLOG_END_TRANS;
Line 3313  xlog_pack_data_checksum( Line 3309  xlog_pack_data_checksum(
         int             size)          int             size)
 {  {
         int             i;          int             i;
         uint            *up;          __be32          *up;
         uint            chksum = 0;          uint            chksum = 0;
   
         up = (uint *)iclog->ic_datap;          up = (__be32 *)iclog->ic_datap;
         /* divide length by 4 to get # words */          /* divide length by 4 to get # words */
         for (i = 0; i < (size >> 2); i++) {          for (i = 0; i < (size >> 2); i++) {
                 chksum ^= INT_GET(*up, ARCH_CONVERT);                  chksum ^= be32_to_cpu(*up);
                 up++;                  up++;
         }          }
         INT_SET(iclog->ic_header.h_chksum, ARCH_CONVERT, chksum);          iclog->ic_header.h_chksum = cpu_to_be32(chksum);
 }  }
 #else  #else
 #define xlog_pack_data_checksum(log, iclog, size)  #define xlog_pack_data_checksum(log, iclog, size)
Line 3339  xlog_pack_data( Line 3335  xlog_pack_data(
 {  {
         int                     i, j, k;          int                     i, j, k;
         int                     size = iclog->ic_offset + roundoff;          int                     size = iclog->ic_offset + roundoff;
         uint                    cycle_lsn;          __be32                  cycle_lsn;
         xfs_caddr_t             dp;          xfs_caddr_t             dp;
         xlog_in_core_2_t        *xhdr;          xlog_in_core_2_t        *xhdr;
   
Line 3350  xlog_pack_data( Line 3346  xlog_pack_data(
         dp = iclog->ic_datap;          dp = iclog->ic_datap;
         for (i = 0; i < BTOBB(size) &&          for (i = 0; i < BTOBB(size) &&
                 i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {                  i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
                 iclog->ic_header.h_cycle_data[i] = *(uint *)dp;                  iclog->ic_header.h_cycle_data[i] = *(__be32 *)dp;
                 *(uint *)dp = cycle_lsn;                  *(__be32 *)dp = cycle_lsn;
                 dp += BBSIZE;                  dp += BBSIZE;
         }          }
   
Line 3360  xlog_pack_data( Line 3356  xlog_pack_data(
                 for ( ; i < BTOBB(size); i++) {                  for ( ; i < BTOBB(size); i++) {
                         j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);                          j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
                         k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);                          k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
                         xhdr[j].hic_xheader.xh_cycle_data[k] = *(uint *)dp;                          xhdr[j].hic_xheader.xh_cycle_data[k] = *(__be32 *)dp;
                         *(uint *)dp = cycle_lsn;                          *(__be32 *)dp = cycle_lsn;
                         dp += BBSIZE;                          dp += BBSIZE;
                 }                  }
   
Line 3378  xlog_unpack_data_checksum( Line 3374  xlog_unpack_data_checksum(
         xfs_caddr_t             dp,          xfs_caddr_t             dp,
         xlog_t                  *log)          xlog_t                  *log)
 {  {
         uint                    *up = (uint *)dp;          __be32                  *up = (__be32 *)dp;
         uint                    chksum = 0;          uint                    chksum = 0;
         int                     i;          int                     i;
   
         /* divide length by 4 to get # words */          /* divide length by 4 to get # words */
         for (i=0; i < INT_GET(rhead->h_len, ARCH_CONVERT) >> 2; i++) {          for (i=0; i < be32_to_cpu(rhead->h_len) >> 2; i++) {
                 chksum ^= INT_GET(*up, ARCH_CONVERT);                  chksum ^= be32_to_cpu(*up);
                 up++;                  up++;
         }          }
         if (chksum != INT_GET(rhead->h_chksum, ARCH_CONVERT)) {          if (chksum != be32_to_cpu(rhead->h_chksum)) {
             if (rhead->h_chksum ||              if (rhead->h_chksum ||
                 ((log->l_flags & XLOG_CHKSUM_MISMATCH) == 0)) {                  ((log->l_flags & XLOG_CHKSUM_MISMATCH) == 0)) {
                     cmn_err(CE_DEBUG,                      cmn_err(CE_DEBUG,
                         "XFS: LogR chksum mismatch: was (0x%x) is (0x%x)\n",                          "XFS: LogR chksum mismatch: was (0x%x) is (0x%x)\n",
                             INT_GET(rhead->h_chksum, ARCH_CONVERT), chksum);                              be32_to_cpu(rhead->h_chksum), chksum);
                     cmn_err(CE_DEBUG,                      cmn_err(CE_DEBUG,
 "XFS: Disregard message if filesystem was created with non-DEBUG kernel");  "XFS: Disregard message if filesystem was created with non-DEBUG kernel");
                     if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {                      if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
Line 3416  xlog_unpack_data( Line 3412  xlog_unpack_data(
         int                     i, j, k;          int                     i, j, k;
         xlog_in_core_2_t        *xhdr;          xlog_in_core_2_t        *xhdr;
   
         for (i = 0; i < BTOBB(INT_GET(rhead->h_len, ARCH_CONVERT)) &&          for (i = 0; i < BTOBB(be32_to_cpu(rhead->h_len)) &&
                   i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {                    i < (XLOG_HEADER_CYCLE_SIZE / BBSIZE); i++) {
                 *(uint *)dp = *(uint *)&rhead->h_cycle_data[i];                  *(__be32 *)dp = *(__be32 *)&rhead->h_cycle_data[i];
                 dp += BBSIZE;                  dp += BBSIZE;
         }          }
   
         if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {          if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
                 xhdr = (xlog_in_core_2_t *)rhead;                  xhdr = (xlog_in_core_2_t *)rhead;
                 for ( ; i < BTOBB(INT_GET(rhead->h_len, ARCH_CONVERT)); i++) {                  for ( ; i < BTOBB(be32_to_cpu(rhead->h_len)); i++) {
                         j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);                          j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
                         k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);                          k = i % (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
                         *(uint *)dp = xhdr[j].hic_xheader.xh_cycle_data[k];                          *(__be32 *)dp = xhdr[j].hic_xheader.xh_cycle_data[k];
                         dp += BBSIZE;                          dp += BBSIZE;
                 }                  }
         }          }
Line 3443  xlog_valid_rec_header( Line 3439  xlog_valid_rec_header(
 {  {
         int                     hlen;          int                     hlen;
   
         if (unlikely(          if (unlikely(be32_to_cpu(rhead->h_magicno) != XLOG_HEADER_MAGIC_NUM)) {
             (INT_GET(rhead->h_magicno, ARCH_CONVERT) !=  
                         XLOG_HEADER_MAGIC_NUM))) {  
                 XFS_ERROR_REPORT("xlog_valid_rec_header(1)",                  XFS_ERROR_REPORT("xlog_valid_rec_header(1)",
                                 XFS_ERRLEVEL_LOW, log->l_mp);                                  XFS_ERRLEVEL_LOW, log->l_mp);
                 return XFS_ERROR(EFSCORRUPTED);                  return XFS_ERROR(EFSCORRUPTED);
         }          }
         if (unlikely(          if (unlikely(
             (!rhead->h_version ||              (!rhead->h_version ||
             (INT_GET(rhead->h_version, ARCH_CONVERT) &              (be32_to_cpu(rhead->h_version) & (~XLOG_VERSION_OKBITS))))) {
                         (~XLOG_VERSION_OKBITS)) != 0))) {  
                 xlog_warn("XFS: %s: unrecognised log version (%d).",                  xlog_warn("XFS: %s: unrecognised log version (%d).",
                         __FUNCTION__, INT_GET(rhead->h_version, ARCH_CONVERT));                          __FUNCTION__, be32_to_cpu(rhead->h_version));
                 return XFS_ERROR(EIO);                  return XFS_ERROR(EIO);
         }          }
   
         /* LR body must have data or it wouldn't have been written */          /* LR body must have data or it wouldn't have been written */
         hlen = INT_GET(rhead->h_len, ARCH_CONVERT);          hlen = be32_to_cpu(rhead->h_len);
         if (unlikely( hlen <= 0 || hlen > INT_MAX )) {          if (unlikely( hlen <= 0 || hlen > INT_MAX )) {
                 XFS_ERROR_REPORT("xlog_valid_rec_header(2)",                  XFS_ERROR_REPORT("xlog_valid_rec_header(2)",
                                 XFS_ERRLEVEL_LOW, log->l_mp);                                  XFS_ERRLEVEL_LOW, log->l_mp);
Line 3520  xlog_do_recovery_pass( Line 3513  xlog_do_recovery_pass(
                 error = xlog_valid_rec_header(log, rhead, tail_blk);                  error = xlog_valid_rec_header(log, rhead, tail_blk);
                 if (error)                  if (error)
                         goto bread_err1;                          goto bread_err1;
                 h_size = INT_GET(rhead->h_size, ARCH_CONVERT);                  h_size = be32_to_cpu(rhead->h_size);
                 if ((INT_GET(rhead->h_version, ARCH_CONVERT)                  if ((be32_to_cpu(rhead->h_version) & XLOG_VERSION_2) &&
                                 & XLOG_VERSION_2) &&  
                     (h_size > XLOG_HEADER_CYCLE_SIZE)) {                      (h_size > XLOG_HEADER_CYCLE_SIZE)) {
                         hblks = h_size / XLOG_HEADER_CYCLE_SIZE;                          hblks = h_size / XLOG_HEADER_CYCLE_SIZE;
                         if (h_size % XLOG_HEADER_CYCLE_SIZE)                          if (h_size % XLOG_HEADER_CYCLE_SIZE)
Line 3559  xlog_do_recovery_pass( Line 3551  xlog_do_recovery_pass(
                                 goto bread_err2;                                  goto bread_err2;
   
                         /* blocks in data section */                          /* blocks in data section */
                         bblks = (int)BTOBB(INT_GET(rhead->h_len, ARCH_CONVERT));                          bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
                         error = xlog_bread(log, blk_no + hblks, bblks, dbp);                          error = xlog_bread(log, blk_no + hblks, bblks, dbp);
                         if (error)                          if (error)
                                 goto bread_err2;                                  goto bread_err2;
Line 3634  xlog_do_recovery_pass( Line 3626  xlog_do_recovery_pass(
                         if (error)                          if (error)
                                 goto bread_err2;                                  goto bread_err2;
   
                         bblks = (int)BTOBB(INT_GET(rhead->h_len, ARCH_CONVERT));                          bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
                         blk_no += hblks;                          blk_no += hblks;
   
                         /* Read in data for log record */                          /* Read in data for log record */
Line 3705  xlog_do_recovery_pass( Line 3697  xlog_do_recovery_pass(
                         error = xlog_valid_rec_header(log, rhead, blk_no);                          error = xlog_valid_rec_header(log, rhead, blk_no);
                         if (error)                          if (error)
                                 goto bread_err2;                                  goto bread_err2;
                         bblks = (int)BTOBB(INT_GET(rhead->h_len, ARCH_CONVERT));                          bblks = (int)BTOBB(be32_to_cpu(rhead->h_len));
                         if ((error = xlog_bread(log, blk_no+hblks, bblks, dbp)))                          if ((error = xlog_bread(log, blk_no+hblks, bblks, dbp)))
                                 goto bread_err2;                                  goto bread_err2;
                         offset = xlog_align(log, blk_no+hblks, bblks, dbp);                          offset = xlog_align(log, blk_no+hblks, bblks, dbp);
Removed from v.1.328  
changed lines
  Added in v.1.329

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>