git.ipfire.org Git - thirdparty/xfsprogs-dev.git/blob

1 /*

4 *

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

7 * published by the Free Software Foundation.

8 *

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

17 */

19 #include <libxfs.h>

20 #include "avl.h"

21 #include "globals.h"

22 #include "agheader.h"

23 #include "incore.h"

24 #include "protos.h"

25 #include "err_protos.h"

26 #include "dir2.h"

27 #include "dinode.h"

28 #include "scan.h"

29 #include "versions.h"

30 #include "attr_repair.h"

31 #include "bmap.h"

32 #include "threads.h"

34 /*

35 * inode clearing routines

36 */

38 static int

39 clear_dinode_attr(xfs_mount_t *mp, xfs_dinode_t *dino, xfs_ino_t ino_num)

40 {

41 ASSERT(dino->di_forkoff != 0);

43 if (!no_modify)

44 fprintf(stderr,

45 _("clearing inode %" PRIu64 " attributes\n"), ino_num);

46 else

47 fprintf(stderr,

48 _("would have cleared inode %" PRIu64 " attributes\n"), ino_num);

50 if (be16_to_cpu(dino->di_anextents) != 0) {

51 if (no_modify)

52 return(1);

53 dino->di_anextents = cpu_to_be16(0);

54 }

56 if (dino->di_aformat != XFS_DINODE_FMT_EXTENTS) {

57 if (no_modify)

58 return(1);

59 dino->di_aformat = XFS_DINODE_FMT_EXTENTS;

60 }

62 /* get rid of the fork by clearing forkoff */

64 /* Originally, when the attr repair code was added, the fork was cleared

65 * by turning it into shortform status. This meant clearing the

66 * hdr.totsize/count fields and also changing aformat to LOCAL

67 * (vs EXTENTS). Over various fixes, the aformat and forkoff have

68 * been updated to not show an attribute fork at all, however.

69 * It could be possible that resetting totsize/count are not needed,

70 * but just to be safe, leave it in for now.

71 */

73 if (!no_modify) {

74 xfs_attr_shortform_t *asf = (xfs_attr_shortform_t *)

75 XFS_DFORK_APTR(dino);

76 asf->hdr.totsize = cpu_to_be16(sizeof(xfs_attr_sf_hdr_t));

77 asf->hdr.count = 0;

78 dino->di_forkoff = 0; /* got to do this after asf is set */

79 }

81 /*

82 * always returns 1 since the fork gets zapped

83 */

84 return(1);

85 }

87 static int

88 clear_dinode_core(struct xfs_mount *mp, xfs_dinode_t *dinoc, xfs_ino_t ino_num)

89 {

90 int dirty = 0;

91 int i;

93 #define __dirty_no_modify_ret(dirty) \

94 ({ (dirty) = 1; if (no_modify) return 1; })

96 if (be16_to_cpu(dinoc->di_magic) != XFS_DINODE_MAGIC) {

97 __dirty_no_modify_ret(dirty);

98 dinoc->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);

99 }

100

101 if (!XFS_DINODE_GOOD_VERSION(dinoc->di_version) ||

102 (!fs_inode_nlink && dinoc->di_version > 1)) {

103 __dirty_no_modify_ret(dirty);

104 if (xfs_sb_version_hascrc(&mp->m_sb))

105 dinoc->di_version = 3;

106 else

107 dinoc->di_version = (fs_inode_nlink) ? 2 : 1;

108 }

109

110 if (be16_to_cpu(dinoc->di_mode) != 0) {

111 __dirty_no_modify_ret(dirty);

112 dinoc->di_mode = 0;

113 }

114

115 if (be16_to_cpu(dinoc->di_flags) != 0) {

116 __dirty_no_modify_ret(dirty);

117 dinoc->di_flags = 0;

118 }

119

120 if (be32_to_cpu(dinoc->di_dmevmask) != 0) {

121 __dirty_no_modify_ret(dirty);

122 dinoc->di_dmevmask = 0;

123 }

124

125 if (dinoc->di_forkoff != 0) {

126 __dirty_no_modify_ret(dirty);

127 dinoc->di_forkoff = 0;

128 }

129

130 if (dinoc->di_format != XFS_DINODE_FMT_EXTENTS) {

131 __dirty_no_modify_ret(dirty);

132 dinoc->di_format = XFS_DINODE_FMT_EXTENTS;

133 }

134

135 if (dinoc->di_aformat != XFS_DINODE_FMT_EXTENTS) {

136 __dirty_no_modify_ret(dirty);

137 dinoc->di_aformat = XFS_DINODE_FMT_EXTENTS;

138 }

139

140 if (be64_to_cpu(dinoc->di_size) != 0) {

141 __dirty_no_modify_ret(dirty);

142 dinoc->di_size = 0;

143 }

144

145 if (be64_to_cpu(dinoc->di_nblocks) != 0) {

146 __dirty_no_modify_ret(dirty);

147 dinoc->di_nblocks = 0;

148 }

149

150 if (be16_to_cpu(dinoc->di_onlink) != 0) {

151 __dirty_no_modify_ret(dirty);

152 dinoc->di_onlink = 0;

153 }

154

155 if (be32_to_cpu(dinoc->di_nextents) != 0) {

156 __dirty_no_modify_ret(dirty);

157 dinoc->di_nextents = 0;

158 }

159

160 if (be16_to_cpu(dinoc->di_anextents) != 0) {

161 __dirty_no_modify_ret(dirty);

162 dinoc->di_anextents = 0;

163 }

164

165 if (dinoc->di_version > 1 &&

166 be32_to_cpu(dinoc->di_nlink) != 0) {

167 __dirty_no_modify_ret(dirty);

168 dinoc->di_nlink = 0;

169 }

170

171 /* we are done for version 1/2 inodes */

172 if (dinoc->di_version < 3)

173 return dirty;

174

175 if (be64_to_cpu(dinoc->di_ino) != ino_num) {

176 __dirty_no_modify_ret(dirty);

177 dinoc->di_ino = cpu_to_be64(ino_num);

178 }

179

180 if (platform_uuid_compare(&dinoc->di_uuid, &mp->m_sb.sb_uuid)) {

181 __dirty_no_modify_ret(dirty);

182 platform_uuid_copy(&dinoc->di_uuid, &mp->m_sb.sb_uuid);

183 }

184

185 for (i = 0; i < 16; i++) {

186 if (dinoc->di_pad[i] != 0) {

187 __dirty_no_modify_ret(dirty);

188 memset(dinoc->di_pad, 0, 16);

189 break;

190 }

191 }

192

193 if (be64_to_cpu(dinoc->di_flags2) != 0) {

194 __dirty_no_modify_ret(dirty);

195 dinoc->di_flags2 = 0;

196 }

197

198 if (be64_to_cpu(dinoc->di_lsn) != 0) {

199 __dirty_no_modify_ret(dirty);

200 dinoc->di_lsn = 0;

201 }

202

203 if (be64_to_cpu(dinoc->di_changecount) != 0) {

204 __dirty_no_modify_ret(dirty);

205 dinoc->di_changecount = 0;

206 }

207

208 return dirty;

209 }

210

211 static int

212 clear_dinode_unlinked(xfs_mount_t *mp, xfs_dinode_t *dino)

213 {

214

215 if (be32_to_cpu(dino->di_next_unlinked) != NULLAGINO) {

216 if (!no_modify)

217 dino->di_next_unlinked = cpu_to_be32(NULLAGINO);

218 return(1);

219 }

220

221 return(0);

222 }

223

224 /*

225 * this clears the unlinked list too so it should not be called

226 * until after the agi unlinked lists are walked in phase 3.

227 * returns > zero if the inode has been altered while being cleared

228 */

229 static int

230 clear_dinode(xfs_mount_t *mp, xfs_dinode_t *dino, xfs_ino_t ino_num)

231 {

232 int dirty;

233

234 dirty = clear_dinode_core(mp, dino, ino_num);

235 dirty += clear_dinode_unlinked(mp, dino);

236

237 /* and clear the forks */

238

239 if (dirty && !no_modify)

240 memset(XFS_DFORK_DPTR(dino), 0,

241 XFS_LITINO(mp, dino->di_version));

242

243 return(dirty);

244 }

245

246

247 /*

248 * misc. inode-related utility routines

249 */

250

251 /*

252 * verify_ag_bno is heavily used. In the common case, it

253 * performs just two number of compares

254 * Returns 1 for bad ag/bno pair or 0 if it's valid.

255 */

256 static __inline int

257 verify_ag_bno(xfs_sb_t *sbp,

258 xfs_agnumber_t agno,

259 xfs_agblock_t agbno)

260 {

261 if (agno < (sbp->sb_agcount - 1))

262 return (agbno >= sbp->sb_agblocks);

263 if (agno == (sbp->sb_agcount - 1))

264 return (agbno >= (sbp->sb_dblocks -

265 ((xfs_drfsbno_t)(sbp->sb_agcount - 1) *

266 sbp->sb_agblocks)));

267 return 1;

268 }

269

270 /*

271 * returns 0 if inode number is valid, 1 if bogus

272 */

273 int

274 verify_inum(xfs_mount_t *mp,

275 xfs_ino_t ino)

276 {

277 xfs_agnumber_t agno;

278 xfs_agino_t agino;

279 xfs_agblock_t agbno;

280 xfs_sb_t *sbp = &mp->m_sb;;

281

282 /* range check ag #, ag block. range-checking offset is pointless */

283

284 agno = XFS_INO_TO_AGNO(mp, ino);

285 agino = XFS_INO_TO_AGINO(mp, ino);

286 agbno = XFS_AGINO_TO_AGBNO(mp, agino);

287 if (agbno == 0)

288 return 1;

289

290 if (ino == 0 || ino == NULLFSINO)

291 return(1);

292

293 if (ino != XFS_AGINO_TO_INO(mp, agno, agino))

294 return(1);

295

296 return verify_ag_bno(sbp, agno, agbno);

297 }

298

299 /*

300 * have a separate routine to ensure that we don't accidentally

301 * lose illegally set bits in the agino by turning it into an FSINO

302 * to feed to the above routine

303 */

304 int

305 verify_aginum(xfs_mount_t *mp,

306 xfs_agnumber_t agno,

307 xfs_agino_t agino)

308 {

309 xfs_agblock_t agbno;

310 xfs_sb_t *sbp = &mp->m_sb;;

311

312 /* range check ag #, ag block. range-checking offset is pointless */

313

314 if (agino == 0 || agino == NULLAGINO)

315 return(1);

316

317 /*

318 * agino's can't be too close to NULLAGINO because the min blocksize

319 * is 9 bits and at most 1 bit of that gets used for the inode offset

320 * so if the agino gets shifted by the # of offset bits and compared

321 * to the legal agbno values, a bogus agino will be too large. there

322 * will be extra bits set at the top that shouldn't be set.

323 */

324 agbno = XFS_AGINO_TO_AGBNO(mp, agino);

325 if (agbno == 0)

326 return 1;

327

328 return verify_ag_bno(sbp, agno, agbno);

329 }

330

331 /*

332 * return 1 if block number is good, 0 if out of range

333 */

334 int

335 verify_dfsbno(xfs_mount_t *mp,

336 xfs_dfsbno_t fsbno)

337 {

338 xfs_agnumber_t agno;

339 xfs_agblock_t agbno;

340 xfs_sb_t *sbp = &mp->m_sb;;

341

342 /* range check ag #, ag block. range-checking offset is pointless */

343

344 agno = XFS_FSB_TO_AGNO(mp, fsbno);

345 agbno = XFS_FSB_TO_AGBNO(mp, fsbno);

346

347 return verify_ag_bno(sbp, agno, agbno) == 0;

348 }

349

350 #define XR_DFSBNORANGE_VALID 0

351 #define XR_DFSBNORANGE_BADSTART 1

352 #define XR_DFSBNORANGE_BADEND 2

353 #define XR_DFSBNORANGE_OVERFLOW 3

354

355 static __inline int

356 verify_dfsbno_range(xfs_mount_t *mp,

357 xfs_dfsbno_t fsbno,

358 xfs_dfilblks_t count)

359 {

360 xfs_agnumber_t agno;

361 xfs_agblock_t agbno;

362 xfs_sb_t *sbp = &mp->m_sb;;

363

364 /* the start and end blocks better be in the same allocation group */

365 agno = XFS_FSB_TO_AGNO(mp, fsbno);

366 if (agno != XFS_FSB_TO_AGNO(mp, fsbno + count - 1)) {

367 return XR_DFSBNORANGE_OVERFLOW;

368 }

369

370 agbno = XFS_FSB_TO_AGBNO(mp, fsbno);

371 if (verify_ag_bno(sbp, agno, agbno)) {

372 return XR_DFSBNORANGE_BADSTART;

373 }

374

375 agbno = XFS_FSB_TO_AGBNO(mp, fsbno + count - 1);

376 if (verify_ag_bno(sbp, agno, agbno)) {

377 return XR_DFSBNORANGE_BADEND;

378 }

379

380 return (XR_DFSBNORANGE_VALID);

381 }

382

383 int

384 verify_agbno(xfs_mount_t *mp,

385 xfs_agnumber_t agno,

386 xfs_agblock_t agbno)

387 {

388 xfs_sb_t *sbp = &mp->m_sb;;

389

390 /* range check ag #, ag block. range-checking offset is pointless */

391 return verify_ag_bno(sbp, agno, agbno) == 0;

392 }

393

394 static int

395 process_rt_rec(

396 xfs_mount_t *mp,

397 xfs_bmbt_irec_t *irec,

398 xfs_ino_t ino,

399 xfs_drfsbno_t *tot,

400 int check_dups)

