Merge tag 'for-linus' of git://git.armlinux.org.uk/~rmk/linux-arm
[platform/kernel/linux-rpi.git] / fs / xfs / xfs_fsops.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
4  * All Rights Reserved.
5  */
6 #include "xfs.h"
7 #include "xfs_fs.h"
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_log_format.h"
11 #include "xfs_trans_resv.h"
12 #include "xfs_sb.h"
13 #include "xfs_mount.h"
14 #include "xfs_trans.h"
15 #include "xfs_error.h"
16 #include "xfs_alloc.h"
17 #include "xfs_fsops.h"
18 #include "xfs_trans_space.h"
19 #include "xfs_log.h"
20 #include "xfs_log_priv.h"
21 #include "xfs_ag.h"
22 #include "xfs_ag_resv.h"
23 #include "xfs_trace.h"
24
25 /*
26  * Write new AG headers to disk. Non-transactional, but need to be
27  * written and completed prior to the growfs transaction being logged.
28  * To do this, we use a delayed write buffer list and wait for
29  * submission and IO completion of the list as a whole. This allows the
30  * IO subsystem to merge all the AG headers in a single AG into a single
31  * IO and hide most of the latency of the IO from us.
32  *
33  * This also means that if we get an error whilst building the buffer
34  * list to write, we can cancel the entire list without having written
35  * anything.
36  */
37 static int
38 xfs_resizefs_init_new_ags(
39         struct xfs_trans        *tp,
40         struct aghdr_init_data  *id,
41         xfs_agnumber_t          oagcount,
42         xfs_agnumber_t          nagcount,
43         xfs_rfsblock_t          delta,
44         bool                    *lastag_extended)
45 {
46         struct xfs_mount        *mp = tp->t_mountp;
47         xfs_rfsblock_t          nb = mp->m_sb.sb_dblocks + delta;
48         int                     error;
49
50         *lastag_extended = false;
51
52         INIT_LIST_HEAD(&id->buffer_list);
53         for (id->agno = nagcount - 1;
54              id->agno >= oagcount;
55              id->agno--, delta -= id->agsize) {
56
57                 if (id->agno == nagcount - 1)
58                         id->agsize = nb - (id->agno *
59                                         (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
60                 else
61                         id->agsize = mp->m_sb.sb_agblocks;
62
63                 error = xfs_ag_init_headers(mp, id);
64                 if (error) {
65                         xfs_buf_delwri_cancel(&id->buffer_list);
66                         return error;
67                 }
68         }
69
70         error = xfs_buf_delwri_submit(&id->buffer_list);
71         if (error)
72                 return error;
73
74         if (delta) {
75                 *lastag_extended = true;
76                 error = xfs_ag_extend_space(mp, tp, id, delta);
77         }
78         return error;
79 }
80
81 /*
82  * growfs operations
83  */
84 static int
85 xfs_growfs_data_private(
86         struct xfs_mount        *mp,            /* mount point for filesystem */
87         struct xfs_growfs_data  *in)            /* growfs data input struct */
88 {
89         struct xfs_buf          *bp;
90         int                     error;
91         xfs_agnumber_t          nagcount;
92         xfs_agnumber_t          nagimax = 0;
93         xfs_rfsblock_t          nb, nb_div, nb_mod;
94         int64_t                 delta;
95         bool                    lastag_extended;
96         xfs_agnumber_t          oagcount;
97         struct xfs_trans        *tp;
98         struct aghdr_init_data  id = {};
99
100         nb = in->newblocks;
101         error = xfs_sb_validate_fsb_count(&mp->m_sb, nb);
102         if (error)
103                 return error;
104
105         if (nb > mp->m_sb.sb_dblocks) {
106                 error = xfs_buf_read_uncached(mp->m_ddev_targp,
107                                 XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
108                                 XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);
109                 if (error)
110                         return error;
111                 xfs_buf_relse(bp);
112         }
113
114         nb_div = nb;
115         nb_mod = do_div(nb_div, mp->m_sb.sb_agblocks);
116         nagcount = nb_div + (nb_mod != 0);
117         if (nb_mod && nb_mod < XFS_MIN_AG_BLOCKS) {
118                 nagcount--;
119                 nb = (xfs_rfsblock_t)nagcount * mp->m_sb.sb_agblocks;
120         }
121         delta = nb - mp->m_sb.sb_dblocks;
122         /*
123          * Reject filesystems with a single AG because they are not
124          * supported, and reject a shrink operation that would cause a
125          * filesystem to become unsupported.
126          */
127         if (delta < 0 && nagcount < 2)
128                 return -EINVAL;
129
130         oagcount = mp->m_sb.sb_agcount;
131
132         /* allocate the new per-ag structures */
133         if (nagcount > oagcount) {
134                 error = xfs_initialize_perag(mp, nagcount, &nagimax);
135                 if (error)
136                         return error;
137         } else if (nagcount < oagcount) {
138                 /* TODO: shrinking the entire AGs hasn't yet completed */
139                 return -EINVAL;
140         }
141
142         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growdata,
143                         (delta > 0 ? XFS_GROWFS_SPACE_RES(mp) : -delta), 0,
144                         XFS_TRANS_RESERVE, &tp);
145         if (error)
146                 return error;
147
148         if (delta > 0) {
149                 error = xfs_resizefs_init_new_ags(tp, &id, oagcount, nagcount,
150                                                   delta, &lastag_extended);
151         } else {
152                 static struct ratelimit_state shrink_warning = \
153                         RATELIMIT_STATE_INIT("shrink_warning", 86400 * HZ, 1);
154                 ratelimit_set_flags(&shrink_warning, RATELIMIT_MSG_ON_RELEASE);
155
156                 if (__ratelimit(&shrink_warning))
157                         xfs_alert(mp,
158         "EXPERIMENTAL online shrink feature in use. Use at your own risk!");
159
160                 error = xfs_ag_shrink_space(mp, &tp, nagcount - 1, -delta);
161         }
162         if (error)
163                 goto out_trans_cancel;
164
165         /*
166          * Update changed superblock fields transactionally. These are not
167          * seen by the rest of the world until the transaction commit applies
168          * them atomically to the superblock.
169          */
170         if (nagcount > oagcount)
171                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_AGCOUNT, nagcount - oagcount);
172         if (delta)
173                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS, delta);
174         if (id.nfree)
175                 xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, id.nfree);
176
177         /*
178          * Sync sb counters now to reflect the updated values. This is
179          * particularly important for shrink because the write verifier
180          * will fail if sb_fdblocks is ever larger than sb_dblocks.
181          */
182         if (xfs_has_lazysbcount(mp))
183                 xfs_log_sb(tp);
184
185         xfs_trans_set_sync(tp);
186         error = xfs_trans_commit(tp);
187         if (error)
188                 return error;
189
190         /* New allocation groups fully initialized, so update mount struct */
191         if (nagimax)
192                 mp->m_maxagi = nagimax;
193         xfs_set_low_space_thresholds(mp);
194         mp->m_alloc_set_aside = xfs_alloc_set_aside(mp);
195
196         if (delta > 0) {
197                 /*
198                  * If we expanded the last AG, free the per-AG reservation
199                  * so we can reinitialize it with the new size.
200                  */
201                 if (lastag_extended) {
202                         struct xfs_perag        *pag;
203
204                         pag = xfs_perag_get(mp, id.agno);
205                         error = xfs_ag_resv_free(pag);
206                         xfs_perag_put(pag);
207                         if (error)
208                                 return error;
209                 }
210                 /*
211                  * Reserve AG metadata blocks. ENOSPC here does not mean there
212                  * was a growfs failure, just that there still isn't space for
213                  * new user data after the grow has been run.
214                  */
215                 error = xfs_fs_reserve_ag_blocks(mp);
216                 if (error == -ENOSPC)
217                         error = 0;
218         }
219         return error;
220
221 out_trans_cancel:
222         xfs_trans_cancel(tp);
223         return error;
224 }
225
226 static int
227 xfs_growfs_log_private(
228         struct xfs_mount        *mp,    /* mount point for filesystem */
229         struct xfs_growfs_log   *in)    /* growfs log input struct */
230 {
231         xfs_extlen_t            nb;
232
233         nb = in->newblocks;
234         if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
235                 return -EINVAL;
236         if (nb == mp->m_sb.sb_logblocks &&
237             in->isint == (mp->m_sb.sb_logstart != 0))
238                 return -EINVAL;
239         /*
240          * Moving the log is hard, need new interfaces to sync
241          * the log first, hold off all activity while moving it.
242          * Can have shorter or longer log in the same space,
243          * or transform internal to external log or vice versa.
244          */
245         return -ENOSYS;
246 }
247
248 static int
249 xfs_growfs_imaxpct(
250         struct xfs_mount        *mp,
251         __u32                   imaxpct)
252 {
253         struct xfs_trans        *tp;
254         int                     dpct;
255         int                     error;
256
257         if (imaxpct > 100)
258                 return -EINVAL;
259
260         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_growdata,
261                         XFS_GROWFS_SPACE_RES(mp), 0, XFS_TRANS_RESERVE, &tp);
262         if (error)
263                 return error;
264
265         dpct = imaxpct - mp->m_sb.sb_imax_pct;
266         xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
267         xfs_trans_set_sync(tp);
268         return xfs_trans_commit(tp);
269 }
270
271 /*
272  * protected versions of growfs function acquire and release locks on the mount
273  * point - exported through ioctls: XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG,
274  * XFS_IOC_FSGROWFSRT
275  */
276 int
277 xfs_growfs_data(
278         struct xfs_mount        *mp,
279         struct xfs_growfs_data  *in)
280 {
281         int                     error = 0;
282
283         if (!capable(CAP_SYS_ADMIN))
284                 return -EPERM;
285         if (!mutex_trylock(&mp->m_growlock))
286                 return -EWOULDBLOCK;
287
288         /* update imaxpct separately to the physical grow of the filesystem */
289         if (in->imaxpct != mp->m_sb.sb_imax_pct) {
290                 error = xfs_growfs_imaxpct(mp, in->imaxpct);
291                 if (error)
292                         goto out_error;
293         }
294
295         if (in->newblocks != mp->m_sb.sb_dblocks) {
296                 error = xfs_growfs_data_private(mp, in);
297                 if (error)
298                         goto out_error;
299         }
300
301         /* Post growfs calculations needed to reflect new state in operations */
302         if (mp->m_sb.sb_imax_pct) {
303                 uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
304                 do_div(icount, 100);
305                 M_IGEO(mp)->maxicount = XFS_FSB_TO_INO(mp, icount);
306         } else
307                 M_IGEO(mp)->maxicount = 0;
308
309         /* Update secondary superblocks now the physical grow has completed */
310         error = xfs_update_secondary_sbs(mp);
311
312 out_error:
313         /*
314          * Increment the generation unconditionally, the error could be from
315          * updating the secondary superblocks, in which case the new size
316          * is live already.
317          */
318         mp->m_generation++;
319         mutex_unlock(&mp->m_growlock);
320         return error;
321 }
322
323 int
324 xfs_growfs_log(
325         xfs_mount_t             *mp,
326         struct xfs_growfs_log   *in)
327 {
328         int error;
329
330         if (!capable(CAP_SYS_ADMIN))
331                 return -EPERM;
332         if (!mutex_trylock(&mp->m_growlock))
333                 return -EWOULDBLOCK;
334         error = xfs_growfs_log_private(mp, in);
335         mutex_unlock(&mp->m_growlock);
336         return error;
337 }
338
339 /*
340  * exported through ioctl XFS_IOC_FSCOUNTS
341  */
342
343 void
344 xfs_fs_counts(
345         xfs_mount_t             *mp,
346         xfs_fsop_counts_t       *cnt)
347 {
348         cnt->allocino = percpu_counter_read_positive(&mp->m_icount);
349         cnt->freeino = percpu_counter_read_positive(&mp->m_ifree);
350         cnt->freedata = percpu_counter_read_positive(&mp->m_fdblocks) -
351                                                 xfs_fdblocks_unavailable(mp);
352
353         spin_lock(&mp->m_sb_lock);
354         cnt->freertx = mp->m_sb.sb_frextents;
355         spin_unlock(&mp->m_sb_lock);
356 }
357
358 /*
359  * exported through ioctl XFS_IOC_SET_RESBLKS & XFS_IOC_GET_RESBLKS
360  *
361  * xfs_reserve_blocks is called to set m_resblks
362  * in the in-core mount table. The number of unused reserved blocks
363  * is kept in m_resblks_avail.
364  *
365  * Reserve the requested number of blocks if available. Otherwise return
366  * as many as possible to satisfy the request. The actual number
367  * reserved are returned in outval
368  *
369  * A null inval pointer indicates that only the current reserved blocks
370  * available  should  be returned no settings are changed.
371  */
372
373 int
374 xfs_reserve_blocks(
375         xfs_mount_t             *mp,
376         uint64_t              *inval,
377         xfs_fsop_resblks_t      *outval)
378 {
379         int64_t                 lcounter, delta;
380         int64_t                 fdblks_delta = 0;
381         uint64_t                request;
382         int64_t                 free;
383         int                     error = 0;
384
385         /* If inval is null, report current values and return */
386         if (inval == (uint64_t *)NULL) {
387                 if (!outval)
388                         return -EINVAL;
389                 outval->resblks = mp->m_resblks;
390                 outval->resblks_avail = mp->m_resblks_avail;
391                 return 0;
392         }
393
394         request = *inval;
395
396         /*
397          * With per-cpu counters, this becomes an interesting problem. we need
398          * to work out if we are freeing or allocation blocks first, then we can
399          * do the modification as necessary.
400          *
401          * We do this under the m_sb_lock so that if we are near ENOSPC, we will
402          * hold out any changes while we work out what to do. This means that
403          * the amount of free space can change while we do this, so we need to
404          * retry if we end up trying to reserve more space than is available.
405          */
406         spin_lock(&mp->m_sb_lock);
407
408         /*
409          * If our previous reservation was larger than the current value,
410          * then move any unused blocks back to the free pool. Modify the resblks
411          * counters directly since we shouldn't have any problems unreserving
412          * space.
413          */
414         if (mp->m_resblks > request) {
415                 lcounter = mp->m_resblks_avail - request;
416                 if (lcounter  > 0) {            /* release unused blocks */
417                         fdblks_delta = lcounter;
418                         mp->m_resblks_avail -= lcounter;
419                 }
420                 mp->m_resblks = request;
421                 if (fdblks_delta) {
422                         spin_unlock(&mp->m_sb_lock);
423                         error = xfs_mod_fdblocks(mp, fdblks_delta, 0);
424                         spin_lock(&mp->m_sb_lock);
425                 }
426
427                 goto out;
428         }
429
430         /*
431          * If the request is larger than the current reservation, reserve the
432          * blocks before we update the reserve counters. Sample m_fdblocks and
433          * perform a partial reservation if the request exceeds free space.
434          *
435          * The code below estimates how many blocks it can request from
436          * fdblocks to stash in the reserve pool.  This is a classic TOCTOU
437          * race since fdblocks updates are not always coordinated via
438          * m_sb_lock.  Set the reserve size even if there's not enough free
439          * space to fill it because mod_fdblocks will refill an undersized
440          * reserve when it can.
441          */
442         free = percpu_counter_sum(&mp->m_fdblocks) -
443                                                 xfs_fdblocks_unavailable(mp);
444         delta = request - mp->m_resblks;
445         mp->m_resblks = request;
446         if (delta > 0 && free > 0) {
447                 /*
448                  * We'll either succeed in getting space from the free block
449                  * count or we'll get an ENOSPC.  Don't set the reserved flag
450                  * here - we don't want to reserve the extra reserve blocks
451                  * from the reserve.
452                  *
453                  * The desired reserve size can change after we drop the lock.
454                  * Use mod_fdblocks to put the space into the reserve or into
455                  * fdblocks as appropriate.
456                  */
457                 fdblks_delta = min(free, delta);
458                 spin_unlock(&mp->m_sb_lock);
459                 error = xfs_mod_fdblocks(mp, -fdblks_delta, 0);
460                 if (!error)
461                         xfs_mod_fdblocks(mp, fdblks_delta, 0);
462                 spin_lock(&mp->m_sb_lock);
463         }
464 out:
465         if (outval) {
466                 outval->resblks = mp->m_resblks;
467                 outval->resblks_avail = mp->m_resblks_avail;
468         }
469
470         spin_unlock(&mp->m_sb_lock);
471         return error;
472 }
473
474 int
475 xfs_fs_goingdown(
476         xfs_mount_t     *mp,
477         uint32_t        inflags)
478 {
479         switch (inflags) {
480         case XFS_FSOP_GOING_FLAGS_DEFAULT: {
481                 if (!freeze_bdev(mp->m_super->s_bdev)) {
482                         xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
483                         thaw_bdev(mp->m_super->s_bdev);
484                 }
485                 break;
486         }
487         case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
488                 xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
489                 break;
490         case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
491                 xfs_force_shutdown(mp,
492                                 SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
493                 break;
494         default:
495                 return -EINVAL;
496         }
497
498         return 0;
499 }
500
501 /*
502  * Force a shutdown of the filesystem instantly while keeping the filesystem
503  * consistent. We don't do an unmount here; just shutdown the shop, make sure
504  * that absolutely nothing persistent happens to this filesystem after this
505  * point.
506  *
507  * The shutdown state change is atomic, resulting in the first and only the
508  * first shutdown call processing the shutdown. This means we only shutdown the
509  * log once as it requires, and we don't spam the logs when multiple concurrent
510  * shutdowns race to set the shutdown flags.
511  */
512 void
513 xfs_do_force_shutdown(
514         struct xfs_mount *mp,
515         int             flags,
516         char            *fname,
517         int             lnnum)
518 {
519         int             tag;
520         const char      *why;
521
522
523         if (test_and_set_bit(XFS_OPSTATE_SHUTDOWN, &mp->m_opstate)) {
524                 xlog_shutdown_wait(mp->m_log);
525                 return;
526         }
527         if (mp->m_sb_bp)
528                 mp->m_sb_bp->b_flags |= XBF_DONE;
529
530         if (flags & SHUTDOWN_FORCE_UMOUNT)
531                 xfs_alert(mp, "User initiated shutdown received.");
532
533         if (xlog_force_shutdown(mp->m_log, flags)) {
534                 tag = XFS_PTAG_SHUTDOWN_LOGERROR;
535                 why = "Log I/O Error";
536         } else if (flags & SHUTDOWN_CORRUPT_INCORE) {
537                 tag = XFS_PTAG_SHUTDOWN_CORRUPT;
538                 why = "Corruption of in-memory data";
539         } else {
540                 tag = XFS_PTAG_SHUTDOWN_IOERROR;
541                 why = "Metadata I/O Error";
542         }
543
544         trace_xfs_force_shutdown(mp, tag, flags, fname, lnnum);
545
546         xfs_alert_tag(mp, tag,
547 "%s (0x%x) detected at %pS (%s:%d).  Shutting down filesystem.",
548                         why, flags, __return_address, fname, lnnum);
549         xfs_alert(mp,
550                 "Please unmount the filesystem and rectify the problem(s)");
551         if (xfs_error_level >= XFS_ERRLEVEL_HIGH)
552                 xfs_stack_trace();
553 }
554
555 /*
556  * Reserve free space for per-AG metadata.
557  */
558 int
559 xfs_fs_reserve_ag_blocks(
560         struct xfs_mount        *mp)
561 {
562         xfs_agnumber_t          agno;
563         struct xfs_perag        *pag;
564         int                     error = 0;
565         int                     err2;
566
567         mp->m_finobt_nores = false;
568         for_each_perag(mp, agno, pag) {
569                 err2 = xfs_ag_resv_init(pag, NULL);
570                 if (err2 && !error)
571                         error = err2;
572         }
573
574         if (error && error != -ENOSPC) {
575                 xfs_warn(mp,
576         "Error %d reserving per-AG metadata reserve pool.", error);
577                 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
578         }
579
580         return error;
581 }
582
583 /*
584  * Free space reserved for per-AG metadata.
585  */
586 int
587 xfs_fs_unreserve_ag_blocks(
588         struct xfs_mount        *mp)
589 {
590         xfs_agnumber_t          agno;
591         struct xfs_perag        *pag;
592         int                     error = 0;
593         int                     err2;
594
595         for_each_perag(mp, agno, pag) {
596                 err2 = xfs_ag_resv_free(pag);
597                 if (err2 && !error)
598                         error = err2;
599         }
600
601         if (error)
602                 xfs_warn(mp,
603         "Error %d freeing per-AG metadata reserve pool.", error);
604
605         return error;
606 }