~ubuntu-branches/ubuntu/utopic/xfsprogs/utopic-proposed

« back to all changes in this revision

Viewing changes to db/bmap.c

• browse files at revision 9
• compare with another revision
• download diff
• download tarball
• view history from revision 9

Show diffs side-by-side

added

removed

db/bmap.c

36

36

                                     xfs_bmbt_ptr_t *pp, int nrecs);

37

37

 

38

38

static const cmdinfo_t  bmap_cmd =

39

 

        { "bmap", NULL, bmap_f, 0, 3, 0, "[-ad] [block [len]]",

40

 

          "show block map for current file", NULL };

 

39

        { "bmap", NULL, bmap_f, 0, 3, 0, N_("[-ad] [block [len]]"),

 

40

          N_("show block map for current file"), NULL };

41

41

 

42

42

void

43

43

bmap(

47

47

        int                     *nexp,

48

48

        bmap_ext_t              *bep)

49

49

{

50

 

        xfs_bmbt_block_t        *block;

 

50

        struct xfs_btree_block  *block;

51

51

        xfs_fsblock_t           bno;

52

52

        xfs_dfiloff_t           curoffset;

53

53

        xfs_dinode_t            *dip;

91

91

                bno = NULLFSBLOCK;

92

92

                rblock = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork);

93

93

                fsize = XFS_DFORK_SIZE(dip, mp, whichfork);

94

 

                pp = XFS_BTREE_PTR_ADDR(fsize, xfs_bmdr, rblock, 1,

95

 

                        XFS_BTREE_BLOCK_MAXRECS(fsize, xfs_bmdr, 0));

96

 

                kp = XFS_BTREE_KEY_ADDR(fsize, xfs_bmdr, rblock, 1,

97

 

                        XFS_BTREE_BLOCK_MAXRECS(fsize, xfs_bmdr, 0));

98

 

                bno = select_child(curoffset, kp, pp, INT_GET(rblock->bb_numrecs, ARCH_CONVERT));

 

94

                pp = XFS_BMDR_PTR_ADDR(rblock, 1, xfs_bmdr_maxrecs(mp, fsize, 0));

 

95

                kp = XFS_BMDR_KEY_ADDR(rblock, 1);

 

96

                bno = select_child(curoffset, kp, pp, 

 

97

                                        be16_to_cpu(rblock->bb_numrecs));

99

98

                for (;;) {

100

99

                        set_cur(&typtab[typ], XFS_FSB_TO_DADDR(mp, bno),

101

100

                                blkbb, DB_RING_IGN, NULL);

102

 

                        block = (xfs_bmbt_block_t *)iocur_top->data;

103

 

                        if (INT_GET(block->bb_level, ARCH_CONVERT) == 0)

 

101

                        block = (struct xfs_btree_block *)iocur_top->data;

 

102

                        if (be16_to_cpu(block->bb_level) == 0)

104

103

                                break;

105

 

                        pp = XFS_BTREE_PTR_ADDR(mp->m_sb.sb_blocksize, xfs_bmbt,

106

 

                                block, 1,

107

 

                                XFS_BTREE_BLOCK_MAXRECS(mp->m_sb.sb_blocksize,

108

 

                                        xfs_bmbt, 0));

109

 

                        kp = XFS_BTREE_KEY_ADDR(mp->m_sb.sb_blocksize, xfs_bmbt,

110

 

                                block, 1,

111

 

                                XFS_BTREE_BLOCK_MAXRECS(mp->m_sb.sb_blocksize,

112

 

                                        xfs_bmbt, 0));

 

104

                        pp = XFS_BMDR_PTR_ADDR(block, 1,

 

105

                                xfs_bmbt_maxrecs(mp, mp->m_sb.sb_blocksize, 0));

 

106

                        kp = XFS_BMDR_KEY_ADDR(block, 1);

113

107

                        bno = select_child(curoffset, kp, pp,

114

 

                                INT_GET(block->bb_numrecs, ARCH_CONVERT));

 

108

                                        be16_to_cpu(block->bb_numrecs));

115

109

                }

116

110

                for (;;) {

117

 

                        nextbno = INT_GET(block->bb_rightsib, ARCH_CONVERT);

118

 

                        nextents = INT_GET(block->bb_numrecs, ARCH_CONVERT);

119

 

                        xp = (xfs_bmbt_rec_64_t *)XFS_BTREE_REC_ADDR(

120

 

                                mp->m_sb.sb_blocksize, xfs_bmbt, block, 1,

121

 

                                XFS_BTREE_BLOCK_MAXRECS(mp->m_sb.sb_blocksize,

122

 

                                        xfs_bmbt, 1));

 

111

                        nextbno = be64_to_cpu(block->bb_u.l.bb_rightsib);

 

112

                        nextents = be16_to_cpu(block->bb_numrecs);

 

113

                        xp = (xfs_bmbt_rec_64_t *)

 

114

                                XFS_BMBT_REC_ADDR(mp, block, 1);

123

115

                        for (ep = xp; ep < &xp[nextents] && n < nex; ep++) {

124

116

                                if (!bmap_one_extent(ep, &curoffset, eoffset,

125

117

                                                &n, bep)) {

132

124

                                break;

133

125

                        set_cur(&typtab[typ], XFS_FSB_TO_DADDR(mp, bno),

134

126

                                blkbb, DB_RING_IGN, NULL);

135

 

                        block = (xfs_bmbt_block_t *)iocur_top->data;

 

127

                        block = (struct xfs_btree_block *)iocur_top->data;

136

128

                }

137

129

                pop_cur();

138

130

        }

158

150

        int             whichfork;

159

151

 

160

152

        if (iocur_top->ino == NULLFSINO) {

161

 

                dbprintf("no current inode\n");

 

153

                dbprintf(_("no current inode\n"));

162

154

                return 0;

163

155

        }

164

156

        optind = 0;

171

163

                        dfork = 1;

172

164

                        break;

173

165

                default:

174

 

                        dbprintf("bad option for bmap command\n");

 

166

                        dbprintf(_("bad option for bmap command\n"));

175

167

                        return 0;

176

168

                }