401 {

402 xfs_dfsbno_t b;

403 xfs_drtbno_t ext;

404 int state;

405 int pwe; /* partially-written extent */

406

407 /*

408 * check numeric validity of the extent

409 */

410 if (irec->br_startblock >= mp->m_sb.sb_rblocks) {

411 do_warn(

412 _("inode %" PRIu64 " - bad rt extent start block number %" PRIu64 ", offset %" PRIu64 "\n"),

413 ino,

414 irec->br_startblock,

415 irec->br_startoff);

416 return 1;

417 }

418 if (irec->br_startblock + irec->br_blockcount - 1 >= mp->m_sb.sb_rblocks) {

419 do_warn(

420 _("inode %" PRIu64 " - bad rt extent last block number %" PRIu64 ", offset %" PRIu64 "\n"),

421 ino,

422 irec->br_startblock + irec->br_blockcount - 1,

423 irec->br_startoff);

424 return 1;

425 }

426 if (irec->br_startblock + irec->br_blockcount - 1 < irec->br_startblock) {

427 do_warn(

428 _("inode %" PRIu64 " - bad rt extent overflows - start %" PRIu64 ", "

429 "end %" PRIu64 ", offset %" PRIu64 "\n"),

430 ino,

431 irec->br_startblock,

432 irec->br_startblock + irec->br_blockcount - 1,

433 irec->br_startoff);

434 return 1;

435 }

436

437 /*

438 * verify that the blocks listed in the record

439 * are multiples of an extent

440 */

441 if (xfs_sb_version_hasextflgbit(&mp->m_sb) == 0 &&

442 (irec->br_startblock % mp->m_sb.sb_rextsize != 0 ||

443 irec->br_blockcount % mp->m_sb.sb_rextsize != 0)) {

444 do_warn(

445 _("malformed rt inode extent [%" PRIu64 " %" PRIu64 "] (fs rtext size = %u)\n"),

446 irec->br_startblock,

447 irec->br_blockcount,

448 mp->m_sb.sb_rextsize);

449 return 1;

450 }

451

452 /*

453 * set the appropriate number of extents

454 * this iterates block by block, this can be optimised using extents

455 */

456 for (b = irec->br_startblock; b < irec->br_startblock +

457 irec->br_blockcount; b += mp->m_sb.sb_rextsize) {

458 ext = (xfs_drtbno_t) b / mp->m_sb.sb_rextsize;

459 pwe = xfs_sb_version_hasextflgbit(&mp->m_sb) &&

460 irec->br_state == XFS_EXT_UNWRITTEN &&

461 (b % mp->m_sb.sb_rextsize != 0);

462

463 if (check_dups == 1) {

464 if (search_rt_dup_extent(mp, ext) && !pwe) {

465 do_warn(

466 _("data fork in rt ino %" PRIu64 " claims dup rt extent,"

467 "off - %" PRIu64 ", start - %" PRIu64 ", count %" PRIu64 "\n"),

468 ino,

469 irec->br_startoff,

470 irec->br_startblock,

471 irec->br_blockcount);

472 return 1;

473 }

474 continue;

475 }

476

477 state = get_rtbmap(ext);

478 switch (state) {

479 case XR_E_FREE:

480 case XR_E_UNKNOWN:

481 set_rtbmap(ext, XR_E_INUSE);

482 break;

483 case XR_E_BAD_STATE:

484 do_error(

485 _("bad state in rt block map %" PRIu64 "\n"),

486 ext);

487 case XR_E_FS_MAP:

488 case XR_E_INO:

489 case XR_E_INUSE_FS:

490 do_error(

491 _("data fork in rt inode %" PRIu64 " found metadata block %" PRIu64 " in rt bmap\n"),

492 ino, ext);

493 case XR_E_INUSE:

494 if (pwe)

495 break;

496 case XR_E_MULT:

497 set_rtbmap(ext, XR_E_MULT);

498 do_warn(

499 _("data fork in rt inode %" PRIu64 " claims used rt block %" PRIu64 "\n"),

500 ino, ext);

501 return 1;

502 case XR_E_FREE1:

503 default:

504 do_error(

505 _("illegal state %d in rt block map %" PRIu64 "\n"),

506 state, b);

507 }

508 }

509

510 /*

511 * bump up the block counter

512 */

513 *tot += irec->br_blockcount;

514

515 return 0;

516 }

517

518 /*

519 * return 1 if inode should be cleared, 0 otherwise

520 * if check_dups should be set to 1, that implies that

521 * the primary purpose of this call is to see if the

522 * file overlaps with any duplicate extents (in the

523 * duplicate extent list).

524 */

525 static int

526 process_bmbt_reclist_int(

527 xfs_mount_t *mp,

528 xfs_bmbt_rec_t *rp,

529 int *numrecs,

530 int type,

531 xfs_ino_t ino,

532 xfs_drfsbno_t *tot,

533 blkmap_t **blkmapp,

534 xfs_dfiloff_t *first_key,

535 xfs_dfiloff_t *last_key,

536 int check_dups,

537 int whichfork)

538 {

539 xfs_bmbt_irec_t irec;

540 xfs_dfilblks_t cp = 0; /* prev count */

541 xfs_dfsbno_t sp = 0; /* prev start */

542 xfs_dfiloff_t op = 0; /* prev offset */

543 xfs_dfsbno_t b;

544 char *ftype;

545 char *forkname;

546 int i;

547 int state;

548 xfs_agnumber_t agno;

549 xfs_agblock_t agbno;

550 xfs_agblock_t ebno;

551 xfs_extlen_t blen;

552 xfs_agnumber_t locked_agno = -1;

553 int error = 1;

554

555 if (whichfork == XFS_DATA_FORK)

556 forkname = _("data");

557 else

558 forkname = _("attr");

559

560 if (type == XR_INO_RTDATA)

561 ftype = _("real-time");

562 else

563 ftype = _("regular");

564

565 for (i = 0; i < *numrecs; i++) {

566 libxfs_bmbt_disk_get_all(rp + i, &irec);

567 if (i == 0)

568 *last_key = *first_key = irec.br_startoff;

569 else

570 *last_key = irec.br_startoff;

571 if (i > 0 && op + cp > irec.br_startoff) {

572 do_warn(

573 _("bmap rec out of order, inode %" PRIu64" entry %d "

574 "[o s c] [%" PRIu64 " %" PRIu64 " %" PRIu64 "], "

575 "%d [%" PRIu64 " %" PRIu64 " %" PRIu64 "]\n"),

576 ino, i, irec.br_startoff, irec.br_startblock,

577 irec.br_blockcount, i - 1, op, sp, cp);

578 goto done;

579 }

580 op = irec.br_startoff;

581 cp = irec.br_blockcount;

582 sp = irec.br_startblock;

583

584 /*

585 * check numeric validity of the extent

586 */

587 if (irec.br_blockcount == 0) {

588 do_warn(

589 _("zero length extent (off = %" PRIu64 ", fsbno = %" PRIu64 ") in ino %" PRIu64 "\n"),

590 irec.br_startoff,

591 irec.br_startblock,

592 ino);

593 goto done;

594 }

595

596 if (type == XR_INO_RTDATA && whichfork == XFS_DATA_FORK) {

597 /*

598 * realtime bitmaps don't use AG locks, so returning

599 * immediately is fine for this code path.

600 */

601 if (process_rt_rec(mp, &irec, ino, tot, check_dups))

602 return 1;

603 /*

604 * skip rest of loop processing since that'irec.br_startblock

605 * all for regular file forks and attr forks

606 */

607 continue;

608 }

609

610 /*

611 * regular file data fork or attribute fork

612 */

613 switch (verify_dfsbno_range(mp, irec.br_startblock,

614 irec.br_blockcount)) {

615 case XR_DFSBNORANGE_VALID:

616 break;

617

618 case XR_DFSBNORANGE_BADSTART:

619 do_warn(

620 _("inode %" PRIu64 " - bad extent starting block number %" PRIu64 ", offset %" PRIu64 "\n"),

621 ino,

622 irec.br_startblock,

623 irec.br_startoff);

624 goto done;

625

626 case XR_DFSBNORANGE_BADEND:

627 do_warn(

628 _("inode %" PRIu64 " - bad extent last block number %" PRIu64 ", offset %" PRIu64 "\n"),

629 ino,

630 irec.br_startblock + irec.br_blockcount - 1,

631 irec.br_startoff);

632 goto done;

633

634 case XR_DFSBNORANGE_OVERFLOW:

635 do_warn(

636 _("inode %" PRIu64 " - bad extent overflows - start %" PRIu64 ", "

637 "end %" PRIu64 ", offset %" PRIu64 "\n"),

638 ino,

639 irec.br_startblock,

640 irec.br_startblock + irec.br_blockcount - 1,

641 irec.br_startoff);

642 goto done;

643 }

644 if (irec.br_startoff >= fs_max_file_offset) {

645 do_warn(

646 _("inode %" PRIu64 " - extent offset too large - start %" PRIu64 ", "

647 "count %" PRIu64 ", offset %" PRIu64 "\n"),

648 ino, irec.br_startblock, irec.br_blockcount,

649 irec.br_startoff);

650 goto done;

651 }

652

653 if (blkmapp && *blkmapp) {

654 error = blkmap_set_ext(blkmapp, irec.br_startoff,

655 irec.br_startblock, irec.br_blockcount);

656 if (error) {

657 /*

658 * we don't want to clear the inode due to an

659 * internal bmap tracking error, but if we've

660 * run out of memory then we simply can't

661 * validate that the filesystem is consistent.

662 * Hence just abort at this point with an ENOMEM

663 * error.

664 */

665 do_abort(

666 _("Fatal error: inode %" PRIu64 " - blkmap_set_ext(): %s\n"

667 "\t%s fork, off - %" PRIu64 ", start - %" PRIu64 ", cnt %" PRIu64 "\n"),

668 ino, strerror(error), forkname,

669 irec.br_startoff, irec.br_startblock,

670 irec.br_blockcount);

671 }

672 }

673

674 /*

675 * Profiling shows that the following loop takes the

676 * most time in all of xfs_repair.

677 */

678 agno = XFS_FSB_TO_AGNO(mp, irec.br_startblock);

679 agbno = XFS_FSB_TO_AGBNO(mp, irec.br_startblock);

680 ebno = agbno + irec.br_blockcount;

681 if (agno != locked_agno) {

682 if (locked_agno != -1)

683 pthread_mutex_unlock(&ag_locks[locked_agno]);

684 pthread_mutex_lock(&ag_locks[agno]);

685 locked_agno = agno;

686 }

687

688 if (check_dups) {

689 /*

690 * if we're just checking the bmap for dups,

691 * return if we find one, otherwise, continue

692 * checking each entry without setting the

693 * block bitmap

694 */

695 if (search_dup_extent(agno, agbno, ebno)) {

696 do_warn(

697 _("%s fork in ino %" PRIu64 " claims dup extent, "

698 "off - %" PRIu64 ", start - %" PRIu64 ", cnt %" PRIu64 "\n"),

699 forkname, ino, irec.br_startoff,

700 irec.br_startblock,

701 irec.br_blockcount);

702 goto done;

703 }

704 *tot += irec.br_blockcount;

705 continue;

706 }

707

708 for (b = irec.br_startblock;

709 agbno < ebno;

710 b += blen, agbno += blen) {

711 state = get_bmap_ext(agno, agbno, ebno, &blen);

712 switch (state) {

713 case XR_E_FREE:

714 case XR_E_FREE1:

715 do_warn(

716 _("%s fork in ino %" PRIu64 " claims free block %" PRIu64 "\n"),

717 forkname, ino, (__uint64_t) b);

718 /* fall through ... */

719 case XR_E_UNKNOWN:

720 set_bmap_ext(agno, agbno, blen, XR_E_INUSE);

721 break;

722

723 case XR_E_BAD_STATE:

724 do_error(_("bad state in block map %" PRIu64 "\n"), b);

725

726 case XR_E_FS_MAP:

727 case XR_E_INO:

728 case XR_E_INUSE_FS:

729 do_warn(

730 _("%s fork in inode %" PRIu64 " claims metadata block %" PRIu64 "\n"),

731 forkname, ino, b);

732 goto done;

733

734 case XR_E_INUSE:

735 case XR_E_MULT:

736 set_bmap_ext(agno, agbno, blen, XR_E_MULT);

737 do_warn(

738 _("%s fork in %s inode %" PRIu64 " claims used block %" PRIu64 "\n"),

739 forkname, ftype, ino, b);

740 goto done;

741

742 default:

743 do_error(

744 _("illegal state %d in block map %" PRIu64 "\n"),

745 state, b);

746 }

747 }

748 *tot += irec.br_blockcount;

749 }

750 error = 0;

751 done:

752 if (locked_agno != -1)

753 pthread_mutex_unlock(&ag_locks[locked_agno]);

754

755 if (i != *numrecs) {

756 ASSERT(i < *numrecs);

757 do_warn(_("correcting nextents for inode %" PRIu64 "\n"), ino);

758 *numrecs = i;

759 }

760

761 return error;

762 }

763

764 /*

765 * return 1 if inode should be cleared, 0 otherwise, sets block bitmap

766 * as a side-effect

767 */

768 int

769 process_bmbt_reclist(

770 xfs_mount_t *mp,

771 xfs_bmbt_rec_t *rp,

772 int *numrecs,

773 int type,

774 xfs_ino_t ino,

775 xfs_drfsbno_t *tot,

776 blkmap_t **blkmapp,

777 xfs_dfiloff_t *first_key,

778 xfs_dfiloff_t *last_key,

779 int whichfork)

780 {

781 return process_bmbt_reclist_int(mp, rp, numrecs, type, ino, tot,

782 blkmapp, first_key, last_key, 0, whichfork);

783 }

784

785 /*

786 * return 1 if inode should be cleared, 0 otherwise, does not set

787 * block bitmap

788 */

789 int

790 scan_bmbt_reclist(

791 xfs_mount_t *mp,

792 xfs_bmbt_rec_t *rp,

793 int *numrecs,

794 int type,

795 xfs_ino_t ino,

796 xfs_drfsbno_t *tot,

797 int whichfork)

798 {

799 xfs_dfiloff_t first_key = 0;

800 xfs_dfiloff_t last_key = 0;

801

802 return process_bmbt_reclist_int(mp, rp, numrecs, type, ino, tot,

803 NULL, &first_key, &last_key, 1, whichfork);

804 }

