Loading...
Note: File does not exist in v4.10.11.
1/*
2 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
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 */
18#include "xfs.h"
19#include "xfs_fs.h"
20#include "xfs_types.h"
21#include "xfs_bit.h"
22#include "xfs_log.h"
23#include "xfs_inum.h"
24#include "xfs_trans.h"
25#include "xfs_sb.h"
26#include "xfs_ag.h"
27#include "xfs_mount.h"
28#include "xfs_bmap_btree.h"
29#include "xfs_alloc_btree.h"
30#include "xfs_ialloc_btree.h"
31#include "xfs_dinode.h"
32#include "xfs_inode.h"
33#include "xfs_btree.h"
34#include "xfs_ialloc.h"
35#include "xfs_alloc.h"
36#include "xfs_rtalloc.h"
37#include "xfs_error.h"
38#include "xfs_bmap.h"
39
40
41/*
42 * Allocation group level functions.
43 */
44static inline int
45xfs_ialloc_cluster_alignment(
46 xfs_alloc_arg_t *args)
47{
48 if (xfs_sb_version_hasalign(&args->mp->m_sb) &&
49 args->mp->m_sb.sb_inoalignmt >=
50 XFS_B_TO_FSBT(args->mp, XFS_INODE_CLUSTER_SIZE(args->mp)))
51 return args->mp->m_sb.sb_inoalignmt;
52 return 1;
53}
54
55/*
56 * Lookup a record by ino in the btree given by cur.
57 */
58int /* error */
59xfs_inobt_lookup(
60 struct xfs_btree_cur *cur, /* btree cursor */
61 xfs_agino_t ino, /* starting inode of chunk */
62 xfs_lookup_t dir, /* <=, >=, == */
63 int *stat) /* success/failure */
64{
65 cur->bc_rec.i.ir_startino = ino;
66 cur->bc_rec.i.ir_freecount = 0;
67 cur->bc_rec.i.ir_free = 0;
68 return xfs_btree_lookup(cur, dir, stat);
69}
70
71/*
72 * Update the record referred to by cur to the value given.
73 * This either works (return 0) or gets an EFSCORRUPTED error.
74 */
75STATIC int /* error */
76xfs_inobt_update(
77 struct xfs_btree_cur *cur, /* btree cursor */
78 xfs_inobt_rec_incore_t *irec) /* btree record */
79{
80 union xfs_btree_rec rec;
81
82 rec.inobt.ir_startino = cpu_to_be32(irec->ir_startino);
83 rec.inobt.ir_freecount = cpu_to_be32(irec->ir_freecount);
84 rec.inobt.ir_free = cpu_to_be64(irec->ir_free);
85 return xfs_btree_update(cur, &rec);
86}
87
88/*
89 * Get the data from the pointed-to record.
90 */
91int /* error */
92xfs_inobt_get_rec(
93 struct xfs_btree_cur *cur, /* btree cursor */
94 xfs_inobt_rec_incore_t *irec, /* btree record */
95 int *stat) /* output: success/failure */
96{
97 union xfs_btree_rec *rec;
98 int error;
99
100 error = xfs_btree_get_rec(cur, &rec, stat);
101 if (!error && *stat == 1) {
102 irec->ir_startino = be32_to_cpu(rec->inobt.ir_startino);
103 irec->ir_freecount = be32_to_cpu(rec->inobt.ir_freecount);
104 irec->ir_free = be64_to_cpu(rec->inobt.ir_free);
105 }
106 return error;
107}
108
109/*
110 * Verify that the number of free inodes in the AGI is correct.
111 */
112#ifdef DEBUG
113STATIC int
114xfs_check_agi_freecount(
115 struct xfs_btree_cur *cur,
116 struct xfs_agi *agi)
117{
118 if (cur->bc_nlevels == 1) {
119 xfs_inobt_rec_incore_t rec;
120 int freecount = 0;
121 int error;
122 int i;
123
124 error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &i);
125 if (error)
126 return error;
127
128 do {
129 error = xfs_inobt_get_rec(cur, &rec, &i);
130 if (error)
131 return error;
132
133 if (i) {
134 freecount += rec.ir_freecount;
135 error = xfs_btree_increment(cur, 0, &i);
136 if (error)
137 return error;
138 }
139 } while (i == 1);
140
141 if (!XFS_FORCED_SHUTDOWN(cur->bc_mp))
142 ASSERT(freecount == be32_to_cpu(agi->agi_freecount));
143 }
144 return 0;
145}
146#else
147#define xfs_check_agi_freecount(cur, agi) 0
148#endif
149
150/*
151 * Initialise a new set of inodes.
152 */
153STATIC void
154xfs_ialloc_inode_init(
155 struct xfs_mount *mp,
156 struct xfs_trans *tp,
157 xfs_agnumber_t agno,
158 xfs_agblock_t agbno,
159 xfs_agblock_t length,
160 unsigned int gen)
161{
162 struct xfs_buf *fbuf;
163 struct xfs_dinode *free;
164 int blks_per_cluster, nbufs, ninodes;
165 int version;
166 int i, j;
167 xfs_daddr_t d;
168
169 /*
170 * Loop over the new block(s), filling in the inodes.
171 * For small block sizes, manipulate the inodes in buffers
172 * which are multiples of the blocks size.
173 */
174 if (mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp)) {
175 blks_per_cluster = 1;
176 nbufs = length;
177 ninodes = mp->m_sb.sb_inopblock;
178 } else {
179 blks_per_cluster = XFS_INODE_CLUSTER_SIZE(mp) /
180 mp->m_sb.sb_blocksize;
181 nbufs = length / blks_per_cluster;
182 ninodes = blks_per_cluster * mp->m_sb.sb_inopblock;
183 }
184
185 /*
186 * Figure out what version number to use in the inodes we create.
187 * If the superblock version has caught up to the one that supports
188 * the new inode format, then use the new inode version. Otherwise
189 * use the old version so that old kernels will continue to be
190 * able to use the file system.
191 */
192 if (xfs_sb_version_hasnlink(&mp->m_sb))
193 version = 2;
194 else
195 version = 1;
196
197 for (j = 0; j < nbufs; j++) {
198 /*
199 * Get the block.
200 */
201 d = XFS_AGB_TO_DADDR(mp, agno, agbno + (j * blks_per_cluster));
202 fbuf = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
203 mp->m_bsize * blks_per_cluster,
204 XBF_LOCK);
205 ASSERT(!xfs_buf_geterror(fbuf));
206
207 /*
208 * Initialize all inodes in this buffer and then log them.
209 *
210 * XXX: It would be much better if we had just one transaction
211 * to log a whole cluster of inodes instead of all the
212 * individual transactions causing a lot of log traffic.
213 */
214 xfs_buf_zero(fbuf, 0, ninodes << mp->m_sb.sb_inodelog);
215 for (i = 0; i < ninodes; i++) {
216 int ioffset = i << mp->m_sb.sb_inodelog;
217 uint isize = sizeof(struct xfs_dinode);
218
219 free = xfs_make_iptr(mp, fbuf, i);
220 free->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
221 free->di_version = version;
222 free->di_gen = cpu_to_be32(gen);
223 free->di_next_unlinked = cpu_to_be32(NULLAGINO);
224 xfs_trans_log_buf(tp, fbuf, ioffset, ioffset + isize - 1);
225 }
226 xfs_trans_inode_alloc_buf(tp, fbuf);
227 }
228}
229
230/*
231 * Allocate new inodes in the allocation group specified by agbp.
232 * Return 0 for success, else error code.
233 */
234STATIC int /* error code or 0 */
235xfs_ialloc_ag_alloc(
236 xfs_trans_t *tp, /* transaction pointer */
237 xfs_buf_t *agbp, /* alloc group buffer */
238 int *alloc)
239{
240 xfs_agi_t *agi; /* allocation group header */
241 xfs_alloc_arg_t args; /* allocation argument structure */
242 xfs_btree_cur_t *cur; /* inode btree cursor */
243 xfs_agnumber_t agno;
244 int error;
245 int i;
246 xfs_agino_t newino; /* new first inode's number */
247 xfs_agino_t newlen; /* new number of inodes */
248 xfs_agino_t thisino; /* current inode number, for loop */
249 int isaligned = 0; /* inode allocation at stripe unit */
250 /* boundary */
251 struct xfs_perag *pag;
252
253 args.tp = tp;
254 args.mp = tp->t_mountp;
255
256 /*
257 * Locking will ensure that we don't have two callers in here
258 * at one time.
259 */
260 newlen = XFS_IALLOC_INODES(args.mp);
261 if (args.mp->m_maxicount &&
262 args.mp->m_sb.sb_icount + newlen > args.mp->m_maxicount)
263 return XFS_ERROR(ENOSPC);
264 args.minlen = args.maxlen = XFS_IALLOC_BLOCKS(args.mp);
265 /*
266 * First try to allocate inodes contiguous with the last-allocated
267 * chunk of inodes. If the filesystem is striped, this will fill
268 * an entire stripe unit with inodes.
269 */
270 agi = XFS_BUF_TO_AGI(agbp);
271 newino = be32_to_cpu(agi->agi_newino);
272 agno = be32_to_cpu(agi->agi_seqno);
273 args.agbno = XFS_AGINO_TO_AGBNO(args.mp, newino) +
274 XFS_IALLOC_BLOCKS(args.mp);
275 if (likely(newino != NULLAGINO &&
276 (args.agbno < be32_to_cpu(agi->agi_length)))) {
277 args.fsbno = XFS_AGB_TO_FSB(args.mp, agno, args.agbno);
278 args.type = XFS_ALLOCTYPE_THIS_BNO;
279 args.mod = args.total = args.wasdel = args.isfl =
280 args.userdata = args.minalignslop = 0;
281 args.prod = 1;
282
283 /*
284 * We need to take into account alignment here to ensure that
285 * we don't modify the free list if we fail to have an exact
286 * block. If we don't have an exact match, and every oher
287 * attempt allocation attempt fails, we'll end up cancelling
288 * a dirty transaction and shutting down.
289 *
290 * For an exact allocation, alignment must be 1,
291 * however we need to take cluster alignment into account when
292 * fixing up the freelist. Use the minalignslop field to
293 * indicate that extra blocks might be required for alignment,
294 * but not to use them in the actual exact allocation.
295 */
296 args.alignment = 1;
297 args.minalignslop = xfs_ialloc_cluster_alignment(&args) - 1;
298
299 /* Allow space for the inode btree to split. */
300 args.minleft = args.mp->m_in_maxlevels - 1;
301 if ((error = xfs_alloc_vextent(&args)))
302 return error;
303 } else
304 args.fsbno = NULLFSBLOCK;
305
306 if (unlikely(args.fsbno == NULLFSBLOCK)) {
307 /*
308 * Set the alignment for the allocation.
309 * If stripe alignment is turned on then align at stripe unit
310 * boundary.
311 * If the cluster size is smaller than a filesystem block
312 * then we're doing I/O for inodes in filesystem block size
313 * pieces, so don't need alignment anyway.
314 */
315 isaligned = 0;
316 if (args.mp->m_sinoalign) {
317 ASSERT(!(args.mp->m_flags & XFS_MOUNT_NOALIGN));
318 args.alignment = args.mp->m_dalign;
319 isaligned = 1;
320 } else
321 args.alignment = xfs_ialloc_cluster_alignment(&args);
322 /*
323 * Need to figure out where to allocate the inode blocks.
324 * Ideally they should be spaced out through the a.g.
325 * For now, just allocate blocks up front.
326 */
327 args.agbno = be32_to_cpu(agi->agi_root);
328 args.fsbno = XFS_AGB_TO_FSB(args.mp, agno, args.agbno);
329 /*
330 * Allocate a fixed-size extent of inodes.
331 */
332 args.type = XFS_ALLOCTYPE_NEAR_BNO;
333 args.mod = args.total = args.wasdel = args.isfl =
334 args.userdata = args.minalignslop = 0;
335 args.prod = 1;
336 /*
337 * Allow space for the inode btree to split.
338 */
339 args.minleft = args.mp->m_in_maxlevels - 1;
340 if ((error = xfs_alloc_vextent(&args)))
341 return error;
342 }
343
344 /*
345 * If stripe alignment is turned on, then try again with cluster
346 * alignment.
347 */
348 if (isaligned && args.fsbno == NULLFSBLOCK) {
349 args.type = XFS_ALLOCTYPE_NEAR_BNO;
350 args.agbno = be32_to_cpu(agi->agi_root);
351 args.fsbno = XFS_AGB_TO_FSB(args.mp, agno, args.agbno);
352 args.alignment = xfs_ialloc_cluster_alignment(&args);
353 if ((error = xfs_alloc_vextent(&args)))
354 return error;
355 }
356
357 if (args.fsbno == NULLFSBLOCK) {
358 *alloc = 0;
359 return 0;
360 }
361 ASSERT(args.len == args.minlen);
362
363 /*
364 * Stamp and write the inode buffers.
365 *
366 * Seed the new inode cluster with a random generation number. This
367 * prevents short-term reuse of generation numbers if a chunk is
368 * freed and then immediately reallocated. We use random numbers
369 * rather than a linear progression to prevent the next generation
370 * number from being easily guessable.
371 */
372 xfs_ialloc_inode_init(args.mp, tp, agno, args.agbno, args.len,
373 random32());
374
375 /*
376 * Convert the results.
377 */
378 newino = XFS_OFFBNO_TO_AGINO(args.mp, args.agbno, 0);
379 be32_add_cpu(&agi->agi_count, newlen);
380 be32_add_cpu(&agi->agi_freecount, newlen);
381 pag = xfs_perag_get(args.mp, agno);
382 pag->pagi_freecount += newlen;
383 xfs_perag_put(pag);
384 agi->agi_newino = cpu_to_be32(newino);
385
386 /*
387 * Insert records describing the new inode chunk into the btree.
388 */
389 cur = xfs_inobt_init_cursor(args.mp, tp, agbp, agno);
390 for (thisino = newino;
391 thisino < newino + newlen;
392 thisino += XFS_INODES_PER_CHUNK) {
393 cur->bc_rec.i.ir_startino = thisino;
394 cur->bc_rec.i.ir_freecount = XFS_INODES_PER_CHUNK;
395 cur->bc_rec.i.ir_free = XFS_INOBT_ALL_FREE;
396 error = xfs_btree_lookup(cur, XFS_LOOKUP_EQ, &i);
397 if (error) {
398 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
399 return error;
400 }
401 ASSERT(i == 0);
402 error = xfs_btree_insert(cur, &i);
403 if (error) {
404 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
405 return error;
406 }
407 ASSERT(i == 1);
408 }
409 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
410 /*
411 * Log allocation group header fields
412 */
413 xfs_ialloc_log_agi(tp, agbp,
414 XFS_AGI_COUNT | XFS_AGI_FREECOUNT | XFS_AGI_NEWINO);
415 /*
416 * Modify/log superblock values for inode count and inode free count.
417 */
418 xfs_trans_mod_sb(tp, XFS_TRANS_SB_ICOUNT, (long)newlen);
419 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, (long)newlen);
420 *alloc = 1;
421 return 0;
422}
423
424STATIC xfs_agnumber_t
425xfs_ialloc_next_ag(
426 xfs_mount_t *mp)
427{
428 xfs_agnumber_t agno;
429
430 spin_lock(&mp->m_agirotor_lock);
431 agno = mp->m_agirotor;
432 if (++mp->m_agirotor == mp->m_maxagi)
433 mp->m_agirotor = 0;
434 spin_unlock(&mp->m_agirotor_lock);
435
436 return agno;
437}
438
439/*
440 * Select an allocation group to look for a free inode in, based on the parent
441 * inode and then mode. Return the allocation group buffer.
442 */
443STATIC xfs_buf_t * /* allocation group buffer */
444xfs_ialloc_ag_select(
445 xfs_trans_t *tp, /* transaction pointer */
446 xfs_ino_t parent, /* parent directory inode number */
447 mode_t mode, /* bits set to indicate file type */
448 int okalloc) /* ok to allocate more space */
449{
450 xfs_buf_t *agbp; /* allocation group header buffer */
451 xfs_agnumber_t agcount; /* number of ag's in the filesystem */
452 xfs_agnumber_t agno; /* current ag number */
453 int flags; /* alloc buffer locking flags */
454 xfs_extlen_t ineed; /* blocks needed for inode allocation */
455 xfs_extlen_t longest = 0; /* longest extent available */
456 xfs_mount_t *mp; /* mount point structure */
457 int needspace; /* file mode implies space allocated */
458 xfs_perag_t *pag; /* per allocation group data */
459 xfs_agnumber_t pagno; /* parent (starting) ag number */
460
461 /*
462 * Files of these types need at least one block if length > 0
463 * (and they won't fit in the inode, but that's hard to figure out).
464 */
465 needspace = S_ISDIR(mode) || S_ISREG(mode) || S_ISLNK(mode);
466 mp = tp->t_mountp;
467 agcount = mp->m_maxagi;
468 if (S_ISDIR(mode))
469 pagno = xfs_ialloc_next_ag(mp);
470 else {
471 pagno = XFS_INO_TO_AGNO(mp, parent);
472 if (pagno >= agcount)
473 pagno = 0;
474 }
475 ASSERT(pagno < agcount);
476 /*
477 * Loop through allocation groups, looking for one with a little
478 * free space in it. Note we don't look for free inodes, exactly.
479 * Instead, we include whether there is a need to allocate inodes
480 * to mean that blocks must be allocated for them,
481 * if none are currently free.
482 */
483 agno = pagno;
484 flags = XFS_ALLOC_FLAG_TRYLOCK;
485 for (;;) {
486 pag = xfs_perag_get(mp, agno);
487 if (!pag->pagi_init) {
488 if (xfs_ialloc_read_agi(mp, tp, agno, &agbp)) {
489 agbp = NULL;
490 goto nextag;
491 }
492 } else
493 agbp = NULL;
494
495 if (!pag->pagi_inodeok) {
496 xfs_ialloc_next_ag(mp);
497 goto unlock_nextag;
498 }
499
500 /*
501 * Is there enough free space for the file plus a block
502 * of inodes (if we need to allocate some)?
503 */
504 ineed = pag->pagi_freecount ? 0 : XFS_IALLOC_BLOCKS(mp);
505 if (ineed && !pag->pagf_init) {
506 if (agbp == NULL &&
507 xfs_ialloc_read_agi(mp, tp, agno, &agbp)) {
508 agbp = NULL;
509 goto nextag;
510 }
511 (void)xfs_alloc_pagf_init(mp, tp, agno, flags);
512 }
513 if (!ineed || pag->pagf_init) {
514 if (ineed && !(longest = pag->pagf_longest))
515 longest = pag->pagf_flcount > 0;
516 if (!ineed ||
517 (pag->pagf_freeblks >= needspace + ineed &&
518 longest >= ineed &&
519 okalloc)) {
520 if (agbp == NULL &&
521 xfs_ialloc_read_agi(mp, tp, agno, &agbp)) {
522 agbp = NULL;
523 goto nextag;
524 }
525 xfs_perag_put(pag);
526 return agbp;
527 }
528 }
529unlock_nextag:
530 if (agbp)
531 xfs_trans_brelse(tp, agbp);
532nextag:
533 xfs_perag_put(pag);
534 /*
535 * No point in iterating over the rest, if we're shutting
536 * down.
537 */
538 if (XFS_FORCED_SHUTDOWN(mp))
539 return NULL;
540 agno++;
541 if (agno >= agcount)
542 agno = 0;
543 if (agno == pagno) {
544 if (flags == 0)
545 return NULL;
546 flags = 0;
547 }
548 }
549}
550
551/*
552 * Try to retrieve the next record to the left/right from the current one.
553 */
554STATIC int
555xfs_ialloc_next_rec(
556 struct xfs_btree_cur *cur,
557 xfs_inobt_rec_incore_t *rec,
558 int *done,
559 int left)
560{
561 int error;
562 int i;
563
564 if (left)
565 error = xfs_btree_decrement(cur, 0, &i);
566 else
567 error = xfs_btree_increment(cur, 0, &i);
568
569 if (error)
570 return error;
571 *done = !i;
572 if (i) {
573 error = xfs_inobt_get_rec(cur, rec, &i);
574 if (error)
575 return error;
576 XFS_WANT_CORRUPTED_RETURN(i == 1);
577 }
578
579 return 0;
580}
581
582STATIC int
583xfs_ialloc_get_rec(
584 struct xfs_btree_cur *cur,
585 xfs_agino_t agino,
586 xfs_inobt_rec_incore_t *rec,
587 int *done,
588 int left)
589{
590 int error;
591 int i;
592
593 error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_EQ, &i);
594 if (error)
595 return error;
596 *done = !i;
597 if (i) {
598 error = xfs_inobt_get_rec(cur, rec, &i);
599 if (error)
600 return error;
601 XFS_WANT_CORRUPTED_RETURN(i == 1);
602 }
603
604 return 0;
605}
606
607/*
608 * Visible inode allocation functions.
609 */
610
611/*
612 * Allocate an inode on disk.
613 * Mode is used to tell whether the new inode will need space, and whether
614 * it is a directory.
615 *
616 * The arguments IO_agbp and alloc_done are defined to work within
617 * the constraint of one allocation per transaction.
618 * xfs_dialloc() is designed to be called twice if it has to do an
619 * allocation to make more free inodes. On the first call,
620 * IO_agbp should be set to NULL. If an inode is available,
621 * i.e., xfs_dialloc() did not need to do an allocation, an inode
622 * number is returned. In this case, IO_agbp would be set to the
623 * current ag_buf and alloc_done set to false.
624 * If an allocation needed to be done, xfs_dialloc would return
625 * the current ag_buf in IO_agbp and set alloc_done to true.
626 * The caller should then commit the current transaction, allocate a new
627 * transaction, and call xfs_dialloc() again, passing in the previous
628 * value of IO_agbp. IO_agbp should be held across the transactions.
629 * Since the agbp is locked across the two calls, the second call is
630 * guaranteed to have a free inode available.
631 *
632 * Once we successfully pick an inode its number is returned and the
633 * on-disk data structures are updated. The inode itself is not read
634 * in, since doing so would break ordering constraints with xfs_reclaim.
635 */
636int
637xfs_dialloc(
638 xfs_trans_t *tp, /* transaction pointer */
639 xfs_ino_t parent, /* parent inode (directory) */
640 mode_t mode, /* mode bits for new inode */
641 int okalloc, /* ok to allocate more space */
642 xfs_buf_t **IO_agbp, /* in/out ag header's buffer */
643 boolean_t *alloc_done, /* true if we needed to replenish
644 inode freelist */
645 xfs_ino_t *inop) /* inode number allocated */
646{
647 xfs_agnumber_t agcount; /* number of allocation groups */
648 xfs_buf_t *agbp; /* allocation group header's buffer */
649 xfs_agnumber_t agno; /* allocation group number */
650 xfs_agi_t *agi; /* allocation group header structure */
651 xfs_btree_cur_t *cur; /* inode allocation btree cursor */
652 int error; /* error return value */
653 int i; /* result code */
654 int ialloced; /* inode allocation status */
655 int noroom = 0; /* no space for inode blk allocation */
656 xfs_ino_t ino; /* fs-relative inode to be returned */
657 /* REFERENCED */
658 int j; /* result code */
659 xfs_mount_t *mp; /* file system mount structure */
660 int offset; /* index of inode in chunk */
661 xfs_agino_t pagino; /* parent's AG relative inode # */
662 xfs_agnumber_t pagno; /* parent's AG number */
663 xfs_inobt_rec_incore_t rec; /* inode allocation record */
664 xfs_agnumber_t tagno; /* testing allocation group number */
665 xfs_btree_cur_t *tcur; /* temp cursor */
666 xfs_inobt_rec_incore_t trec; /* temp inode allocation record */
667 struct xfs_perag *pag;
668
669
670 if (*IO_agbp == NULL) {
671 /*
672 * We do not have an agbp, so select an initial allocation
673 * group for inode allocation.
674 */
675 agbp = xfs_ialloc_ag_select(tp, parent, mode, okalloc);
676 /*
677 * Couldn't find an allocation group satisfying the
678 * criteria, give up.
679 */
680 if (!agbp) {
681 *inop = NULLFSINO;
682 return 0;
683 }
684 agi = XFS_BUF_TO_AGI(agbp);
685 ASSERT(agi->agi_magicnum == cpu_to_be32(XFS_AGI_MAGIC));
686 } else {
687 /*
688 * Continue where we left off before. In this case, we
689 * know that the allocation group has free inodes.
690 */
691 agbp = *IO_agbp;
692 agi = XFS_BUF_TO_AGI(agbp);
693 ASSERT(agi->agi_magicnum == cpu_to_be32(XFS_AGI_MAGIC));
694 ASSERT(be32_to_cpu(agi->agi_freecount) > 0);
695 }
696 mp = tp->t_mountp;
697 agcount = mp->m_sb.sb_agcount;
698 agno = be32_to_cpu(agi->agi_seqno);
699 tagno = agno;
700 pagno = XFS_INO_TO_AGNO(mp, parent);
701 pagino = XFS_INO_TO_AGINO(mp, parent);
702
703 /*
704 * If we have already hit the ceiling of inode blocks then clear
705 * okalloc so we scan all available agi structures for a free
706 * inode.
707 */
708
709 if (mp->m_maxicount &&
710 mp->m_sb.sb_icount + XFS_IALLOC_INODES(mp) > mp->m_maxicount) {
711 noroom = 1;
712 okalloc = 0;
713 }
714
715 /*
716 * Loop until we find an allocation group that either has free inodes
717 * or in which we can allocate some inodes. Iterate through the
718 * allocation groups upward, wrapping at the end.
719 */
720 *alloc_done = B_FALSE;
721 while (!agi->agi_freecount) {
722 /*
723 * Don't do anything if we're not supposed to allocate
724 * any blocks, just go on to the next ag.
725 */
726 if (okalloc) {
727 /*
728 * Try to allocate some new inodes in the allocation
729 * group.
730 */
731 if ((error = xfs_ialloc_ag_alloc(tp, agbp, &ialloced))) {
732 xfs_trans_brelse(tp, agbp);
733 if (error == ENOSPC) {
734 *inop = NULLFSINO;
735 return 0;
736 } else
737 return error;
738 }
739 if (ialloced) {
740 /*
741 * We successfully allocated some inodes, return
742 * the current context to the caller so that it
743 * can commit the current transaction and call
744 * us again where we left off.
745 */
746 ASSERT(be32_to_cpu(agi->agi_freecount) > 0);
747 *alloc_done = B_TRUE;
748 *IO_agbp = agbp;
749 *inop = NULLFSINO;
750 return 0;
751 }
752 }
753 /*
754 * If it failed, give up on this ag.
755 */
756 xfs_trans_brelse(tp, agbp);
757 /*
758 * Go on to the next ag: get its ag header.
759 */
760nextag:
761 if (++tagno == agcount)
762 tagno = 0;
763 if (tagno == agno) {
764 *inop = NULLFSINO;
765 return noroom ? ENOSPC : 0;
766 }
767 pag = xfs_perag_get(mp, tagno);
768 if (pag->pagi_inodeok == 0) {
769 xfs_perag_put(pag);
770 goto nextag;
771 }
772 error = xfs_ialloc_read_agi(mp, tp, tagno, &agbp);
773 xfs_perag_put(pag);
774 if (error)
775 goto nextag;
776 agi = XFS_BUF_TO_AGI(agbp);
777 ASSERT(agi->agi_magicnum == cpu_to_be32(XFS_AGI_MAGIC));
778 }
779 /*
780 * Here with an allocation group that has a free inode.
781 * Reset agno since we may have chosen a new ag in the
782 * loop above.
783 */
784 agno = tagno;
785 *IO_agbp = NULL;
786 pag = xfs_perag_get(mp, agno);
787
788 restart_pagno:
789 cur = xfs_inobt_init_cursor(mp, tp, agbp, be32_to_cpu(agi->agi_seqno));
790 /*
791 * If pagino is 0 (this is the root inode allocation) use newino.
792 * This must work because we've just allocated some.
793 */
794 if (!pagino)
795 pagino = be32_to_cpu(agi->agi_newino);
796
797 error = xfs_check_agi_freecount(cur, agi);
798 if (error)
799 goto error0;
800
801 /*
802 * If in the same AG as the parent, try to get near the parent.
803 */
804 if (pagno == agno) {
805 int doneleft; /* done, to the left */
806 int doneright; /* done, to the right */
807 int searchdistance = 10;
808
809 error = xfs_inobt_lookup(cur, pagino, XFS_LOOKUP_LE, &i);
810 if (error)
811 goto error0;
812 XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
813
814 error = xfs_inobt_get_rec(cur, &rec, &j);
815 if (error)
816 goto error0;
817 XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
818
819 if (rec.ir_freecount > 0) {
820 /*
821 * Found a free inode in the same chunk
822 * as the parent, done.
823 */
824 goto alloc_inode;
825 }
826
827
828 /*
829 * In the same AG as parent, but parent's chunk is full.
830 */
831
832 /* duplicate the cursor, search left & right simultaneously */
833 error = xfs_btree_dup_cursor(cur, &tcur);
834 if (error)
835 goto error0;
836
837 /*
838 * Skip to last blocks looked up if same parent inode.
839 */
840 if (pagino != NULLAGINO &&
841 pag->pagl_pagino == pagino &&
842 pag->pagl_leftrec != NULLAGINO &&
843 pag->pagl_rightrec != NULLAGINO) {
844 error = xfs_ialloc_get_rec(tcur, pag->pagl_leftrec,
845 &trec, &doneleft, 1);
846 if (error)
847 goto error1;
848
849 error = xfs_ialloc_get_rec(cur, pag->pagl_rightrec,
850 &rec, &doneright, 0);
851 if (error)
852 goto error1;
853 } else {
854 /* search left with tcur, back up 1 record */
855 error = xfs_ialloc_next_rec(tcur, &trec, &doneleft, 1);
856 if (error)
857 goto error1;
858
859 /* search right with cur, go forward 1 record. */
860 error = xfs_ialloc_next_rec(cur, &rec, &doneright, 0);
861 if (error)
862 goto error1;
863 }
864
865 /*
866 * Loop until we find an inode chunk with a free inode.
867 */
868 while (!doneleft || !doneright) {
869 int useleft; /* using left inode chunk this time */
870
871 if (!--searchdistance) {
872 /*
873 * Not in range - save last search
874 * location and allocate a new inode
875 */
876 xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR);
877 pag->pagl_leftrec = trec.ir_startino;
878 pag->pagl_rightrec = rec.ir_startino;
879 pag->pagl_pagino = pagino;
880 goto newino;
881 }
882
883 /* figure out the closer block if both are valid. */
884 if (!doneleft && !doneright) {
885 useleft = pagino -
886 (trec.ir_startino + XFS_INODES_PER_CHUNK - 1) <
887 rec.ir_startino - pagino;
888 } else {
889 useleft = !doneleft;
890 }
891
892 /* free inodes to the left? */
893 if (useleft && trec.ir_freecount) {
894 rec = trec;
895 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
896 cur = tcur;
897
898 pag->pagl_leftrec = trec.ir_startino;
899 pag->pagl_rightrec = rec.ir_startino;
900 pag->pagl_pagino = pagino;
901 goto alloc_inode;
902 }
903
904 /* free inodes to the right? */
905 if (!useleft && rec.ir_freecount) {
906 xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR);
907
908 pag->pagl_leftrec = trec.ir_startino;
909 pag->pagl_rightrec = rec.ir_startino;
910 pag->pagl_pagino = pagino;
911 goto alloc_inode;
912 }
913
914 /* get next record to check */
915 if (useleft) {
916 error = xfs_ialloc_next_rec(tcur, &trec,
917 &doneleft, 1);
918 } else {
919 error = xfs_ialloc_next_rec(cur, &rec,
920 &doneright, 0);
921 }
922 if (error)
923 goto error1;
924 }
925
926 /*
927 * We've reached the end of the btree. because
928 * we are only searching a small chunk of the
929 * btree each search, there is obviously free
930 * inodes closer to the parent inode than we
931 * are now. restart the search again.
932 */
933 pag->pagl_pagino = NULLAGINO;
934 pag->pagl_leftrec = NULLAGINO;
935 pag->pagl_rightrec = NULLAGINO;
936 xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR);
937 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
938 goto restart_pagno;
939 }
940
941 /*
942 * In a different AG from the parent.
943 * See if the most recently allocated block has any free.
944 */
945newino:
946 if (agi->agi_newino != cpu_to_be32(NULLAGINO)) {
947 error = xfs_inobt_lookup(cur, be32_to_cpu(agi->agi_newino),
948 XFS_LOOKUP_EQ, &i);
949 if (error)
950 goto error0;
951
952 if (i == 1) {
953 error = xfs_inobt_get_rec(cur, &rec, &j);
954 if (error)
955 goto error0;
956
957 if (j == 1 && rec.ir_freecount > 0) {
958 /*
959 * The last chunk allocated in the group
960 * still has a free inode.
961 */
962 goto alloc_inode;
963 }
964 }
965 }
966
967 /*
968 * None left in the last group, search the whole AG
969 */
970 error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &i);
971 if (error)
972 goto error0;
973 XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
974
975 for (;;) {
976 error = xfs_inobt_get_rec(cur, &rec, &i);
977 if (error)
978 goto error0;
979 XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
980 if (rec.ir_freecount > 0)
981 break;
982 error = xfs_btree_increment(cur, 0, &i);
983 if (error)
984 goto error0;
985 XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
986 }
987
988alloc_inode:
989 offset = xfs_ialloc_find_free(&rec.ir_free);
990 ASSERT(offset >= 0);
991 ASSERT(offset < XFS_INODES_PER_CHUNK);
992 ASSERT((XFS_AGINO_TO_OFFSET(mp, rec.ir_startino) %
993 XFS_INODES_PER_CHUNK) == 0);
994 ino = XFS_AGINO_TO_INO(mp, agno, rec.ir_startino + offset);
995 rec.ir_free &= ~XFS_INOBT_MASK(offset);
996 rec.ir_freecount--;
997 error = xfs_inobt_update(cur, &rec);
998 if (error)
999 goto error0;
1000 be32_add_cpu(&agi->agi_freecount, -1);
1001 xfs_ialloc_log_agi(tp, agbp, XFS_AGI_FREECOUNT);
1002 pag->pagi_freecount--;
1003
1004 error = xfs_check_agi_freecount(cur, agi);
1005 if (error)
1006 goto error0;
1007
1008 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
1009 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, -1);
1010 xfs_perag_put(pag);
1011 *inop = ino;
1012 return 0;
1013error1:
1014 xfs_btree_del_cursor(tcur, XFS_BTREE_ERROR);
1015error0:
1016 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
1017 xfs_perag_put(pag);
1018 return error;
1019}
1020
1021/*
1022 * Free disk inode. Carefully avoids touching the incore inode, all
1023 * manipulations incore are the caller's responsibility.
1024 * The on-disk inode is not changed by this operation, only the
1025 * btree (free inode mask) is changed.
1026 */
1027int
1028xfs_difree(
1029 xfs_trans_t *tp, /* transaction pointer */
1030 xfs_ino_t inode, /* inode to be freed */
1031 xfs_bmap_free_t *flist, /* extents to free */
1032 int *delete, /* set if inode cluster was deleted */
1033 xfs_ino_t *first_ino) /* first inode in deleted cluster */
1034{
1035 /* REFERENCED */
1036 xfs_agblock_t agbno; /* block number containing inode */
1037 xfs_buf_t *agbp; /* buffer containing allocation group header */
1038 xfs_agino_t agino; /* inode number relative to allocation group */
1039 xfs_agnumber_t agno; /* allocation group number */
1040 xfs_agi_t *agi; /* allocation group header */
1041 xfs_btree_cur_t *cur; /* inode btree cursor */
1042 int error; /* error return value */
1043 int i; /* result code */
1044 int ilen; /* inodes in an inode cluster */
1045 xfs_mount_t *mp; /* mount structure for filesystem */
1046 int off; /* offset of inode in inode chunk */
1047 xfs_inobt_rec_incore_t rec; /* btree record */
1048 struct xfs_perag *pag;
1049
1050 mp = tp->t_mountp;
1051
1052 /*
1053 * Break up inode number into its components.
1054 */
1055 agno = XFS_INO_TO_AGNO(mp, inode);
1056 if (agno >= mp->m_sb.sb_agcount) {
1057 xfs_warn(mp, "%s: agno >= mp->m_sb.sb_agcount (%d >= %d).",
1058 __func__, agno, mp->m_sb.sb_agcount);
1059 ASSERT(0);
1060 return XFS_ERROR(EINVAL);
1061 }
1062 agino = XFS_INO_TO_AGINO(mp, inode);
1063 if (inode != XFS_AGINO_TO_INO(mp, agno, agino)) {
1064 xfs_warn(mp, "%s: inode != XFS_AGINO_TO_INO() (%llu != %llu).",
1065 __func__, (unsigned long long)inode,
1066 (unsigned long long)XFS_AGINO_TO_INO(mp, agno, agino));
1067 ASSERT(0);
1068 return XFS_ERROR(EINVAL);
1069 }
1070 agbno = XFS_AGINO_TO_AGBNO(mp, agino);
1071 if (agbno >= mp->m_sb.sb_agblocks) {
1072 xfs_warn(mp, "%s: agbno >= mp->m_sb.sb_agblocks (%d >= %d).",
1073 __func__, agbno, mp->m_sb.sb_agblocks);
1074 ASSERT(0);
1075 return XFS_ERROR(EINVAL);
1076 }
1077 /*
1078 * Get the allocation group header.
1079 */
1080 error = xfs_ialloc_read_agi(mp, tp, agno, &agbp);
1081 if (error) {
1082 xfs_warn(mp, "%s: xfs_ialloc_read_agi() returned error %d.",
1083 __func__, error);
1084 return error;
1085 }
1086 agi = XFS_BUF_TO_AGI(agbp);
1087 ASSERT(agi->agi_magicnum == cpu_to_be32(XFS_AGI_MAGIC));
1088 ASSERT(agbno < be32_to_cpu(agi->agi_length));
1089 /*
1090 * Initialize the cursor.
1091 */
1092 cur = xfs_inobt_init_cursor(mp, tp, agbp, agno);
1093
1094 error = xfs_check_agi_freecount(cur, agi);
1095 if (error)
1096 goto error0;
1097
1098 /*
1099 * Look for the entry describing this inode.
1100 */
1101 if ((error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_LE, &i))) {
1102 xfs_warn(mp, "%s: xfs_inobt_lookup() returned error %d.",
1103 __func__, error);
1104 goto error0;
1105 }
1106 XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
1107 error = xfs_inobt_get_rec(cur, &rec, &i);
1108 if (error) {
1109 xfs_warn(mp, "%s: xfs_inobt_get_rec() returned error %d.",
1110 __func__, error);
1111 goto error0;
1112 }
1113 XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
1114 /*
1115 * Get the offset in the inode chunk.
1116 */
1117 off = agino - rec.ir_startino;
1118 ASSERT(off >= 0 && off < XFS_INODES_PER_CHUNK);
1119 ASSERT(!(rec.ir_free & XFS_INOBT_MASK(off)));
1120 /*
1121 * Mark the inode free & increment the count.
1122 */
1123 rec.ir_free |= XFS_INOBT_MASK(off);
1124 rec.ir_freecount++;
1125
1126 /*
1127 * When an inode cluster is free, it becomes eligible for removal
1128 */
1129 if (!(mp->m_flags & XFS_MOUNT_IKEEP) &&
1130 (rec.ir_freecount == XFS_IALLOC_INODES(mp))) {
1131
1132 *delete = 1;
1133 *first_ino = XFS_AGINO_TO_INO(mp, agno, rec.ir_startino);
1134
1135 /*
1136 * Remove the inode cluster from the AGI B+Tree, adjust the
1137 * AGI and Superblock inode counts, and mark the disk space
1138 * to be freed when the transaction is committed.
1139 */
1140 ilen = XFS_IALLOC_INODES(mp);
1141 be32_add_cpu(&agi->agi_count, -ilen);
1142 be32_add_cpu(&agi->agi_freecount, -(ilen - 1));
1143 xfs_ialloc_log_agi(tp, agbp, XFS_AGI_COUNT | XFS_AGI_FREECOUNT);
1144 pag = xfs_perag_get(mp, agno);
1145 pag->pagi_freecount -= ilen - 1;
1146 xfs_perag_put(pag);
1147 xfs_trans_mod_sb(tp, XFS_TRANS_SB_ICOUNT, -ilen);
1148 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, -(ilen - 1));
1149
1150 if ((error = xfs_btree_delete(cur, &i))) {
1151 xfs_warn(mp, "%s: xfs_btree_delete returned error %d.",
1152 __func__, error);
1153 goto error0;
1154 }
1155
1156 xfs_bmap_add_free(XFS_AGB_TO_FSB(mp,
1157 agno, XFS_INO_TO_AGBNO(mp,rec.ir_startino)),
1158 XFS_IALLOC_BLOCKS(mp), flist, mp);
1159 } else {
1160 *delete = 0;
1161
1162 error = xfs_inobt_update(cur, &rec);
1163 if (error) {
1164 xfs_warn(mp, "%s: xfs_inobt_update returned error %d.",
1165 __func__, error);
1166 goto error0;
1167 }
1168
1169 /*
1170 * Change the inode free counts and log the ag/sb changes.
1171 */
1172 be32_add_cpu(&agi->agi_freecount, 1);
1173 xfs_ialloc_log_agi(tp, agbp, XFS_AGI_FREECOUNT);
1174 pag = xfs_perag_get(mp, agno);
1175 pag->pagi_freecount++;
1176 xfs_perag_put(pag);
1177 xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, 1);
1178 }
1179
1180 error = xfs_check_agi_freecount(cur, agi);
1181 if (error)
1182 goto error0;
1183
1184 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
1185 return 0;
1186
1187error0:
1188 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
1189 return error;
1190}
1191
1192STATIC int
1193xfs_imap_lookup(
1194 struct xfs_mount *mp,
1195 struct xfs_trans *tp,
1196 xfs_agnumber_t agno,
1197 xfs_agino_t agino,
1198 xfs_agblock_t agbno,
1199 xfs_agblock_t *chunk_agbno,
1200 xfs_agblock_t *offset_agbno,
1201 int flags)
1202{
1203 struct xfs_inobt_rec_incore rec;
1204 struct xfs_btree_cur *cur;
1205 struct xfs_buf *agbp;
1206 int error;
1207 int i;
1208
1209 error = xfs_ialloc_read_agi(mp, tp, agno, &agbp);
1210 if (error) {
1211 xfs_alert(mp,
1212 "%s: xfs_ialloc_read_agi() returned error %d, agno %d",
1213 __func__, error, agno);
1214 return error;
1215 }
1216
1217 /*
1218 * Lookup the inode record for the given agino. If the record cannot be
1219 * found, then it's an invalid inode number and we should abort. Once
1220 * we have a record, we need to ensure it contains the inode number
1221 * we are looking up.
1222 */
1223 cur = xfs_inobt_init_cursor(mp, tp, agbp, agno);
1224 error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_LE, &i);
1225 if (!error) {
1226 if (i)
1227 error = xfs_inobt_get_rec(cur, &rec, &i);
1228 if (!error && i == 0)
1229 error = EINVAL;
1230 }
1231
1232 xfs_trans_brelse(tp, agbp);
1233 xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
1234 if (error)
1235 return error;
1236
1237 /* check that the returned record contains the required inode */
1238 if (rec.ir_startino > agino ||
1239 rec.ir_startino + XFS_IALLOC_INODES(mp) <= agino)
1240 return EINVAL;
1241
1242 /* for untrusted inodes check it is allocated first */
1243 if ((flags & XFS_IGET_UNTRUSTED) &&
1244 (rec.ir_free & XFS_INOBT_MASK(agino - rec.ir_startino)))
1245 return EINVAL;
1246
1247 *chunk_agbno = XFS_AGINO_TO_AGBNO(mp, rec.ir_startino);
1248 *offset_agbno = agbno - *chunk_agbno;
1249 return 0;
1250}
1251
1252/*
1253 * Return the location of the inode in imap, for mapping it into a buffer.
1254 */
1255int
1256xfs_imap(
1257 xfs_mount_t *mp, /* file system mount structure */
1258 xfs_trans_t *tp, /* transaction pointer */
1259 xfs_ino_t ino, /* inode to locate */
1260 struct xfs_imap *imap, /* location map structure */
1261 uint flags) /* flags for inode btree lookup */
1262{
1263 xfs_agblock_t agbno; /* block number of inode in the alloc group */
1264 xfs_agino_t agino; /* inode number within alloc group */
1265 xfs_agnumber_t agno; /* allocation group number */
1266 int blks_per_cluster; /* num blocks per inode cluster */
1267 xfs_agblock_t chunk_agbno; /* first block in inode chunk */
1268 xfs_agblock_t cluster_agbno; /* first block in inode cluster */
1269 int error; /* error code */
1270 int offset; /* index of inode in its buffer */
1271 int offset_agbno; /* blks from chunk start to inode */
1272
1273 ASSERT(ino != NULLFSINO);
1274
1275 /*
1276 * Split up the inode number into its parts.
1277 */
1278 agno = XFS_INO_TO_AGNO(mp, ino);
1279 agino = XFS_INO_TO_AGINO(mp, ino);
1280 agbno = XFS_AGINO_TO_AGBNO(mp, agino);
1281 if (agno >= mp->m_sb.sb_agcount || agbno >= mp->m_sb.sb_agblocks ||
1282 ino != XFS_AGINO_TO_INO(mp, agno, agino)) {
1283#ifdef DEBUG
1284 /*
1285 * Don't output diagnostic information for untrusted inodes
1286 * as they can be invalid without implying corruption.
1287 */
1288 if (flags & XFS_IGET_UNTRUSTED)
1289 return XFS_ERROR(EINVAL);
1290 if (agno >= mp->m_sb.sb_agcount) {
1291 xfs_alert(mp,
1292 "%s: agno (%d) >= mp->m_sb.sb_agcount (%d)",
1293 __func__, agno, mp->m_sb.sb_agcount);
1294 }
1295 if (agbno >= mp->m_sb.sb_agblocks) {
1296 xfs_alert(mp,
1297 "%s: agbno (0x%llx) >= mp->m_sb.sb_agblocks (0x%lx)",
1298 __func__, (unsigned long long)agbno,
1299 (unsigned long)mp->m_sb.sb_agblocks);
1300 }
1301 if (ino != XFS_AGINO_TO_INO(mp, agno, agino)) {
1302 xfs_alert(mp,
1303 "%s: ino (0x%llx) != XFS_AGINO_TO_INO() (0x%llx)",
1304 __func__, ino,
1305 XFS_AGINO_TO_INO(mp, agno, agino));
1306 }
1307 xfs_stack_trace();
1308#endif /* DEBUG */
1309 return XFS_ERROR(EINVAL);
1310 }
1311
1312 blks_per_cluster = XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_blocklog;
1313
1314 /*
1315 * For bulkstat and handle lookups, we have an untrusted inode number
1316 * that we have to verify is valid. We cannot do this just by reading
1317 * the inode buffer as it may have been unlinked and removed leaving
1318 * inodes in stale state on disk. Hence we have to do a btree lookup
1319 * in all cases where an untrusted inode number is passed.
1320 */
1321 if (flags & XFS_IGET_UNTRUSTED) {
1322 error = xfs_imap_lookup(mp, tp, agno, agino, agbno,
1323 &chunk_agbno, &offset_agbno, flags);
1324 if (error)
1325 return error;
1326 goto out_map;
1327 }
1328
1329 /*
1330 * If the inode cluster size is the same as the blocksize or
1331 * smaller we get to the buffer by simple arithmetics.
1332 */
1333 if (XFS_INODE_CLUSTER_SIZE(mp) <= mp->m_sb.sb_blocksize) {
1334 offset = XFS_INO_TO_OFFSET(mp, ino);
1335 ASSERT(offset < mp->m_sb.sb_inopblock);
1336
1337 imap->im_blkno = XFS_AGB_TO_DADDR(mp, agno, agbno);
1338 imap->im_len = XFS_FSB_TO_BB(mp, 1);
1339 imap->im_boffset = (ushort)(offset << mp->m_sb.sb_inodelog);
1340 return 0;
1341 }
1342
1343 /*
1344 * If the inode chunks are aligned then use simple maths to
1345 * find the location. Otherwise we have to do a btree
1346 * lookup to find the location.
1347 */
1348 if (mp->m_inoalign_mask) {
1349 offset_agbno = agbno & mp->m_inoalign_mask;
1350 chunk_agbno = agbno - offset_agbno;
1351 } else {
1352 error = xfs_imap_lookup(mp, tp, agno, agino, agbno,
1353 &chunk_agbno, &offset_agbno, flags);
1354 if (error)
1355 return error;
1356 }
1357
1358out_map:
1359 ASSERT(agbno >= chunk_agbno);
1360 cluster_agbno = chunk_agbno +
1361 ((offset_agbno / blks_per_cluster) * blks_per_cluster);
1362 offset = ((agbno - cluster_agbno) * mp->m_sb.sb_inopblock) +
1363 XFS_INO_TO_OFFSET(mp, ino);
1364
1365 imap->im_blkno = XFS_AGB_TO_DADDR(mp, agno, cluster_agbno);
1366 imap->im_len = XFS_FSB_TO_BB(mp, blks_per_cluster);
1367 imap->im_boffset = (ushort)(offset << mp->m_sb.sb_inodelog);
1368
1369 /*
1370 * If the inode number maps to a block outside the bounds
1371 * of the file system then return NULL rather than calling
1372 * read_buf and panicing when we get an error from the
1373 * driver.
1374 */
1375 if ((imap->im_blkno + imap->im_len) >
1376 XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)) {
1377 xfs_alert(mp,
1378 "%s: (im_blkno (0x%llx) + im_len (0x%llx)) > sb_dblocks (0x%llx)",
1379 __func__, (unsigned long long) imap->im_blkno,
1380 (unsigned long long) imap->im_len,
1381 XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks));
1382 return XFS_ERROR(EINVAL);
1383 }
1384 return 0;
1385}
1386
1387/*
1388 * Compute and fill in value of m_in_maxlevels.
1389 */
1390void
1391xfs_ialloc_compute_maxlevels(
1392 xfs_mount_t *mp) /* file system mount structure */
1393{
1394 int level;
1395 uint maxblocks;
1396 uint maxleafents;
1397 int minleafrecs;
1398 int minnoderecs;
1399
1400 maxleafents = (1LL << XFS_INO_AGINO_BITS(mp)) >>
1401 XFS_INODES_PER_CHUNK_LOG;
1402 minleafrecs = mp->m_alloc_mnr[0];
1403 minnoderecs = mp->m_alloc_mnr[1];
1404 maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs;
1405 for (level = 1; maxblocks > 1; level++)
1406 maxblocks = (maxblocks + minnoderecs - 1) / minnoderecs;
1407 mp->m_in_maxlevels = level;
1408}
1409
1410/*
1411 * Log specified fields for the ag hdr (inode section)
1412 */
1413void
1414xfs_ialloc_log_agi(
1415 xfs_trans_t *tp, /* transaction pointer */
1416 xfs_buf_t *bp, /* allocation group header buffer */
1417 int fields) /* bitmask of fields to log */
1418{
1419 int first; /* first byte number */
1420 int last; /* last byte number */
1421 static const short offsets[] = { /* field starting offsets */
1422 /* keep in sync with bit definitions */
1423 offsetof(xfs_agi_t, agi_magicnum),
1424 offsetof(xfs_agi_t, agi_versionnum),
1425 offsetof(xfs_agi_t, agi_seqno),
1426 offsetof(xfs_agi_t, agi_length),
1427 offsetof(xfs_agi_t, agi_count),
1428 offsetof(xfs_agi_t, agi_root),
1429 offsetof(xfs_agi_t, agi_level),
1430 offsetof(xfs_agi_t, agi_freecount),
1431 offsetof(xfs_agi_t, agi_newino),
1432 offsetof(xfs_agi_t, agi_dirino),
1433 offsetof(xfs_agi_t, agi_unlinked),
1434 sizeof(xfs_agi_t)
1435 };
1436#ifdef DEBUG
1437 xfs_agi_t *agi; /* allocation group header */
1438
1439 agi = XFS_BUF_TO_AGI(bp);
1440 ASSERT(agi->agi_magicnum == cpu_to_be32(XFS_AGI_MAGIC));
1441#endif
1442 /*
1443 * Compute byte offsets for the first and last fields.
1444 */
1445 xfs_btree_offsets(fields, offsets, XFS_AGI_NUM_BITS, &first, &last);
1446 /*
1447 * Log the allocation group inode header buffer.
1448 */
1449 xfs_trans_log_buf(tp, bp, first, last);
1450}
1451
1452#ifdef DEBUG
1453STATIC void
1454xfs_check_agi_unlinked(
1455 struct xfs_agi *agi)
1456{
1457 int i;
1458
1459 for (i = 0; i < XFS_AGI_UNLINKED_BUCKETS; i++)
1460 ASSERT(agi->agi_unlinked[i]);
1461}
1462#else
1463#define xfs_check_agi_unlinked(agi)
1464#endif
1465
1466/*
1467 * Read in the allocation group header (inode allocation section)
1468 */
1469int
1470xfs_read_agi(
1471 struct xfs_mount *mp, /* file system mount structure */
1472 struct xfs_trans *tp, /* transaction pointer */
1473 xfs_agnumber_t agno, /* allocation group number */
1474 struct xfs_buf **bpp) /* allocation group hdr buf */
1475{
1476 struct xfs_agi *agi; /* allocation group header */
1477 int agi_ok; /* agi is consistent */
1478 int error;
1479
1480 ASSERT(agno != NULLAGNUMBER);
1481
1482 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
1483 XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
1484 XFS_FSS_TO_BB(mp, 1), 0, bpp);
1485 if (error)
1486 return error;
1487
1488 ASSERT(!xfs_buf_geterror(*bpp));
1489 agi = XFS_BUF_TO_AGI(*bpp);
1490
1491 /*
1492 * Validate the magic number of the agi block.
1493 */
1494 agi_ok = agi->agi_magicnum == cpu_to_be32(XFS_AGI_MAGIC) &&
1495 XFS_AGI_GOOD_VERSION(be32_to_cpu(agi->agi_versionnum)) &&
1496 be32_to_cpu(agi->agi_seqno) == agno;
1497 if (unlikely(XFS_TEST_ERROR(!agi_ok, mp, XFS_ERRTAG_IALLOC_READ_AGI,
1498 XFS_RANDOM_IALLOC_READ_AGI))) {
1499 XFS_CORRUPTION_ERROR("xfs_read_agi", XFS_ERRLEVEL_LOW,
1500 mp, agi);
1501 xfs_trans_brelse(tp, *bpp);
1502 return XFS_ERROR(EFSCORRUPTED);
1503 }
1504
1505 XFS_BUF_SET_VTYPE_REF(*bpp, B_FS_AGI, XFS_AGI_REF);
1506
1507 xfs_check_agi_unlinked(agi);
1508 return 0;
1509}
1510
1511int
1512xfs_ialloc_read_agi(
1513 struct xfs_mount *mp, /* file system mount structure */
1514 struct xfs_trans *tp, /* transaction pointer */
1515 xfs_agnumber_t agno, /* allocation group number */
1516 struct xfs_buf **bpp) /* allocation group hdr buf */
1517{
1518 struct xfs_agi *agi; /* allocation group header */
1519 struct xfs_perag *pag; /* per allocation group data */
1520 int error;
1521
1522 error = xfs_read_agi(mp, tp, agno, bpp);
1523 if (error)
1524 return error;
1525
1526 agi = XFS_BUF_TO_AGI(*bpp);
1527 pag = xfs_perag_get(mp, agno);
1528 if (!pag->pagi_init) {
1529 pag->pagi_freecount = be32_to_cpu(agi->agi_freecount);
1530 pag->pagi_count = be32_to_cpu(agi->agi_count);
1531 pag->pagi_init = 1;
1532 }
1533
1534 /*
1535 * It's possible for these to be out of sync if
1536 * we are in the middle of a forced shutdown.
1537 */
1538 ASSERT(pag->pagi_freecount == be32_to_cpu(agi->agi_freecount) ||
1539 XFS_FORCED_SHUTDOWN(mp));
1540 xfs_perag_put(pag);
1541 return 0;
1542}
1543
1544/*
1545 * Read in the agi to initialise the per-ag data in the mount structure
1546 */
1547int
1548xfs_ialloc_pagi_init(
1549 xfs_mount_t *mp, /* file system mount structure */
1550 xfs_trans_t *tp, /* transaction pointer */
1551 xfs_agnumber_t agno) /* allocation group number */
1552{
1553 xfs_buf_t *bp = NULL;
1554 int error;
1555
1556 error = xfs_ialloc_read_agi(mp, tp, agno, &bp);
1557 if (error)
1558 return error;
1559 if (bp)
1560 xfs_trans_brelse(tp, bp);
1561 return 0;
1562}