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 52199914649 : 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 52199914649 : struct user_namespace *sb_userns = mp->m_super->s_user_ns;
64 52199914649 : struct xfs_inode *ip; /* incore inode pointer */
65 52199914649 : struct inode *inode;
66 52199914649 : struct xfs_bulkstat *buf = bc->buf;
67 52199914649 : xfs_extnum_t nextents;
68 52199914649 : int error = -EINVAL;
69 52199914649 : vfsuid_t vfsuid;
70 52199914649 : vfsgid_t vfsgid;
71 :
72 52199914649 : if (xfs_internal_inum(mp, ino))
73 8953954 : goto out_advance;
74 :
75 51814612847 : error = xfs_iget(mp, tp, ino,
76 : (XFS_IGET_DONTCACHE | XFS_IGET_UNTRUSTED),
77 : XFS_ILOCK_SHARED, &ip);
78 53410019992 : if (error == -ENOENT || error == -EINVAL)
79 1918336 : goto out_advance;
80 53408101656 : if (error)
81 3266 : goto out;
82 :
83 53408098390 : ASSERT(ip != NULL);
84 53408098390 : ASSERT(ip->i_imap.im_blkno != 0);
85 53408098390 : inode = VFS_I(ip);
86 53408098390 : vfsuid = i_uid_into_vfsuid(idmap, inode);
87 52258186860 : vfsgid = i_gid_into_vfsgid(idmap, inode);
88 :
89 : /* xfs_iget returns the following without needing
90 : * further change.
91 : */
92 52524803625 : buf->bs_projectid = ip->i_projid;
93 52524803625 : buf->bs_ino = ino;
94 52524803625 : buf->bs_uid = from_kuid(sb_userns, vfsuid_into_kuid(vfsuid));
95 52555370936 : buf->bs_gid = from_kgid(sb_userns, vfsgid_into_kgid(vfsgid));
96 52739799055 : buf->bs_size = ip->i_disk_size;
97 :
98 52739799055 : buf->bs_nlink = inode->i_nlink;
99 52739799055 : buf->bs_atime = inode->i_atime.tv_sec;
100 52739799055 : buf->bs_atime_nsec = inode->i_atime.tv_nsec;
101 52739799055 : buf->bs_mtime = inode->i_mtime.tv_sec;
102 52739799055 : buf->bs_mtime_nsec = inode->i_mtime.tv_nsec;
103 52739799055 : buf->bs_ctime = inode->i_ctime.tv_sec;
104 52739799055 : buf->bs_ctime_nsec = inode->i_ctime.tv_nsec;
105 52739799055 : buf->bs_gen = inode->i_generation;
106 52739799055 : buf->bs_mode = inode->i_mode;
107 :
108 52739799055 : buf->bs_xflags = xfs_ip2xflags(ip);
109 51861176616 : buf->bs_extsize_blks = ip->i_extsize;
110 :
111 51861176616 : nextents = xfs_ifork_nextents(&ip->i_df);
112 51861176616 : if (!(bc->breq->flags & XFS_IBULK_NREXT64))
113 51282292281 : buf->bs_extents = min(nextents, XFS_MAX_EXTCNT_DATA_FORK_SMALL);
114 : else
115 578884335 : buf->bs_extents64 = nextents;
116 :
117 51861176616 : xfs_bulkstat_health(ip, buf);
118 53248055989 : buf->bs_aextents = xfs_ifork_nextents(&ip->i_af);
119 53248055989 : buf->bs_forkoff = xfs_inode_fork_boff(ip);
120 53248055989 : buf->bs_version = XFS_BULKSTAT_VERSION_V5;
121 :
122 53248055989 : if (xfs_has_v3inodes(mp)) {
123 53027059955 : buf->bs_btime = ip->i_crtime.tv_sec;
124 53027059955 : buf->bs_btime_nsec = ip->i_crtime.tv_nsec;
125 53027059955 : if (ip->i_diflags2 & XFS_DIFLAG2_COWEXTSIZE)
126 21763 : buf->bs_cowextsize_blks = ip->i_cowextsize;
127 : }
128 :
129 53248055989 : switch (ip->i_df.if_format) {
130 19518473447 : case XFS_DINODE_FMT_DEV:
131 19518473447 : buf->bs_rdev = sysv_encode_dev(inode->i_rdev);
132 19518473447 : buf->bs_blksize = BLKDEV_IOSIZE;
133 19518473447 : buf->bs_blocks = 0;
134 19518473447 : break;
135 11058804215 : case XFS_DINODE_FMT_LOCAL:
136 11058804215 : buf->bs_rdev = 0;
137 11058804215 : buf->bs_blksize = mp->m_sb.sb_blocksize;
138 11058804215 : buf->bs_blocks = 0;
139 11058804215 : break;
140 22670778327 : case XFS_DINODE_FMT_EXTENTS:
141 : case XFS_DINODE_FMT_BTREE:
142 22670778327 : buf->bs_rdev = 0;
143 22670778327 : buf->bs_blksize = mp->m_sb.sb_blocksize;
144 22670778327 : buf->bs_blocks = ip->i_nblocks + ip->i_delayed_blks;
145 22670778327 : break;
146 : }
147 53248055989 : xfs_iunlock(ip, XFS_ILOCK_SHARED);
148 51618660298 : xfs_irele(ip);
149 :
150 52932303546 : error = bc->formatter(bc->breq, buf);
151 51960191863 : if (error == -ECANCELED)
152 366992698 : goto out_advance;
153 51593199165 : if (error)
154 0 : goto out;
155 :
156 51593199165 : 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 51971064153 : bc->breq->startino = ino + 1;
164 51971067419 : out:
165 51971067419 : return error;
166 : }
167 :
168 : /* Bulkstat a single inode. */
169 : int
170 1485595 : xfs_bulkstat_one(
171 : struct xfs_ibulk *breq,
172 : bulkstat_one_fmt_pf formatter)
173 : {
174 1485595 : struct xfs_bstat_chunk bc = {
175 : .formatter = formatter,
176 : .breq = breq,
177 : };
178 1485595 : struct xfs_trans *tp;
179 1485595 : int error;
180 :
181 1485595 : 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 1485595 : ASSERT(breq->icount == 1);
188 :
189 1485595 : bc.buf = kmem_zalloc(sizeof(struct xfs_bulkstat),
190 : KM_MAYFAIL);
191 1485599 : 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 1485599 : error = xfs_trans_alloc_empty(breq->mp, &tp);
199 1485652 : if (error)
200 0 : goto out;
201 :
202 1485652 : error = xfs_bulkstat_one_int(breq->mp, breq->idmap, tp,
203 : breq->startino, &bc);
204 1485686 : xfs_trans_cancel(tp);
205 1485741 : out:
206 1485741 : 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 1485727 : if (error == -ECANCELED)
213 725214 : error = 0;
214 :
215 : return error;
216 : }
217 :
218 : static int
219 52036193374 : xfs_bulkstat_iwalk(
220 : struct xfs_mount *mp,
221 : struct xfs_trans *tp,
222 : xfs_ino_t ino,
223 : void *data)
224 : {
225 52036193374 : struct xfs_bstat_chunk *bc = data;
226 52036193374 : int error;
227 :
228 52036193374 : error = xfs_bulkstat_one_int(mp, bc->breq->idmap, tp, ino, data);
229 : /* bulkstat just skips over missing inodes */
230 52164035550 : if (error == -ENOENT || error == -EINVAL)
231 10111780 : 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 381294108 : xfs_bulkstat_already_done(
249 : struct xfs_mount *mp,
250 : xfs_ino_t startino)
251 : {
252 381294108 : xfs_agnumber_t agno = XFS_INO_TO_AGNO(mp, startino);
253 381294108 : xfs_agino_t agino = XFS_INO_TO_AGINO(mp, startino);
254 :
255 381294108 : return agno >= mp->m_sb.sb_agcount ||
256 381283516 : startino != XFS_AGINO_TO_INO(mp, agno, agino);
257 : }
258 :
259 : /* Return stat information in bulk (by-inode) for the filesystem. */
260 : int
261 369272531 : xfs_bulkstat(
262 : struct xfs_ibulk *breq,
263 : bulkstat_one_fmt_pf formatter)
264 : {
265 369272531 : struct xfs_bstat_chunk bc = {
266 : .formatter = formatter,
267 : .breq = breq,
268 : };
269 369272531 : struct xfs_trans *tp;
270 369272531 : unsigned int iwalk_flags = 0;
271 369272531 : int error;
272 :
273 369272531 : 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 369272531 : if (xfs_bulkstat_already_done(breq->mp, breq->startino))
279 : return 0;
280 :
281 369275216 : bc.buf = kmem_zalloc(sizeof(struct xfs_bulkstat),
282 : KM_MAYFAIL);
283 369327687 : 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 369327687 : error = xfs_trans_alloc_empty(breq->mp, &tp);
291 369288086 : if (error)
292 0 : goto out;
293 :
294 369288086 : if (breq->flags & XFS_IBULK_SAME_AG)
295 87736 : iwalk_flags |= XFS_IWALK_SAME_AG;
296 :
297 369288086 : error = xfs_iwalk(breq->mp, tp, breq->startino, iwalk_flags,
298 : xfs_bulkstat_iwalk, breq->icount, &bc);
299 369380473 : xfs_trans_cancel(tp);
300 369391028 : out:
301 369391028 : 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 369392516 : if (breq->ocount > 0)
311 367959355 : error = 0;
312 :
313 : return error;
314 : }
315 :
316 : /* Convert bulkstat (v5) to bstat (v1). */
317 : void
318 52054342957 : 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 52054342957 : memset(bs1, 0, sizeof(struct xfs_bstat));
325 52054342957 : bs1->bs_ino = bstat->bs_ino;
326 52054342957 : bs1->bs_mode = bstat->bs_mode;
327 52054342957 : bs1->bs_nlink = bstat->bs_nlink;
328 52054342957 : bs1->bs_uid = bstat->bs_uid;
329 52054342957 : bs1->bs_gid = bstat->bs_gid;
330 52054342957 : bs1->bs_rdev = bstat->bs_rdev;
331 52054342957 : bs1->bs_blksize = bstat->bs_blksize;
332 52054342957 : bs1->bs_size = bstat->bs_size;
333 52054342957 : bs1->bs_atime.tv_sec = bstat->bs_atime;
334 52054342957 : bs1->bs_mtime.tv_sec = bstat->bs_mtime;
335 52054342957 : bs1->bs_ctime.tv_sec = bstat->bs_ctime;
336 52054342957 : bs1->bs_atime.tv_nsec = bstat->bs_atime_nsec;
337 52054342957 : bs1->bs_mtime.tv_nsec = bstat->bs_mtime_nsec;
338 52054342957 : bs1->bs_ctime.tv_nsec = bstat->bs_ctime_nsec;
339 52054342957 : bs1->bs_blocks = bstat->bs_blocks;
340 52054342957 : bs1->bs_xflags = bstat->bs_xflags;
341 52054342957 : bs1->bs_extsize = XFS_FSB_TO_B(mp, bstat->bs_extsize_blks);
342 52054342957 : bs1->bs_extents = bstat->bs_extents;
343 52054342957 : bs1->bs_gen = bstat->bs_gen;
344 52054342957 : bs1->bs_projid_lo = bstat->bs_projectid & 0xFFFF;
345 52054342957 : bs1->bs_forkoff = bstat->bs_forkoff;
346 52054342957 : bs1->bs_projid_hi = bstat->bs_projectid >> 16;
347 52054342957 : bs1->bs_sick = bstat->bs_sick;
348 52054342957 : bs1->bs_checked = bstat->bs_checked;
349 52054342957 : bs1->bs_cowextsize = XFS_FSB_TO_B(mp, bstat->bs_cowextsize_blks);
350 52054342957 : bs1->bs_dmevmask = 0;
351 52054342957 : bs1->bs_dmstate = 0;
352 52054342957 : bs1->bs_aextents = bstat->bs_aextents;
353 52054342957 : }
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 15514011 : 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 31028022 : struct xfs_inumbers inogrp = {
384 15514011 : .xi_startino = XFS_AGINO_TO_INO(mp, agno, irec->ir_startino),
385 15514011 : .xi_alloccount = irec->ir_count - irec->ir_freecount,
386 15514011 : .xi_allocmask = ~irec->ir_free,
387 : .xi_version = XFS_INUMBERS_VERSION_V5,
388 : };
389 15514011 : struct xfs_inumbers_chunk *ic = data;
390 15514011 : int error;
391 :
392 15514011 : error = ic->formatter(ic->breq, &inogrp);
393 15531068 : if (error && error != -ECANCELED)
394 : return error;
395 :
396 15531068 : ic->breq->startino = XFS_AGINO_TO_INO(mp, agno, irec->ir_startino) +
397 : XFS_INODES_PER_CHUNK;
398 15531068 : return error;
399 : }
400 :
401 : /*
402 : * Return inode number table for the filesystem.
403 : */
404 : int
405 12035097 : xfs_inumbers(
406 : struct xfs_ibulk *breq,
407 : inumbers_fmt_pf formatter)
408 : {
409 12035097 : struct xfs_inumbers_chunk ic = {
410 : .formatter = formatter,
411 : .breq = breq,
412 : };
413 12035097 : struct xfs_trans *tp;
414 12035097 : int error = 0;
415 :
416 12035097 : 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 12021485 : error = xfs_trans_alloc_empty(breq->mp, &tp);
424 12016089 : if (error)
425 0 : goto out;
426 :
427 12016089 : error = xfs_inobt_walk(breq->mp, tp, breq->startino, breq->flags,
428 : xfs_inumbers_walk, breq->icount, &ic);
429 12028621 : xfs_trans_cancel(tp);
430 12018700 : 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 12018700 : if (breq->ocount > 0)
440 10222653 : error = 0;
441 :
442 : return error;
443 : }
444 :
445 : /* Convert an inumbers (v5) struct to a inogrp (v1) struct. */
446 : void
447 69469 : 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 69469 : memset(ig1, 0, sizeof(struct xfs_inogrp));
453 69469 : ig1->xi_startino = ig->xi_startino;
454 69469 : ig1->xi_alloccount = ig->xi_alloccount;
455 69469 : ig1->xi_allocmask = ig->xi_allocmask;
456 69469 : }
|