805

806 /*

807 * these two are meant for routines that read and work with inodes

808 * one at a time where the inodes may be in any order (like walking

809 * the unlinked lists to look for inodes). the caller is responsible

810 * for writing/releasing the buffer.

811 */

812 xfs_buf_t *

813 get_agino_buf(xfs_mount_t *mp,

814 xfs_agnumber_t agno,

815 xfs_agino_t agino,

816 xfs_dinode_t **dipp)

817 {

818 ino_tree_node_t *irec;

819 xfs_buf_t *bp;

820 int size;

821

822 if ((irec = find_inode_rec(mp, agno, agino)) == NULL)

823 return(NULL);

824

825 size = XFS_FSB_TO_BB(mp, MAX(1, XFS_INODES_PER_CHUNK/inodes_per_block));

826 bp = libxfs_readbuf(mp->m_dev, XFS_AGB_TO_DADDR(mp, agno,

827 XFS_AGINO_TO_AGBNO(mp, irec->ino_startnum)), size, 0,

828 &xfs_inode_buf_ops);

829 if (!bp) {

830 do_warn(_("cannot read inode (%u/%u), disk block %" PRIu64 "\n"),

831 agno, irec->ino_startnum,

832 XFS_AGB_TO_DADDR(mp, agno,

833 XFS_AGINO_TO_AGBNO(mp, irec->ino_startnum)));

834 return(NULL);

835 }

836

837 *dipp = xfs_make_iptr(mp, bp, agino -

838 XFS_OFFBNO_TO_AGINO(mp, XFS_AGINO_TO_AGBNO(mp,

839 irec->ino_startnum),

840 0));

841

842 return(bp);

843 }

844

845 /*

846 * these next routines return the filesystem blockno of the

847 * block containing the block "bno" in the file whose bmap

848 * tree (or extent list) is rooted by "rootblock".

849 *

850 * the next routines are utility routines for the third

851 * routine, get_bmapi().

852 *

853 * NOTE: getfunc_extlist only used by dirv1 checking code

854 */

855 static xfs_dfsbno_t

856 getfunc_extlist(xfs_mount_t *mp,

857 xfs_ino_t ino,

858 xfs_dinode_t *dip,

859 xfs_dfiloff_t bno,

860 int whichfork)

861 {

862 xfs_bmbt_irec_t irec;

863 xfs_dfsbno_t final_fsbno = NULLDFSBNO;

864 xfs_bmbt_rec_t *rootblock = (xfs_bmbt_rec_t *)

865 XFS_DFORK_PTR(dip, whichfork);

866 xfs_extnum_t nextents = XFS_DFORK_NEXTENTS(dip, whichfork);

867 int i;

868

869 for (i = 0; i < nextents; i++) {

870 libxfs_bmbt_disk_get_all(rootblock + i, &irec);

871 if (irec.br_startoff <= bno &&

872 bno < irec.br_startoff + irec.br_blockcount) {

873 final_fsbno = bno - irec.br_startoff + irec.br_startblock;

874 break;

875 }

876 }

877

878 return(final_fsbno);

879 }

880

881 /*

882 * NOTE: getfunc_btree only used by dirv1 checking code...

883 */

884 static xfs_dfsbno_t

885 getfunc_btree(xfs_mount_t *mp,

886 xfs_ino_t ino,

887 xfs_dinode_t *dip,

888 xfs_dfiloff_t bno,

889 int whichfork)

890 {

891 int i;

892 #ifdef DEBUG

893 int prev_level;

894 #endif

895 int found;

896 int numrecs;

897 xfs_bmbt_rec_t *rec;

898 xfs_bmbt_irec_t irec;

899 xfs_bmbt_ptr_t *pp;

900 xfs_bmbt_key_t *key;

901 xfs_bmdr_key_t *rkey;

902 xfs_bmdr_ptr_t *rp;

903 xfs_dfsbno_t fsbno;

904 xfs_buf_t *bp;

905 xfs_dfsbno_t final_fsbno = NULLDFSBNO;

906 struct xfs_btree_block *block;

907 xfs_bmdr_block_t *rootblock = (xfs_bmdr_block_t *)

908 XFS_DFORK_PTR(dip, whichfork);

909

910 ASSERT(rootblock->bb_level != 0);

911 /*

912 * deal with root block, it's got a slightly different

913 * header structure than interior nodes. We know that

914 * a btree should have at least 2 levels otherwise it

915 * would be an extent list.

916 */

917 rkey = XFS_BMDR_KEY_ADDR(rootblock, 1);

918 rp = XFS_BMDR_PTR_ADDR(rootblock, 1,

919 xfs_bmdr_maxrecs(mp, XFS_DFORK_SIZE(dip, mp, whichfork), 1));

920 found = -1;

921 for (i = 0; i < be16_to_cpu(rootblock->bb_numrecs) - 1; i++) {

922 if (be64_to_cpu(rkey[i].br_startoff) <= bno &&

923 bno < be64_to_cpu(rkey[i + 1].br_startoff)) {

924 found = i;

925 break;

926 }

927 }

928 if (i == be16_to_cpu(rootblock->bb_numrecs) - 1 &&

929 bno >= be64_to_cpu(rkey[i].br_startoff))

930 found = i;

931

932 ASSERT(found != -1);

933

934 fsbno = be64_to_cpu(rp[found]);

935

936 ASSERT(verify_dfsbno(mp, fsbno));

937

938 bp = libxfs_readbuf(mp->m_dev, XFS_FSB_TO_DADDR(mp, fsbno),

939 XFS_FSB_TO_BB(mp, 1), 0, NULL);

940 if (!bp) {

941 do_error(_("cannot read bmap block %" PRIu64 "\n"), fsbno);

942 return(NULLDFSBNO);

943 }

944 block = XFS_BUF_TO_BLOCK(bp);

945 numrecs = be16_to_cpu(block->bb_numrecs);

946

947 /*

948 * ok, now traverse any interior btree nodes

949 */

950 #ifdef DEBUG

951 prev_level = be16_to_cpu(block->bb_level);

952 #endif

953

954 while (be16_to_cpu(block->bb_level) > 0) {

955 #ifdef DEBUG

956 ASSERT(be16_to_cpu(block->bb_level) < prev_level);

957

958 prev_level = be16_to_cpu(block->bb_level);

959 #endif

960 if (numrecs > mp->m_bmap_dmxr[1]) {

961 do_warn(

962 _("# of bmap records in inode %" PRIu64 " exceeds max (%u, max - %u)\n"),

963 ino, numrecs,

964 mp->m_bmap_dmxr[1]);

965 libxfs_putbuf(bp);

966 return(NULLDFSBNO);

967 }

968 if (verbose && numrecs < mp->m_bmap_dmnr[1]) {

969 do_warn(

970 _("- # of bmap records in inode %" PRIu64 " less than minimum (%u, min - %u), proceeding ...\n"),

971 ino, numrecs, mp->m_bmap_dmnr[1]);

972 }

973 key = XFS_BMBT_KEY_ADDR(mp, block, 1);

974 pp = XFS_BMBT_PTR_ADDR(mp, block, 1, mp->m_bmap_dmxr[1]);

975 for (found = -1, i = 0; i < numrecs - 1; i++) {

976 if (be64_to_cpu(key[i].br_startoff) <= bno && bno <

977 be64_to_cpu(key[i + 1].br_startoff)) {

978 found = i;

979 break;

980 }

981 }

982 if (i == numrecs - 1 && bno >= be64_to_cpu(key[i].br_startoff))

983 found = i;

984

985 ASSERT(found != -1);

986 fsbno = be64_to_cpu(pp[found]);

987

988 ASSERT(verify_dfsbno(mp, fsbno));

989

990 /*

991 * release current btree block and read in the

992 * next btree block to be traversed

993 */

994 libxfs_putbuf(bp);

995 bp = libxfs_readbuf(mp->m_dev, XFS_FSB_TO_DADDR(mp, fsbno),

996 XFS_FSB_TO_BB(mp, 1), 0, NULL);

997 if (!bp) {

998 do_error(_("cannot read bmap block %" PRIu64 "\n"),

999 fsbno);

1000 return(NULLDFSBNO);

1001 }

1002 block = XFS_BUF_TO_BLOCK(bp);

1003 numrecs = be16_to_cpu(block->bb_numrecs);

1004 }

1005

1006 /*

1007 * current block must be a leaf block

1008 */

1009 ASSERT(be16_to_cpu(block->bb_level) == 0);

1010 if (numrecs > mp->m_bmap_dmxr[0]) {

1011 do_warn(

1012 _("# of bmap records in inode %" PRIu64 " greater than maximum (%u, max - %u)\n"),

1013 ino, numrecs, mp->m_bmap_dmxr[0]);

1014 libxfs_putbuf(bp);

1015 return(NULLDFSBNO);

1016 }

1017 if (verbose && numrecs < mp->m_bmap_dmnr[0])

1018 do_warn(

1019 _("- # of bmap records in inode %" PRIu64 " less than minimum (%u, min - %u), continuing...\n"),

1020 ino, numrecs, mp->m_bmap_dmnr[0]);

1021

1022 rec = XFS_BMBT_REC_ADDR(mp, block, 1);

1023 for (i = 0; i < numrecs; i++) {

1024 libxfs_bmbt_disk_get_all(rec + i, &irec);

1025 if (irec.br_startoff <= bno &&

1026 bno < irec.br_startoff + irec.br_blockcount) {

1027 final_fsbno = bno - irec.br_startoff +

1028 irec.br_startblock;

1029 break;

1030 }

1031 }

1032 libxfs_putbuf(bp);

1033

1034 if (final_fsbno == NULLDFSBNO)

1035 do_warn(_("could not map block %" PRIu64 "\n"), bno);

1036

1037 return(final_fsbno);

1038 }

1039

1040 /*

1041 * this could be smarter. maybe we should have an open inode

1042 * routine that would get the inode buffer and return back

1043 * an inode handle. I'm betting for the moment that this

1044 * is used only by the directory and attribute checking code

1045 * and that the avl tree find and buffer cache search are

1046 * relatively cheap. If they're too expensive, we'll just

1047 * have to fix this and add an inode handle to the da btree

1048 * cursor.

1049 *

1050 * caller is responsible for checking doubly referenced blocks

1051 * and references to holes

1052 *

1053 * NOTE: get_bmapi only used by dirv1 checking code

1054 */

1055 xfs_dfsbno_t

1056 get_bmapi(xfs_mount_t *mp, xfs_dinode_t *dino_p,

1057 xfs_ino_t ino_num, xfs_dfiloff_t bno, int whichfork)

1058 {

1059 xfs_dfsbno_t fsbno;

1060

1061 switch (XFS_DFORK_FORMAT(dino_p, whichfork)) {

1062 case XFS_DINODE_FMT_EXTENTS:

1063 fsbno = getfunc_extlist(mp, ino_num, dino_p, bno, whichfork);

1064 break;

1065 case XFS_DINODE_FMT_BTREE:

1066 fsbno = getfunc_btree(mp, ino_num, dino_p, bno, whichfork);

1067 break;

1068 case XFS_DINODE_FMT_LOCAL:

1069 do_error(_("get_bmapi() called for local inode %" PRIu64 "\n"),

1070 ino_num);

1071 fsbno = NULLDFSBNO;

1072 break;

1073 default:

1074 /*

1075 * shouldn't happen

1076 */

1077 do_error(_("bad inode format for inode %" PRIu64 "\n"), ino_num);

1078 fsbno = NULLDFSBNO;

1079 }

1080

1081 return(fsbno);

1082 }

1083

1084 /*

1085 * higher level inode processing stuff starts here:

1086 * first, one utility routine for each type of inode

1087 */

1088

1089 /*

1090 * return 1 if inode should be cleared, 0 otherwise

1091 */

1092 static int

1093 process_btinode(

1094 xfs_mount_t *mp,

1095 xfs_agnumber_t agno,

1096 xfs_agino_t ino,

1097 xfs_dinode_t *dip,

1098 int type,

1099 int *dirty,

1100 xfs_drfsbno_t *tot,

1101 __uint64_t *nex,

1102 blkmap_t **blkmapp,

1103 int whichfork,

1104 int check_dups)

1105 {

1106 xfs_bmdr_block_t *dib;

1107 xfs_dfiloff_t last_key;

1108 xfs_dfiloff_t first_key = 0;

1109 xfs_ino_t lino;

1110 xfs_bmbt_ptr_t *pp;

1111 xfs_bmbt_key_t *pkey;

1112 char *forkname;

1113 int i;

1114 int level;

1115 int numrecs;

1116 bmap_cursor_t cursor;

1117 __uint64_t magic;

1118

1119 dib = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork);

1120 lino = XFS_AGINO_TO_INO(mp, agno, ino);

1121 *tot = 0;

1122 *nex = 0;

1123

1124 if (whichfork == XFS_DATA_FORK)

1125 forkname = _("data");

1126 else

1127 forkname = _("attr");

1128

1129 magic = xfs_sb_version_hascrc(&mp->m_sb) ? XFS_BMAP_CRC_MAGIC

1130 : XFS_BMAP_MAGIC;

1131

1132 level = be16_to_cpu(dib->bb_level);

1133 numrecs = be16_to_cpu(dib->bb_numrecs);

1134

1135 if ((level == 0) || (level > XFS_BM_MAXLEVELS(mp, whichfork))) {

1136 /*

1137 * XXX - if we were going to fix up the inode,

1138 * we'd try to treat the fork as an interior

1139 * node and see if we could get an accurate

1140 * level value from one of the blocks pointed

1141 * to by the pointers in the fork. For now

1142 * though, we just bail (and blow out the inode).

1143 */

1144 do_warn(

1145 _("bad level %d in inode %" PRIu64 " bmap btree root block\n"),

1146 level, XFS_AGINO_TO_INO(mp, agno, ino));

1147 return(1);

1148 }