177

169

        }

179

171

                push_cur();

180

172

                set_cur_inode(iocur_top->ino);

181

173

                dip = iocur_top->data;

182

 

                if (INT_GET(dip->di_core.di_nextents, ARCH_CONVERT))

 

174

                if (be32_to_cpu(dip->di_core.di_nextents))

183

175

                        dfork = 1;

184

 

                if (INT_GET(dip->di_core.di_anextents, ARCH_CONVERT))

 

176

                if (be16_to_cpu(dip->di_core.di_anextents))

185

177

                        afork = 1;

186

178

                pop_cur();

187

179

        }

188

180

        if (optind < argc) {

189

181

                co = (xfs_dfiloff_t)strtoull(argv[optind], &p, 0);

190

182

                if (*p != '\0') {

191

 

                        dbprintf("bad block number for bmap %s\n",

 

183

                        dbprintf(_("bad block number for bmap %s\n"),

192

184

                                argv[optind]);

193

185

                        return 0;

194

186

                }

196

188

                if (optind < argc) {

197

189

                        len = (xfs_dfilblks_t)strtoull(argv[optind], &p, 0);

198

190

                        if (*p != '\0') {

199

 

                                dbprintf("bad len for bmap %s\n", argv[optind]);

 

191

                                dbprintf(_("bad len for bmap %s\n"), argv[optind]);

200

192

                                return 0;

201

193

                        }

202

194

                        eo = co + len - 1;

219

211

                        bmap(co, eo - co + 1, whichfork, &nex, &be);

220

212

                        if (nex == 0)

221

213

                                break;

222

 

                        dbprintf("%s offset %lld startblock %llu (%u/%u) count "

223

 

                                 "%llu flag %u\n",

224

 

                                whichfork == XFS_DATA_FORK ? "data" : "attr",

 

214

                        dbprintf(_("%s offset %lld startblock %llu (%u/%u) count "

 

215

                                 "%llu flag %u\n"),

 

216

                                whichfork == XFS_DATA_FORK ? _("data") : _("attr"),

225

217

                                be.startoff, be.startblock,

226

218

                                XFS_FSB_TO_AGNO(mp, be.startblock),

227

219

                                XFS_FSB_TO_AGBNO(mp, be.startblock),

285

277

        xfs_dfilblks_t          *cp,

286

278

        int                     *fp)

287

279

{

288

 

        xfs_bmbt_irec_t irec, *s = &irec;

289

 

        xfs_bmbt_rec_t rpcopy, *p = &rpcopy;

290

 

 

291

 

        memmove(&rpcopy, rp, sizeof(rpcopy));

292

 

        libxfs_bmbt_disk_get_all(p, s);

293

 

 

294

 

        if (s->br_state == XFS_EXT_UNWRITTEN) {

295

 

                *fp = 1;

296

 

        } else {

297

 

                *fp = 0;

298

 

        }

299

 

 

300

 

        *op = s->br_startoff;

301

 

        *sp = s->br_startblock;

302

 

        *cp = s->br_blockcount;

 

280

        xfs_bmbt_irec_t         irec;

 

281

 

 

282

        libxfs_bmbt_disk_get_all(rp, &irec);

 

283

 

 

284

        *fp = irec.br_state == XFS_EXT_UNWRITTEN;

 

285

        *op = irec.br_startoff;

 

286

        *sp = irec.br_startblock;

 

287

        *cp = irec.br_blockcount;

303

288

}

304

289

 

305

290

void

334

319

        int             i;

335

320

 

336

321

        for (i = 0; i < nrecs; i++) {

337

 

                if (INT_GET(kp[i].br_startoff, ARCH_CONVERT) == off)

338

 

                        return INT_GET(pp[i], ARCH_CONVERT);

339

 

                if (INT_GET(kp[i].br_startoff, ARCH_CONVERT) > off) {

 

322

                if (be64_to_cpu(kp[i].br_startoff) == off)

 

323

                        return be64_to_cpu(pp[i]);

 

324

                if (be64_to_cpu(kp[i].br_startoff) > off) {

340

325

                        if (i == 0)

341

 

                                return INT_GET(pp[i], ARCH_CONVERT);

 

326

                                return be64_to_cpu(pp[i]);

342

327

                        else

343

 

                                return INT_GET(pp[i - 1], ARCH_CONVERT);

 

328

                                return be64_to_cpu(pp[i - 1]);

344

329

                }

345

330

        }

346

 

        return INT_GET(pp[nrecs - 1], ARCH_CONVERT);

 

331

        return be64_to_cpu(pp[nrecs - 1]);

347

332

}

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1