// SPDX-License-Identifier: GPL-2.0 /* * Copyright ( c ) 2000 - 2006 Silicon Graphics , Inc . * Copyright ( c ) 2016 - 2018 Christoph Hellwig . * All Rights Reserved . #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_mount.h" #include "xfs_inode.h" #include "xfs_btree.h" #include "xfs_bmap_btree.h" #include "xfs_bmap.h" #include "xfs_bmap_util.h" #include "xfs_errortag.h" #include "xfs_error.h" #include "xfs_trans.h" #include "xfs_trans_space.h" #include "xfs_inode_item.h" #include "xfs_iomap.h" #include "xfs_trace.h" #include "xfs_quota.h" #include "xfs_rtgroup.h" #include "xfs_dquot_item.h" #include "xfs_dquot.h" #include "xfs_reflink.h" #include "xfs_health.h" #include "xfs_rtbitmap.h" #include "xfs_icache.h" #include "xfs_zone_alloc.h" #define XFS_ALLOC_ALIGN(mp, off) \static int "Access to block zero in inode %llu " "start_block: %llx start_off: %llx " "blkcnt: %llx extent-state: %x" ,unsigned long long )ip->i_ino,unsigned long long )imap->br_startblock,unsigned long long )imap->br_startoff,unsigned long long )imap->br_blockcount,return -EFSCORRUPTED;struct xfs_inode *ip,0 ;if (iomap_flags & IOMAP_F_XATTR)return READ_ONCE(ip->i_af.if_seq);if ((iomap_flags & IOMAP_F_SHARED) && ip->i_cowfp)32 ;return cookie | READ_ONCE(ip->i_df.if_seq);/* * Check that the iomap passed to us is still valid for the given offset and * length . static bool struct inode *inode,const struct iomap *iomap)struct xfs_inode *ip = XFS_I(inode);if (iomap->type == IOMAP_HOLE)return true ;if (iomap->validity_cookie !=return false ;return true ;const struct iomap_write_ops xfs_iomap_write_ops = {int struct xfs_inode *ip,struct iomap *iomap,struct xfs_bmbt_irec *imap,unsigned int mapping_flags,struct xfs_mount *mp = ip->i_mount;struct xfs_buftarg *target = xfs_inode_buftarg(ip);if (unlikely(!xfs_valid_startblock(ip, imap->br_startblock))) {return xfs_alert_fsblock_zero(ip, imap);if (imap->br_startblock == HOLESTARTBLOCK) {else if (imap->br_startblock == DELAYSTARTBLOCK ||else {if (mapping_flags & IOMAP_DAX)if (imap->br_state == XFS_EXT_UNWRITTEN)else /* * Mark iomaps starting at the first sector of a RTG as merge * boundary so that each I / O completions is contained to a * single RTG . if (XFS_IS_REALTIME_INODE(ip) && xfs_has_rtgroups(mp) &&if (mapping_flags & IOMAP_DAX)else if (xfs_ipincount(ip) &&return 0 ;static void struct xfs_inode *ip,struct iomap *iomap,struct xfs_buftarg *target = xfs_inode_buftarg(ip);static inline xfs_fileoff_tstruct xfs_mount *mp,return min(XFS_B_TO_FSB(mp, offset + count),static xfs_extlen_tstruct xfs_inode *ip)struct xfs_mount *mp = ip->i_mount;0 ;if (!XFS_IS_REALTIME_INODE(ip)) {/* * Round up the allocation request to a stripe unit * ( m_dalign ) boundary if the file size is > = stripe unit * size , and we are allocating past the allocation eof . * * If mounted with the " - o swalloc " option the alignment is * increased from the strip unit size to the stripe width . if (mp->m_swidth && xfs_has_swalloc(mp))else if (mp->m_dalign)if (align && XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, align))0 ;return align;/* * Check if last_fsb is outside the last extent , and if so grow it to the next * stripe unit boundary . struct xfs_inode *ip,struct xfs_ifork *ifp = xfs_ifork_ptr(ip, XFS_DATA_FORK);struct xfs_bmbt_irec irec;struct xfs_iext_cursor icur;/* * Always round up the allocation request to the extent hint boundary . if (extsz) {if (align)else if (align) {if (!xfs_iext_get_extent(ifp, &icur, &irec) ||return aligned_end_fsb;return end_fsb;int struct xfs_inode *ip,unsigned int flags,struct xfs_bmbt_irec *imap,struct xfs_mount *mp = ip->i_mount;struct xfs_trans *tp;int nimaps;unsigned int dblocks, rblocks;bool force = false ;int error;int bmapi_flags = XFS_BMAPI_PREALLOC;int nr_exts = XFS_IEXT_ADD_NOSPLIT_CNT;0 );if (unlikely(XFS_IS_REALTIME_INODE(ip))) {0 );else {0 ;if (error)return error;/* * For DAX , we do not allocate unwritten extents , but instead we zero * the block before we commit the transaction . Ideally we ' d like to do * this outside the transaction context , but if we commit and then crash * we may not have zeroed the blocks and this will be exposed on * recovery of the allocation . Hence we must zero before commit . * * Further , if we are mapping unwritten extents here , we need to zero * and convert them to written so that we don ' t need an unwritten extent * callback for DAX . This also means that we need to be able to dip into * the reserve block pool for bmbt block allocation if there is no space * left but we need to do unwritten extent conversion . if (flags & IOMAP_DAX) {if (imap->br_state == XFS_EXT_UNWRITTEN) {true ;0 ) << 1 ;if (error)return error;if (error)goto out_trans_cancel;/* * From this point onwards we overwrite the imap pointer that the * caller gave to us . 1 ;0 ,if (error)goto out_trans_cancel;/* * Complete the transaction if (error)goto out_unlock;if (unlikely(!xfs_valid_startblock(ip, imap->br_startblock))) {0 );return error;goto out_unlock;STATIC bool struct xfs_inode *ip,struct xfs_dquot *dq = xfs_inode_dquot(ip, type);struct xfs_dquot_res *res;struct xfs_dquot_pre *pre;if (!dq || !xfs_this_quota_on(ip->i_mount, type))return false ;if (XFS_IS_REALTIME_INODE(ip)) {else {/* no hi watermark, no throttle */ if (!pre->q_prealloc_hi_wmark)return false ;/* under the lo watermark, no throttle */ if (res->reserved + alloc_blocks < pre->q_prealloc_lo_wmark)return false ;return true ;STATIC void struct xfs_inode *ip,int *qshift,struct xfs_dquot *dq = xfs_inode_dquot(ip, type);struct xfs_dquot_res *res;struct xfs_dquot_pre *pre;int shift = 0 ;if (!dq) {else if (XFS_IS_REALTIME_INODE(ip)) {else {/* no dq, or over hi wmark, squash the prealloc completely */ if (!res || res->reserved >= pre->q_prealloc_hi_wmark) {0 ;0 ;return ;if (freesp < pre->q_low_space[XFS_QLOWSP_5_PCNT]) {2 ;if (freesp < pre->q_low_space[XFS_QLOWSP_3_PCNT])2 ;if (freesp < pre->q_low_space[XFS_QLOWSP_1_PCNT])2 ;if (freesp < *qfreesp)/* only overwrite the throttle values if we are more aggressive */ if ((freesp >> shift) < (*qblocks >> *qshift)) {static int64_tstruct xfs_mount *mp,unsigned int idx,int *shift)if (freesp < low_space[XFS_LOWSP_5_PCNT]) {2 ;if (freesp < low_space[XFS_LOWSP_4_PCNT])if (freesp < low_space[XFS_LOWSP_3_PCNT])if (freesp < low_space[XFS_LOWSP_2_PCNT])if (freesp < low_space[XFS_LOWSP_1_PCNT])return freesp;/* * If we don ' t have a user specified preallocation size , dynamically increase * the preallocation size as the size of the file grows . Cap the maximum size * at a single extent or less if the filesystem is near full . The closer the * filesystem is to being full , the smaller the maximum preallocation . STATIC xfs_fsblock_tstruct xfs_inode *ip,int whichfork,struct xfs_iext_cursor *icur)struct xfs_iext_cursor ncur = *icur;struct xfs_bmbt_irec prev, got;struct xfs_mount *mp = ip->i_mount;struct xfs_ifork *ifp = xfs_ifork_ptr(ip, whichfork);0 ;int shift = 0 ;int qshift = 0 ;/* * As an exception we don ' t do any preallocation at all if the file is * smaller than the minimum preallocation and we are using the default * dynamic preallocation scheme , as it is likely this is the only write * to the file that is going to be done . if (XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_allocsize_blocks))return 0 ;/* * Use the minimum preallocation size for small files or if we are * writing right after a hole . if (XFS_ISIZE(ip) < XFS_FSB_TO_B(mp, mp->m_dalign) ||return mp->m_allocsize_blocks;/* * Take the size of the preceding data extents as the basis for the * preallocation size . Note that we don ' t care if the previous extents * are written or not . while (xfs_iext_prev_extent(ifp, &ncur, &got)) {if (plen > XFS_MAX_BMBT_EXTLEN / 2 ||break ;/* * If the size of the extents is greater than half the maximum extent * length , then use the current offset as the basis . This ensures that * for large files the preallocation size always extends to * XFS_BMBT_MAX_EXTLEN rather than falling short due to things like stripe * unit / width alignment of real extents . 2 ;if (alloc_blocks > XFS_MAX_BMBT_EXTLEN)/* * XFS_BMBT_MAX_EXTLEN is not a power of two value but we round the prealloc * down to the nearest power of two value after throttling . To prevent * the round down from unconditionally reducing the maximum supported * prealloc size , we round up first , apply appropriate throttling , round * down and cap the value to XFS_BMBT_MAX_EXTLEN . if (unlikely(XFS_IS_REALTIME_INODE(ip)))else /* * Check each quota to cap the prealloc size , provide a shift value to * throttle with and adjust amount of available space . if (xfs_quota_need_throttle(ip, XFS_DQTYPE_USER, alloc_blocks))if (xfs_quota_need_throttle(ip, XFS_DQTYPE_GROUP, alloc_blocks))if (xfs_quota_need_throttle(ip, XFS_DQTYPE_PROJ, alloc_blocks))/* * The final prealloc size is set to the minimum of free space available * in each of the quotas and the overall filesystem . * * The shift throttle value is set to the maximum value as determined by * the global low free space values and per - quota low free space values . if (shift)/* * rounddown_pow_of_two ( ) returns an undefined result if we pass in * alloc_blocks = 0 . if (alloc_blocks)if (alloc_blocks > XFS_MAX_BMBT_EXTLEN)/* * If we are still trying to allocate more space than is * available , squash the prealloc hard . This can happen if we * have a large file on a small filesystem and the above * lowspace thresholds are smaller than XFS_BMBT_MAX_EXTLEN . while (alloc_blocks && alloc_blocks >= freesp)4 ;if (alloc_blocks < mp->m_allocsize_blocks)return alloc_blocks;int bool update_isize)int nimaps;struct inode *inode = VFS_I(ip);int error;/* * Reserve enough blocks in this transaction for two complete extent * btree splits . We may be converting the middle part of an unwritten * extent and in this case we will insert two new extents in the btree * each of which could cause a full split . * * This reservation amount will be used in the first call to * xfs_bmbt_split ( ) to select an AG with enough space to satisfy the * rest of the operation . 0 ) << 1 ;/* Attach dquots so that bmbt splits are accounted correctly. */ if (error)return error;do {/* * Set up a transaction to convert the range of extents * from unwritten to real . Do allocations in a loop until * we have covered the range passed in . * * Note that we can ' t risk to recursing back into the filesystem * here as we might be asked to write out the same inode that we * complete here and might deadlock on the iolock . 0 , true , &tp);if (error)return error;if (error)goto error_on_bmapi_transaction;/* * Modify the unwritten extent state of the buffer . 1 ;if (error)goto error_on_bmapi_transaction;/* * Log the updated inode size as we go . We have to be careful * to only log it up to the actual write offset if it is * halfway into a block . if (i_size > offset + count)if (update_isize && i_size > i_size_read(inode))if (i_size) {if (error)return error;if (unlikely(!xfs_valid_startblock(ip, imap.br_startblock))) {return xfs_alert_fsblock_zero(ip, &imap);if ((numblks_fsb = imap.br_blockcount) == 0 ) {/* * The numblks_fsb value should always get * smaller , otherwise the loop is stuck . break ;while (count_fsb > 0 );return 0 ;return error;static inline bool struct inode *inode,unsigned flags,struct xfs_bmbt_irec *imap,int nimaps)/* don't allocate blocks when just zeroing */ if (flags & IOMAP_ZERO)return false ;if (!nimaps ||return true ;/* we convert unwritten extents before copying the data for DAX */ if ((flags & IOMAP_DAX) && imap->br_state == XFS_EXT_UNWRITTEN)return true ;return false ;static inline bool struct xfs_inode *ip,unsigned int flags,struct xfs_bmbt_irec *imap,int nimaps)if (!xfs_is_cow_inode(ip))return false ;/* when zeroing we don't have to COW holes or unwritten extents */ if (flags & (IOMAP_UNSHARE | IOMAP_ZERO)) {if (!nimaps ||return false ;return true ;/* * Extents not yet cached requires exclusive access , don ' t block for * IOMAP_NOWAIT . * * This is basically an opencoded xfs_ilock_data_map_shared ( ) call , but with * support for IOMAP_NOWAIT . static int struct xfs_inode *ip,unsigned flags,unsigned *lockmode)if (flags & IOMAP_NOWAIT) {if (xfs_need_iread_extents(&ip->i_df))return -EAGAIN;if (!xfs_ilock_nowait(ip, *lockmode))return -EAGAIN;else {if (xfs_need_iread_extents(&ip->i_df))return 0 ;/* * Check that the imap we are going to return to the caller spans the entire * range that the caller requested for the IO . static bool struct xfs_bmbt_irec *imap,if (imap->br_startoff > offset_fsb)return false ;if (imap->br_startoff + imap->br_blockcount < end_fsb)return false ;return true ;static bool struct xfs_inode *ip,struct xfs_bmbt_irec *imap,struct xfs_mount *mp = ip->i_mount;/* * atomic writes are required to be naturally aligned for disk blocks , * which ensures that we adhere to block layer rules that we won ' t * straddle any boundary or violate write alignment requirement . if (!IS_ALIGNED(imap->br_startblock, imap->br_blockcount))return false ;/* * Spanning multiple extents would mean that multiple BIOs would be * issued , and so would lose atomicity required for REQ_ATOMIC - based * atomics . if (!imap_spans_range(imap, offset_fsb, end_fsb))return false ;/* * The - > iomap_begin caller should ensure this , but check anyway . return len <= xfs_inode_buftarg(ip)->bt_awu_max;static int struct inode *inode,unsigned flags,struct iomap *iomap,struct iomap *srcmap)struct xfs_inode *ip = XFS_I(inode);struct xfs_mount *mp = ip->i_mount;struct xfs_bmbt_irec imap, cmap;int nimaps = 1 , error = 0 ;bool shared = false ;0 ;bool needs_alloc;unsigned int lockmode;if (xfs_is_shutdown(mp))return -EIO;/* * Writes that span EOF might trigger an IO size update on completion , * so consider them to be dirty for the purposes of O_DSYNC even if * there is no other metadata changes pending or have been made here . if (offset + length > i_size_read(inode))/* HW-offload atomics are always used in this path */ if (flags & IOMAP_ATOMIC)/* * COW writes may allocate delalloc space or convert unwritten COW * extents , so we need to make sure to take the lock exclusively here . if (xfs_is_cow_inode(ip))else if (error)return error;/* * The reflink iflag could have changed since the earlier unlocked * check , check if it again and relock if needed . if (xfs_is_cow_inode(ip) && lockmode == XFS_ILOCK_SHARED) {goto relock;0 );if (error)goto out_unlock;if (imap_needs_cow(ip, flags, &imap, nimaps)) {if (flags & IOMAP_NOWAIT)goto out_unlock;/* may drop and re-acquire the ilock */ if (error)goto out_unlock;if (shared) {if ((flags & IOMAP_ATOMIC) &&goto out_unlock;goto out_found_cow;if (flags & IOMAP_ATOMIC) {/* * If we allocate less than what is required for the write * then we may end up with multiple extents , which means that * REQ_ATOMIC - based cannot be used , so avoid this possibility . if (needs_alloc && orig_end_fsb - offset_fsb > 1 )goto out_unlock;if (!xfs_bmap_hw_atomic_write_possible(ip, &imap, offset_fsb,goto out_unlock;if (needs_alloc)goto allocate_blocks;/* * NOWAIT and OVERWRITE I / O needs to span the entire requested I / O with * a single map so that we avoid partial IO failures due to the rest of * the I / O range not covered by this map triggering an EAGAIN condition * when it is subsequently mapped and aborting the I / O . if (flags & (IOMAP_NOWAIT | IOMAP_OVERWRITE_ONLY)) {if (!imap_spans_range(&imap, offset_fsb, end_fsb))goto out_unlock;/* * For overwrite only I / O , we cannot convert unwritten extents without * requiring sub - block zeroing . This can only be done under an * exclusive IOLOCK , hence return - EAGAIN if this is not a written * extent to tell the caller to try again . if (flags & IOMAP_OVERWRITE_ONLY) {if (imap.br_state != XFS_EXT_NORM &&goto out_unlock;return xfs_bmbt_to_iomap(ip, iomap, &imap, flags, iomap_flags, seq);if (flags & (IOMAP_NOWAIT | IOMAP_OVERWRITE_ONLY))goto out_unlock;/* * We cap the maximum length we map to a sane size to keep the chunks * of work done where somewhat symmetric with the work writeback does . * This is a completely arbitrary number pulled out of thin air as a * best guess for initial testing . * * Note that the values needs to be less than 32 - bits wide until the * lower level functions are updated . 1024 * PAGE_SIZE);if (offset + length > XFS_ISIZE(ip))else if (nimaps && imap.br_startblock == HOLESTARTBLOCK)if (error)return error;return xfs_bmbt_to_iomap(ip, iomap, &imap, flags,if (imap.br_startblock != HOLESTARTBLOCK) {0 );0 , seq);if (error)goto out_unlock;return xfs_bmbt_to_iomap(ip, iomap, &cmap, flags, IOMAP_F_SHARED, seq);if (lockmode)return error;const struct iomap_ops xfs_direct_write_iomap_ops = {#ifdef CONFIG_XFS_RT/* * This is really simple . The space has already been reserved before taking the * IOLOCK , the actual block allocation is done just before submitting the bio * and only recorded in the extent map on I / O completion . static int struct inode *inode,unsigned flags,struct iomap *iomap,struct iomap *srcmap)struct xfs_inode *ip = XFS_I(inode);int error;/* * Needs to be pushed down into the allocator so that only writes into * a single zone can be supported . if (flags & IOMAP_NOWAIT)return -EAGAIN;/* * Ensure the extent list is in memory in so that we don ' t have to do * read it from the I / O completion handler . if (xfs_need_iread_extents(&ip->i_df)) {if (error)return error;return 0 ;const struct iomap_ops xfs_zoned_direct_write_iomap_ops = {#endif /* CONFIG_XFS_RT */ #ifdef DEBUGstatic void struct xfs_inode *ip,const struct xfs_bmbt_irec *cmap)struct xfs_iext_cursor icur;struct xfs_bmbt_irec cmap2 = { };if (xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &cmap2))#else # define xfs_check_atomic_cow_conversion(...) ((void )0 )#endif static int struct inode *inode,unsigned flags,struct iomap *iomap,struct iomap *srcmap)struct xfs_inode *ip = XFS_I(inode);struct xfs_mount *mp = ip->i_mount;const xfs_fileoff_t offset_fsb = XFS_B_TO_FSBT(mp, offset);const xfs_fileoff_t end_fsb = XFS_B_TO_FSB(mp, offset + length);const xfs_filblks_t count_fsb = end_fsb - offset_fsb;int nmaps = 1 ;struct xfs_bmbt_irec cmap;struct xfs_iext_cursor icur;struct xfs_trans *tp;unsigned int dblocks = 0 , rblocks = 0 ;int error;if (xfs_is_shutdown(mp))return -EIO;if (!xfs_can_sw_atomic_write(mp)) {return -EINVAL;/* blocks are always allocated in this path */ if (flags & IOMAP_NOWAIT)return -EAGAIN;if (!ip->i_cowfp) {if (!xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &cmap))if (cmap.br_startoff <= offset_fsb) {if (isnullstartblock(cmap.br_startblock))goto convert_delay;/* * cmap could extend outside the write range due to previous * speculative preallocations . We must trim cmap to the write * range because the cow fork treats written mappings to mean * " write in progress " . goto found;if (XFS_IS_REALTIME_INODE(ip)) {0 );else {0 ;false , &tp);if (error)return error;/* extent layout could have changed since the unlock, so check again */ if (!xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &cmap))if (cmap.br_startoff <= offset_fsb) {if (isnullstartblock(cmap.br_startblock))goto convert_delay;goto found;/* * Allocate the entire reservation as unwritten blocks . * * Use XFS_BMAPI_EXTSZALIGN to hint at aligning new extents according to * extszhint , such that there will be a greater chance that future * atomic writes to that same range will be aligned ( and don ' t require * this COW - based method ) . 0 , &cmap, &nmaps);if (error) {goto out_unlock;if (error)goto out_unlock;/* * cmap could map more blocks than the range we passed into bmapi_write * because of EXTSZALIGN or adjacent pre - existing unwritten mappings * that were merged . Trim cmap to the original write range so that we * don ' t convert more than we were asked to do for this write . if (cmap.br_state != XFS_EXT_NORM) {if (error)goto out_unlock;return xfs_bmbt_to_iomap(ip, iomap, &cmap, flags, IOMAP_F_SHARED, seq);if (error)return error;/* * Try the lookup again , because the delalloc conversion might have * turned the COW mapping into unwritten , but we need it to be in * written state . goto retry;return error;const struct iomap_ops xfs_atomic_write_cow_iomap_ops = {static int struct inode *inode,unsigned flags,struct iomap *iomap)struct xfs_inode *ip = XFS_I(inode);if (!xfs_is_cow_inode(ip))return 0 ;if (!written)return xfs_reflink_cancel_cow_range(ip, pos, length, true );return xfs_reflink_end_cow(ip, pos, written);const struct iomap_ops xfs_dax_write_iomap_ops = {/* * Convert a hole to a delayed allocation . static void struct xfs_inode *ip, /* incore inode pointer */ int whichfork,struct xfs_iext_cursor *icur,struct xfs_bmbt_irec *new ) /* new data to add to file extents */ struct xfs_ifork *ifp; /* inode fork pointer */ /* left neighbor extent entry */ 0 ; /* new indirect size */ 0 ; /* old indirect size */ /* right neighbor extent entry */ /* temp for indirect calculations */ new ->br_startblock));/* * Check and set flags if this segment has a left neighbor if (xfs_iext_peek_prev_extent(ifp, icur, &left)) {if (isnullstartblock(left.br_startblock))/* * Check and set flags if the current ( right ) segment exists . * If it doesn ' t exist , we ' re converting the hole at end - of - file . if (xfs_iext_get_extent(ifp, icur, &right)) {if (isnullstartblock(right.br_startblock))/* * Set contiguity flags on the left and right neighbors . * Don ' t let extents get too large , even if the pieces are contiguous . if ((state & BMAP_LEFT_VALID) && (state & BMAP_LEFT_DELAY) &&new ->br_startoff &&new ->br_blockcount <= XFS_MAX_BMBT_EXTLEN)if ((state & BMAP_RIGHT_VALID) && (state & BMAP_RIGHT_DELAY) &&new ->br_startoff + new ->br_blockcount == right.br_startoff &&new ->br_blockcount + right.br_blockcount <= XFS_MAX_BMBT_EXTLEN &&new ->br_blockcount +/* * Switch out based on the contiguity flags . switch (state & (BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG)) {case BMAP_LEFT_CONTIG | BMAP_RIGHT_CONTIG:/* * New allocation is contiguous with delayed allocations * on the left and on the right . * Merge all three into a single extent record . new ->br_blockcount +new ->br_startblock) +break ;case BMAP_LEFT_CONTIG:/* * New allocation is contiguous with a delayed allocation * on the left . * Merge the new allocation with the left neighbor . new ->br_blockcount;new ->br_startblock);break ;case BMAP_RIGHT_CONTIG:/* * New allocation is contiguous with a delayed allocation * on the right . * Merge the new allocation with the right neighbor . new ->br_blockcount + right.br_blockcount;new ->br_startblock) +new ->br_startoff;break ;case 0 :/* * New allocation is not contiguous with another * delayed allocation . * Insert a new entry . 0 ;new , state);break ;if (oldlen != newlen) {/* * Nothing to do for disk quota accounting here . 0 , (int64_t)newlen - oldlen);/* * Add a delayed allocation extent to an inode . Blocks are reserved from the * global pool and the extent inserted into the inode in - core extent tree . * * On entry , got refers to the first extent beyond the offset of the extent to * allocate or eof is specified if no such extent exists . On return , got refers * to the extent record that was inserted to the inode fork . * * Note that the allocated extent may have been merged with contiguous extents * during insertion into the inode fork . Thus , got does not reflect the current * state of the inode fork on return . If necessary , the caller can use lastx to * look up the updated record in the inode fork . static int struct xfs_inode *ip,int whichfork,struct xfs_bmbt_irec *got,struct xfs_iext_cursor *icur,int eof)struct xfs_mount *mp = ip->i_mount;struct xfs_ifork *ifp = xfs_ifork_ptr(ip, whichfork);int error;bool use_cowextszhint =/* * Cap the alloc length . Keep track of prealloc so we know whether to * tag the inode before we return . if (!eof)if (prealloc && alen >= len)/* * If we ' re targetting the COW fork but aren ' t creating a speculative * posteof preallocation , try to expand the reservation to align with * the COW extent size hint if there ' s sufficient free space . * * Unlike the data fork , the CoW cancellation functions will free all * the reservations at inactivation , so we don ' t require that every * delalloc reservation have a dirty pagecache . if (use_cowextszhint) {struct xfs_bmbt_irec prev;if (!xfs_iext_peek_prev_extent(ifp, icur, &prev))0 , eof,1 , 0 , &aoff, &alen);/* * Make a transaction - less quota reservation for delayed allocation * blocks . This number gets adjusted later . We return if we haven ' t * allocated blocks already inside this loop . if (error)goto out;/* * Split changing sb for alen and indlen since they could be coming * from different places . 0 );if (XFS_IS_REALTIME_INODE(ip)) {if (error)goto out_unreserve_quota;else {false );if (error)goto out_unreserve_frextents;/* * Tag the inode if blocks were preallocated . Note that COW fork * preallocation can occur at the start or end of the extent , even when * prealloc = = 0 , so we must also check the aligned offset and length . if (whichfork == XFS_DATA_FORK && prealloc)if (whichfork == XFS_COW_FORK && (prealloc || aoff < off || alen > len))return 0 ;if (XFS_IS_REALTIME_INODE(ip))if (XFS_IS_QUOTA_ON(mp))if (error == -ENOSPC || error == -EDQUOT) {if (prealloc || use_cowextszhint) {/* retry without any preallocation */ false ;0 ;goto retry;return error;static int struct inode *inode,unsigned flags,struct iomap *iomap,struct iomap *srcmap)struct iomap_iter *iter =struct iomap_iter, iomap);struct xfs_zone_alloc_ctx *ac = iter->private ;struct xfs_inode *ip = XFS_I(inode);struct xfs_mount *mp = ip->i_mount;unsigned int lockmode = XFS_ILOCK_EXCL;struct xfs_bmbt_irec got;struct xfs_iext_cursor icur;int error = 0 ;if (xfs_is_shutdown(mp))return -EIO;if (error)return error;if (error)return error;if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(&ip->i_df)) ||false , mp, XFS_ERRTAG_BMAPIFORMAT)) {goto out_unlock;if (error)goto out_unlock;/* * For zeroing operations check if there is any data to zero first . * * For regular writes we always need to allocate new blocks , but need to * provide the source mapping when the range is unaligned to support * read - modify - write of the whole block in the page cache . * * In either case we need to limit the reported range to the boundaries * of the source map in the data fork . if (!IS_ALIGNED(offset, mp->m_sb.sb_blocksize) ||struct xfs_bmbt_irec smap;struct xfs_iext_cursor scur;if (!xfs_iext_lookup_extent(ip, &ip->i_df, offset_fsb, &scur,/* fake hole until EOF */ if (smap.br_startoff > offset_fsb) {/* * We never need to allocate blocks for zeroing a hole . if (flags & IOMAP_ZERO) {goto out_unlock;else {0 ,0 ));if (error)goto out_unlock;if (!ip->i_cowfp)if (!xfs_iext_lookup_extent(ip, ip->i_cowfp, offset_fsb, &icur, &got))if (got.br_startoff <= offset_fsb) {goto done;/* * Cap the maximum length to keep the chunks of work done here somewhat * symmetric with the work writeback does . 1024 * PAGE_SIZE));/* * The block reservation is supposed to cover all blocks that the * operation could possible write , but there is a nasty corner case * where blocks could be stolen from underneath us : * * 1 ) while this thread iterates over a larger buffered write , * 2 ) another thread is causing a write fault that calls into * - > page_mkwrite in range this thread writes to , using up the * delalloc reservation created by a previous call to this function . * 3 ) another thread does direct I / O on the range that the write fault * happened on , which causes writeback of the dirty data . * 4 ) this then set the stale flag , which cuts the current iomap * iteration short , causing the new call to - > iomap_begin that gets * us here again , but now without a sufficient reservation . * * This is a very unusual I / O pattern , and nothing but generic / 095 is * known to hit it . There ' s not really much we can do here , so turn this * into a short write . if (count_fsb > ac->reserved_blocks) {"Short write on ino 0x%llx comm %.20s due to three-way race with write fault and direct I/O" ,if (!count_fsb) {goto out_unlock;if (error)goto out_unlock;false );if (error)goto out_unlock;return error;static int struct inode *inode,unsigned flags,struct iomap *iomap,struct iomap *srcmap)struct xfs_inode *ip = XFS_I(inode);struct xfs_mount *mp = ip->i_mount;struct xfs_bmbt_irec imap, cmap;struct xfs_iext_cursor icur, ccur;0 ;bool eof = false , cow_eof = false , shared = false ;int allocfork = XFS_DATA_FORK;int error = 0 ;unsigned int lockmode = XFS_ILOCK_EXCL;unsigned int iomap_flags = 0 ;if (xfs_is_shutdown(mp))return -EIO;if (xfs_is_zoned_inode(ip))return xfs_zoned_buffered_write_iomap_begin(inode, offset,/* we can't use delayed allocations when using extent size hints */ if (xfs_get_extsz_hint(ip))return xfs_direct_write_iomap_begin(inode, offset, count,if (error)return error;if (error)return error;if (XFS_IS_CORRUPT(mp, !xfs_ifork_has_extents(&ip->i_df)) ||false , mp, XFS_ERRTAG_BMAPIFORMAT)) {goto out_unlock;if (error)goto out_unlock;/* * Search the data fork first to look up our source mapping . We * always need the data fork map , as we have to return it to the * iomap code so that the higher level write code can read data in to * perform read - modify - write cycles for unaligned writes . if (eof)/* fake hole until the end */ /* We never need to allocate blocks for zeroing or unsharing a hole. */ if ((flags & (IOMAP_UNSHARE | IOMAP_ZERO)) &&goto out_unlock;/* * For zeroing , trim a delalloc extent that extends beyond the EOF * block . If it starts beyond the EOF block , convert it to an * unwritten extent . if ((flags & IOMAP_ZERO) && imap.br_startoff <= offset_fsb &&if (offset_fsb >= eof_fsb)goto convert_delay;if (end_fsb > eof_fsb) {/* * Search the COW fork extent list even if we did not find a data fork * extent . This serves two purposes : first this implements the * speculative preallocation using cowextsize , so that we also unshare * block adjacent to shared blocks instead of just the shared blocks * themselves . Second the lookup in the extent list is generally faster * than going out to the shared extent tree . if (xfs_is_cow_inode(ip)) {if (!ip->i_cowfp) {if (!cow_eof && cmap.br_startoff <= offset_fsb) {goto found_cow;if (imap.br_startoff <= offset_fsb) {/* * For reflink files we may need a delalloc reservation when * overwriting shared extents . This includes zeroing of * existing extents that contain data . if (!xfs_is_cow_inode(ip) ||goto found_imap;/* Trim the mapping to the nearest shared extent boundary. */ if (error)goto out_unlock;/* Not shared? Just report the (potentially capped) extent. */ if (!shared) {goto found_imap;/* * Fork all the shared blocks from our write offset until the * end of the extent . else {/* * We cap the maximum length we map here to MAX_WRITEBACK_PAGES * pages to keep the chunks of work done where somewhat * symmetric with the work writeback does . This is a completely * arbitrary number pulled out of thin air . * * Note that the values needs to be less than 32 - bits wide until * the lower level functions are updated . 1024 * PAGE_SIZE);if (xfs_is_always_cow_inode(ip))if (eof && offset + count > XFS_ISIZE(ip)) {/* * Determine the initial size of the preallocation . * We clean up any extra preallocation when the file is closed . if (xfs_has_allocsize(mp))else if (allocfork == XFS_DATA_FORK)else if (prealloc_blocks) {1 );if (align)/* * Flag newly allocated delalloc blocks with IOMAP_F_NEW so we punch * them out if the write happens to fail . if (allocfork == XFS_COW_FORK) {if (error)goto out_unlock;goto found_cow;if (error)goto out_unlock;return xfs_bmbt_to_iomap(ip, iomap, &imap, flags, iomap_flags, seq);if (error)return error;return 0 ;if (imap.br_startoff <= offset_fsb) {0 ,0 ));if (error)goto out_unlock;else {return xfs_bmbt_to_iomap(ip, iomap, &cmap, flags, iomap_flags, seq);return error;static void struct inode *inode,struct iomap *iomap)struct iomap_iter *iter =struct iomap_iter, iomap);private );static int struct inode *inode,unsigned flags,struct iomap *iomap)/* If we didn't reserve the blocks, we're not allowed to punch them. */ if (iomap->type != IOMAP_DELALLOC || !(iomap->flags & IOMAP_F_NEW))return 0 ;/* * iomap_page_mkwrite ( ) will never fail in a way that requires delalloc * extents that it allocated to be revoked . Hence never try to release * them here . if (flags & IOMAP_FAULT)return 0 ;/* Nothing to do if we've written the entire delalloc extent */ if (start_byte >= end_byte)return 0 ;/* For zeroing operations the callers already hold invalidate_lock. */ if (flags & (IOMAP_UNSHARE | IOMAP_ZERO)) {else {return 0 ;const struct iomap_ops xfs_buffered_write_iomap_ops = {static int struct inode *inode,unsigned flags,struct iomap *iomap,struct iomap *srcmap)struct xfs_inode *ip = XFS_I(inode);struct xfs_mount *mp = ip->i_mount;struct xfs_bmbt_irec imap;int nimaps = 1 , error = 0 ;bool shared = false ;unsigned int lockmode = XFS_ILOCK_SHARED;if (xfs_is_shutdown(mp))return -EIO;if (error)return error;0 );if (!error && ((flags & IOMAP_REPORT) || IS_DAX(inode)))0 );if (error)return error;return xfs_bmbt_to_iomap(ip, iomap, &imap, flags,0 , seq);const struct iomap_ops xfs_read_iomap_ops = {static int struct inode *inode,unsigned flags,struct iomap *iomap,struct iomap *srcmap)struct xfs_inode *ip = XFS_I(inode);struct xfs_mount *mp = ip->i_mount;struct xfs_iext_cursor icur;struct xfs_bmbt_irec imap, cmap;int error = 0 ;unsigned lockmode;if (xfs_is_shutdown(mp))return -EIO;if (error)goto out_unlock;if (xfs_iext_lookup_extent(ip, &ip->i_df, offset_fsb, &icur, &imap)) {/* * If we found a data extent we are done . if (imap.br_startoff <= offset_fsb)goto done;else {/* * Fake a hole until the end of the file . /* * If a COW fork extent covers the hole , report it - capped to the next * data fork extent : if (xfs_inode_has_cow_data(ip) &&if (cow_fsb != NULLFILEOFF && cow_fsb <= offset_fsb) {if (data_fsb < cow_fsb + cmap.br_blockcount)/* * This is a COW extent , so we must probe the page cache * because there could be dirty page cache being backed * by this extent . goto out_unlock;/* * Else report a hole , capped to the next found data or COW extent . if (cow_fsb != NULLFILEOFF && cow_fsb < data_fsb)else 0 );0 , seq);return error;const struct iomap_ops xfs_seek_iomap_ops = {static int struct inode *inode,unsigned flags,struct iomap *iomap,struct iomap *srcmap)struct xfs_inode *ip = XFS_I(inode);struct xfs_mount *mp = ip->i_mount;struct xfs_bmbt_irec imap;int nimaps = 1 , error = 0 ;unsigned lockmode;int seq;if (xfs_is_shutdown(mp))return -EIO;/* if there are no attribute fork or extents, return ENOENT */ if (!xfs_inode_has_attr_fork(ip) || !ip->i_af.if_nextents) {goto out_unlock;if (error)return error;return xfs_bmbt_to_iomap(ip, iomap, &imap, flags, IOMAP_F_XATTR, seq);const struct iomap_ops xfs_xattr_iomap_ops = {int struct xfs_inode *ip,struct xfs_zone_alloc_ctx *ac,bool *did_zero)struct inode *inode = VFS_I(ip);if (IS_DAX(inode))return dax_zero_range(inode, pos, len, did_zero,return iomap_zero_range(inode, pos, len, did_zero,int struct xfs_inode *ip,struct xfs_zone_alloc_ctx *ac,bool *did_zero)struct inode *inode = VFS_I(ip);if (IS_DAX(inode))return dax_truncate_page(inode, pos, did_zero,return iomap_truncate_page(inode, pos, did_zero,
Messung V0.5 in Prozent C=96 H=85 G=90
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.35Angebot
(Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-09-28)
¤ *Eine klare Vorstellung vom Zielzustand