1149 if (numrecs == 0) {

1150 do_warn(

1151 _("bad numrecs 0 in inode %" PRIu64 " bmap btree root block\n"),

1152 XFS_AGINO_TO_INO(mp, agno, ino));

1153 return(1);

1154 }

1155 /*

1156 * use bmdr/dfork_dsize since the root block is in the data fork

1157 */

1158 if (XFS_BMDR_SPACE_CALC(numrecs) > XFS_DFORK_SIZE(dip, mp, whichfork)) {

1159 do_warn(

1160 _("indicated size of %s btree root (%d bytes) greater than space in "

1161 "inode %" PRIu64 " %s fork\n"),

1162 forkname, XFS_BMDR_SPACE_CALC(numrecs), lino, forkname);

1163 return(1);

1164 }

1165

1166 init_bm_cursor(&cursor, level + 1);

1167

1168 pp = XFS_BMDR_PTR_ADDR(dib, 1,

1169 xfs_bmdr_maxrecs(mp, XFS_DFORK_SIZE(dip, mp, whichfork), 0));

1170 pkey = XFS_BMDR_KEY_ADDR(dib, 1);

1171 last_key = NULLDFILOFF;

1172

1173 for (i = 0; i < numrecs; i++) {

1174 /*

1175 * XXX - if we were going to do more to fix up the inode

1176 * btree, we'd do it right here. For now, if there's a

1177 * problem, we'll bail out and presumably clear the inode.

1178 */

1179 if (!verify_dfsbno(mp, be64_to_cpu(pp[i]))) {

1180 do_warn(_("bad bmap btree ptr 0x%llx in ino %" PRIu64 "\n"),

1181 (unsigned long long) be64_to_cpu(pp[i]), lino);

1182 return(1);

1183 }

1184

1185 if (scan_lbtree(be64_to_cpu(pp[i]), level, scan_bmapbt, type,

1186 whichfork, lino, tot, nex, blkmapp, &cursor,

1187 1, check_dups, magic, &xfs_bmbt_buf_ops))

1188 return(1);

1189 /*

1190 * fix key (offset) mismatches between the keys in root

1191 * block records and the first key of each child block.

1192 * fixes cases where entries have been shifted between

1193 * blocks but the parent hasn't been updated

1194 */

1195 if (!check_dups && cursor.level[level-1].first_key !=

1196 be64_to_cpu(pkey[i].br_startoff)) {

1197 if (!no_modify) {

1198 do_warn(

1199 _("correcting key in bmbt root (was %llu, now %" PRIu64") in inode "

1200 "%" PRIu64" %s fork\n"),

1201 (unsigned long long)

1202 be64_to_cpu(pkey[i].br_startoff),

1203 cursor.level[level-1].first_key,

1204 XFS_AGINO_TO_INO(mp, agno, ino),

1205 forkname);

1206 *dirty = 1;

1207 pkey[i].br_startoff = cpu_to_be64(

1208 cursor.level[level-1].first_key);

1209 } else {

1210 do_warn(

1211 _("bad key in bmbt root (is %llu, would reset to %" PRIu64 ") in inode "

1212 "%" PRIu64 " %s fork\n"),

1213 (unsigned long long)

1214 be64_to_cpu(pkey[i].br_startoff),

1215 cursor.level[level-1].first_key,

1216 XFS_AGINO_TO_INO(mp, agno, ino),

1217 forkname);

1218 }

1219 }

1220 /*

1221 * make sure that keys are in ascending order. blow out

1222 * inode if the ordering doesn't hold

1223 */

1224 if (check_dups == 0) {

1225 if (last_key != NULLDFILOFF && last_key >=

1226 cursor.level[level-1].first_key) {

1227 do_warn(

1228 _("out of order bmbt root key %" PRIu64 " in inode %" PRIu64 " %s fork\n"),

1229 first_key,

1230 XFS_AGINO_TO_INO(mp, agno, ino),

1231 forkname);

1232 return(1);

1233 }

1234 last_key = cursor.level[level-1].first_key;

1235 }

1236 }

1237 /*

1238 * Ideally if all the extents are ok (perhaps after further

1239 * checks below?) we'd just move this back into extents format.

1240 * But for now clear it, as the kernel will choke on this

1241 */

1242 if (*nex <= XFS_DFORK_SIZE(dip, mp, whichfork) /

1243 sizeof(xfs_bmbt_rec_t)) {

1244 do_warn(

1245 _("extent count for ino %" PRIu64 " %s fork too low (%" PRIu64 ") for file format\n"),

1246 lino, forkname, *nex);

1247 return(1);

1248 }

1249 /*

1250 * Check that the last child block's forward sibling pointer

1251 * is NULL.

1252 */

1253 if (check_dups == 0 &&

1254 cursor.level[0].right_fsbno != NULLDFSBNO) {

1255 do_warn(

1256 _("bad fwd (right) sibling pointer (saw %" PRIu64 " should be NULLDFSBNO)\n"),

1257 cursor.level[0].right_fsbno);

1258 do_warn(

1259 _("\tin inode %" PRIu64 " (%s fork) bmap btree block %" PRIu64 "\n"),

1260 XFS_AGINO_TO_INO(mp, agno, ino), forkname,

1261 cursor.level[0].fsbno);

1262 return(1);

1263 }

1264

1265 return(0);

1266 }

1267

1268 /*

1269 * return 1 if inode should be cleared, 0 otherwise

1270 */

1271 static int

1272 process_exinode(

1273 xfs_mount_t *mp,

1274 xfs_agnumber_t agno,

1275 xfs_agino_t ino,

1276 xfs_dinode_t *dip,

1277 int type,

1278 int *dirty,

1279 xfs_drfsbno_t *tot,

1280 __uint64_t *nex,

1281 blkmap_t **blkmapp,

1282 int whichfork,

1283 int check_dups)

1284 {

1285 xfs_ino_t lino;

1286 xfs_bmbt_rec_t *rp;

1287 xfs_dfiloff_t first_key;

1288 xfs_dfiloff_t last_key;

1289 int32_t numrecs;

1290 int ret;

1291

1292 lino = XFS_AGINO_TO_INO(mp, agno, ino);

1293 rp = (xfs_bmbt_rec_t *)XFS_DFORK_PTR(dip, whichfork);

1294 *tot = 0;

1295 numrecs = XFS_DFORK_NEXTENTS(dip, whichfork);

1296

1297 /*

1298 * We've already decided on the maximum number of extents on the inode,

1299 * and numrecs may be corrupt. Hence make sure we only allow numrecs to

1300 * be in the range of valid on-disk numbers, which is:

1301 * 0 < numrecs < 2^31 - 1

1302 */

1303 if (numrecs < 0)

1304 numrecs = *nex;

1305

1306 /*

1307 * XXX - if we were going to fix up the btree record,

1308 * we'd do it right here. For now, if there's a problem,

1309 * we'll bail out and presumably clear the inode.

1310 */

1311 if (check_dups == 0)

1312 ret = process_bmbt_reclist(mp, rp, &numrecs, type, lino,

1313 tot, blkmapp, &first_key, &last_key,

1314 whichfork);

1315 else

1316 ret = scan_bmbt_reclist(mp, rp, &numrecs, type, lino, tot,

1317 whichfork);

1318

1319 *nex = numrecs;

1320 return ret;

1321 }

1322

1323 /*

1324 * return 1 if inode should be cleared, 0 otherwise

1325 */

1326 static int

1327 process_lclinode(

1328 xfs_mount_t *mp,

1329 xfs_agnumber_t agno,

1330 xfs_agino_t ino,

1331 xfs_dinode_t *dip,

1332 int whichfork)

1333 {

1334 xfs_attr_shortform_t *asf;

1335 xfs_ino_t lino;

1336

1337 lino = XFS_AGINO_TO_INO(mp, agno, ino);

1338 if (whichfork == XFS_DATA_FORK && be64_to_cpu(dip->di_size) >

1339 XFS_DFORK_DSIZE(dip, mp)) {

1340 do_warn(

1341 _("local inode %" PRIu64 " data fork is too large (size = %lld, max = %d)\n"),

1342 lino, (unsigned long long) be64_to_cpu(dip->di_size),

1343 XFS_DFORK_DSIZE(dip, mp));

1344 return(1);

1345 } else if (whichfork == XFS_ATTR_FORK) {

1346 asf = (xfs_attr_shortform_t *)XFS_DFORK_APTR(dip);

1347 if (be16_to_cpu(asf->hdr.totsize) > XFS_DFORK_ASIZE(dip, mp)) {

1348 do_warn(

1349 _("local inode %" PRIu64 " attr fork too large (size %d, max = %d)\n"),

1350 lino, be16_to_cpu(asf->hdr.totsize),

1351 XFS_DFORK_ASIZE(dip, mp));

1352 return(1);

1353 }

1354 if (be16_to_cpu(asf->hdr.totsize) < sizeof(xfs_attr_sf_hdr_t)) {

1355 do_warn(

1356 _("local inode %" PRIu64 " attr too small (size = %d, min size = %zd)\n"),

1357 lino, be16_to_cpu(asf->hdr.totsize),

1358 sizeof(xfs_attr_sf_hdr_t));

1359 return(1);

1360 }

1361 }

1362

1363 return(0);

1364 }

1365

1366 static int

1367 process_symlink_extlist(xfs_mount_t *mp, xfs_ino_t lino, xfs_dinode_t *dino)

1368 {

1369 xfs_dfiloff_t expected_offset;

1370 xfs_bmbt_rec_t *rp;

1371 xfs_bmbt_irec_t irec;

1372 int numrecs;

1373 int i;

1374 int max_blocks;

1375

1376 if (be64_to_cpu(dino->di_size) <= XFS_DFORK_DSIZE(dino, mp)) {

1377 if (dino->di_format == XFS_DINODE_FMT_LOCAL)

1378 return 0;

1379 do_warn(

1380 _("mismatch between format (%d) and size (%" PRId64 ") in symlink ino %" PRIu64 "\n"),

1381 dino->di_format,

1382 (__int64_t)be64_to_cpu(dino->di_size), lino);

1383 return 1;

1384 }

1385 if (dino->di_format == XFS_DINODE_FMT_LOCAL) {

1386 do_warn(

1387 _("mismatch between format (%d) and size (%" PRId64 ") in symlink inode %" PRIu64 "\n"),

1388 dino->di_format,

1389 (__int64_t)be64_to_cpu(dino->di_size), lino);

1390 return 1;

1391 }

1392

1393 rp = (xfs_bmbt_rec_t *)XFS_DFORK_DPTR(dino);

1394 numrecs = be32_to_cpu(dino->di_nextents);

1395

1396 /*

1397 * the max # of extents in a symlink inode is equal to the

1398 * number of max # of blocks required to store the symlink

1399 */

1400 if (numrecs > max_symlink_blocks) {

1401 do_warn(

1402 _("bad number of extents (%d) in symlink %" PRIu64 " data fork\n"),

1403 numrecs, lino);

1404 return(1);

1405 }

1406

1407 max_blocks = max_symlink_blocks;

1408 expected_offset = 0;

1409

1410 for (i = 0; i < numrecs; i++) {

1411 libxfs_bmbt_disk_get_all(rp + i, &irec);

1412

1413 if (irec.br_startoff != expected_offset) {

1414 do_warn(

1415 _("bad extent #%d offset (%" PRIu64 ") in symlink %" PRIu64 " data fork\n"),

1416 i, irec.br_startoff, lino);

1417 return(1);

1418 }

1419 if (irec.br_blockcount == 0 || irec.br_blockcount > max_blocks) {

1420 do_warn(

1421 _("bad extent #%d count (%" PRIu64 ") in symlink %" PRIu64 " data fork\n"),

1422 i, irec.br_blockcount, lino);

1423 return(1);

1424 }

1425

1426 max_blocks -= irec.br_blockcount;

1427 expected_offset += irec.br_blockcount;

1428 }

1429

1430 return(0);

1431 }

1432

1433 /*

1434 * takes a name and length and returns 1 if the name contains

1435 * a \0, returns 0 otherwise

1436 */

1437 static int

1438 null_check(char *name, int length)

1439 {

1440 int i;

1441

1442 ASSERT(length < MAXPATHLEN);

1443

1444 for (i = 0; i < length; i++, name++) {

1445 if (*name == '\0')

1446 return(1);

1447 }

1448

1449 return(0);

1450 }

1451

1452 static int

1453 process_symlink_remote(

1454 struct xfs_mount *mp,

1455 xfs_ino_t lino,

1456 struct xfs_dinode *dino,

1457 struct blkmap *blkmap,

1458 char *dst)

1459 {

1460 xfs_dfsbno_t fsbno;

1461 struct xfs_buf *bp;

1462 char *src;

1463 int pathlen;

1464 int offset;

1465 int i;

1466

1467 offset = 0;

1468 pathlen = be64_to_cpu(dino->di_size);

1469 i = 0;

1470

1471 while (pathlen > 0) {

1472 int blk_cnt = 1;

1473 int byte_cnt;

1474

1475 fsbno = blkmap_get(blkmap, i);

1476 if (fsbno == NULLDFSBNO) {

1477 do_warn(

1478 _("cannot read inode %" PRIu64 ", file block %d, NULL disk block\n"),

1479 lino, i);

1480 return 1;

1481 }

1482

1483 /*

1484 * There's a symlink header for each contiguous extent. If

1485 * there are contiguous blocks, read them in one go.

1486 */

1487 while (blk_cnt <= max_symlink_blocks) {

1488 if (blkmap_get(blkmap, i + 1) != fsbno + 1)

1489 break;

1490 blk_cnt++;

1491 i++;

1492 }

1493

1494 byte_cnt = XFS_FSB_TO_B(mp, blk_cnt);

1495

1496 bp = libxfs_readbuf(mp->m_dev, XFS_FSB_TO_DADDR(mp, fsbno),

1497 BTOBB(byte_cnt), 0, &xfs_symlink_buf_ops);

1498 if (!bp) {

1499 do_warn(

1500 _("cannot read inode %" PRIu64 ", file block %d, disk block %" PRIu64 "\n"),

1501 lino, i, fsbno);

1502 return 1;

1503 }

1504

1505 byte_cnt = XFS_SYMLINK_BUF_SPACE(mp, byte_cnt);

1506 byte_cnt = MIN(pathlen, byte_cnt);

1507

1508 src = bp->b_addr;

1509 if (xfs_sb_version_hascrc(&mp->m_sb)) {

1510 if (!libxfs_symlink_hdr_ok(mp, lino, offset,

1511 byte_cnt, bp)) {

1512 do_warn(

1513 _("bad symlink header ino %" PRIu64 ", file block %d, disk block %" PRIu64 "\n"),

1514 lino, i, fsbno);

1515 libxfs_putbuf(bp);

1516 return 1;

1517 }

1518 src += sizeof(struct xfs_dsymlink_hdr);

1519 }

1520

1521 memmove(dst + offset, src, byte_cnt);

1522

1523 pathlen -= byte_cnt;

1524 offset += byte_cnt;

1525 i++;

1526

1527 libxfs_putbuf(bp);

1528 }

1529 return 0;

1530 }

1531

1532 /*

1533 * like usual, returns 0 if everything's ok and 1 if something's

1534 * bogus

1535 */

1536 static int

1537 process_symlink(

1538 xfs_mount_t *mp,

1539 xfs_ino_t lino,

1540 xfs_dinode_t *dino,

1541 blkmap_t *blkmap)

1542 {

1543 char *symlink, *cptr;

1544 char data[MAXPATHLEN];

1545

1546 /*

1547 * check size against kernel symlink limits. we know

1548 * size is consistent with inode storage format -- e.g.

1549 * the inode is structurally ok so we don't have to check

1550 * for that

1551 */

1552 if (be64_to_cpu(dino->di_size) >= MAXPATHLEN) {

1553 do_warn(_("symlink in inode %" PRIu64 " too long (%llu chars)\n"),

1554 lino, (unsigned long long) be64_to_cpu(dino->di_size));

1555 return(1);

1556 }

1557

1558 /*

1559 * have to check symlink component by component.

1560 * get symlink contents into data area

1561 */

1562 symlink = &data[0];

1563 if (be64_to_cpu(dino->di_size) <= XFS_DFORK_DSIZE(dino, mp)) {

1564 /*

1565 * local symlink, just copy the symlink out of the

1566 * inode into the data area

1567 */

1568 memmove(symlink, XFS_DFORK_DPTR(dino),

1569 be64_to_cpu(dino->di_size));

1570 } else {

1571 int error;

1572

1573 error = process_symlink_remote(mp, lino, dino, blkmap, symlink);

1574 if (error)

1575 return error;

1576 }

1577

1578 data[be64_to_cpu(dino->di_size)] = '\0';

1579

1580 /*

1581 * check for nulls

1582 */

1583 if (null_check(symlink, be64_to_cpu(dino->di_size))) {

1584 do_warn(

1585 _("found illegal null character in symlink inode %" PRIu64 "\n"),

1586 lino);

1587 return(1);

1588 }

1589

1590 /*

1591 * check for any component being too long

1592 */

1593 if (be64_to_cpu(dino->di_size) >= MAXNAMELEN) {

1594 cptr = strchr(symlink, '/');

1595

1596 while (cptr != NULL) {

1597 if (cptr - symlink >= MAXNAMELEN) {

1598 do_warn(

1599 _("component of symlink in inode %" PRIu64 " too long\n"),

1600 lino);

1601 return(1);

1602 }

1603 symlink = cptr + 1;

1604 cptr = strchr(symlink, '/');

1605 }

1606

1607 if (strlen(symlink) >= MAXNAMELEN) {

1608 do_warn(

1609 _("component of symlink in inode %" PRIu64 " too long\n"),

1610 lino);

1611 return(1);

1612 }

1613 }

1614

1615 return(0);

1616 }

1617

1618 /*

1619 * called to process the set of misc inode special inode types

1620 * that have no associated data storage (fifos, pipes, devices, etc.).

1621 */

1622 static int

1623 process_misc_ino_types(xfs_mount_t *mp,

1624 xfs_dinode_t *dino,

1625 xfs_ino_t lino,

1626 int type)

