Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
4 : * All Rights Reserved.
5 : */
6 : #include "xfs.h"
7 : #include "xfs_fs.h"
8 : #include "xfs_shared.h"
9 : #include "xfs_format.h"
10 : #include "xfs_log_format.h"
11 : #include "xfs_trans_resv.h"
12 : #include "xfs_mount.h"
13 : #include "xfs_inode.h"
14 : #include "xfs_btree.h"
15 : #include "xfs_ialloc.h"
16 : #include "xfs_ialloc_btree.h"
17 : #include "xfs_iwalk.h"
18 : #include "xfs_itable.h"
19 : #include "xfs_error.h"
20 : #include "xfs_icache.h"
21 : #include "xfs_health.h"
22 : #include "xfs_trans.h"
23 :
24 : /*
25 : * Bulk Stat
26 : * =========
27 : *
28 : * Use the inode walking functions to fill out struct xfs_bulkstat for every
29 : * allocated inode, then pass the stat information to some externally provided
30 : * iteration function.
31 : */
32 :
33 : struct xfs_bstat_chunk {
34 : bulkstat_one_fmt_pf formatter;
35 : struct xfs_ibulk *breq;
36 : struct xfs_bulkstat *buf;
37 : };
38 :
39 : /*
40 : * Fill out the bulkstat info for a single inode and report it somewhere.
41 : *
42 : * bc->breq->lastino is effectively the inode cursor as we walk through the
43 : * filesystem. Therefore, we update it any time we need to move the cursor
44 : * forward, regardless of whether or not we're sending any bstat information
45 : * back to userspace. If the inode is internal metadata or, has been freed
46 : * out from under us, we just simply keep going.
47 : *
48 : * However, if any other type of error happens we want to stop right where we
49 : * are so that userspace will call back with exact number of the bad inode and
50 : * we can send back an error code.
51 : *
52 : * Note that if the formatter tells us there's no space left in the buffer we
53 : * move the cursor forward and abort the walk.
54 : */
55 : STATIC int
56 46742901574 : xfs_bulkstat_one_int(
57 : struct xfs_mount *mp,
58 : struct mnt_idmap *idmap,
59 : struct xfs_trans *tp,
60 : xfs_ino_t ino,
61 : struct xfs_bstat_chunk *bc)
62 : {
63 46742901574 : struct user_namespace *sb_userns = mp->m_super->s_user_ns;
64 46742901574 : struct xfs_inode *ip; /* incore inode pointer */
65 46742901574 : struct inode *inode;
66 46742901574 : struct xfs_bulkstat *buf = bc->buf;
67 46742901574 : xfs_extnum_t nextents;
68 46742901574 : int error = -EINVAL;
69 46742901574 : vfsuid_t vfsuid;
70 46742901574 : vfsgid_t vfsgid;
71 :
72 46742901574 : if (xfs_internal_inum(mp, ino))
73 7606740 : goto out_advance;
74 :
75 47033771881 : error = xfs_iget(mp, tp, ino,
76 : (XFS_IGET_DONTCACHE | XFS_IGET_UNTRUSTED),
77 : XFS_ILOCK_SHARED, &ip);
78 46685741384 : if (error == -ENOENT || error == -EINVAL)
79 1090050 : goto out_advance;
80 46684651334 : if (error)
81 2249 : goto out;
82 :
83 46684649085 : ASSERT(ip != NULL);
84 46684649085 : ASSERT(ip->i_imap.im_blkno != 0);
85 46684649085 : inode = VFS_I(ip);
86 46684649085 : vfsuid = i_uid_into_vfsuid(idmap, inode);
87 47010666092 : vfsgid = i_gid_into_vfsgid(idmap, inode);
88 :
89 : /* xfs_iget returns the following without needing
90 : * further change.
91 : */
92 47010343111 : buf->bs_projectid = ip->i_projid;
93 47010343111 : buf->bs_ino = ino;
94 47010343111 : buf->bs_uid = from_kuid(sb_userns, vfsuid_into_kuid(vfsuid));
95 47021330429 : buf->bs_gid = from_kgid(sb_userns, vfsgid_into_kgid(vfsgid));
96 46673257220 : buf->bs_size = ip->i_disk_size;
97 :
98 46673257220 : buf->bs_nlink = inode->i_nlink;
99 46673257220 : buf->bs_atime = inode->i_atime.tv_sec;
100 46673257220 : buf->bs_atime_nsec = inode->i_atime.tv_nsec;
101 46673257220 : buf->bs_mtime = inode->i_mtime.tv_sec;
102 46673257220 : buf->bs_mtime_nsec = inode->i_mtime.tv_nsec;
103 46673257220 : buf->bs_ctime = inode->i_ctime.tv_sec;
104 46673257220 : buf->bs_ctime_nsec = inode->i_ctime.tv_nsec;
105 46673257220 : buf->bs_gen = inode->i_generation;
106 46673257220 : buf->bs_mode = inode->i_mode;
107 :
108 46673257220 : buf->bs_xflags = xfs_ip2xflags(ip);
109 46883699554 : buf->bs_extsize_blks = ip->i_extsize;
110 :
111 46883699554 : nextents = xfs_ifork_nextents(&ip->i_df);
112 46883699554 : if (!(bc->breq->flags & XFS_IBULK_NREXT64))
113 46442605231 : buf->bs_extents = min(nextents, XFS_MAX_EXTCNT_DATA_FORK_SMALL);
114 : else
115 441094323 : buf->bs_extents64 = nextents;
116 :
117 46883699554 : xfs_bulkstat_health(ip, buf);
118 47073323550 : buf->bs_aextents = xfs_ifork_nextents(&ip->i_af);
119 47073323550 : buf->bs_forkoff = xfs_inode_fork_boff(ip);
120 47073323550 : buf->bs_version = XFS_BULKSTAT_VERSION_V5;
121 :
122 47073323550 : if (xfs_has_v3inodes(mp)) {
123 46643699704 : buf->bs_btime = ip->i_crtime.tv_sec;
124 46643699704 : buf->bs_btime_nsec = ip->i_crtime.tv_nsec;
125 46643699704 : if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
126 5856 : buf->bs_cowextsize_blks = ip->i_cowextsize;
127 : }
128 :
129 47073323550 : switch (ip->i_df.if_format) {
130 17584787738 : case XFS_DINODE_FMT_DEV:
131 17584787738 : buf->bs_rdev = sysv_encode_dev(inode->i_rdev);
132 17584787738 : buf->bs_blksize = BLKDEV_IOSIZE;
133 17584787738 : buf->bs_blocks = 0;
134 17584787738 : break;
135 9834067901 : case XFS_DINODE_FMT_LOCAL:
136 9834067901 : buf->bs_rdev = 0;
137 9834067901 : buf->bs_blksize = mp->m_sb.sb_blocksize;
138 9834067901 : buf->bs_blocks = 0;
139 9834067901 : break;
140 19654467911 : case XFS_DINODE_FMT_EXTENTS:
141 : case XFS_DINODE_FMT_BTREE:
142 19654467911 : buf->bs_rdev = 0;
143 19654467911 : buf->bs_blksize = mp->m_sb.sb_blocksize;
144 19654467911 : buf->bs_blocks = ip->i_nblocks + ip->i_delayed_blks;
145 19654467911 : break;
146 : }
147 47073323550 : xfs_iunlock(ip, XFS_ILOCK_SHARED);
148 47031503495 : xfs_irele(ip);
149 :
150 46940523723 : error = bc->formatter(bc->breq, buf);
151 46945797337 : if (error == -ECANCELED)
152 318220792 : goto out_advance;
153 46627576545 : if (error)
154 0 : goto out;
155 :
156 46627576545 : out_advance:
157 : /*
158 : * Advance the cursor to the inode that comes after the one we just
159 : * looked at. We want the caller to move along if the bulkstat
160 : * information was copied successfully; if we tried to grab the inode
161 : * but it's no longer allocated; or if it's internal metadata.
162 : */
163 46954494127 : bc->breq->startino = ino + 1;
164 46954496376 : out:
165 46954496376 : return error;
166 : }
167 :
168 : /* Bulkstat a single inode. */
169 : int
170 935561 : xfs_bulkstat_one(
171 : struct xfs_ibulk *breq,
172 : bulkstat_one_fmt_pf formatter)
173 : {
174 935561 : struct xfs_bstat_chunk bc = {
175 : .formatter = formatter,
176 : .breq = breq,
177 : };
178 935561 : struct xfs_trans *tp;
179 935561 : int error;
180 :
181 935561 : if (breq->idmap != &nop_mnt_idmap) {
182 0 : xfs_warn_ratelimited(breq->mp,
183 : "bulkstat not supported inside of idmapped mounts.");
184 0 : return -EINVAL;
185 : }
186 :
187 935561 : ASSERT(breq->icount == 1);
188 :
189 935561 : bc.buf = kmem_zalloc(sizeof(struct xfs_bulkstat),
190 : KM_MAYFAIL);
191 935561 : if (!bc.buf)
192 : return -ENOMEM;
193 :
194 : /*
195 : * Grab an empty transaction so that we can use its recursive buffer
196 : * locking abilities to detect cycles in the inobt without deadlocking.
197 : */
198 935561 : error = xfs_trans_alloc_empty(breq->mp, &tp);
199 935560 : if (error)
200 0 : goto out;
201 :
202 935560 : error = xfs_bulkstat_one_int(breq->mp, breq->idmap, tp,
203 : breq->startino, &bc);
204 935561 : xfs_trans_cancel(tp);
205 935560 : out:
206 935560 : kmem_free(bc.buf);
207 :
208 : /*
209 : * If we reported one inode to userspace then we abort because we hit
210 : * the end of the buffer. Don't leak that back to userspace.
211 : */
212 935558 : if (error == -ECANCELED)
213 446518 : error = 0;
214 :
215 : return error;
216 : }
217 :
218 : static int
219 46993099038 : xfs_bulkstat_iwalk(
220 : struct xfs_mount *mp,
221 : struct xfs_trans *tp,
222 : xfs_ino_t ino,
223 : void *data)
224 : {
225 46993099038 : struct xfs_bstat_chunk *bc = data;
226 46993099038 : int error;
227 :
228 46993099038 : error = xfs_bulkstat_one_int(mp, bc->breq->idmap, tp, ino, data);
229 : /* bulkstat just skips over missing inodes */
230 47015985427 : if (error == -ENOENT || error == -EINVAL)
231 8207746 : return 0;
232 : return error;
233 : }
234 :
235 : /*
236 : * Check the incoming lastino parameter.
237 : *
238 : * We allow any inode value that could map to physical space inside the
239 : * filesystem because if there are no inodes there, bulkstat moves on to the
240 : * next chunk. In other words, the magic agino value of zero takes us to the
241 : * first chunk in the AG, and an agino value past the end of the AG takes us to
242 : * the first chunk in the next AG.
243 : *
244 : * Therefore we can end early if the requested inode is beyond the end of the
245 : * filesystem or doesn't map properly.
246 : */
247 : static inline bool
248 329529380 : xfs_bulkstat_already_done(
249 : struct xfs_mount *mp,
250 : xfs_ino_t startino)
251 : {
252 329529380 : xfs_agnumber_t agno = XFS_INO_TO_AGNO(mp, startino);
253 329529380 : xfs_agino_t agino = XFS_INO_TO_AGINO(mp, startino);
254 :
255 329529380 : return agno >= mp->m_sb.sb_agcount ||
256 329529410 : startino != XFS_AGINO_TO_INO(mp, agno, agino);
257 : }
258 :
259 : /* Return stat information in bulk (by-inode) for the filesystem. */
260 : int
261 319825096 : xfs_bulkstat(
262 : struct xfs_ibulk *breq,
263 : bulkstat_one_fmt_pf formatter)
264 : {
265 319825096 : struct xfs_bstat_chunk bc = {
266 : .formatter = formatter,
267 : .breq = breq,
268 : };
269 319825096 : struct xfs_trans *tp;
270 319825096 : unsigned int iwalk_flags = 0;
271 319825096 : int error;
272 :
273 319825096 : if (breq->idmap != &nop_mnt_idmap) {
274 0 : xfs_warn_ratelimited(breq->mp,
275 : "bulkstat not supported inside of idmapped mounts.");
276 0 : return -EINVAL;
277 : }
278 319825096 : if (xfs_bulkstat_already_done(breq->mp, breq->startino))
279 : return 0;
280 :
281 319834456 : bc.buf = kmem_zalloc(sizeof(struct xfs_bulkstat),
282 : KM_MAYFAIL);
283 319832237 : if (!bc.buf)
284 : return -ENOMEM;
285 :
286 : /*
287 : * Grab an empty transaction so that we can use its recursive buffer
288 : * locking abilities to detect cycles in the inobt without deadlocking.
289 : */
290 319832237 : error = xfs_trans_alloc_empty(breq->mp, &tp);
291 319833284 : if (error)
292 0 : goto out;
293 :
294 319833284 : if (breq->flags & XFS_IBULK_SAME_AG)
295 15952 : iwalk_flags |= XFS_IWALK_SAME_AG;
296 :
297 319833284 : error = xfs_iwalk(breq->mp, tp, breq->startino, iwalk_flags,
298 : xfs_bulkstat_iwalk, breq->icount, &bc);
299 319834839 : xfs_trans_cancel(tp);
300 319841589 : out:
301 319841589 : kmem_free(bc.buf);
302 :
303 : /*
304 : * We found some inodes, so clear the error status and return them.
305 : * The lastino pointer will point directly at the inode that triggered
306 : * any error that occurred, so on the next call the error will be
307 : * triggered again and propagated to userspace as there will be no
308 : * formatted inodes in the buffer.
309 : */
310 319821724 : if (breq->ocount > 0)
311 318931239 : error = 0;
312 :
313 : return error;
314 : }
315 :
316 : /* Convert bulkstat (v5) to bstat (v1). */
317 : void
318 46518557487 : xfs_bulkstat_to_bstat(
319 : struct xfs_mount *mp,
320 : struct xfs_bstat *bs1,
321 : const struct xfs_bulkstat *bstat)
322 : {
323 : /* memset is needed here because of padding holes in the structure. */
324 46518557487 : memset(bs1, 0, sizeof(struct xfs_bstat));
325 46518557487 : bs1->bs_ino = bstat->bs_ino;
326 46518557487 : bs1->bs_mode = bstat->bs_mode;
327 46518557487 : bs1->bs_nlink = bstat->bs_nlink;
328 46518557487 : bs1->bs_uid = bstat->bs_uid;
329 46518557487 : bs1->bs_gid = bstat->bs_gid;
330 46518557487 : bs1->bs_rdev = bstat->bs_rdev;
331 46518557487 : bs1->bs_blksize = bstat->bs_blksize;
332 46518557487 : bs1->bs_size = bstat->bs_size;
333 46518557487 : bs1->bs_atime.tv_sec = bstat->bs_atime;
334 46518557487 : bs1->bs_mtime.tv_sec = bstat->bs_mtime;
335 46518557487 : bs1->bs_ctime.tv_sec = bstat->bs_ctime;
336 46518557487 : bs1->bs_atime.tv_nsec = bstat->bs_atime_nsec;
337 46518557487 : bs1->bs_mtime.tv_nsec = bstat->bs_mtime_nsec;
338 46518557487 : bs1->bs_ctime.tv_nsec = bstat->bs_ctime_nsec;
339 46518557487 : bs1->bs_blocks = bstat->bs_blocks;
340 46518557487 : bs1->bs_xflags = bstat->bs_xflags;
341 46518557487 : bs1->bs_extsize = XFS_FSB_TO_B(mp, bstat->bs_extsize_blks);
342 46518557487 : bs1->bs_extents = bstat->bs_extents;
343 46518557487 : bs1->bs_gen = bstat->bs_gen;
344 46518557487 : bs1->bs_projid_lo = bstat->bs_projectid & 0xFFFF;
345 46518557487 : bs1->bs_forkoff = bstat->bs_forkoff;
346 46518557487 : bs1->bs_projid_hi = bstat->bs_projectid >> 16;
347 46518557487 : bs1->bs_sick = bstat->bs_sick;
348 46518557487 : bs1->bs_checked = bstat->bs_checked;
349 46518557487 : bs1->bs_cowextsize = XFS_FSB_TO_B(mp, bstat->bs_cowextsize_blks);
350 46518557487 : bs1->bs_dmevmask = 0;
351 46518557487 : bs1->bs_dmstate = 0;
352 46518557487 : bs1->bs_aextents = bstat->bs_aextents;
353 46518557487 : }
354 :
355 : struct xfs_inumbers_chunk {
356 : inumbers_fmt_pf formatter;
357 : struct xfs_ibulk *breq;
358 : };
359 :
360 : /*
361 : * INUMBERS
362 : * ========
363 : * This is how we export inode btree records to userspace, so that XFS tools
364 : * can figure out where inodes are allocated.
365 : */
366 :
367 : /*
368 : * Format the inode group structure and report it somewhere.
369 : *
370 : * Similar to xfs_bulkstat_one_int, lastino is the inode cursor as we walk
371 : * through the filesystem so we move it forward unless there was a runtime
372 : * error. If the formatter tells us the buffer is now full we also move the
373 : * cursor forward and abort the walk.
374 : */
375 : STATIC int
376 12411084 : xfs_inumbers_walk(
377 : struct xfs_mount *mp,
378 : struct xfs_trans *tp,
379 : xfs_agnumber_t agno,
380 : const struct xfs_inobt_rec_incore *irec,
381 : void *data)
382 : {
383 24822168 : struct xfs_inumbers inogrp = {
384 12411084 : .xi_startino = XFS_AGINO_TO_INO(mp, agno, irec->ir_startino),
385 12411084 : .xi_alloccount = irec->ir_count - irec->ir_freecount,
386 12411084 : .xi_allocmask = ~irec->ir_free,
387 : .xi_version = XFS_INUMBERS_VERSION_V5,
388 : };
389 12411084 : struct xfs_inumbers_chunk *ic = data;
390 12411084 : int error;
391 :
392 12411084 : error = ic->formatter(ic->breq, &inogrp);
393 12409839 : if (error && error != -ECANCELED)
394 : return error;
395 :
396 12409839 : ic->breq->startino = XFS_AGINO_TO_INO(mp, agno, irec->ir_startino) +
397 : XFS_INODES_PER_CHUNK;
398 12409839 : return error;
399 : }
400 :
401 : /*
402 : * Return inode number table for the filesystem.
403 : */
404 : int
405 9697195 : xfs_inumbers(
406 : struct xfs_ibulk *breq,
407 : inumbers_fmt_pf formatter)
408 : {
409 9697195 : struct xfs_inumbers_chunk ic = {
410 : .formatter = formatter,
411 : .breq = breq,
412 : };
413 9697195 : struct xfs_trans *tp;
414 9697195 : int error = 0;
415 :
416 9697195 : if (xfs_bulkstat_already_done(breq->mp, breq->startino))
417 : return 0;
418 :
419 : /*
420 : * Grab an empty transaction so that we can use its recursive buffer
421 : * locking abilities to detect cycles in the inobt without deadlocking.
422 : */
423 9696197 : error = xfs_trans_alloc_empty(breq->mp, &tp);
424 9694577 : if (error)
425 0 : goto out;
426 :
427 9694577 : error = xfs_inobt_walk(breq->mp, tp, breq->startino, breq->flags,
428 : xfs_inumbers_walk, breq->icount, &ic);
429 9698029 : xfs_trans_cancel(tp);
430 9697645 : out:
431 :
432 : /*
433 : * We found some inode groups, so clear the error status and return
434 : * them. The lastino pointer will point directly at the inode that
435 : * triggered any error that occurred, so on the next call the error
436 : * will be triggered again and propagated to userspace as there will be
437 : * no formatted inode groups in the buffer.
438 : */
439 9697645 : if (breq->ocount > 0)
440 8054678 : error = 0;
441 :
442 : return error;
443 : }
444 :
445 : /* Convert an inumbers (v5) struct to a inogrp (v1) struct. */
446 : void
447 12764 : xfs_inumbers_to_inogrp(
448 : struct xfs_inogrp *ig1,
449 : const struct xfs_inumbers *ig)
450 : {
451 : /* memset is needed here because of padding holes in the structure. */
452 12764 : memset(ig1, 0, sizeof(struct xfs_inogrp));
453 12764 : ig1->xi_startino = ig->xi_startino;
454 12764 : ig1->xi_alloccount = ig->xi_alloccount;
455 12764 : ig1->xi_allocmask = ig->xi_allocmask;
456 12764 : }
|
