~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/xfs/xfs_discard.c

Version: ~ [ linux-5.10-rc5 ] ~ [ linux-5.9.10 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.79 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.159 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.208 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.245 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.245 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp