diff options
Diffstat (limited to 'fs/xfs/xfs_ialloc.c')
| -rw-r--r-- | fs/xfs/xfs_ialloc.c | 2189 |
1 files changed, 0 insertions, 2189 deletions
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c deleted file mode 100644 index 16fb63a9bc5e..000000000000 --- a/fs/xfs/xfs_ialloc.c +++ /dev/null @@ -1,2189 +0,0 @@ -/* - * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc. - * All Rights Reserved. - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License as - * published by the Free Software Foundation. - * - * This program is distributed in the hope that it would be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - */ -#include "xfs.h" -#include "xfs_fs.h" -#include "xfs_shared.h" -#include "xfs_format.h" -#include "xfs_log_format.h" -#include "xfs_trans_resv.h" -#include "xfs_bit.h" -#include "xfs_inum.h" -#include "xfs_sb.h" -#include "xfs_ag.h" -#include "xfs_mount.h" -#include "xfs_inode.h" -#include "xfs_btree.h" -#include "xfs_ialloc.h" -#include "xfs_ialloc_btree.h" -#include "xfs_alloc.h" -#include "xfs_rtalloc.h" -#include "xfs_error.h" -#include "xfs_bmap.h" -#include "xfs_cksum.h" -#include "xfs_trans.h" -#include "xfs_buf_item.h" -#include "xfs_icreate_item.h" -#include "xfs_icache.h" -#include "xfs_dinode.h" -#include "xfs_trace.h" - - -/* - * Allocation group level functions. - */ -static inline int -xfs_ialloc_cluster_alignment( - xfs_alloc_arg_t *args) -{ - if (xfs_sb_version_hasalign(&args->mp->m_sb) && - args->mp->m_sb.sb_inoalignmt >= - XFS_B_TO_FSBT(args->mp, args->mp->m_inode_cluster_size)) - return args->mp->m_sb.sb_inoalignmt; - return 1; -} - -/* - * Lookup a record by ino in the btree given by cur. - */ -int /* error */ -xfs_inobt_lookup( - struct xfs_btree_cur *cur, /* btree cursor */ - xfs_agino_t ino, /* starting inode of chunk */ - xfs_lookup_t dir, /* <=, >=, == */ - int *stat) /* success/failure */ -{ - cur->bc_rec.i.ir_startino = ino; - cur->bc_rec.i.ir_freecount = 0; - cur->bc_rec.i.ir_free = 0; - return xfs_btree_lookup(cur, dir, stat); -} - -/* - * Update the record referred to by cur to the value given. - * This either works (return 0) or gets an EFSCORRUPTED error. - */ -STATIC int /* error */ -xfs_inobt_update( - struct xfs_btree_cur *cur, /* btree cursor */ - xfs_inobt_rec_incore_t *irec) /* btree record */ -{ - union xfs_btree_rec rec; - - rec.inobt.ir_startino = cpu_to_be32(irec->ir_startino); - rec.inobt.ir_freecount = cpu_to_be32(irec->ir_freecount); - rec.inobt.ir_free = cpu_to_be64(irec->ir_free); - return xfs_btree_update(cur, &rec); -} - -/* - * Get the data from the pointed-to record. - */ -int /* error */ -xfs_inobt_get_rec( - struct xfs_btree_cur *cur, /* btree cursor */ - xfs_inobt_rec_incore_t *irec, /* btree record */ - int *stat) /* output: success/failure */ -{ - union xfs_btree_rec *rec; - int error; - - error = xfs_btree_get_rec(cur, &rec, stat); - if (!error && *stat == 1) { - irec->ir_startino = be32_to_cpu(rec->inobt.ir_startino); - irec->ir_freecount = be32_to_cpu(rec->inobt.ir_freecount); - irec->ir_free = be64_to_cpu(rec->inobt.ir_free); - } - return error; -} - -/* - * Insert a single inobt record. Cursor must already point to desired location. - */ -STATIC int -xfs_inobt_insert_rec( - struct xfs_btree_cur *cur, - __int32_t freecount, - xfs_inofree_t free, - int *stat) -{ - cur->bc_rec.i.ir_freecount = freecount; - cur->bc_rec.i.ir_free = free; - return xfs_btree_insert(cur, stat); -} - -/* - * Insert records describing a newly allocated inode chunk into the inobt. - */ -STATIC int -xfs_inobt_insert( - struct xfs_mount *mp, - struct xfs_trans *tp, - struct xfs_buf *agbp, - xfs_agino_t newino, - xfs_agino_t newlen, - xfs_btnum_t btnum) -{ - struct xfs_btree_cur *cur; - struct xfs_agi *agi = XFS_BUF_TO_AGI(agbp); - xfs_agnumber_t agno = be32_to_cpu(agi->agi_seqno); - xfs_agino_t thisino; - int i; - int error; - - cur = xfs_inobt_init_cursor(mp, tp, agbp, agno, btnum); - - for (thisino = newino; - thisino < newino + newlen; - thisino += XFS_INODES_PER_CHUNK) { - error = xfs_inobt_lookup(cur, thisino, XFS_LOOKUP_EQ, &i); - if (error) { - xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); - return error; - } - ASSERT(i == 0); - - error = xfs_inobt_insert_rec(cur, XFS_INODES_PER_CHUNK, - XFS_INOBT_ALL_FREE, &i); - if (error) { - xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); - return error; - } - ASSERT(i == 1); - } - - xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); - - return 0; -} - -/* - * Verify that the number of free inodes in the AGI is correct. - */ -#ifdef DEBUG -STATIC int -xfs_check_agi_freecount( - struct xfs_btree_cur *cur, - struct xfs_agi *agi) -{ - if (cur->bc_nlevels == 1) { - xfs_inobt_rec_incore_t rec; - int freecount = 0; - int error; - int i; - - error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &i); - if (error) - return error; - - do { - error = xfs_inobt_get_rec(cur, &rec, &i); - if (error) - return error; - - if (i) { - freecount += rec.ir_freecount; - error = xfs_btree_increment(cur, 0, &i); - if (error) - return error; - } - } while (i == 1); - - if (!XFS_FORCED_SHUTDOWN(cur->bc_mp)) - ASSERT(freecount == be32_to_cpu(agi->agi_freecount)); - } - return 0; -} -#else -#define xfs_check_agi_freecount(cur, agi) 0 -#endif - -/* - * Initialise a new set of inodes. When called without a transaction context - * (e.g. from recovery) we initiate a delayed write of the inode buffers rather - * than logging them (which in a transaction context puts them into the AIL - * for writeback rather than the xfsbufd queue). - */ -int -xfs_ialloc_inode_init( - struct xfs_mount *mp, - struct xfs_trans *tp, - struct list_head *buffer_list, - xfs_agnumber_t agno, - xfs_agblock_t agbno, - xfs_agblock_t length, - unsigned int gen) -{ - struct xfs_buf *fbuf; - struct xfs_dinode *free; - int nbufs, blks_per_cluster, inodes_per_cluster; - int version; - int i, j; - xfs_daddr_t d; - xfs_ino_t ino = 0; - - /* - * Loop over the new block(s), filling in the inodes. For small block - * sizes, manipulate the inodes in buffers which are multiples of the - * blocks size. - */ - blks_per_cluster = xfs_icluster_size_fsb(mp); - inodes_per_cluster = blks_per_cluster << mp->m_sb.sb_inopblog; - nbufs = length / blks_per_cluster; - - /* - * Figure out what version number to use in the inodes we create. If - * the superblock version has caught up to the one that supports the new - * inode format, then use the new inode version. Otherwise use the old - * version so that old kernels will continue to be able to use the file - * system. - * - * For v3 inodes, we also need to write the inode number into the inode, - * so calculate the first inode number of the chunk here as - * XFS_OFFBNO_TO_AGINO() only works within a filesystem block, not - * across multiple filesystem blocks (such as a cluster) and so cannot - * be used in the cluster buffer loop below. - * - * Further, because we are writing the inode directly into the buffer - * and calculating a CRC on the entire inode, we have ot log the entire - * inode so that the entire range the CRC covers is present in the log. - * That means for v3 inode we log the entire buffer rather than just the - * inode cores. - */ - if (xfs_sb_version_hascrc(&mp->m_sb)) { - version = 3; - ino = XFS_AGINO_TO_INO(mp, agno, - XFS_OFFBNO_TO_AGINO(mp, agbno, 0)); - - /* - * log the initialisation that is about to take place as an - * logical operation. This means the transaction does not - * need to log the physical changes to the inode buffers as log - * recovery will know what initialisation is actually needed. - * Hence we only need to log the buffers as "ordered" buffers so - * they track in the AIL as if they were physically logged. - */ - if (tp) - xfs_icreate_log(tp, agno, agbno, mp->m_ialloc_inos, - mp->m_sb.sb_inodesize, length, gen); - } else - version = 2; - - for (j = 0; j < nbufs; j++) { - /* - * Get the block. - */ - d = XFS_AGB_TO_DADDR(mp, agno, agbno + (j * blks_per_cluster)); - fbuf = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, - mp->m_bsize * blks_per_cluster, - XBF_UNMAPPED); - if (!fbuf) - return ENOMEM; - - /* Initialize the inode buffers and log them appropriately. */ - fbuf->b_ops = &xfs_inode_buf_ops; - xfs_buf_zero(fbuf, 0, BBTOB(fbuf->b_length)); - for (i = 0; i < inodes_per_cluster; i++) { - int ioffset = i << mp->m_sb.sb_inodelog; - uint isize = xfs_dinode_size(version); - - free = xfs_make_iptr(mp, fbuf, i); - free->di_magic = cpu_to_be16(XFS_DINODE_MAGIC); - free->di_version = version; - free->di_gen = cpu_to_be32(gen); - free->di_next_unlinked = cpu_to_be32(NULLAGINO); - - if (version == 3) { - free->di_ino = cpu_to_be64(ino); - ino++; - uuid_copy(&free->di_uuid, &mp->m_sb.sb_uuid); - xfs_dinode_calc_crc(mp, free); - } else if (tp) { - /* just log the inode core */ - xfs_trans_log_buf(tp, fbuf, ioffset, - ioffset + isize - 1); - } - } - - if (tp) { - /* - * Mark the buffer as an inode allocation buffer so it - * sticks in AIL at the point of this allocation - * transaction. This ensures the they are on disk before - * the tail of the log can be moved past this - * transaction (i.e. by preventing relogging from moving - * it forward in the log). - */ - xfs_trans_inode_alloc_buf(tp, fbuf); - if (version == 3) { - /* - * Mark the buffer as ordered so that they are - * not physically logged in the transaction but - * still tracked in the AIL as part of the - * transaction and pin the log appropriately. - */ - xfs_trans_ordered_buf(tp, fbuf); - xfs_trans_log_buf(tp, fbuf, 0, - BBTOB(fbuf->b_length) - 1); - } - } else { - fbuf->b_flags |= XBF_DONE; - xfs_buf_delwri_queue(fbuf, buffer_list); - xfs_buf_relse(fbuf); - } - } - return 0; -} - -/* - * Allocate new inodes in the allocation group specified by agbp. - * Return 0 for success, else error code. - */ -STATIC int /* error code or 0 */ -xfs_ialloc_ag_alloc( - xfs_trans_t *tp, /* transaction pointer */ - xfs_buf_t *agbp, /* alloc group buffer */ - int *alloc) -{ - xfs_agi_t *agi; /* allocation group header */ - xfs_alloc_arg_t args; /* allocation argument structure */ - xfs_agnumber_t agno; - int error; - xfs_agino_t newino; /* new first inode's number */ - xfs_agino_t newlen; /* new number of inodes */ - int isaligned = 0; /* inode allocation at stripe unit */ - /* boundary */ - struct xfs_perag *pag; - - memset(&args, 0, sizeof(args)); - args.tp = tp; - args.mp = tp->t_mountp; - - /* - * Locking will ensure that we don't have two callers in here - * at one time. - */ - newlen = args.mp->m_ialloc_inos; - if (args.mp->m_maxicount && - args.mp->m_sb.sb_icount + newlen > args.mp->m_maxicount) - return ENOSPC; - args.minlen = args.maxlen = args.mp->m_ialloc_blks; - /* - * First try to allocate inodes contiguous with the last-allocated - * chunk of inodes. If the filesystem is striped, this will fill - * an entire stripe unit with inodes. - */ - agi = XFS_BUF_TO_AGI(agbp); - newino = be32_to_cpu(agi->agi_newino); - agno = be32_to_cpu(agi->agi_seqno); - args.agbno = XFS_AGINO_TO_AGBNO(args.mp, newino) + - args.mp->m_ialloc_blks; - if (likely(newino != NULLAGINO && - (args.agbno < be32_to_cpu(agi->agi_length)))) { - args.fsbno = XFS_AGB_TO_FSB(args.mp, agno, args.agbno); - args.type = XFS_ALLOCTYPE_THIS_BNO; - args.prod = 1; - - /* - * We need to take into account alignment here to ensure that - * we don't modify the free list if we fail to have an exact - * block. If we don't have an exact match, and every oher - * attempt allocation attempt fails, we'll end up cancelling - * a dirty transaction and shutting down. - * - * For an exact allocation, alignment must be 1, - * however we need to take cluster alignment into account when - * fixing up the freelist. Use the minalignslop field to - * indicate that extra blocks might be required for alignment, - * but not to use them in the actual exact allocation. - */ - args.alignment = 1; - args.minalignslop = xfs_ialloc_cluster_alignment(&args) - 1; - - /* Allow space for the inode btree to split. */ - args.minleft = args.mp->m_in_maxlevels - 1; - if ((error = xfs_alloc_vextent(&args))) - return error; - - /* - * This request might have dirtied the transaction if the AG can - * satisfy the request, but the exact block was not available. - * If the allocation did fail, subsequent requests will relax - * the exact agbno requirement and increase the alignment - * instead. It is critical that the total size of the request - * (len + alignment + slop) does not increase from this point - * on, so reset minalignslop to ensure it is not included in - * subsequent requests. - */ - args.minalignslop = 0; - } else - args.fsbno = NULLFSBLOCK; - - if (unlikely(args.fsbno == NULLFSBLOCK)) { - /* - * Set the alignment for the allocation. - * If stripe alignment is turned on then align at stripe unit - * boundary. - * If the cluster size is smaller than a filesystem block - * then we're doing I/O for inodes in filesystem block size - * pieces, so don't need alignment anyway. - */ - isaligned = 0; - if (args.mp->m_sinoalign) { - ASSERT(!(args.mp->m_flags & XFS_MOUNT_NOALIGN)); - args.alignment = args.mp->m_dalign; - isaligned = 1; - } else - args.alignment = xfs_ialloc_cluster_alignment(&args); - /* - * Need to figure out where to allocate the inode blocks. - * Ideally they should be spaced out through the a.g. - * For now, just allocate blocks up front. - */ - args.agbno = be32_to_cpu(agi->agi_root); - args.fsbno = XFS_AGB_TO_FSB(args.mp, agno, args.agbno); - /* - * Allocate a fixed-size extent of inodes. - */ - args.type = XFS_ALLOCTYPE_NEAR_BNO; - args.prod = 1; - /* - * Allow space for the inode btree to split. - */ - args.minleft = args.mp->m_in_maxlevels - 1; - if ((error = xfs_alloc_vextent(&args))) - return error; - } - - /* - * If stripe alignment is turned on, then try again with cluster - * alignment. - */ - if (isaligned && args.fsbno == NULLFSBLOCK) { - args.type = XFS_ALLOCTYPE_NEAR_BNO; - args.agbno = be32_to_cpu(agi->agi_root); - args.fsbno = XFS_AGB_TO_FSB(args.mp, agno, args.agbno); - args.alignment = xfs_ialloc_cluster_alignment(&args); - if ((error = xfs_alloc_vextent(&args))) - return error; - } - - if (args.fsbno == NULLFSBLOCK) { - *alloc = 0; - return 0; - } - ASSERT(args.len == args.minlen); - - /* - * Stamp and write the inode buffers. - * - * Seed the new inode cluster with a random generation number. This - * prevents short-term reuse of generation numbers if a chunk is - * freed and then immediately reallocated. We use random numbers - * rather than a linear progression to prevent the next generation - * number from being easily guessable. - */ - error = xfs_ialloc_inode_init(args.mp, tp, NULL, agno, args.agbno, - args.len, prandom_u32()); - - if (error) - return error; - /* - * Convert the results. - */ - newino = XFS_OFFBNO_TO_AGINO(args.mp, args.agbno, 0); - be32_add_cpu(&agi->agi_count, newlen); - be32_add_cpu(&agi->agi_freecount, newlen); - pag = xfs_perag_get(args.mp, agno); - pag->pagi_freecount += newlen; - xfs_perag_put(pag); - agi->agi_newino = cpu_to_be32(newino); - - /* - * Insert records describing the new inode chunk into the btrees. - */ - error = xfs_inobt_insert(args.mp, tp, agbp, newino, newlen, - XFS_BTNUM_INO); - if (error) - return error; - - if (xfs_sb_version_hasfinobt(&args.mp->m_sb)) { - error = xfs_inobt_insert(args.mp, tp, agbp, newino, newlen, - XFS_BTNUM_FINO); - if (error) - return error; - } - /* - * Log allocation group header fields - */ - xfs_ialloc_log_agi(tp, agbp, - XFS_AGI_COUNT | XFS_AGI_FREECOUNT | XFS_AGI_NEWINO); - /* - * Modify/log superblock values for inode count and inode free count. - */ - xfs_trans_mod_sb(tp, XFS_TRANS_SB_ICOUNT, (long)newlen); - xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, (long)newlen); - *alloc = 1; - return 0; -} - -STATIC xfs_agnumber_t -xfs_ialloc_next_ag( - xfs_mount_t *mp) -{ - xfs_agnumber_t agno; - - spin_lock(&mp->m_agirotor_lock); - agno = mp->m_agirotor; - if (++mp->m_agirotor >= mp->m_maxagi) - mp->m_agirotor = 0; - spin_unlock(&mp->m_agirotor_lock); - - return agno; -} - -/* - * Select an allocation group to look for a free inode in, based on the parent - * inode and the mode. Return the allocation group buffer. - */ -STATIC xfs_agnumber_t -xfs_ialloc_ag_select( - xfs_trans_t *tp, /* transaction pointer */ - xfs_ino_t parent, /* parent directory inode number */ - umode_t mode, /* bits set to indicate file type */ - int okalloc) /* ok to allocate more space */ -{ - xfs_agnumber_t agcount; /* number of ag's in the filesystem */ - xfs_agnumber_t agno; /* current ag number */ - int flags; /* alloc buffer locking flags */ - xfs_extlen_t ineed; /* blocks needed for inode allocation */ - xfs_extlen_t longest = 0; /* longest extent available */ - xfs_mount_t *mp; /* mount point structure */ - int needspace; /* file mode implies space allocated */ - xfs_perag_t *pag; /* per allocation group data */ - xfs_agnumber_t pagno; /* parent (starting) ag number */ - int error; - - /* - * Files of these types need at least one block if length > 0 - * (and they won't fit in the inode, but that's hard to figure out). - */ - needspace = S_ISDIR(mode) || S_ISREG(mode) || S_ISLNK(mode); - mp = tp->t_mountp; - agcount = mp->m_maxagi; - if (S_ISDIR(mode)) - pagno = xfs_ialloc_next_ag(mp); - else { - pagno = XFS_INO_TO_AGNO(mp, parent); - if (pagno >= agcount) - pagno = 0; - } - - ASSERT(pagno < agcount); - - /* - * Loop through allocation groups, looking for one with a little - * free space in it. Note we don't look for free inodes, exactly. - * Instead, we include whether there is a need to allocate inodes - * to mean that blocks must be allocated for them, - * if none are currently free. - */ - agno = pagno; - flags = XFS_ALLOC_FLAG_TRYLOCK; - for (;;) { - pag = xfs_perag_get(mp, agno); - if (!pag->pagi_inodeok) { - xfs_ialloc_next_ag(mp); - goto nextag; - } - - if (!pag->pagi_init) { - error = xfs_ialloc_pagi_init(mp, tp, agno); - if (error) - goto nextag; - } - - if (pag->pagi_freecount) { - xfs_perag_put(pag); - return agno; - } - - if (!okalloc) - goto nextag; - - if (!pag->pagf_init) { - error = xfs_alloc_pagf_init(mp, tp, agno, flags); - if (error) - goto nextag; - } - - /* - * Is there enough free space for the file plus a block of - * inodes? (if we need to allocate some)? - */ - ineed = mp->m_ialloc_blks; - longest = pag->pagf_longest; - if (!longest) - longest = pag->pagf_flcount > 0; - - if (pag->pagf_freeblks >= needspace + ineed && - longest >= ineed) { - xfs_perag_put(pag); - return agno; - } -nextag: - xfs_perag_put(pag); - /* - * No point in iterating over the rest, if we're shutting - * down. - */ - if (XFS_FORCED_SHUTDOWN(mp)) - return NULLAGNUMBER; - agno++; - if (agno >= agcount) - agno = 0; - if (agno == pagno) { - if (flags == 0) - return NULLAGNUMBER; - flags = 0; - } - } -} - -/* - * Try to retrieve the next record to the left/right from the current one. - */ -STATIC int -xfs_ialloc_next_rec( - struct xfs_btree_cur *cur, - xfs_inobt_rec_incore_t *rec, - int *done, - int left) -{ - int error; - int i; - - if (left) - error = xfs_btree_decrement(cur, 0, &i); - else - error = xfs_btree_increment(cur, 0, &i); - - if (error) - return error; - *done = !i; - if (i) { - error = xfs_inobt_get_rec(cur, rec, &i); - if (error) - return error; - XFS_WANT_CORRUPTED_RETURN(i == 1); - } - - return 0; -} - -STATIC int -xfs_ialloc_get_rec( - struct xfs_btree_cur *cur, - xfs_agino_t agino, - xfs_inobt_rec_incore_t *rec, - int *done) -{ - int error; - int i; - - error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_EQ, &i); - if (error) - return error; - *done = !i; - if (i) { - error = xfs_inobt_get_rec(cur, rec, &i); - if (error) - return error; - XFS_WANT_CORRUPTED_RETURN(i == 1); - } - - return 0; -} - -/* - * Allocate an inode using the inobt-only algorithm. - */ -STATIC int -xfs_dialloc_ag_inobt( - struct xfs_trans *tp, - struct xfs_buf *agbp, - xfs_ino_t parent, - xfs_ino_t *inop) -{ - struct xfs_mount *mp = tp->t_mountp; - struct xfs_agi *agi = XFS_BUF_TO_AGI(agbp); - xfs_agnumber_t agno = be32_to_cpu(agi->agi_seqno); - xfs_agnumber_t pagno = XFS_INO_TO_AGNO(mp, parent); - xfs_agino_t pagino = XFS_INO_TO_AGINO(mp, parent); - struct xfs_perag *pag; - struct xfs_btree_cur *cur, *tcur; - struct xfs_inobt_rec_incore rec, trec; - xfs_ino_t ino; - int error; - int offset; - int i, j; - - pag = xfs_perag_get(mp, agno); - - ASSERT(pag->pagi_init); - ASSERT(pag->pagi_inodeok); - ASSERT(pag->pagi_freecount > 0); - - restart_pagno: - cur = xfs_inobt_init_cursor(mp, tp, agbp, agno, XFS_BTNUM_INO); - /* - * If pagino is 0 (this is the root inode allocation) use newino. - * This must work because we've just allocated some. - */ - if (!pagino) - pagino = be32_to_cpu(agi->agi_newino); - - error = xfs_check_agi_freecount(cur, agi); - if (error) - goto error0; - - /* - * If in the same AG as the parent, try to get near the parent. - */ - if (pagno == agno) { - int doneleft; /* done, to the left */ - int doneright; /* done, to the right */ - int searchdistance = 10; - - error = xfs_inobt_lookup(cur, pagino, XFS_LOOKUP_LE, &i); - if (error) - goto error0; - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); - - error = xfs_inobt_get_rec(cur, &rec, &j); - if (error) - goto error0; - XFS_WANT_CORRUPTED_GOTO(j == 1, error0); - - if (rec.ir_freecount > 0) { - /* - * Found a free inode in the same chunk - * as the parent, done. - */ - goto alloc_inode; - } - - - /* - * In the same AG as parent, but parent's chunk is full. - */ - - /* duplicate the cursor, search left & right simultaneously */ - error = xfs_btree_dup_cursor(cur, &tcur); - if (error) - goto error0; - - /* - * Skip to last blocks looked up if same parent inode. - */ - if (pagino != NULLAGINO && - pag->pagl_pagino == pagino && - pag->pagl_leftrec != NULLAGINO && - pag->pagl_rightrec != NULLAGINO) { - error = xfs_ialloc_get_rec(tcur, pag->pagl_leftrec, - &trec, &doneleft); - if (error) - goto error1; - - error = xfs_ialloc_get_rec(cur, pag->pagl_rightrec, - &rec, &doneright); - if (error) - goto error1; - } else { - /* search left with tcur, back up 1 record */ - error = xfs_ialloc_next_rec(tcur, &trec, &doneleft, 1); - if (error) - goto error1; - - /* search right with cur, go forward 1 record. */ - error = xfs_ialloc_next_rec(cur, &rec, &doneright, 0); - if (error) - goto error1; - } - - /* - * Loop until we find an inode chunk with a free inode. - */ - while (!doneleft || !doneright) { - int useleft; /* using left inode chunk this time */ - - if (!--searchdistance) { - /* - * Not in range - save last search - * location and allocate a new inode - */ - xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR); - pag->pagl_leftrec = trec.ir_startino; - pag->pagl_rightrec = rec.ir_startino; - pag->pagl_pagino = pagino; - goto newino; - } - - /* figure out the closer block if both are valid. */ - if (!doneleft && !doneright) { - useleft = pagino - - (trec.ir_startino + XFS_INODES_PER_CHUNK - 1) < - rec.ir_startino - pagino; - } else { - useleft = !doneleft; - } - - /* free inodes to the left? */ - if (useleft && trec.ir_freecount) { - rec = trec; - xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); - cur = tcur; - - pag->pagl_leftrec = trec.ir_startino; - pag->pagl_rightrec = rec.ir_startino; - pag->pagl_pagino = pagino; - goto alloc_inode; - } - - /* free inodes to the right? */ - if (!useleft && rec.ir_freecount) { - xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR); - - pag->pagl_leftrec = trec.ir_startino; - pag->pagl_rightrec = rec.ir_startino; - pag->pagl_pagino = pagino; - goto alloc_inode; - } - - /* get next record to check */ - if (useleft) { - error = xfs_ialloc_next_rec(tcur, &trec, - &doneleft, 1); - } else { - error = xfs_ialloc_next_rec(cur, &rec, - &doneright, 0); - } - if (error) - goto error1; - } - - /* - * We've reached the end of the btree. because - * we are only searching a small chunk of the - * btree each search, there is obviously free - * inodes closer to the parent inode than we - * are now. restart the search again. - */ - pag->pagl_pagino = NULLAGINO; - pag->pagl_leftrec = NULLAGINO; - pag->pagl_rightrec = NULLAGINO; - xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR); - xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); - goto restart_pagno; - } - - /* - * In a different AG from the parent. - * See if the most recently allocated block has any free. - */ -newino: - if (agi->agi_newino != cpu_to_be32(NULLAGINO)) { - error = xfs_inobt_lookup(cur, be32_to_cpu(agi->agi_newino), - XFS_LOOKUP_EQ, &i); - if (error) - goto error0; - - if (i == 1) { - error = xfs_inobt_get_rec(cur, &rec, &j); - if (error) - goto error0; - - if (j == 1 && rec.ir_freecount > 0) { - /* - * The last chunk allocated in the group - * still has a free inode. - */ - goto alloc_inode; - } - } - } - - /* - * None left in the last group, search the whole AG - */ - error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &i); - if (error) - goto error0; - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); - - for (;;) { - error = xfs_inobt_get_rec(cur, &rec, &i); - if (error) - goto error0; - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); - if (rec.ir_freecount > 0) - break; - error = xfs_btree_increment(cur, 0, &i); - if (error) - goto error0; - XFS_WANT_CORRUPTED_GOTO(i == 1, error0); - } - -alloc_inode: - offset = xfs_lowbit64(rec.ir_free); - ASSERT(offset >= 0); - ASSERT(offset < XFS_INODES_PER_CHUNK); - ASSERT((XFS_AGINO_TO_OFFSET(mp, rec.ir_startino) % - XFS_INODES_PER_CHUNK) == 0); - ino = XFS_AGINO_TO_INO(mp, agno, rec.ir_startino + offset); - rec.ir_free &= ~XFS_INOBT_MASK(offset); - rec.ir_freecount--; - error = xfs_inobt_update(cur, &rec); - if (error) - goto error0; - be32_add_cpu(&agi->agi_freecount, -1); - xfs_ialloc_log_agi(tp, agbp, XFS_AGI_FREECOUNT); - pag->pagi_freecount--; - - error = xfs_check_agi_freecount(cur, agi); - if (error) - goto error0; - - xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR); - xfs_trans_mod_sb(tp, XFS_TRANS_SB_IFREE, -1); - xfs_perag_put(pag); - *inop = ino; - return 0; -error1: - xfs_btree_del_cursor(tcur, XFS_BTREE_ERROR); -error0: - xfs_btree_del_cursor(cur, XFS_BTREE_ERROR); - xfs_perag_put(pag); - return error; -} - -/* - * Use the free inode btree to allocate an inode based on distance from the - * parent. Note that the provided cursor may be deleted and replaced. - */ -STATIC int -xfs_dialloc_ag_finobt_near( - xfs_agino_t pagino, - struct xfs_btree_cur **ocur, - struct xfs_inobt_rec_incore *rec) -{ - struct xfs_btree_cur *lcur = *ocur; /* left search cursor */ - struct xfs_btree_cur *rcur; /* right search cursor */ - struct xfs_inobt_rec_incore rrec; - int error; - int i, j; - - error = xfs_inobt_lookup(lcur, pagino, XFS_LOOKUP_LE, &i); - if (error) - return error; - - if (i == 1) { - error = xfs_inobt_get_rec(lcur, rec, &i); - if (error) - return error; - XFS_WANT_CORRUPTED_RETURN(i == 1); - - /* - * See if we've landed in the parent inode record. The finobt - * only tracks chunks with at least one free inode, so record - * existence is enough. - */ - if (pagino >= rec->ir_startino && - pagino < (rec->ir_startino + XFS_INODES_PER_CHUNK)) - return 0; - } - - error = xfs_btree_dup_cursor(lcur, &rcur); - if (error) - return error; - - error = xfs_inobt_lookup(rcur, pagino, XFS_LOOKUP_GE, &j); - if (error) - goto error_rcur; - if (j == 1) { - error = xfs_inobt_get_rec(rcur, &rrec, &j); - if (error) - goto error_rcur; - XFS_WANT_CORRUPTED_GOTO(j == 1, error_rcur); - } - - XFS_WANT_CORRUPTED_GOTO(i == 1 || j == 1, error_rcur); - if (i == 1 && j == 1) { - /* - * Both the left and right records are valid. Choose the closer - * inode chunk to the target. - */ - if ((pagino - rec->ir_startino + XFS_INODES_PER_CHUNK - 1) > - (rrec.ir_startino - pagino)) { - *rec = rrec; - xfs_btree_del_cursor(lcur, XFS_BTREE_NOERROR); - *ocur = rcur; - } else { - xfs_btree_del_cursor(rcur, XFS_BTREE_NOERROR); - } - } else if (j == 1) { - /* only the right record is valid */ - *rec = rrec; - xfs_btree_del_cursor(lcur, XFS_BTREE_NOERROR); - *ocur = rcur; - } else if (i == 1) { - /* only the left record is valid */ - xfs_btree_del_cursor(rcur, XFS_BTREE_NOERROR); - } - - return 0; - -error_rcur: - xfs_btree_del_cursor(rcur, XFS_BTREE_ERROR); - return error; -} - -/* - * Use the free inode btree to find a free inode based on a newino hint. If - * the hint is NULL, find the first free inode in the AG. - */ -STATIC int -xfs_dialloc_ag_finobt_newino( - struct xfs_agi *agi, - struct xfs_btree_cur *cur, - struct xfs_inobt_rec_incore *rec) -{ - int error; - int i; - - if (agi->agi_newino != cpu_to_be32(NULLAGINO)) { - error = xfs_inobt_lookup(cur, agi->agi_newino, XFS_LOOKUP_EQ, - &i); - if (error) - return error; - if (i == 1) { - error = xfs_inobt_get_rec(cur, rec, &i); - if (error) - return error; - XFS_WANT_CORRUPTED_RETURN(i == 1); - - return 0; - } - } - - /* - * Find the first inode available in the AG. - */ - error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &i); - if (error) - return error; - XFS_WANT_CORRUPTED_RETURN(i == 1); - - error = xfs_inobt_get_rec(cur, rec, &i); - if (error) - return error; - XFS_WANT_CORRUPTED_RETURN(i == 1); - - return 0; -} - -/* - * Update the inobt based on a modification made to the finobt. Also ensure that - * the records from both trees are equivalent post-modification. - */ -STATIC int -xfs_dialloc_ag_update_inobt( - struct xfs_btree_cur *cur, /* inobt cursor */ - struct xfs_inobt_rec_incore *frec, /* finobt record */ - int offset) /* inode offset */ -{ - struct xfs_inobt_rec_incore rec; - int error; - int i; - - error = xfs_inobt_lookup(cur, frec->ir_startino, XFS_LOOKUP_EQ, &i); - if (error) - return error; - XFS_WANT_CORRUPTED_RETURN(i == 1); - - error = xfs_inobt_get_rec(cur, &rec, &i); - if (error) - return error; - XFS_WANT_CORRUPTED_RETURN(i == 1); - ASSERT((XFS_AGINO_TO_OFFSET(cur->bc_mp, rec.ir_startino) % - XFS_INODES_PER_CHUNK) == 0); - - rec.ir_free &= ~XFS_INOBT_MASK(offset); - rec.ir_freecount--; - - XFS_WANT_CORRUPTED_RETURN((rec.ir_free == frec->ir_free) && - (rec.ir_freecount == frec->ir_freecount)); - - error = xfs_inobt_update(cur, &rec); - if (error) - return error; - - return 0; -} - -/* - * Allocate an inode using the free inode btree, if available. Otherwise, fall - * back to the inobt search algorithm. - * - * The caller selected an AG for us, and made sure that free inodes are - * available. - */ -STATIC int -xfs_dialloc_ag( - struct xfs_trans *tp, - struct xfs_buf *agbp, - xfs_ino_t parent, - xfs_ino_t *inop) -{ - struct xfs_mount *mp = tp->t_mountp; - struct xfs_agi *agi = XFS_BUF_TO_AGI(agbp); - xfs_agnumber_t agno = be32_to_cpu(agi->agi_seqno); - xfs_agnumber_t pagno = XFS_INO_TO_AGNO(mp, parent); - xfs_agino_t pagino = XFS_INO_TO_AGINO(mp, parent); - struct xfs_perag *pag; - struct xfs_btree_cur *cur; /* finobt cursor */ - struct xfs_btree_cur *icur; /* inobt cursor */ - struct xfs_inobt_rec_incore rec; - xfs_ino_t ino; - int error; - int offset; - int i; - - if (!xfs_sb_version_hasfinobt(&mp->m_sb)) - return xfs_dialloc_ag_inobt(tp, agbp, parent, inop); - - pag = xfs_perag_get(mp, agno); - - /* - * If pagino is 0 (this is the root inode allocation) use newino. - * This must work because we've just allocated some. - */ |