1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2010 Red Hat, Inc. 4 * All Rights Reserved. 5 */ 6 #include "xfs.h" 7 #include "xfs_shared.h" 8 #include "xfs_format.h" 9 #include "xfs_log_format.h" 10 #include "xfs_trans_resv.h" 11 #include "xfs_mount.h" 12 #include "xfs_btree.h" 13 #include "xfs_alloc_btree.h" 14 #include "xfs_alloc.h" 15 #include "xfs_discard.h" 16 #include "xfs_error.h" 17 #include "xfs_extent_busy.h" 18 #include "xfs_trace.h" 19 #include "xfs_log.h" 20 #include "xfs_ag.h" 21 22 STATIC int 23 xfs_trim_extents( 24 struct xfs_mount *mp, 25 xfs_agnumber_t agno, 26 xfs_daddr_t start, 27 xfs_daddr_t end, 28 xfs_daddr_t minlen, 29 uint64_t *blocks_trimmed) 30 { 31 struct block_device *bdev = mp->m_ddev_targp->bt_bdev; 32 struct xfs_btree_cur *cur; 33 struct xfs_buf *agbp; 34 struct xfs_agf *agf; 35 struct xfs_perag *pag; 36 int error; 37 int i; 38 39 pag = xfs_perag_get(mp, agno); 40 41 /* 42 * Force out the log. This means any transactions that might have freed 43 * space before we take the AGF buffer lock are now on disk, and the 44 * volatile disk cache is flushed. 45 */ 46 xfs_log_force(mp, XFS_LOG_SYNC); 47 48 error = xfs_alloc_read_agf(mp, NULL, agno, 0, &agbp); 49 if (error) 50 goto out_put_perag; 51 agf = agbp->b_addr; 52 53 cur = xfs_allocbt_init_cursor(mp, NULL, agbp, pag, XFS_BTNUM_CNT); 54 55 /* 56 * Look up the longest btree in the AGF and start with it. 57 */ 58 error = xfs_alloc_lookup_ge(cur, 0, be32_to_cpu(agf->agf_longest), &i); 59 if (error) 60 goto out_del_cursor; 61 62 /* 63 * Loop until we are done with all extents that are large 64 * enough to be worth discarding. 65 */ 66 while (i) { 67 xfs_agblock_t fbno; 68 xfs_extlen_t flen; 69 xfs_daddr_t dbno; 70 xfs_extlen_t dlen; 71 72 error = xfs_alloc_get_rec(cur, &fbno, &flen, &i); 73 if (error) 74 goto out_del_cursor; 75 if (XFS_IS_CORRUPT(mp, i != 1)) { 76 error = -EFSCORRUPTED; 77 goto out_del_cursor; 78 } 79 ASSERT(flen <= be32_to_cpu(agf->agf_longest)); 80 81 /* 82 * use daddr format for all range/len calculations as that is 83 * the format the range/len variables are supplied in by 84 * userspace. 85 */ 86 dbno = XFS_AGB_TO_DADDR(mp, agno, fbno); 87 dlen = XFS_FSB_TO_BB(mp, flen); 88 89 /* 90 * Too small? Give up. 91 */ 92 if (dlen < minlen) { 93 trace_xfs_discard_toosmall(mp, agno, fbno, flen); 94 goto out_del_cursor; 95 } 96 97 /* 98 * If the extent is entirely outside of the range we are 99 * supposed to discard skip it. Do not bother to trim 100 * down partially overlapping ranges for now. 101 */ 102 if (dbno + dlen < start || dbno > end) { 103 trace_xfs_discard_exclude(mp, agno, fbno, flen); 104 goto next_extent; 105 } 106 107 /* 108 * If any blocks in the range are still busy, skip the 109 * discard and try again the next time. 110 */ 111 if (xfs_extent_busy_search(mp, pag, fbno, flen)) { 112 trace_xfs_discard_busy(mp, agno, fbno, flen); 113 goto next_extent; 114 } 115 116 trace_xfs_discard_extent(mp, agno, fbno, flen); 117 error = blkdev_issue_discard(bdev, dbno, dlen, GFP_NOFS); 118 if (error) 119 goto out_del_cursor; 120 *blocks_trimmed += flen; 121 122 next_extent: 123 error = xfs_btree_decrement(cur, 0, &i); 124 if (error) 125 goto out_del_cursor; 126 127 if (fatal_signal_pending(current)) { 128 error = -ERESTARTSYS; 129 goto out_del_cursor; 130 } 131 } 132 133 out_del_cursor: 134 xfs_btree_del_cursor(cur, error); 135 xfs_buf_relse(agbp); 136 out_put_perag: 137 xfs_perag_put(pag); 138 return error; 139 } 140 141 /* 142 * trim a range of the filesystem. 143 * 144 * Note: the parameters passed from userspace are byte ranges into the 145 * filesystem which does not match to the format we use for filesystem block 146 * addressing. FSB addressing is sparse (AGNO|AGBNO), while the incoming format 147 * is a linear address range. Hence we need to use DADDR based conversions and 148 * comparisons for determining the correct offset and regions to trim. 149 */ 150 int 151 xfs_ioc_trim( 152 struct xfs_mount *mp, 153 struct fstrim_range __user *urange) 154 { 155 unsigned int granularity = 156 bdev_discard_granularity(mp->m_ddev_targp->bt_bdev); 157 struct fstrim_range range; 158 xfs_daddr_t start, end, minlen; 159 xfs_agnumber_t start_agno, end_agno, agno; 160 uint64_t blocks_trimmed = 0; 161 int error, last_error = 0; 162 163 if (!capable(CAP_SYS_ADMIN)) 164 return -EPERM; 165 if (!bdev_max_discard_sectors(mp->m_ddev_targp->bt_bdev)) 166 return -EOPNOTSUPP; 167 168 /* 169 * We haven't recovered the log, so we cannot use our bnobt-guided 170 * storage zapping commands. 171 */ 172 if (xfs_has_norecovery(mp)) 173 return -EROFS; 174 175 if (copy_from_user(&range, urange, sizeof(range))) 176 return -EFAULT; 177 178 range.minlen = max_t(u64, granularity, range.minlen); 179 minlen = BTOBB(range.minlen); 180 /* 181 * Truncating down the len isn't actually quite correct, but using 182 * BBTOB would mean we trivially get overflows for values 183 * of ULLONG_MAX or slightly lower. And ULLONG_MAX is the default 184 * used by the fstrim application. In the end it really doesn't 185 * matter as trimming blocks is an advisory interface. 186 */ 187 if (range.start >= XFS_FSB_TO_B(mp, mp->m_sb.sb_dblocks) || 188 range.minlen > XFS_FSB_TO_B(mp, mp->m_ag_max_usable) || 189 range.len < mp->m_sb.sb_blocksize) 190 return -EINVAL; 191 192 start = BTOBB(range.start); 193 end = start + BTOBBT(range.len) - 1; 194 195 if (end > XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks) - 1) 196 end = XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)- 1; 197 198 start_agno = xfs_daddr_to_agno(mp, start); 199 end_agno = xfs_daddr_to_agno(mp, end); 200 201 for (agno = start_agno; agno <= end_agno; agno++) { 202 error = xfs_trim_extents(mp, agno, start, end, minlen, 203 &blocks_trimmed); 204 if (error) { 205 last_error = error; 206 if (error == -ERESTARTSYS) 207 break; 208 } 209 } 210 211 if (last_error) 212 return last_error; 213 214 range.len = XFS_FSB_TO_B(mp, blocks_trimmed); 215 if (copy_to_user(urange, &range, sizeof(range))) 216 return -EFAULT; 217 return 0; 218 } 219