1627 {

1628 /*

1629 * disallow mountpoint inodes until such time as the

1630 * kernel actually allows them to be created (will

1631 * probably require a superblock version rev, sigh).

1632 */

1633 if (type == XR_INO_MOUNTPOINT) {

1634 do_warn(

1635 _("inode %" PRIu64 " has bad inode type (IFMNT)\n"), lino);

1636 return(1);

1637 }

1638

1639 /*

1640 * must also have a zero size

1641 */

1642 if (be64_to_cpu(dino->di_size) != 0) {

1643 switch (type) {

1644 case XR_INO_CHRDEV:

1645 do_warn(

1646 _("size of character device inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino,

1647 (__int64_t)be64_to_cpu(dino->di_size));

1648 break;

1649 case XR_INO_BLKDEV:

1650 do_warn(

1651 _("size of block device inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino,

1652 (__int64_t)be64_to_cpu(dino->di_size));

1653 break;

1654 case XR_INO_SOCK:

1655 do_warn(

1656 _("size of socket inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino,

1657 (__int64_t)be64_to_cpu(dino->di_size));

1658 break;

1659 case XR_INO_FIFO:

1660 do_warn(

1661 _("size of fifo inode %" PRIu64 " != 0 (%" PRId64 " bytes)\n"), lino,

1662 (__int64_t)be64_to_cpu(dino->di_size));

1663 break;

1664 default:

1665 do_warn(_("Internal error - process_misc_ino_types, "

1666 "illegal type %d\n"), type);

1667 abort();

1668 }

1669

1670 return(1);

1671 }

1672

1673 return(0);

1674 }

1675

1676 static int

1677 process_misc_ino_types_blocks(xfs_drfsbno_t totblocks, xfs_ino_t lino, int type)

1678 {

1679 /*

1680 * you can not enforce all misc types have zero data fork blocks

1681 * by checking dino->di_nblocks because atotblocks (attribute

1682 * blocks) are part of nblocks. We must check this later when atotblocks

1683 * has been calculated or by doing a simple check that anExtents == 0.

1684 * We must also guarantee that totblocks is 0. Thus nblocks checking

1685 * will be done later in process_dinode_int for misc types.

1686 */

1687

1688 if (totblocks != 0) {

1689 switch (type) {

1690 case XR_INO_CHRDEV:

1691 do_warn(

1692 _("size of character device inode %" PRIu64 " != 0 (%" PRIu64 " blocks)\n"),

1693 lino, totblocks);

1694 break;

1695 case XR_INO_BLKDEV:

1696 do_warn(

1697 _("size of block device inode %" PRIu64 " != 0 (%" PRIu64 " blocks)\n"),

1698 lino, totblocks);

1699 break;

1700 case XR_INO_SOCK:

1701 do_warn(

1702 _("size of socket inode %" PRIu64 " != 0 (%" PRIu64 " blocks)\n"),

1703 lino, totblocks);

1704 break;

1705 case XR_INO_FIFO:

1706 do_warn(

1707 _("size of fifo inode %" PRIu64 " != 0 (%" PRIu64 " blocks)\n"),

1708 lino, totblocks);

1709 break;

1710 default:

1711 return(0);

1712 }

1713 return(1);

1714 }

1715 return (0);

1716 }

1717

1718 static inline int

1719 dinode_fmt(

1720 xfs_dinode_t *dino)

1721 {

1722 return be16_to_cpu(dino->di_mode) & S_IFMT;

1723 }

1724

1725 static inline void

1726 change_dinode_fmt(

1727 xfs_dinode_t *dino,

1728 int new_fmt)

1729 {

1730 int mode = be16_to_cpu(dino->di_mode);

1731

1732 ASSERT((new_fmt & ~S_IFMT) == 0);

1733

1734 mode &= ~S_IFMT;

1735 mode |= new_fmt;

1736 dino->di_mode = cpu_to_be16(mode);

1737 }

1738

1739 static int

1740 check_dinode_mode_format(

1741 xfs_dinode_t *dinoc)

1742 {

1743 if (dinoc->di_format >= XFS_DINODE_FMT_UUID)

1744 return -1; /* FMT_UUID is not used */

1745

1746 switch (dinode_fmt(dinoc)) {

1747 case S_IFIFO:

1748 case S_IFCHR:

1749 case S_IFBLK:

1750 case S_IFSOCK:

1751 return (dinoc->di_format != XFS_DINODE_FMT_DEV) ? -1 : 0;

1752

1753 case S_IFDIR:

1754 return (dinoc->di_format < XFS_DINODE_FMT_LOCAL ||

1755 dinoc->di_format > XFS_DINODE_FMT_BTREE) ? -1 : 0;

1756

1757 case S_IFREG:

1758 return (dinoc->di_format < XFS_DINODE_FMT_EXTENTS ||

1759 dinoc->di_format > XFS_DINODE_FMT_BTREE) ? -1 : 0;

1760

1761 case S_IFLNK:

1762 return (dinoc->di_format < XFS_DINODE_FMT_LOCAL ||

1763 dinoc->di_format > XFS_DINODE_FMT_EXTENTS) ? -1 : 0;

1764

1765 default: ;

1766 }

1767 return 0; /* invalid modes are checked elsewhere */

1768 }

1769

1770 /*

1771 * If inode is a superblock inode, does type check to make sure is it valid.

1772 * Returns 0 if it's valid, non-zero if it needs to be cleared.

1773 */

1774

1775 static int

1776 process_check_sb_inodes(

1777 xfs_mount_t *mp,

1778 xfs_dinode_t *dinoc,

1779 xfs_ino_t lino,

1780 int *type,

1781 int *dirty)

1782 {

1783 if (lino == mp->m_sb.sb_rootino) {

1784 if (*type != XR_INO_DIR) {

1785 do_warn(_("root inode %" PRIu64 " has bad type 0x%x\n"),

1786 lino, dinode_fmt(dinoc));

1787 *type = XR_INO_DIR;

1788 if (!no_modify) {

1789 do_warn(_("resetting to directory\n"));

1790 change_dinode_fmt(dinoc, S_IFDIR);

1791 *dirty = 1;

1792 } else

1793 do_warn(_("would reset to directory\n"));

1794 }

1795 return 0;

1796 }

1797 if (lino == mp->m_sb.sb_uquotino) {

1798 if (*type != XR_INO_DATA) {

1799 do_warn(_("user quota inode %" PRIu64 " has bad type 0x%x\n"),

1800 lino, dinode_fmt(dinoc));

1801 mp->m_sb.sb_uquotino = NULLFSINO;

1802 return 1;

1803 }

1804 return 0;

1805 }

1806 if (lino == mp->m_sb.sb_gquotino) {

1807 if (*type != XR_INO_DATA) {

1808 do_warn(_("group quota inode %" PRIu64 " has bad type 0x%x\n"),

1809 lino, dinode_fmt(dinoc));

1810 mp->m_sb.sb_gquotino = NULLFSINO;

1811 return 1;

1812 }

1813 return 0;

1814 }

1815 if (lino == mp->m_sb.sb_rsumino) {

1816 if (*type != XR_INO_RTSUM) {

1817 do_warn(

1818 _("realtime summary inode %" PRIu64 " has bad type 0x%x, "),

1819 lino, dinode_fmt(dinoc));

1820 if (!no_modify) {

1821 do_warn(_("resetting to regular file\n"));

1822 change_dinode_fmt(dinoc, S_IFREG);

1823 *dirty = 1;

1824 } else {

1825 do_warn(_("would reset to regular file\n"));

1826 }

1827 }

1828 if (mp->m_sb.sb_rblocks == 0 && dinoc->di_nextents != 0) {

1829 do_warn(

1830 _("bad # of extents (%u) for realtime summary inode %" PRIu64 "\n"),

1831 be32_to_cpu(dinoc->di_nextents), lino);

1832 return 1;

1833 }

1834 return 0;

1835 }

1836 if (lino == mp->m_sb.sb_rbmino) {

1837 if (*type != XR_INO_RTBITMAP) {

1838 do_warn(

1839 _("realtime bitmap inode %" PRIu64 " has bad type 0x%x, "),

1840 lino, dinode_fmt(dinoc));

1841 if (!no_modify) {

1842 do_warn(_("resetting to regular file\n"));

1843 change_dinode_fmt(dinoc, S_IFREG);

1844 *dirty = 1;

1845 } else {

1846 do_warn(_("would reset to regular file\n"));

1847 }

1848 }

1849 if (mp->m_sb.sb_rblocks == 0 && dinoc->di_nextents != 0) {

1850 do_warn(

1851 _("bad # of extents (%u) for realtime bitmap inode %" PRIu64 "\n"),

1852 be32_to_cpu(dinoc->di_nextents), lino);

1853 return 1;

1854 }

1855 return 0;

1856 }

1857 return 0;

1858 }

1859

1860 /*

1861 * general size/consistency checks:

1862 *

1863 * if the size <= size of the data fork, directories must be

1864 * local inodes unlike regular files which would be extent inodes.

1865 * all the other mentioned types have to have a zero size value.

1866 *

1867 * if the size and format don't match, get out now rather than

1868 * risk trying to process a non-existent extents or btree

1869 * type data fork.

1870 */

1871 static int

1872 process_check_inode_sizes(

1873 xfs_mount_t *mp,

1874 xfs_dinode_t *dino,

1875 xfs_ino_t lino,

1876 int type)

1877 {

1878 xfs_fsize_t size = be64_to_cpu(dino->di_size);

1879

1880 switch (type) {

1881

1882 case XR_INO_DIR:

1883 if (size <= XFS_DFORK_DSIZE(dino, mp) &&

1884 dino->di_format != XFS_DINODE_FMT_LOCAL) {

1885 do_warn(

1886 _("mismatch between format (%d) and size (%" PRId64 ") in directory ino %" PRIu64 "\n"),

1887 dino->di_format, size, lino);

1888 return 1;

1889 }

1890 if (size > XFS_DIR2_LEAF_OFFSET) {

1891 do_warn(

1892 _("directory inode %" PRIu64 " has bad size %" PRId64 "\n"),

1893 lino, size);

1894 return 1;

1895 }

1896 break;

1897

1898 case XR_INO_SYMLINK:

1899 if (process_symlink_extlist(mp, lino, dino)) {

1900 do_warn(_("bad data fork in symlink %" PRIu64 "\n"), lino);

1901 return 1;

1902 }

1903 break;

1904

1905 case XR_INO_CHRDEV: /* fall through to FIFO case ... */

1906 case XR_INO_BLKDEV: /* fall through to FIFO case ... */

1907 case XR_INO_SOCK: /* fall through to FIFO case ... */

1908 case XR_INO_MOUNTPOINT: /* fall through to FIFO case ... */

1909 case XR_INO_FIFO:

1910 if (process_misc_ino_types(mp, dino, lino, type))

1911 return 1;

1912 break;

1913

1914 case XR_INO_RTDATA:

1915 /*

1916 * if we have no realtime blocks, any inode claiming

1917 * to be a real-time file is bogus

1918 */

1919 if (mp->m_sb.sb_rblocks == 0) {

1920 do_warn(

1921 _("found inode %" PRIu64 " claiming to be a real-time file\n"), lino);

1922 return 1;

1923 }

1924 break;

1925

1926 case XR_INO_RTBITMAP:

1927 if (size != (__int64_t)mp->m_sb.sb_rbmblocks *

1928 mp->m_sb.sb_blocksize) {

1929 do_warn(

1930 _("realtime bitmap inode %" PRIu64 " has bad size %" PRId64 " (should be %" PRIu64 ")\n"),

1931 lino, size,

1932 (__int64_t) mp->m_sb.sb_rbmblocks *

1933 mp->m_sb.sb_blocksize);

1934 return 1;

1935 }

1936 break;

1937

1938 case XR_INO_RTSUM:

1939 if (size != mp->m_rsumsize) {

1940 do_warn(

1941 _("realtime summary inode %" PRIu64 " has bad size %" PRId64 " (should be %d)\n"),

1942 lino, size, mp->m_rsumsize);

1943 return 1;

1944 }

1945 break;

1946

1947 default:

1948 break;

1949 }

1950 return 0;

1951 }

1952

1953 /*

1954 * check for illegal values of forkoff

1955 */

1956 static int

1957 process_check_inode_forkoff(

1958 xfs_mount_t *mp,

1959 xfs_dinode_t *dino,

1960 xfs_ino_t lino)

1961 {

1962 if (dino->di_forkoff == 0)

1963 return 0;

1964

1965 switch (dino->di_format) {

1966 case XFS_DINODE_FMT_DEV:

1967 if (dino->di_forkoff != (roundup(sizeof(xfs_dev_t), 8) >> 3)) {

1968 do_warn(

1969 _("bad attr fork offset %d in dev inode %" PRIu64 ", should be %d\n"),

1970 dino->di_forkoff, lino,

1971 (int)(roundup(sizeof(xfs_dev_t), 8) >> 3));

1972 return 1;

1973 }

1974 break;

1975 case XFS_DINODE_FMT_LOCAL: /* fall through ... */

1976 case XFS_DINODE_FMT_EXTENTS: /* fall through ... */

1977 case XFS_DINODE_FMT_BTREE:

1978 if (dino->di_forkoff >=

1979 (XFS_LITINO(mp, dino->di_version) >> 3)) {

1980 do_warn(

1981 _("bad attr fork offset %d in inode %" PRIu64 ", max=%d\n"),

1982 dino->di_forkoff, lino,

1983 XFS_LITINO(mp, dino->di_version) >> 3);

1984 return 1;

1985 }

1986 break;

1987 default:

1988 do_error(_("unexpected inode format %d\n"), dino->di_format);

1989 break;

1990 }

1991 return 0;

1992 }

1993

1994 /*

1995 * Updates the inodes block and extent counts if they are wrong

1996 */

1997 static int

1998 process_inode_blocks_and_extents(

1999 xfs_dinode_t *dino,

2000 xfs_drfsbno_t nblocks,

2001 __uint64_t nextents,

2002 __uint64_t anextents,

2003 xfs_ino_t lino,

2004 int *dirty)

2005 {

2006 if (nblocks != be64_to_cpu(dino->di_nblocks)) {

2007 if (!no_modify) {

2008 do_warn(

2009 _("correcting nblocks for inode %" PRIu64 ", was %llu - counted %" PRIu64 "\n"), lino,

2010 (unsigned long long) be64_to_cpu(dino->di_nblocks),

2011 nblocks);

2012 dino->di_nblocks = cpu_to_be64(nblocks);

2013 *dirty = 1;

2014 } else {

2015 do_warn(

2016 _("bad nblocks %llu for inode %" PRIu64 ", would reset to %" PRIu64 "\n"),

2017 (unsigned long long) be64_to_cpu(dino->di_nblocks),

2018 lino, nblocks);

2019 }

2020 }

2021

2022 if (nextents > MAXEXTNUM) {

2023 do_warn(

2024 _("too many data fork extents (%" PRIu64 ") in inode %" PRIu64 "\n"),

2025 nextents, lino);

2026 return 1;

2027 }

2028 if (nextents != be32_to_cpu(dino->di_nextents)) {

2029 if (!no_modify) {

2030 do_warn(

2031 _("correcting nextents for inode %" PRIu64 ", was %d - counted %" PRIu64 "\n"),

2032 lino,

2033 be32_to_cpu(dino->di_nextents),

2034 nextents);

2035 dino->di_nextents = cpu_to_be32(nextents);

2036 *dirty = 1;

2037 } else {

2038 do_warn(

2039 _("bad nextents %d for inode %" PRIu64 ", would reset to %" PRIu64 "\n"),

2040 be32_to_cpu(dino->di_nextents),

2041 lino, nextents);

2042 }

2043 }

2044

2045 if (anextents > MAXAEXTNUM) {

2046 do_warn(

2047 _("too many attr fork extents (%" PRIu64 ") in inode %" PRIu64 "\n"),

2048 anextents, lino);

2049 return 1;

2050 }

2051 if (anextents != be16_to_cpu(dino->di_anextents)) {

2052 if (!no_modify) {

2053 do_warn(

2054 _("correcting anextents for inode %" PRIu64 ", was %d - counted %" PRIu64 "\n"),

2055 lino,

2056 be16_to_cpu(dino->di_anextents), anextents);

2057 dino->di_anextents = cpu_to_be16(anextents);

2058 *dirty = 1;

2059 } else {

2060 do_warn(

2061 _("bad anextents %d for inode %" PRIu64 ", would reset to %" PRIu64 "\n"),

2062 be16_to_cpu(dino->di_anextents),

2063 lino, anextents);

2064 }

2065 }

2066

2067 /*

2068 * We are comparing different units here, but that's fine given that

2069 * an extent has to have at least a block in it.

2070 */

2071 if (nblocks < nextents + anextents) {

2072 do_warn(

2073 _("nblocks (%" PRIu64 ") smaller than nextents for inode %" PRIu64 "\n"), nblocks, lino);

2074 return 1;

2075 }

2076

2077 return 0;

2078 }

2079

2080 /*

2081 * check data fork -- if it's bad, clear the inode

2082 */

2083 static int

2084 process_inode_data_fork(

2085 xfs_mount_t *mp,

2086 xfs_agnumber_t agno,

2087 xfs_agino_t ino,

2088 xfs_dinode_t *dino,

2089 int type,

2090 int *dirty,

2091 xfs_drfsbno_t *totblocks,

2092 __uint64_t *nextents,

2093 blkmap_t **dblkmap,

2094 int check_dups)

2095 {

2096 xfs_ino_t lino = XFS_AGINO_TO_INO(mp, agno, ino);

2097 int err = 0;

2098 int nex;

2099

2100 /*

2101 * extent count on disk is only valid for positive values. The kernel

2102 * uses negative values in memory. hence if we see negative numbers

2103 * here, trash it!

2104 */

2105 nex = be32_to_cpu(dino->di_nextents);

2106 if (nex < 0)

2107 *nextents = 1;

2108 else

2109 *nextents = nex;

2110

2111 if (*nextents > be64_to_cpu(dino->di_nblocks))

2112 *nextents = 1;

2113

2114

2115 if (dino->di_format != XFS_DINODE_FMT_LOCAL && type != XR_INO_RTDATA)

2116 *dblkmap = blkmap_alloc(*nextents, XFS_DATA_FORK);

2117 *nextents = 0;

2118

2119 switch (dino->di_format) {

2120 case XFS_DINODE_FMT_LOCAL:

2121 err = process_lclinode(mp, agno, ino, dino, XFS_DATA_FORK);

2122 *totblocks = 0;

2123 break;

2124 case XFS_DINODE_FMT_EXTENTS:

2125 err = process_exinode(mp, agno, ino, dino, type, dirty,

2126 totblocks, nextents, dblkmap, XFS_DATA_FORK,

2127 check_dups);

2128 break;

2129 case XFS_DINODE_FMT_BTREE:

2130 err = process_btinode(mp, agno, ino, dino, type, dirty,

2131 totblocks, nextents, dblkmap, XFS_DATA_FORK,

2132 check_dups);

2133 break;

2134 case XFS_DINODE_FMT_DEV: /* fall through */

2135 err = 0;

2136 break;

2137 default:

2138 do_error(_("unknown format %d, ino %" PRIu64 " (mode = %d)\n"),

2139 dino->di_format, lino, be16_to_cpu(dino->di_mode));

2140 }

2141

2142 if (err) {

2143 do_warn(_("bad data fork in inode %" PRIu64 "\n"), lino);

2144 if (!no_modify) {

2145 *dirty += clear_dinode(mp, dino, lino);

2146 ASSERT(*dirty > 0);

2147 }

2148 return 1;

2149 }

2150

2151 if (check_dups) {

2152 /*

2153 * if check_dups was non-zero, we have to

2154 * re-process data fork to set bitmap since the

2155 * bitmap wasn't set the first time through

2156 */

2157 switch (dino->di_format) {

2158 case XFS_DINODE_FMT_LOCAL:

2159 err = process_lclinode(mp, agno, ino, dino,

2160 XFS_DATA_FORK);

2161 break;

2162 case XFS_DINODE_FMT_EXTENTS:

2163 err = process_exinode(mp, agno, ino, dino, type,

2164 dirty, totblocks, nextents, dblkmap,

2165 XFS_DATA_FORK, 0);

2166 break;

2167 case XFS_DINODE_FMT_BTREE:

2168 err = process_btinode(mp, agno, ino, dino, type,

2169 dirty, totblocks, nextents, dblkmap,

2170 XFS_DATA_FORK, 0);

2171 break;

2172 case XFS_DINODE_FMT_DEV: /* fall through */

2173 err = 0;

2174 break;

2175 default:

2176 do_error(_("unknown format %d, ino %" PRIu64 " (mode = %d)\n"),

2177 dino->di_format, lino,

2178 be16_to_cpu(dino->di_mode));

2179 }

2180

2181 if (no_modify && err != 0)

2182 return 1;

2183

2184 ASSERT(err == 0);

2185 }

2186 return 0;

2187 }

2188

2189 /*

2190 * Process extended attribute fork in inode

2191 */

2192 static int

2193 process_inode_attr_fork(

2194 xfs_mount_t *mp,

2195 xfs_agnumber_t agno,

2196 xfs_agino_t ino,

2197 xfs_dinode_t *dino,

2198 int type,

2199 int *dirty,

2200 xfs_drfsbno_t *atotblocks,

2201 __uint64_t *anextents,

2202 int check_dups,

2203 int extra_attr_check,

2204 int *retval)

2205 {

2206 xfs_ino_t lino = XFS_AGINO_TO_INO(mp, agno, ino);

2207 blkmap_t *ablkmap = NULL;

2208 int repair = 0;

2209 int err;

2210

2211 if (!XFS_DFORK_Q(dino)) {

2212 *anextents = 0;

2213 if (dino->di_aformat != XFS_DINODE_FMT_EXTENTS) {

2214 do_warn(_("bad attribute format %d in inode %" PRIu64 ", "),

2215 dino->di_aformat, lino);

2216 if (!no_modify) {

2217 do_warn(_("resetting value\n"));

2218 dino->di_aformat = XFS_DINODE_FMT_EXTENTS;

2219 *dirty = 1;

2220 } else

2221 do_warn(_("would reset value\n"));

2222 }

2223 return 0;

2224 }

2225

2226 *anextents = be16_to_cpu(dino->di_anextents);

2227 if (*anextents > be64_to_cpu(dino->di_nblocks))

2228 *anextents = 1;

2229

2230 switch (dino->di_aformat) {

2231 case XFS_DINODE_FMT_LOCAL:

2232 *anextents = 0;

2233 *atotblocks = 0;

2234 err = process_lclinode(mp, agno, ino, dino, XFS_ATTR_FORK);

2235 break;

2236 case XFS_DINODE_FMT_EXTENTS:

2237 ablkmap = blkmap_alloc(*anextents, XFS_ATTR_FORK);

2238 *anextents = 0;

2239 err = process_exinode(mp, agno, ino, dino, type, dirty,

2240 atotblocks, anextents, &ablkmap,

2241 XFS_ATTR_FORK, check_dups);

2242 break;

2243 case XFS_DINODE_FMT_BTREE:

2244 ablkmap = blkmap_alloc(*anextents, XFS_ATTR_FORK);

2245 *anextents = 0;

2246 err = process_btinode(mp, agno, ino, dino, type, dirty,

2247 atotblocks, anextents, &ablkmap,

2248 XFS_ATTR_FORK, check_dups);

2249 break;

2250 default:

2251 do_warn(_("illegal attribute format %d, ino %" PRIu64 "\n"),

2252 dino->di_aformat, lino);

2253 err = 1;

2254 break;

2255 }

2256

2257 if (err) {

2258 /*

2259 * clear the attribute fork if necessary. we can't

2260 * clear the inode because we've already put the

2261 * inode space info into the blockmap.

2262 *

2263 * XXX - put the inode onto the "move it" list and

2264 * log the the attribute scrubbing

2265 */

2266 do_warn(_("bad attribute fork in inode %" PRIu64), lino);

2267

2268 if (!no_modify) {

2269 if (delete_attr_ok) {

2270 do_warn(_(", clearing attr fork\n"));

2271 *dirty += clear_dinode_attr(mp, dino, lino);

2272 dino->di_aformat = XFS_DINODE_FMT_LOCAL;

2273 } else {

2274 do_warn("\n");

2275 *dirty += clear_dinode(mp, dino, lino);

2276 }

2277 ASSERT(*dirty > 0);

2278 } else {

2279 do_warn(_(", would clear attr fork\n"));

2280 }

2281

2282 *atotblocks = 0;

2283 *anextents = 0;

2284 blkmap_free(ablkmap);

2285 *retval = 1;

2286

2287 return delete_attr_ok ? 0 : 1;

2288 }

2289

2290 if (check_dups) {

2291 switch (dino->di_aformat) {

2292 case XFS_DINODE_FMT_LOCAL:

2293 err = process_lclinode(mp, agno, ino, dino,

2294 XFS_ATTR_FORK);

2295 break;

2296 case XFS_DINODE_FMT_EXTENTS:

2297 err = process_exinode(mp, agno, ino, dino,

2298 type, dirty, atotblocks, anextents,

2299 &ablkmap, XFS_ATTR_FORK, 0);

2300 break;

2301 case XFS_DINODE_FMT_BTREE:

2302 err = process_btinode(mp, agno, ino, dino,

2303 type, dirty, atotblocks, anextents,

2304 &ablkmap, XFS_ATTR_FORK, 0);

2305 break;

2306 default:

2307 do_error(_("illegal attribute fmt %d, ino %" PRIu64 "\n"),

2308 dino->di_aformat, lino);

2309 }

2310

2311 if (no_modify && err != 0) {

2312 blkmap_free(ablkmap);

2313 return 1;

2314 }

2315

2316 ASSERT(err == 0);

2317 }

2318

2319 /*

2320 * do attribute semantic-based consistency checks now

2321 */

2322

2323 /* get this only in phase 3, not in both phase 3 and 4 */

2324 if (extra_attr_check &&

2325 process_attributes(mp, lino, dino, ablkmap, &repair)) {

2326 do_warn(

2327 _("problem with attribute contents in inode %" PRIu64 "\n"),

2328 lino);

2329 if (!repair) {

2330 /* clear attributes if not done already */

2331 if (!no_modify) {

2332 *dirty += clear_dinode_attr(mp, dino, lino);

2333 dino->di_aformat = XFS_DINODE_FMT_LOCAL;

2334 } else {

2335 do_warn(_("would clear attr fork\n"));

2336 }

2337 *atotblocks = 0;

2338 *anextents = 0;

2339 }

2340 else {

2341 *dirty = 1; /* it's been repaired */

2342 }

2343 }

2344 blkmap_free(ablkmap);

2345 return 0;

2346 }

2347

2348 /*

2349 * check nlinks feature, if it's a version 1 inode,

2350 * just leave nlinks alone. even if it's set wrong,

2351 * it'll be reset when read in.

2352 */

2353

2354 static int

2355 process_check_inode_nlink_version(

2356 xfs_dinode_t *dino,

2357 xfs_ino_t lino)

2358 {

2359 int dirty = 0;

2360

2361 if (dino->di_version > 1 && !fs_inode_nlink) {

2362 /*

2363 * do we have a fs/inode version mismatch with a valid

2364 * version 2 inode here that has to stay version 2 or

2365 * lose links?

2366 */

2367 if (be32_to_cpu(dino->di_nlink) > XFS_MAXLINK_1) {

2368 /*

2369 * yes. are nlink inodes allowed?

2370 */

2371 if (fs_inode_nlink_allowed) {

2372 /*

2373 * yes, update status variable which will

2374 * cause sb to be updated later.

2375 */

2376 fs_inode_nlink = 1;

2377 do_warn

2378 (_("version 2 inode %" PRIu64 " claims > %u links, "),

2379 lino, XFS_MAXLINK_1);

2380 if (!no_modify) {

2381 do_warn(

2382 _("updating superblock version number\n"));

2383 } else {

2384 do_warn(

2385 _("would update superblock version number\n"));

2386 }

2387 } else {

2388 /*

2389 * no, have to convert back to onlinks

2390 * even if we lose some links

2391 */

2392 do_warn(

2393 _("WARNING: version 2 inode %" PRIu64 " claims > %u links, "),

2394 lino, XFS_MAXLINK_1);

2395 if (!no_modify) {

2396 do_warn(_("converting back to version 1,\n"

2397 "this may destroy %d links\n"),

2398 be32_to_cpu(dino->di_nlink) -

2399 XFS_MAXLINK_1);

2400

2401 dino->di_version = 1;

2402 dino->di_nlink = cpu_to_be32(XFS_MAXLINK_1);

2403 dino->di_onlink = cpu_to_be16(XFS_MAXLINK_1);

2404 dirty = 1;

2405 } else {

2406 do_warn(_("would convert back to version 1,\n"

2407 "\tthis might destroy %d links\n"),

2408 be32_to_cpu(dino->di_nlink) -

2409 XFS_MAXLINK_1);

2410 }

2411 }

2412 } else {

2413 /*

2414 * do we have a v2 inode that we could convert back

2415 * to v1 without losing any links? if we do and

2416 * we have a mismatch between superblock bits and the

2417 * version bit, alter the version bit in this case.

2418 *

2419 * the case where we lost links was handled above.

2420 */

2421 do_warn(_("found version 2 inode %" PRIu64 ", "), lino);

2422 if (!no_modify) {

2423 do_warn(_("converting back to version 1\n"));

2424 dino->di_version = 1;

2425 dino->di_onlink = cpu_to_be16(

2426 be32_to_cpu(dino->di_nlink));

2427 dirty = 1;

2428 } else {

2429 do_warn(_("would convert back to version 1\n"));

2430 }

2431 }

2432 }

2433

2434 /*

2435 * ok, if it's still a version 2 inode, it's going

2436 * to stay a version 2 inode. it should have a zero

2437 * onlink field, so clear it.

2438 */

2439 if (dino->di_version > 1 &&

2440 dino->di_onlink != 0 && fs_inode_nlink > 0) {

2441 if (!no_modify) {

2442 do_warn(

2443 _("clearing obsolete nlink field in version 2 inode %" PRIu64 ", was %d, now 0\n"),

2444 lino, be16_to_cpu(dino->di_onlink));

2445 dino->di_onlink = 0;

2446 dirty = 1;

2447 } else {

2448 do_warn(

2449 _("would clear obsolete nlink field in version 2 inode %" PRIu64 ", currently %d\n"),

2450 lino, be16_to_cpu(dino->di_onlink));

2451 }

2452 }

2453 return dirty;

2454 }

2455

2456 /*

2457 * returns 0 if the inode is ok, 1 if the inode is corrupt

2458 * check_dups can be set to 1 *only* when called by the

2459 * first pass of the duplicate block checking of phase 4.

2460 * *dirty is set > 0 if the dinode has been altered and

2461 * needs to be written out.

2462 *

2463 * for detailed, info, look at process_dinode() comments.

2464 */

2465 static int

2466 process_dinode_int(xfs_mount_t *mp,

2467 xfs_dinode_t *dino,

2468 xfs_agnumber_t agno,

2469 xfs_agino_t ino,

2470 int was_free, /* 1 if inode is currently free */

2471 int *dirty, /* out == > 0 if inode is now dirty */

2472 int *used, /* out == 1 if inode is in use */

2473 int verify_mode, /* 1 == verify but don't modify inode */

2474 int uncertain, /* 1 == inode is uncertain */

2475 int ino_discovery, /* 1 == check dirs for unknown inodes */

2476 int check_dups, /* 1 == check if inode claims

2477 * duplicate blocks */

2478 int extra_attr_check, /* 1 == do attribute format and value checks */

2479 int *isa_dir, /* out == 1 if inode is a directory */

2480 xfs_ino_t *parent) /* out -- parent if ino is a dir */

2481 {

2482 xfs_drfsbno_t totblocks = 0;

2483 xfs_drfsbno_t atotblocks = 0;

2484 int di_mode;

2485 int type;

2486 int retval = 0;

2487 __uint64_t nextents;

2488 __uint64_t anextents;

2489 xfs_ino_t lino;

2490 const int is_free = 0;

2491 const int is_used = 1;

2492 blkmap_t *dblkmap = NULL;

2493

2494 *dirty = *isa_dir = 0;

2495 *used = is_used;

2496 type = XR_INO_UNKNOWN;

2497

2498 lino = XFS_AGINO_TO_INO(mp, agno, ino);

2499 di_mode = be16_to_cpu(dino->di_mode);

2500

2501 /*

2502 * if in verify mode, don't modify the inode.

2503 *

2504 * if correcting, reset stuff that has known values

2505 *

2506 * if in uncertain mode, be silent on errors since we're

2507 * trying to find out if these are inodes as opposed

2508 * to assuming that they are. Just return the appropriate

2509 * return code in that case.

2510 *

2511 * If uncertain is set, verify_mode MUST be set.

2512 */

2513 ASSERT(uncertain == 0 || verify_mode != 0);

2514

2515 if (be16_to_cpu(dino->di_magic) != XFS_DINODE_MAGIC) {

2516 retval = 1;

2517 if (!uncertain)

2518 do_warn(_("bad magic number 0x%x on inode %" PRIu64 "%c"),

2519 be16_to_cpu(dino->di_magic), lino,

2520 verify_mode ? '\n' : ',');

2521 if (!verify_mode) {

2522 if (!no_modify) {

2523 do_warn(_(" resetting magic number\n"));

2524 dino->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);

2525 *dirty = 1;

2526 } else

2527 do_warn(_(" would reset magic number\n"));

2528 }

2529 }

2530

2531 if (!XFS_DINODE_GOOD_VERSION(dino->di_version) ||

2532 (!fs_inode_nlink && dino->di_version > 1) ||

2533 (xfs_sb_version_hascrc(&mp->m_sb) && dino->di_version < 3) ) {

2534 retval = 1;

2535 if (!uncertain)

2536 do_warn(_("bad version number 0x%x on inode %" PRIu64 "%c"),

2537 (__s8)dino->di_version, lino,

2538 verify_mode ? '\n' : ',');

2539 if (!verify_mode) {

2540 if (!no_modify) {

2541 do_warn(_(" resetting version number\n"));

2542 dino->di_version =

2543 xfs_sb_version_hascrc(&mp->m_sb) ? 3 :

2544 (fs_inode_nlink) ? 2 : 1;

2545 *dirty = 1;

2546 } else

2547 do_warn(_(" would reset version number\n"));

2548 }

2549 }

2550

2551 /*

2552 * We don't bother checking the CRC here - we cannot guarantee that when

2553 * we are called here that the inode has not already been modified in

2554 * memory and hence invalidated the CRC.

2555 */

2556 if (xfs_sb_version_hascrc(&mp->m_sb)) {

2557 if (be64_to_cpu(dino->di_ino) != lino) {

2558 if (!uncertain)

2559 do_warn(

2560 _("inode identifier %llu mismatch on inode %" PRIu64 "\n"),

2561 be64_to_cpu(dino->di_ino), lino);

2562 if (verify_mode)

2563 return 1;

2564 goto clear_bad_out;

2565 }

2566 if (platform_uuid_compare(&dino->di_uuid, &mp->m_sb.sb_uuid)) {

2567 if (!uncertain)

2568 do_warn(

2569 _("UUID mismatch on inode %" PRIu64 "\n"), lino);

2570 if (verify_mode)

2571 return 1;

2572 goto clear_bad_out;

2573 }

2574 }

2575

2576 /*

2577 * blow out of here if the inode size is < 0

2578 */

2579 if ((xfs_fsize_t)be64_to_cpu(dino->di_size) < 0) {

2580 if (!uncertain)

2581 do_warn(

2582 _("bad (negative) size %" PRId64 " on inode %" PRIu64 "\n"),

2583 (__int64_t)be64_to_cpu(dino->di_size),

2584 lino);

2585 if (verify_mode)

2586 return 1;

2587 goto clear_bad_out;

2588 }

2589

2590 /*

2591 * if not in verify mode, check to sii if the inode and imap

2592 * agree that the inode is free

2593 */

2594 if (!verify_mode && di_mode == 0) {

2595 /*

2596 * was_free value is not meaningful if we're in verify mode

2597 */

2598 if (was_free) {

2599 /*

2600 * easy case, inode free -- inode and map agree, clear

2601 * it just in case to ensure that format, etc. are

2602 * set correctly

2603 */

2604 if (!no_modify)

2605 *dirty += clear_dinode(mp, dino, lino);

2606 *used = is_free;

2607 return 0;

2608 }

2609 /*

2610 * the inode looks free but the map says it's in use.

2611 * clear the inode just to be safe and mark the inode

2612 * free.

2613 */

2614 do_warn(

2615 _("imap claims a free inode %" PRIu64 " is in use, "), lino);

2616 if (!no_modify) {

2617 do_warn(_("correcting imap and clearing inode\n"));

2618 *dirty += clear_dinode(mp, dino, lino);

2619 retval = 1;

2620 } else

2621 do_warn(_("would correct imap and clear inode\n"));

2622 *used = is_free;

2623 return retval;

2624 }

2625

2626 /*

2627 * because of the lack of any write ordering guarantee, it's

2628 * possible that the core got updated but the forks didn't.

2629 * so rather than be ambitious (and probably incorrect),

2630 * if there's an inconsistency, we get conservative and

2631 * just pitch the file. blow off checking formats of

2632 * free inodes since technically any format is legal

2633 * as we reset the inode when we re-use it.

2634 */

2635 if (di_mode != 0 && check_dinode_mode_format(dino) != 0) {

2636 if (!uncertain)

2637 do_warn(

2638 _("bad inode format in inode %" PRIu64 "\n"), lino);

2639 if (verify_mode)

2640 return 1;

2641 goto clear_bad_out;

2642 }

2643

2644 /*

2645 * check that we only have valid flags set, and those that are set make

2646 * sense.

2647 */

2648 if (dino->di_flags) {

2649 uint16_t flags = be16_to_cpu(dino->di_flags);

2650

2651 if (flags & ~XFS_DIFLAG_ANY) {

2652 if (!uncertain) {

2653 do_warn(

2654 _("Bad flags set in inode %" PRIu64 "\n"),

2655 lino);

2656 }

2657 flags &= ~XFS_DIFLAG_ANY;

2658 }

2659

2660 if (flags & (XFS_DIFLAG_REALTIME | XFS_DIFLAG_RTINHERIT)) {

2661 /* need an rt-dev! */

2662 if (!rt_name) {

2663 if (!uncertain) {

2664 do_warn(

2665 _("inode %" PRIu64 " has RT flag set but there is no RT device\n"),

2666 lino);

2667 }

2668 flags &= ~(XFS_DIFLAG_REALTIME |

2669 XFS_DIFLAG_RTINHERIT);

2670 }

2671 }

2672 if (flags & XFS_DIFLAG_NEWRTBM) {

2673 /* must be a rt bitmap inode */

2674 if (lino != mp->m_sb.sb_rbmino) {

2675 if (!uncertain) {

2676 do_warn(

2677 _("inode %" PRIu64 " not rt bitmap\n"),

2678 lino);

2679 }

2680 flags &= ~XFS_DIFLAG_NEWRTBM;

2681 }

2682 }

2683 if (flags & (XFS_DIFLAG_RTINHERIT |

2684 XFS_DIFLAG_EXTSZINHERIT |

2685 XFS_DIFLAG_PROJINHERIT |

2686 XFS_DIFLAG_NOSYMLINKS)) {

2687 /* must be a directory */

2688 if (di_mode && !S_ISDIR(di_mode)) {

2689 if (!uncertain) {

2690 do_warn(

2691 _("directory flags set on non-directory inode %" PRIu64 "\n" ),

2692 lino);

2693 }

2694 flags &= ~(XFS_DIFLAG_RTINHERIT |

2695 XFS_DIFLAG_EXTSZINHERIT |

2696 XFS_DIFLAG_PROJINHERIT |

2697 XFS_DIFLAG_NOSYMLINKS);

2698 }

2699 }

2700 if (flags & (XFS_DIFLAG_REALTIME | XFS_XFLAG_EXTSIZE)) {

2701 /* must be a file */

2702 if (di_mode && !S_ISREG(di_mode)) {

2703 if (!uncertain) {

2704 do_warn(

2705 _("file flags set on non-file inode %" PRIu64 "\n"),

2706 lino);

2707 }

2708 flags &= ~(XFS_DIFLAG_REALTIME |

2709 XFS_XFLAG_EXTSIZE);

2710 }

2711 }

2712 if (!verify_mode && flags != be16_to_cpu(dino->di_flags)) {

2713 if (!no_modify) {

2714 do_warn(_(", fixing bad flags.\n"));

2715 dino->di_flags = cpu_to_be16(flags);

2716 *dirty = 1;

2717 } else

2718 do_warn(_(", would fix bad flags.\n"));

2719 }

2720 }

2721

2722 if (verify_mode)

2723 return retval;

2724

2725 /*

2726 * clear the next unlinked field if necessary on a good

2727 * inode only during phase 4 -- when checking for inodes

2728 * referencing duplicate blocks. then it's safe because

2729 * we've done the inode discovery and have found all the inodes

2730 * we're going to find. check_dups is set to 1 only during

2731 * phase 4. Ugly.

2732 */

2733 if (check_dups && !no_modify)

2734 *dirty += clear_dinode_unlinked(mp, dino);

2735

2736 /* set type and map type info */

2737

2738 switch (di_mode & S_IFMT) {

2739 case S_IFDIR:

2740 type = XR_INO_DIR;

2741 *isa_dir = 1;

2742 break;

2743 case S_IFREG:

2744 if (be16_to_cpu(dino->di_flags) & XFS_DIFLAG_REALTIME)

2745 type = XR_INO_RTDATA;

2746 else if (lino == mp->m_sb.sb_rbmino)

2747 type = XR_INO_RTBITMAP;

2748 else if (lino == mp->m_sb.sb_rsumino)

2749 type = XR_INO_RTSUM;

2750 else

2751 type = XR_INO_DATA;

2752 break;

2753 case S_IFLNK:

2754 type = XR_INO_SYMLINK;

2755 break;

2756 case S_IFCHR:

2757 type = XR_INO_CHRDEV;

2758 break;

2759 case S_IFBLK:

2760 type = XR_INO_BLKDEV;

2761 break;

2762 case S_IFSOCK:

2763 type = XR_INO_SOCK;

2764 break;

2765 case S_IFIFO:

2766 type = XR_INO_FIFO;

2767 break;

2768 default:

2769 do_warn(_("bad inode type %#o inode %" PRIu64 "\n"),

2770 di_mode & S_IFMT, lino);

2771 goto clear_bad_out;

2772 }

2773

2774 /*

2775 * type checks for superblock inodes

2776 */

2777 if (process_check_sb_inodes(mp, dino, lino, &type, dirty) != 0)

2778 goto clear_bad_out;

2779

2780 /*

2781 * only regular files with REALTIME or EXTSIZE flags set can have

2782 * extsize set, or directories with EXTSZINHERIT.

2783 */

2784 if (be32_to_cpu(dino->di_extsize) != 0) {

2785 if ((type == XR_INO_RTDATA) ||

2786 (type == XR_INO_DIR && (be16_to_cpu(dino->di_flags) &

2787 XFS_DIFLAG_EXTSZINHERIT)) ||

2788 (type == XR_INO_DATA && (be16_to_cpu(dino->di_flags) &

2789 XFS_DIFLAG_EXTSIZE))) {

2790 /* s'okay */ ;

2791 } else {

2792 do_warn(

2793 _("bad non-zero extent size %u for non-realtime/extsize inode %" PRIu64 ", "),

2794 be32_to_cpu(dino->di_extsize), lino);

2795 if (!no_modify) {

2796 do_warn(_("resetting to zero\n"));

2797 dino->di_extsize = 0;

2798 *dirty = 1;

2799 } else

2800 do_warn(_("would reset to zero\n"));

2801 }

2802 }

2803

2804 /*

2805 * general size/consistency checks:

2806 */

2807 if (process_check_inode_sizes(mp, dino, lino, type) != 0)

2808 goto clear_bad_out;

2809

2810 /*

2811 * check for illegal values of forkoff

2812 */

2813 if (process_check_inode_forkoff(mp, dino, lino) != 0)

2814 goto clear_bad_out;

2815

2816 /*

2817 * check data fork -- if it's bad, clear the inode

2818 */

2819 if (process_inode_data_fork(mp, agno, ino, dino, type, dirty,

2820 &totblocks, &nextents, &dblkmap, check_dups) != 0)

2821 goto bad_out;

2822

2823 /*

2824 * check attribute fork if necessary. attributes are

2825 * always stored in the regular filesystem.

2826 */

2827 if (process_inode_attr_fork(mp, agno, ino, dino, type, dirty,

2828 &atotblocks, &anextents, check_dups, extra_attr_check,

2829 &retval))

2830 goto bad_out;

2831

2832 /*

2833 * enforce totblocks is 0 for misc types

2834 */

2835 if (process_misc_ino_types_blocks(totblocks, lino, type))

2836 goto clear_bad_out;

2837

2838 /*

2839 * correct space counters if required

2840 */

2841 if (process_inode_blocks_and_extents(dino, totblocks + atotblocks,

2842 nextents, anextents, lino, dirty) != 0)

2843 goto clear_bad_out;

2844

2845 /*

2846 * do any semantic type-based checking here

2847 */

2848 switch (type) {

2849 case XR_INO_DIR:

2850 if (process_dir2(mp, lino, dino, ino_discovery,

2851 dirty, "", parent, dblkmap)) {

2852 do_warn(

2853 _("problem with directory contents in inode %" PRIu64 "\n"),

2854 lino);

2855 goto clear_bad_out;

2856 }

2857 break;

2858 case XR_INO_SYMLINK:

2859 if (process_symlink(mp, lino, dino, dblkmap) != 0) {

2860 do_warn(

2861 _("problem with symbolic link in inode %" PRIu64 "\n"),

2862 lino);

2863 goto clear_bad_out;

2864 }

2865 break;

2866 default:

2867 break;

2868 }

2869

2870 blkmap_free(dblkmap);

2871

2872 /*

2873 * check nlinks feature, if it's a version 1 inode,

2874 * just leave nlinks alone. even if it's set wrong,

2875 * it'll be reset when read in.

2876 */

2877 *dirty += process_check_inode_nlink_version(dino, lino);

2878

2879 return retval;

2880

2881 clear_bad_out:

2882 if (!no_modify) {

2883 *dirty += clear_dinode(mp, dino, lino);

2884 ASSERT(*dirty > 0);

2885 }

2886 bad_out:

2887 *used = is_free;

2888 *isa_dir = 0;

2889 blkmap_free(dblkmap);

2890 return 1;

2891 }

2892

2893 /*

2894 * returns 1 if inode is used, 0 if free.

2895 * performs any necessary salvaging actions.

2896 * note that we leave the generation count alone

2897 * because nothing we could set it to would be

2898 * guaranteed to be correct so the best guess for

2899 * the correct value is just to leave it alone.

2900 *

2901 * The trick is detecting empty files. For those,

2902 * the core and the forks should all be in the "empty"

2903 * or zero-length state -- a zero or possibly minimum length

2904 * (in the case of dirs) extent list -- although inline directories

2905 * and symlinks might be handled differently. So it should be

2906 * possible to sanity check them against each other.

2907 *

2908 * If the forks are an empty extent list though, then forget it.

2909 * The file is toast anyway since we can't recover its storage.

2910 *

2911 * Parameters:

2912 * Ins:

2913 * mp -- mount structure

2914 * dino -- pointer to on-disk inode structure

2915 * agno/ino -- inode numbers

2916 * free -- whether the map thinks the inode is free (1 == free)

2917 * ino_discovery -- whether we should examine directory

2918 * contents to discover new inodes

2919 * check_dups -- whether we should check to see if the

2920 * inode references duplicate blocks

2921 * if so, we compare the inode's claimed

2922 * blocks against the contents of the

2923 * duplicate extent list but we don't

2924 * set the bitmap. If not, we set the

2925 * bitmap and try and detect multiply

2926 * claimed blocks using the bitmap.

2927 * Outs:

2928 * dirty -- whether we changed the inode (1 == yes)

2929 * used -- 1 if the inode is used, 0 if free. In no modify

2930 * mode, whether the inode should be used or free

2931 * isa_dir -- 1 if the inode is a directory, 0 if not. In

2932 * no modify mode, if the inode would be a dir or not.

2933 *

2934 * Return value -- 0 if the inode is good, 1 if it is/was corrupt

2935 */

2936

2937 int

2938 process_dinode(

2939 xfs_mount_t *mp,

2940 xfs_dinode_t *dino,

2941 xfs_agnumber_t agno,

2942 xfs_agino_t ino,

2943 int was_free,

2944 int *dirty,

2945 int *used,

2946 int ino_discovery,

2947 int check_dups,

2948 int extra_attr_check,

2949 int *isa_dir,

2950 xfs_ino_t *parent)

2951 {

2952 const int verify_mode = 0;

2953 const int uncertain = 0;

2954

2955 #ifdef XR_INODE_TRACE

2956 fprintf(stderr, _("processing inode %d/%d\n"), agno, ino);

2957 #endif

2958 return process_dinode_int(mp, dino, agno, ino, was_free, dirty, used,

2959 verify_mode, uncertain, ino_discovery,

2960 check_dups, extra_attr_check, isa_dir, parent);

2961 }

2962

2963 /*

2964 * a more cursory check, check inode core, *DON'T* check forks

2965 * this basically just verifies whether the inode is an inode

2966 * and whether or not it has been totally trashed. returns 0

2967 * if the inode passes the cursory sanity check, 1 otherwise.

2968 */

2969 int

2970 verify_dinode(

2971 xfs_mount_t *mp,

2972 xfs_dinode_t *dino,

2973 xfs_agnumber_t agno,

2974 xfs_agino_t ino)

2975 {

2976 xfs_ino_t parent;

2977 int used = 0;

2978 int dirty = 0;

2979 int isa_dir = 0;

2980 const int verify_mode = 1;

2981 const int check_dups = 0;

2982 const int ino_discovery = 0;

2983 const int uncertain = 0;

2984

2985 return process_dinode_int(mp, dino, agno, ino, 0, &dirty, &used,

2986 verify_mode, uncertain, ino_discovery,

2987 check_dups, 0, &isa_dir, &parent);

2988 }

2989

2990 /*

2991 * like above only for inode on the uncertain list. it sets

2992 * the uncertain flag which makes process_dinode_int quieter.

2993 * returns 0 if the inode passes the cursory sanity check, 1 otherwise.

2994 */

2995 int

2996 verify_uncertain_dinode(

2997 xfs_mount_t *mp,

2998 xfs_dinode_t *dino,

2999 xfs_agnumber_t agno,

3000 xfs_agino_t ino)

3001 {

3002 xfs_ino_t parent;

3003 int used = 0;

3004 int dirty = 0;

3005 int isa_dir = 0;

3006 const int verify_mode = 1;

3007 const int check_dups = 0;

3008 const int ino_discovery = 0;

3009 const int uncertain = 1;

3010

3011 return process_dinode_int(mp, dino, agno, ino, 0, &dirty, &used,

3012 verify_mode, uncertain, ino_discovery,

3013 check_dups, 0, &isa_dir, &parent);

3014 }