blob: c3b00ba92ed2e037e3b0d2aa1c9cb7305e02b5e7 [file] [log] [blame]
Thomas Gleixner7336d0e2019-05-31 01:09:56 -07001// SPDX-License-Identifier: GPL-2.0-only
David Teiglandb3b94fa2006-01-16 16:50:04 +00002/*
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Bob Petersonfe6c9912008-01-28 11:13:02 -06004 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00005 */
6
Joe Perchesd77d1b52014-03-06 12:10:45 -08007#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
8
David Teiglandb3b94fa2006-01-16 16:50:04 +00009#include <linux/slab.h>
10#include <linux/spinlock.h>
11#include <linux/completion.h>
12#include <linux/buffer_head.h>
Steven Whitehousef42faf42006-01-30 18:34:10 +000013#include <linux/fs.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050014#include <linux/gfs2_ondisk.h>
Bob Peterson1f466a42008-03-10 18:17:47 -050015#include <linux/prefetch.h>
Steven Whitehousef15ab562009-02-09 09:25:01 +000016#include <linux/blkdev.h>
Bob Peterson7c9ca622011-08-31 09:53:19 +010017#include <linux/rbtree.h>
Steven Whitehouse9dbe9612012-10-31 10:37:10 +000018#include <linux/random.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000019
20#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050021#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000022#include "glock.h"
23#include "glops.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000024#include "lops.h"
25#include "meta_io.h"
26#include "quota.h"
27#include "rgrp.h"
28#include "super.h"
29#include "trans.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050030#include "util.h"
Benjamin Marzinski172e0452007-03-23 14:51:56 -060031#include "log.h"
Steven Whitehousec8cdf472007-06-08 10:05:33 +010032#include "inode.h"
Steven Whitehouse63997772009-06-12 08:49:20 +010033#include "trace_gfs2.h"
Andrew Price850d2d92017-12-12 11:42:30 -060034#include "dir.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000035
Steven Whitehouse2c1e52a2006-09-05 15:41:57 -040036#define BFITNOENT ((u32)~0)
Bob Peterson6760bdc2007-07-24 14:09:32 -050037#define NO_BLOCK ((u64)~0)
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040038
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +020039struct gfs2_rbm {
40 struct gfs2_rgrpd *rgd;
41 u32 offset; /* The offset is bitmap relative */
42 int bii; /* Bitmap index */
43};
44
45static inline struct gfs2_bitmap *rbm_bi(const struct gfs2_rbm *rbm)
46{
47 return rbm->rgd->rd_bits + rbm->bii;
48}
49
50static inline u64 gfs2_rbm_to_block(const struct gfs2_rbm *rbm)
51{
52 BUG_ON(rbm->offset >= rbm->rgd->rd_data);
53 return rbm->rgd->rd_data0 + (rbm_bi(rbm)->bi_start * GFS2_NBBY) +
54 rbm->offset;
55}
56
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040057/*
58 * These routines are used by the resource group routines (rgrp.c)
59 * to keep track of block allocation. Each block is represented by two
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040060 * bits. So, each byte represents GFS2_NBBY (i.e. 4) blocks.
61 *
62 * 0 = Free
63 * 1 = Used (not metadata)
64 * 2 = Unlinked (still in use) inode
65 * 3 = Used (metadata)
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040066 */
67
Bob Peterson5ce13432013-11-06 10:55:52 -050068struct gfs2_extent {
69 struct gfs2_rbm rbm;
70 u32 len;
71};
72
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040073static const char valid_change[16] = {
74 /* current */
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040075 /* n */ 0, 1, 1, 1,
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040076 /* e */ 1, 0, 0, 0,
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040077 /* w */ 0, 0, 0, 1,
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040078 1, 0, 0, 0
79};
80
Bob Peterson5ce13432013-11-06 10:55:52 -050081static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 *minext,
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +020082 struct gfs2_blkreserv *rs, bool nowrap);
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +010083
84
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040085/**
86 * gfs2_setbit - Set a bit in the bitmaps
Steven Whitehouse3e6339d2012-08-13 11:37:51 +010087 * @rbm: The position of the bit to set
88 * @do_clone: Also set the clone bitmap, if it exists
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040089 * @new_state: the new state of the block
90 *
91 */
92
Steven Whitehouse3e6339d2012-08-13 11:37:51 +010093static inline void gfs2_setbit(const struct gfs2_rbm *rbm, bool do_clone,
Bob Peterson06344b92012-04-26 12:44:35 -040094 unsigned char new_state)
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040095{
Steven Whitehouseb45e41d2008-02-06 10:11:15 +000096 unsigned char *byte1, *byte2, *end, cur_state;
Bob Petersone579ed42013-09-17 13:12:15 -040097 struct gfs2_bitmap *bi = rbm_bi(rbm);
Andreas Gruenbacher281b4952018-09-26 23:32:46 +010098 unsigned int buflen = bi->bi_bytes;
Steven Whitehouse3e6339d2012-08-13 11:37:51 +010099 const unsigned int bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400100
Bob Petersone579ed42013-09-17 13:12:15 -0400101 byte1 = bi->bi_bh->b_data + bi->bi_offset + (rbm->offset / GFS2_NBBY);
102 end = bi->bi_bh->b_data + bi->bi_offset + buflen;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400103
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000104 BUG_ON(byte1 >= end);
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400105
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000106 cur_state = (*byte1 >> bit) & GFS2_BIT_MASK;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400107
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000108 if (unlikely(!valid_change[new_state * 4 + cur_state])) {
Bob Petersone54c78a2018-10-03 08:47:36 -0500109 struct gfs2_sbd *sdp = rbm->rgd->rd_sbd;
110
111 fs_warn(sdp, "buf_blk = 0x%x old_state=%d, new_state=%d\n",
Joe Perchesd77d1b52014-03-06 12:10:45 -0800112 rbm->offset, cur_state, new_state);
Bob Petersone54c78a2018-10-03 08:47:36 -0500113 fs_warn(sdp, "rgrp=0x%llx bi_start=0x%x biblk: 0x%llx\n",
114 (unsigned long long)rbm->rgd->rd_addr, bi->bi_start,
115 (unsigned long long)bi->bi_bh->b_blocknr);
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100116 fs_warn(sdp, "bi_offset=0x%x bi_bytes=0x%x block=0x%llx\n",
117 bi->bi_offset, bi->bi_bytes,
Bob Petersone54c78a2018-10-03 08:47:36 -0500118 (unsigned long long)gfs2_rbm_to_block(rbm));
Bob Peterson95c8e172011-03-22 10:49:12 -0400119 dump_stack();
Steven Whitehouse3e6339d2012-08-13 11:37:51 +0100120 gfs2_consist_rgrpd(rbm->rgd);
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000121 return;
122 }
123 *byte1 ^= (cur_state ^ new_state) << bit;
124
Bob Petersone579ed42013-09-17 13:12:15 -0400125 if (do_clone && bi->bi_clone) {
126 byte2 = bi->bi_clone + bi->bi_offset + (rbm->offset / GFS2_NBBY);
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000127 cur_state = (*byte2 >> bit) & GFS2_BIT_MASK;
128 *byte2 ^= (cur_state ^ new_state) << bit;
129 }
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400130}
131
132/**
133 * gfs2_testbit - test a bit in the bitmaps
Steven Whitehousec04a2ef2012-08-13 11:14:57 +0100134 * @rbm: The bit to test
Bob Petersondffe12a2018-08-07 10:07:00 -0500135 * @use_clone: If true, test the clone bitmap, not the official bitmap.
136 *
137 * Some callers like gfs2_unaligned_extlen need to test the clone bitmaps,
138 * not the "real" bitmaps, to avoid allocating recently freed blocks.
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400139 *
Steven Whitehousec04a2ef2012-08-13 11:14:57 +0100140 * Returns: The two bit block state of the requested bit
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400141 */
142
Bob Petersondffe12a2018-08-07 10:07:00 -0500143static inline u8 gfs2_testbit(const struct gfs2_rbm *rbm, bool use_clone)
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400144{
Bob Petersone579ed42013-09-17 13:12:15 -0400145 struct gfs2_bitmap *bi = rbm_bi(rbm);
Bob Petersondffe12a2018-08-07 10:07:00 -0500146 const u8 *buffer;
Steven Whitehousec04a2ef2012-08-13 11:14:57 +0100147 const u8 *byte;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400148 unsigned int bit;
149
Bob Petersondffe12a2018-08-07 10:07:00 -0500150 if (use_clone && bi->bi_clone)
151 buffer = bi->bi_clone;
152 else
153 buffer = bi->bi_bh->b_data;
154 buffer += bi->bi_offset;
Steven Whitehousec04a2ef2012-08-13 11:14:57 +0100155 byte = buffer + (rbm->offset / GFS2_NBBY);
156 bit = (rbm->offset % GFS2_NBBY) * GFS2_BIT_SIZE;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400157
Steven Whitehousec04a2ef2012-08-13 11:14:57 +0100158 return (*byte >> bit) & GFS2_BIT_MASK;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400159}
160
161/**
Steven Whitehouse223b2b82009-02-17 14:13:35 +0000162 * gfs2_bit_search
163 * @ptr: Pointer to bitmap data
164 * @mask: Mask to use (normally 0x55555.... but adjusted for search start)
165 * @state: The state we are searching for
166 *
167 * We xor the bitmap data with a patter which is the bitwise opposite
168 * of what we are looking for, this gives rise to a pattern of ones
169 * wherever there is a match. Since we have two bits per entry, we
170 * take this pattern, shift it down by one place and then and it with
171 * the original. All the even bit positions (0,2,4, etc) then represent
172 * successful matches, so we mask with 0x55555..... to remove the unwanted
173 * odd bit positions.
174 *
175 * This allows searching of a whole u64 at once (32 blocks) with a
176 * single test (on 64 bit arches).
177 */
178
179static inline u64 gfs2_bit_search(const __le64 *ptr, u64 mask, u8 state)
180{
181 u64 tmp;
182 static const u64 search[] = {
Hannes Eder075ac442009-02-21 02:11:42 +0100183 [0] = 0xffffffffffffffffULL,
184 [1] = 0xaaaaaaaaaaaaaaaaULL,
185 [2] = 0x5555555555555555ULL,
186 [3] = 0x0000000000000000ULL,
Steven Whitehouse223b2b82009-02-17 14:13:35 +0000187 };
188 tmp = le64_to_cpu(*ptr) ^ search[state];
189 tmp &= (tmp >> 1);
190 tmp &= mask;
191 return tmp;
192}
193
194/**
Bob Peterson8e2e0042012-07-19 08:12:40 -0400195 * rs_cmp - multi-block reservation range compare
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +0200196 * @start: start of the new reservation
Bob Peterson8e2e0042012-07-19 08:12:40 -0400197 * @len: number of blocks in the new reservation
198 * @rs: existing reservation to compare against
199 *
200 * returns: 1 if the block range is beyond the reach of the reservation
201 * -1 if the block range is before the start of the reservation
202 * 0 if the block range overlaps with the reservation
203 */
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +0200204static inline int rs_cmp(u64 start, u32 len, struct gfs2_blkreserv *rs)
Bob Peterson8e2e0042012-07-19 08:12:40 -0400205{
Andreas Gruenbacher07974d22020-10-22 20:34:29 +0200206 if (start >= rs->rs_start + rs->rs_requested)
Bob Peterson8e2e0042012-07-19 08:12:40 -0400207 return 1;
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +0200208 if (rs->rs_start >= start + len)
Bob Peterson8e2e0042012-07-19 08:12:40 -0400209 return -1;
210 return 0;
211}
212
213/**
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400214 * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
215 * a block in a given allocation state.
Bob Peterson886b1412012-04-11 13:03:52 -0400216 * @buf: the buffer that holds the bitmaps
Steven Whitehouse223b2b82009-02-17 14:13:35 +0000217 * @len: the length (in bytes) of the buffer
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400218 * @goal: start search at this block's bit-pair (within @buffer)
Steven Whitehouse223b2b82009-02-17 14:13:35 +0000219 * @state: GFS2_BLKST_XXX the state of the block we're looking for.
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400220 *
221 * Scope of @goal and returned block number is only within this bitmap buffer,
222 * not entire rgrp or filesystem. @buffer will be offset from the actual
Steven Whitehouse223b2b82009-02-17 14:13:35 +0000223 * beginning of a bitmap block buffer, skipping any header structures, but
224 * headers are always a multiple of 64 bits long so that the buffer is
225 * always aligned to a 64 bit boundary.
226 *
227 * The size of the buffer is in bytes, but is it assumed that it is
Anand Gadiyarfd589a82009-07-16 17:13:03 +0200228 * always ok to read a complete multiple of 64 bits at the end
Steven Whitehouse223b2b82009-02-17 14:13:35 +0000229 * of the block in case the end is no aligned to a natural boundary.
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400230 *
231 * Return: the block number (bitmap buffer scope) that was found
232 */
233
Hannes Eder02ab1722009-02-21 02:12:05 +0100234static u32 gfs2_bitfit(const u8 *buf, const unsigned int len,
235 u32 goal, u8 state)
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400236{
Steven Whitehouse223b2b82009-02-17 14:13:35 +0000237 u32 spoint = (goal << 1) & ((8*sizeof(u64)) - 1);
238 const __le64 *ptr = ((__le64 *)buf) + (goal >> 5);
239 const __le64 *end = (__le64 *)(buf + ALIGN(len, sizeof(u64)));
240 u64 tmp;
Hannes Eder075ac442009-02-21 02:11:42 +0100241 u64 mask = 0x5555555555555555ULL;
Steven Whitehouse223b2b82009-02-17 14:13:35 +0000242 u32 bit;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400243
Steven Whitehouse223b2b82009-02-17 14:13:35 +0000244 /* Mask off bits we don't care about at the start of the search */
245 mask <<= spoint;
246 tmp = gfs2_bit_search(ptr, mask, state);
247 ptr++;
248 while(tmp == 0 && ptr < end) {
Hannes Eder075ac442009-02-21 02:11:42 +0100249 tmp = gfs2_bit_search(ptr, 0x5555555555555555ULL, state);
Steven Whitehouse223b2b82009-02-17 14:13:35 +0000250 ptr++;
Bob Peterson1f466a42008-03-10 18:17:47 -0500251 }
Steven Whitehouse223b2b82009-02-17 14:13:35 +0000252 /* Mask off any bits which are more than len bytes from the start */
253 if (ptr == end && (len & (sizeof(u64) - 1)))
254 tmp &= (((u64)~0) >> (64 - 8*(len & (sizeof(u64) - 1))));
255 /* Didn't find anything, so return */
256 if (tmp == 0)
257 return BFITNOENT;
258 ptr--;
Steven Whitehoused8bd5042009-04-23 08:54:02 +0100259 bit = __ffs64(tmp);
Steven Whitehouse223b2b82009-02-17 14:13:35 +0000260 bit /= 2; /* two bits per entry in the bitmap */
261 return (((const unsigned char *)ptr - buf) * GFS2_NBBY) + bit;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400262}
263
264/**
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100265 * gfs2_rbm_from_block - Set the rbm based upon rgd and block number
266 * @rbm: The rbm with rgd already set correctly
267 * @block: The block number (filesystem relative)
268 *
269 * This sets the bi and offset members of an rbm based on a
270 * resource group and a filesystem relative block number. The
271 * resource group must be set in the rbm on entry, the bi and
272 * offset members will be set by this function.
273 *
274 * Returns: 0 on success, or an error code
275 */
276
277static int gfs2_rbm_from_block(struct gfs2_rbm *rbm, u64 block)
278{
Andreas Gruenbacher3548fce2018-10-11 19:35:50 +0200279 if (!rgrp_contains_block(rbm->rgd, block))
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100280 return -E2BIG;
Bob Petersone579ed42013-09-17 13:12:15 -0400281 rbm->bii = 0;
Andreas Gruenbacher3548fce2018-10-11 19:35:50 +0200282 rbm->offset = block - rbm->rgd->rd_data0;
Bob Petersona68a0a32012-10-19 08:32:51 -0400283 /* Check if the block is within the first block */
Bob Petersone579ed42013-09-17 13:12:15 -0400284 if (rbm->offset < rbm_bi(rbm)->bi_blocks)
Bob Petersona68a0a32012-10-19 08:32:51 -0400285 return 0;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100286
Bob Petersona68a0a32012-10-19 08:32:51 -0400287 /* Adjust for the size diff between gfs2_meta_header and gfs2_rgrp */
288 rbm->offset += (sizeof(struct gfs2_rgrp) -
289 sizeof(struct gfs2_meta_header)) * GFS2_NBBY;
Bob Petersone579ed42013-09-17 13:12:15 -0400290 rbm->bii = rbm->offset / rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
291 rbm->offset -= rbm->bii * rbm->rgd->rd_sbd->sd_blocks_per_bitmap;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100292 return 0;
293}
294
295/**
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +0200296 * gfs2_rbm_add - add a number of blocks to an rbm
Bob Peterson149ed7f2013-09-17 13:14:35 -0400297 * @rbm: The rbm with rgd already set correctly
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +0200298 * @blocks: The number of blocks to add to rpm
Bob Peterson149ed7f2013-09-17 13:14:35 -0400299 *
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +0200300 * This function takes an existing rbm structure and adds a number of blocks to
301 * it.
Bob Peterson149ed7f2013-09-17 13:14:35 -0400302 *
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +0200303 * Returns: True if the new rbm would point past the end of the rgrp.
Bob Peterson149ed7f2013-09-17 13:14:35 -0400304 */
305
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +0200306static bool gfs2_rbm_add(struct gfs2_rbm *rbm, u32 blocks)
Bob Peterson149ed7f2013-09-17 13:14:35 -0400307{
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +0200308 struct gfs2_rgrpd *rgd = rbm->rgd;
309 struct gfs2_bitmap *bi = rgd->rd_bits + rbm->bii;
310
311 if (rbm->offset + blocks < bi->bi_blocks) {
312 rbm->offset += blocks;
Bob Peterson149ed7f2013-09-17 13:14:35 -0400313 return false;
314 }
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +0200315 blocks -= bi->bi_blocks - rbm->offset;
Bob Peterson149ed7f2013-09-17 13:14:35 -0400316
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +0200317 for(;;) {
318 bi++;
319 if (bi == rgd->rd_bits + rgd->rd_length)
320 return true;
321 if (blocks < bi->bi_blocks) {
322 rbm->offset = blocks;
323 rbm->bii = bi - rgd->rd_bits;
324 return false;
325 }
326 blocks -= bi->bi_blocks;
327 }
Bob Peterson149ed7f2013-09-17 13:14:35 -0400328}
329
330/**
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100331 * gfs2_unaligned_extlen - Look for free blocks which are not byte aligned
332 * @rbm: Position to search (value/result)
333 * @n_unaligned: Number of unaligned blocks to check
334 * @len: Decremented for each block found (terminate on zero)
335 *
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +0200336 * Returns: true if a non-free block is encountered or the end of the resource
337 * group is reached.
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100338 */
339
340static bool gfs2_unaligned_extlen(struct gfs2_rbm *rbm, u32 n_unaligned, u32 *len)
341{
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100342 u32 n;
343 u8 res;
344
345 for (n = 0; n < n_unaligned; n++) {
Bob Petersondffe12a2018-08-07 10:07:00 -0500346 res = gfs2_testbit(rbm, true);
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100347 if (res != GFS2_BLKST_FREE)
348 return true;
349 (*len)--;
350 if (*len == 0)
351 return true;
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +0200352 if (gfs2_rbm_add(rbm, 1))
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100353 return true;
354 }
355
356 return false;
357}
358
359/**
360 * gfs2_free_extlen - Return extent length of free blocks
Fabian Frederick27ff6a02014-07-02 22:05:27 +0200361 * @rrbm: Starting position
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100362 * @len: Max length to check
363 *
364 * Starting at the block specified by the rbm, see how many free blocks
365 * there are, not reading more than len blocks ahead. This can be done
366 * using memchr_inv when the blocks are byte aligned, but has to be done
367 * on a block by block basis in case of unaligned blocks. Also this
368 * function can cope with bitmap boundaries (although it must stop on
369 * a resource group boundary)
370 *
371 * Returns: Number of free blocks in the extent
372 */
373
374static u32 gfs2_free_extlen(const struct gfs2_rbm *rrbm, u32 len)
375{
376 struct gfs2_rbm rbm = *rrbm;
377 u32 n_unaligned = rbm.offset & 3;
378 u32 size = len;
379 u32 bytes;
380 u32 chunk_size;
381 u8 *ptr, *start, *end;
382 u64 block;
Bob Petersone579ed42013-09-17 13:12:15 -0400383 struct gfs2_bitmap *bi;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100384
385 if (n_unaligned &&
386 gfs2_unaligned_extlen(&rbm, 4 - n_unaligned, &len))
387 goto out;
388
Bob Peterson37015302012-09-12 09:40:31 -0400389 n_unaligned = len & 3;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100390 /* Start is now byte aligned */
391 while (len > 3) {
Bob Petersone579ed42013-09-17 13:12:15 -0400392 bi = rbm_bi(&rbm);
393 start = bi->bi_bh->b_data;
394 if (bi->bi_clone)
395 start = bi->bi_clone;
Bob Petersone579ed42013-09-17 13:12:15 -0400396 start += bi->bi_offset;
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100397 end = start + bi->bi_bytes;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100398 BUG_ON(rbm.offset & 3);
399 start += (rbm.offset / GFS2_NBBY);
400 bytes = min_t(u32, len / GFS2_NBBY, (end - start));
401 ptr = memchr_inv(start, 0, bytes);
402 chunk_size = ((ptr == NULL) ? bytes : (ptr - start));
403 chunk_size *= GFS2_NBBY;
404 BUG_ON(len < chunk_size);
405 len -= chunk_size;
406 block = gfs2_rbm_to_block(&rbm);
Bob Peterson15bd50a2012-12-20 13:21:07 -0500407 if (gfs2_rbm_from_block(&rbm, block + chunk_size)) {
408 n_unaligned = 0;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100409 break;
Bob Peterson15bd50a2012-12-20 13:21:07 -0500410 }
411 if (ptr) {
412 n_unaligned = 3;
413 break;
414 }
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +0100415 n_unaligned = len & 3;
416 }
417
418 /* Deal with any bits left over at the end */
419 if (n_unaligned)
420 gfs2_unaligned_extlen(&rbm, n_unaligned, &len);
421out:
422 return size - len;
423}
424
425/**
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400426 * gfs2_bitcount - count the number of bits in a certain state
Bob Peterson886b1412012-04-11 13:03:52 -0400427 * @rgd: the resource group descriptor
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400428 * @buffer: the buffer that holds the bitmaps
429 * @buflen: the length (in bytes) of the buffer
430 * @state: the state of the block we're looking for
431 *
432 * Returns: The number of bits
433 */
434
Steven Whitehouse110acf32008-01-29 13:30:20 +0000435static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
436 unsigned int buflen, u8 state)
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400437{
Steven Whitehouse110acf32008-01-29 13:30:20 +0000438 const u8 *byte = buffer;
439 const u8 *end = buffer + buflen;
440 const u8 state1 = state << 2;
441 const u8 state2 = state << 4;
442 const u8 state3 = state << 6;
Steven Whitehousecd915492006-09-04 12:49:07 -0400443 u32 count = 0;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400444
445 for (; byte < end; byte++) {
446 if (((*byte) & 0x03) == state)
447 count++;
448 if (((*byte) & 0x0C) == state1)
449 count++;
450 if (((*byte) & 0x30) == state2)
451 count++;
452 if (((*byte) & 0xC0) == state3)
453 count++;
454 }
455
456 return count;
457}
458
David Teiglandb3b94fa2006-01-16 16:50:04 +0000459/**
460 * gfs2_rgrp_verify - Verify that a resource group is consistent
David Teiglandb3b94fa2006-01-16 16:50:04 +0000461 * @rgd: the rgrp
462 *
463 */
464
465void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
466{
467 struct gfs2_sbd *sdp = rgd->rd_sbd;
468 struct gfs2_bitmap *bi = NULL;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100469 u32 length = rgd->rd_length;
Steven Whitehousecd915492006-09-04 12:49:07 -0400470 u32 count[4], tmp;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000471 int buf, x;
472
Steven Whitehousecd915492006-09-04 12:49:07 -0400473 memset(count, 0, 4 * sizeof(u32));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000474
475 /* Count # blocks in each of 4 possible allocation states */
476 for (buf = 0; buf < length; buf++) {
477 bi = rgd->rd_bits + buf;
478 for (x = 0; x < 4; x++)
479 count[x] += gfs2_bitcount(rgd,
480 bi->bi_bh->b_data +
481 bi->bi_offset,
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100482 bi->bi_bytes, x);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000483 }
484
Steven Whitehousecfc8b542008-11-04 10:25:13 +0000485 if (count[0] != rgd->rd_free) {
Andreas Gruenbacher8dc88ac2020-01-23 19:19:38 +0100486 gfs2_lm(sdp, "free data mismatch: %u != %u\n",
487 count[0], rgd->rd_free);
488 gfs2_consist_rgrpd(rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000489 return;
490 }
491
Steven Whitehouse73f74942008-11-04 10:32:57 +0000492 tmp = rgd->rd_data - rgd->rd_free - rgd->rd_dinodes;
Benjamin Marzinski6b946172009-07-10 18:13:26 -0500493 if (count[1] != tmp) {
Andreas Gruenbacher8dc88ac2020-01-23 19:19:38 +0100494 gfs2_lm(sdp, "used data mismatch: %u != %u\n",
495 count[1], tmp);
496 gfs2_consist_rgrpd(rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000497 return;
498 }
499
Benjamin Marzinski6b946172009-07-10 18:13:26 -0500500 if (count[2] + count[3] != rgd->rd_dinodes) {
Andreas Gruenbacher8dc88ac2020-01-23 19:19:38 +0100501 gfs2_lm(sdp, "used metadata mismatch: %u != %u\n",
502 count[2] + count[3], rgd->rd_dinodes);
503 gfs2_consist_rgrpd(rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000504 return;
505 }
506}
507
David Teiglandb3b94fa2006-01-16 16:50:04 +0000508/**
509 * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
510 * @sdp: The GFS2 superblock
Bob Peterson886b1412012-04-11 13:03:52 -0400511 * @blk: The data block number
512 * @exact: True if this needs to be an exact match
David Teiglandb3b94fa2006-01-16 16:50:04 +0000513 *
Steven Whitehouse90bcab92017-12-22 13:13:07 +0100514 * The @exact argument should be set to true by most callers. The exception
515 * is when we need to match blocks which are not represented by the rgrp
516 * bitmap, but which are part of the rgrp (i.e. padding blocks) which are
517 * there for alignment purposes. Another way of looking at it is that @exact
518 * matches only valid data/metadata blocks, but with @exact false, it will
519 * match any block within the extent of the rgrp.
520 *
David Teiglandb3b94fa2006-01-16 16:50:04 +0000521 * Returns: The resource group, or NULL if not found
522 */
523
Steven Whitehouse66fc0612012-02-08 12:58:32 +0000524struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk, bool exact)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000525{
Steven Whitehouse66fc0612012-02-08 12:58:32 +0000526 struct rb_node *n, *next;
Steven Whitehousef75bbfb2011-09-08 10:21:13 +0100527 struct gfs2_rgrpd *cur;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000528
529 spin_lock(&sdp->sd_rindex_spin);
Steven Whitehouse66fc0612012-02-08 12:58:32 +0000530 n = sdp->sd_rindex_tree.rb_node;
531 while (n) {
532 cur = rb_entry(n, struct gfs2_rgrpd, rd_node);
533 next = NULL;
Bob Peterson7c9ca622011-08-31 09:53:19 +0100534 if (blk < cur->rd_addr)
Steven Whitehouse66fc0612012-02-08 12:58:32 +0000535 next = n->rb_left;
Steven Whitehousef75bbfb2011-09-08 10:21:13 +0100536 else if (blk >= cur->rd_data0 + cur->rd_data)
Steven Whitehouse66fc0612012-02-08 12:58:32 +0000537 next = n->rb_right;
538 if (next == NULL) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000539 spin_unlock(&sdp->sd_rindex_spin);
Steven Whitehouse66fc0612012-02-08 12:58:32 +0000540 if (exact) {
541 if (blk < cur->rd_addr)
542 return NULL;
543 if (blk >= cur->rd_data0 + cur->rd_data)
544 return NULL;
545 }
Bob Peterson7c9ca622011-08-31 09:53:19 +0100546 return cur;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000547 }
Steven Whitehouse66fc0612012-02-08 12:58:32 +0000548 n = next;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000549 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000550 spin_unlock(&sdp->sd_rindex_spin);
551
552 return NULL;
553}
554
555/**
556 * gfs2_rgrpd_get_first - get the first Resource Group in the filesystem
557 * @sdp: The GFS2 superblock
558 *
559 * Returns: The first rgrp in the filesystem
560 */
561
562struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp)
563{
Bob Peterson7c9ca622011-08-31 09:53:19 +0100564 const struct rb_node *n;
565 struct gfs2_rgrpd *rgd;
566
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100567 spin_lock(&sdp->sd_rindex_spin);
Bob Peterson7c9ca622011-08-31 09:53:19 +0100568 n = rb_first(&sdp->sd_rindex_tree);
569 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100570 spin_unlock(&sdp->sd_rindex_spin);
Bob Peterson7c9ca622011-08-31 09:53:19 +0100571
572 return rgd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000573}
574
575/**
576 * gfs2_rgrpd_get_next - get the next RG
Bob Peterson886b1412012-04-11 13:03:52 -0400577 * @rgd: the resource group descriptor
David Teiglandb3b94fa2006-01-16 16:50:04 +0000578 *
579 * Returns: The next rgrp
580 */
581
582struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
583{
Bob Peterson7c9ca622011-08-31 09:53:19 +0100584 struct gfs2_sbd *sdp = rgd->rd_sbd;
585 const struct rb_node *n;
586
587 spin_lock(&sdp->sd_rindex_spin);
588 n = rb_next(&rgd->rd_node);
589 if (n == NULL)
590 n = rb_first(&sdp->sd_rindex_tree);
591
592 if (unlikely(&rgd->rd_node == n)) {
593 spin_unlock(&sdp->sd_rindex_spin);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000594 return NULL;
Bob Peterson7c9ca622011-08-31 09:53:19 +0100595 }
596 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
597 spin_unlock(&sdp->sd_rindex_spin);
598 return rgd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000599}
600
Abhi Das00a158b2014-09-18 21:40:28 -0500601void check_and_update_goal(struct gfs2_inode *ip)
602{
603 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
604 if (!ip->i_goal || gfs2_blk2rgrpd(sdp, ip->i_goal, 1) == NULL)
605 ip->i_goal = ip->i_no_addr;
606}
607
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100608void gfs2_free_clones(struct gfs2_rgrpd *rgd)
609{
610 int x;
611
612 for (x = 0; x < rgd->rd_length; x++) {
613 struct gfs2_bitmap *bi = rgd->rd_bits + x;
614 kfree(bi->bi_clone);
615 bi->bi_clone = NULL;
616 }
617}
618
Bob Peterson3792ce92019-05-09 09:21:48 -0500619static void dump_rs(struct seq_file *seq, const struct gfs2_blkreserv *rs,
620 const char *fs_id_buf)
Bob Peterson8e2e0042012-07-19 08:12:40 -0400621{
Bob Petersonf85c10e2018-06-13 08:52:47 -0500622 struct gfs2_inode *ip = container_of(rs, struct gfs2_inode, i_res);
623
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +0200624 gfs2_print_dbg(seq, "%s B: n:%llu s:%llu f:%u\n",
625 fs_id_buf,
Bob Petersonf85c10e2018-06-13 08:52:47 -0500626 (unsigned long long)ip->i_no_addr,
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +0200627 (unsigned long long)rs->rs_start,
Andreas Gruenbacher07974d22020-10-22 20:34:29 +0200628 rs->rs_requested);
Bob Peterson8e2e0042012-07-19 08:12:40 -0400629}
630
Bob Peterson0a305e42012-06-06 11:17:59 +0100631/**
Bob Peterson8e2e0042012-07-19 08:12:40 -0400632 * __rs_deltree - remove a multi-block reservation from the rgd tree
633 * @rs: The reservation to remove
634 *
635 */
Bob Peterson20095212013-03-13 10:26:38 -0400636static void __rs_deltree(struct gfs2_blkreserv *rs)
Bob Peterson8e2e0042012-07-19 08:12:40 -0400637{
638 struct gfs2_rgrpd *rgd;
639
640 if (!gfs2_rs_active(rs))
641 return;
642
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +0200643 rgd = rs->rs_rgd;
Steven Whitehouse9e733d32012-08-23 15:37:59 +0100644 trace_gfs2_rs(rs, TRACE_RS_TREEDEL);
Steven Whitehouse4a993fb2012-07-31 15:21:20 +0100645 rb_erase(&rs->rs_node, &rgd->rd_rstree);
Michel Lespinasse24d634e2012-08-05 22:04:08 -0700646 RB_CLEAR_NODE(&rs->rs_node);
Bob Peterson8e2e0042012-07-19 08:12:40 -0400647
Andreas Gruenbacher07974d22020-10-22 20:34:29 +0200648 if (rs->rs_requested) {
649 /* return requested blocks to the rgrp */
650 BUG_ON(rs->rs_rgd->rd_requested < rs->rs_requested);
651 rs->rs_rgd->rd_requested -= rs->rs_requested;
Andreas Gruenbachera12c6fa2020-10-06 15:16:16 +0200652
Bob Peterson5ea50502013-11-25 11:16:25 +0000653 /* The rgrp extent failure point is likely not to increase;
654 it will only do so if the freed blocks are somehow
655 contiguous with a span of free blocks that follows. Still,
656 it will force the number to be recalculated later. */
Andreas Gruenbacher07974d22020-10-22 20:34:29 +0200657 rgd->rd_extfail_pt += rs->rs_requested;
658 rs->rs_requested = 0;
Bob Peterson8e2e0042012-07-19 08:12:40 -0400659 }
Bob Peterson8e2e0042012-07-19 08:12:40 -0400660}
661
662/**
663 * gfs2_rs_deltree - remove a multi-block reservation from the rgd tree
664 * @rs: The reservation to remove
665 *
666 */
Bob Peterson20095212013-03-13 10:26:38 -0400667void gfs2_rs_deltree(struct gfs2_blkreserv *rs)
Bob Peterson8e2e0042012-07-19 08:12:40 -0400668{
669 struct gfs2_rgrpd *rgd;
670
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +0200671 rgd = rs->rs_rgd;
Steven Whitehouse4a993fb2012-07-31 15:21:20 +0100672 if (rgd) {
673 spin_lock(&rgd->rd_rsspin);
Bob Peterson20095212013-03-13 10:26:38 -0400674 __rs_deltree(rs);
Andreas Gruenbacher07974d22020-10-22 20:34:29 +0200675 BUG_ON(rs->rs_requested);
Steven Whitehouse4a993fb2012-07-31 15:21:20 +0100676 spin_unlock(&rgd->rd_rsspin);
677 }
Bob Peterson8e2e0042012-07-19 08:12:40 -0400678}
679
680/**
Andreas Gruenbacher15955482020-03-06 10:32:35 -0600681 * gfs2_rs_delete - delete a multi-block reservation
Bob Peterson0a305e42012-06-06 11:17:59 +0100682 * @ip: The inode for this reservation
Steven Whitehouseaf5c2692013-09-27 12:49:33 +0100683 * @wcount: The inode's write count, or NULL
Bob Peterson0a305e42012-06-06 11:17:59 +0100684 *
685 */
Andreas Gruenbacher15955482020-03-06 10:32:35 -0600686void gfs2_rs_delete(struct gfs2_inode *ip, atomic_t *wcount)
Bob Peterson0a305e42012-06-06 11:17:59 +0100687{
688 down_write(&ip->i_rw_mutex);
Bob Peterson44f52122016-07-06 10:36:43 -0500689 if ((wcount == NULL) || (atomic_read(wcount) <= 1))
Bob Petersona097dc7e2015-07-16 08:28:04 -0500690 gfs2_rs_deltree(&ip->i_res);
Bob Peterson0a305e42012-06-06 11:17:59 +0100691 up_write(&ip->i_rw_mutex);
692}
693
Bob Peterson8e2e0042012-07-19 08:12:40 -0400694/**
695 * return_all_reservations - return all reserved blocks back to the rgrp.
696 * @rgd: the rgrp that needs its space back
697 *
698 * We previously reserved a bunch of blocks for allocation. Now we need to
699 * give them back. This leave the reservation structures in tact, but removes
700 * all of their corresponding "no-fly zones".
701 */
702static void return_all_reservations(struct gfs2_rgrpd *rgd)
703{
704 struct rb_node *n;
705 struct gfs2_blkreserv *rs;
706
707 spin_lock(&rgd->rd_rsspin);
708 while ((n = rb_first(&rgd->rd_rstree))) {
709 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
Bob Peterson20095212013-03-13 10:26:38 -0400710 __rs_deltree(rs);
Bob Peterson8e2e0042012-07-19 08:12:40 -0400711 }
712 spin_unlock(&rgd->rd_rsspin);
713}
714
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100715void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000716{
Bob Peterson7c9ca622011-08-31 09:53:19 +0100717 struct rb_node *n;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000718 struct gfs2_rgrpd *rgd;
719 struct gfs2_glock *gl;
720
Bob Peterson7c9ca622011-08-31 09:53:19 +0100721 while ((n = rb_first(&sdp->sd_rindex_tree))) {
722 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000723 gl = rgd->rd_gl;
724
Bob Peterson7c9ca622011-08-31 09:53:19 +0100725 rb_erase(n, &sdp->sd_rindex_tree);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000726
727 if (gl) {
Bob Petersonb3422ca2019-11-13 11:50:30 -0600728 if (gl->gl_state != LM_ST_UNLOCKED) {
729 gfs2_glock_cb(gl, LM_ST_UNLOCKED);
730 flush_delayed_work(&gl->gl_work);
731 }
Andreas Gruenbacher10283ea2018-11-05 22:57:24 +0000732 gfs2_rgrp_brelse(rgd);
Bob Petersonb3422ca2019-11-13 11:50:30 -0600733 glock_clear_object(gl, rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000734 gfs2_glock_put(gl);
735 }
736
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100737 gfs2_free_clones(rgd);
Bob Petersond0f17d32020-10-27 10:10:01 -0500738 return_all_reservations(rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000739 kfree(rgd->rd_bits);
Bob Peterson36e4ad02016-06-09 14:24:07 -0500740 rgd->rd_bits = NULL;
Bob Peterson6bdd9be2008-01-28 17:20:26 -0600741 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000742 }
743}
744
David Teiglandb3b94fa2006-01-16 16:50:04 +0000745/**
Lee Jonesc551f662021-03-30 17:44:29 +0100746 * compute_bitstructs - Compute the bitmap sizes
David Teiglandb3b94fa2006-01-16 16:50:04 +0000747 * @rgd: The resource group descriptor
748 *
749 * Calculates bitmap descriptors, one for each block that contains bitmap data
750 *
751 * Returns: errno
752 */
753
754static int compute_bitstructs(struct gfs2_rgrpd *rgd)
755{
756 struct gfs2_sbd *sdp = rgd->rd_sbd;
757 struct gfs2_bitmap *bi;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100758 u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
Steven Whitehousecd915492006-09-04 12:49:07 -0400759 u32 bytes_left, bytes;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000760 int x;
761
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400762 if (!length)
763 return -EINVAL;
764
Steven Whitehousedd894be2006-07-27 14:29:00 -0400765 rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000766 if (!rgd->rd_bits)
767 return -ENOMEM;
768
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100769 bytes_left = rgd->rd_bitbytes;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000770
771 for (x = 0; x < length; x++) {
772 bi = rgd->rd_bits + x;
773
Steven Whitehouse60a0b8f2009-05-21 12:23:12 +0100774 bi->bi_flags = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000775 /* small rgrp; bitmap stored completely in header block */
776 if (length == 1) {
777 bytes = bytes_left;
778 bi->bi_offset = sizeof(struct gfs2_rgrp);
779 bi->bi_start = 0;
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100780 bi->bi_bytes = bytes;
Bob Peterson7e230f52013-09-11 13:44:02 -0500781 bi->bi_blocks = bytes * GFS2_NBBY;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000782 /* header block */
783 } else if (x == 0) {
784 bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
785 bi->bi_offset = sizeof(struct gfs2_rgrp);
786 bi->bi_start = 0;
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100787 bi->bi_bytes = bytes;
Bob Peterson7e230f52013-09-11 13:44:02 -0500788 bi->bi_blocks = bytes * GFS2_NBBY;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000789 /* last block */
790 } else if (x + 1 == length) {
791 bytes = bytes_left;
792 bi->bi_offset = sizeof(struct gfs2_meta_header);
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100793 bi->bi_start = rgd->rd_bitbytes - bytes_left;
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100794 bi->bi_bytes = bytes;
Bob Peterson7e230f52013-09-11 13:44:02 -0500795 bi->bi_blocks = bytes * GFS2_NBBY;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000796 /* other blocks */
797 } else {
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500798 bytes = sdp->sd_sb.sb_bsize -
799 sizeof(struct gfs2_meta_header);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000800 bi->bi_offset = sizeof(struct gfs2_meta_header);
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100801 bi->bi_start = rgd->rd_bitbytes - bytes_left;
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100802 bi->bi_bytes = bytes;
Bob Peterson7e230f52013-09-11 13:44:02 -0500803 bi->bi_blocks = bytes * GFS2_NBBY;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000804 }
805
806 bytes_left -= bytes;
807 }
808
809 if (bytes_left) {
810 gfs2_consist_rgrpd(rgd);
811 return -EIO;
812 }
813 bi = rgd->rd_bits + (length - 1);
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100814 if ((bi->bi_start + bi->bi_bytes) * GFS2_NBBY != rgd->rd_data) {
Andreas Gruenbacher8dc88ac2020-01-23 19:19:38 +0100815 gfs2_lm(sdp,
816 "ri_addr = %llu\n"
817 "ri_length = %u\n"
818 "ri_data0 = %llu\n"
819 "ri_data = %u\n"
820 "ri_bitbytes = %u\n"
821 "start=%u len=%u offset=%u\n",
822 (unsigned long long)rgd->rd_addr,
823 rgd->rd_length,
824 (unsigned long long)rgd->rd_data0,
825 rgd->rd_data,
826 rgd->rd_bitbytes,
827 bi->bi_start, bi->bi_bytes, bi->bi_offset);
828 gfs2_consist_rgrpd(rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000829 return -EIO;
830 }
831
832 return 0;
833}
834
835/**
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500836 * gfs2_ri_total - Total up the file system space, according to the rindex.
Bob Peterson886b1412012-04-11 13:03:52 -0400837 * @sdp: the filesystem
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500838 *
839 */
840u64 gfs2_ri_total(struct gfs2_sbd *sdp)
841{
842 u64 total_data = 0;
843 struct inode *inode = sdp->sd_rindex;
844 struct gfs2_inode *ip = GFS2_I(inode);
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500845 char buf[sizeof(struct gfs2_rindex)];
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500846 int error, rgrps;
847
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500848 for (rgrps = 0;; rgrps++) {
849 loff_t pos = rgrps * sizeof(struct gfs2_rindex);
850
Bob Petersonbcd72782010-12-07 13:58:56 -0500851 if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500852 break;
Andrew Price43066292012-04-16 16:40:55 +0100853 error = gfs2_internal_read(ip, buf, &pos,
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500854 sizeof(struct gfs2_rindex));
855 if (error != sizeof(struct gfs2_rindex))
856 break;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100857 total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500858 }
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500859 return total_data;
860}
861
Bob Peterson6aad1c32012-03-05 09:20:59 -0500862static int rgd_insert(struct gfs2_rgrpd *rgd)
Bob Peterson7c9ca622011-08-31 09:53:19 +0100863{
864 struct gfs2_sbd *sdp = rgd->rd_sbd;
865 struct rb_node **newn = &sdp->sd_rindex_tree.rb_node, *parent = NULL;
866
867 /* Figure out where to put new node */
868 while (*newn) {
869 struct gfs2_rgrpd *cur = rb_entry(*newn, struct gfs2_rgrpd,
870 rd_node);
871
872 parent = *newn;
873 if (rgd->rd_addr < cur->rd_addr)
874 newn = &((*newn)->rb_left);
875 else if (rgd->rd_addr > cur->rd_addr)
876 newn = &((*newn)->rb_right);
877 else
Bob Peterson6aad1c32012-03-05 09:20:59 -0500878 return -EEXIST;
Bob Peterson7c9ca622011-08-31 09:53:19 +0100879 }
880
881 rb_link_node(&rgd->rd_node, parent, newn);
882 rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
Bob Peterson6aad1c32012-03-05 09:20:59 -0500883 sdp->sd_rgrps++;
884 return 0;
Bob Peterson7c9ca622011-08-31 09:53:19 +0100885}
886
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500887/**
Robert Peterson6c532672007-05-10 16:54:38 -0500888 * read_rindex_entry - Pull in a new resource index entry from the disk
Andrew Price43066292012-04-16 16:40:55 +0100889 * @ip: Pointer to the rindex inode
David Teiglandb3b94fa2006-01-16 16:50:04 +0000890 *
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100891 * Returns: 0 on success, > 0 on EOF, error code otherwise
Robert Peterson6c532672007-05-10 16:54:38 -0500892 */
893
Andrew Price43066292012-04-16 16:40:55 +0100894static int read_rindex_entry(struct gfs2_inode *ip)
Robert Peterson6c532672007-05-10 16:54:38 -0500895{
896 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
897 loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100898 struct gfs2_rindex buf;
Robert Peterson6c532672007-05-10 16:54:38 -0500899 int error;
900 struct gfs2_rgrpd *rgd;
901
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100902 if (pos >= i_size_read(&ip->i_inode))
903 return 1;
904
Andrew Price43066292012-04-16 16:40:55 +0100905 error = gfs2_internal_read(ip, (char *)&buf, &pos,
Robert Peterson6c532672007-05-10 16:54:38 -0500906 sizeof(struct gfs2_rindex));
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100907
908 if (error != sizeof(struct gfs2_rindex))
909 return (error == 0) ? 1 : error;
Robert Peterson6c532672007-05-10 16:54:38 -0500910
Bob Peterson6bdd9be2008-01-28 17:20:26 -0600911 rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
Robert Peterson6c532672007-05-10 16:54:38 -0500912 error = -ENOMEM;
913 if (!rgd)
914 return error;
915
Robert Peterson6c532672007-05-10 16:54:38 -0500916 rgd->rd_sbd = sdp;
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100917 rgd->rd_addr = be64_to_cpu(buf.ri_addr);
918 rgd->rd_length = be32_to_cpu(buf.ri_length);
919 rgd->rd_data0 = be64_to_cpu(buf.ri_data0);
920 rgd->rd_data = be32_to_cpu(buf.ri_data);
921 rgd->rd_bitbytes = be32_to_cpu(buf.ri_bitbytes);
Bob Peterson8e2e0042012-07-19 08:12:40 -0400922 spin_lock_init(&rgd->rd_rsspin);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +0100923 mutex_init(&rgd->rd_mutex);
Bob Peterson7c9ca622011-08-31 09:53:19 +0100924
Robert Peterson6c532672007-05-10 16:54:38 -0500925 error = compute_bitstructs(rgd);
926 if (error)
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100927 goto fail;
Robert Peterson6c532672007-05-10 16:54:38 -0500928
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100929 error = gfs2_glock_get(sdp, rgd->rd_addr,
Robert Peterson6c532672007-05-10 16:54:38 -0500930 &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
931 if (error)
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100932 goto fail;
Robert Peterson6c532672007-05-10 16:54:38 -0500933
David Teigland4e2f8842012-11-14 13:47:37 -0500934 rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lksb.sb_lvbptr;
Bob Peterson0e27c182014-10-29 08:02:28 -0500935 rgd->rd_flags &= ~(GFS2_RDF_UPTODATE | GFS2_RDF_PREFERRED);
Bob Peterson7c9ca622011-08-31 09:53:19 +0100936 if (rgd->rd_data > sdp->sd_max_rg_data)
937 sdp->sd_max_rg_data = rgd->rd_data;
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100938 spin_lock(&sdp->sd_rindex_spin);
Bob Peterson6aad1c32012-03-05 09:20:59 -0500939 error = rgd_insert(rgd);
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100940 spin_unlock(&sdp->sd_rindex_spin);
Bob Peterson36e4ad02016-06-09 14:24:07 -0500941 if (!error) {
Andreas Gruenbacher6f6597ba2017-06-30 07:55:08 -0500942 glock_set_object(rgd->rd_gl, rgd);
Bob Peterson6aad1c32012-03-05 09:20:59 -0500943 return 0;
Bob Peterson36e4ad02016-06-09 14:24:07 -0500944 }
Bob Peterson6aad1c32012-03-05 09:20:59 -0500945
946 error = 0; /* someone else read in the rgrp; free it and ignore it */
Bob Petersonc1ac5392012-03-22 08:58:30 -0400947 gfs2_glock_put(rgd->rd_gl);
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100948
949fail:
950 kfree(rgd->rd_bits);
Bob Peterson36e4ad02016-06-09 14:24:07 -0500951 rgd->rd_bits = NULL;
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100952 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
Robert Peterson6c532672007-05-10 16:54:38 -0500953 return error;
954}
955
956/**
Bob Peterson0e27c182014-10-29 08:02:28 -0500957 * set_rgrp_preferences - Run all the rgrps, selecting some we prefer to use
958 * @sdp: the GFS2 superblock
959 *
960 * The purpose of this function is to select a subset of the resource groups
961 * and mark them as PREFERRED. We do it in such a way that each node prefers
962 * to use a unique set of rgrps to minimize glock contention.
963 */
964static void set_rgrp_preferences(struct gfs2_sbd *sdp)
965{
966 struct gfs2_rgrpd *rgd, *first;
967 int i;
968
969 /* Skip an initial number of rgrps, based on this node's journal ID.
970 That should start each node out on its own set. */
971 rgd = gfs2_rgrpd_get_first(sdp);
972 for (i = 0; i < sdp->sd_lockstruct.ls_jid; i++)
973 rgd = gfs2_rgrpd_get_next(rgd);
974 first = rgd;
975
976 do {
977 rgd->rd_flags |= GFS2_RDF_PREFERRED;
978 for (i = 0; i < sdp->sd_journals; i++) {
979 rgd = gfs2_rgrpd_get_next(rgd);
Abhi Das959b6712015-05-05 11:26:04 -0500980 if (!rgd || rgd == first)
Bob Peterson0e27c182014-10-29 08:02:28 -0500981 break;
982 }
Abhi Das959b6712015-05-05 11:26:04 -0500983 } while (rgd && rgd != first);
Bob Peterson0e27c182014-10-29 08:02:28 -0500984}
985
986/**
Robert Peterson6c532672007-05-10 16:54:38 -0500987 * gfs2_ri_update - Pull in a new resource index from the disk
988 * @ip: pointer to the rindex inode
989 *
David Teiglandb3b94fa2006-01-16 16:50:04 +0000990 * Returns: 0 on successful update, error code otherwise
991 */
992
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100993static int gfs2_ri_update(struct gfs2_inode *ip)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000994{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400995 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000996 int error;
997
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100998 do {
Andrew Price43066292012-04-16 16:40:55 +0100999 error = read_rindex_entry(ip);
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001000 } while (error == 0);
1001
1002 if (error < 0)
1003 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001004
Bob Peterson77872152020-11-24 10:44:36 -05001005 if (RB_EMPTY_ROOT(&sdp->sd_rindex_tree)) {
1006 fs_err(sdp, "no resource groups found in the file system.\n");
1007 return -ENOENT;
1008 }
Bob Peterson0e27c182014-10-29 08:02:28 -05001009 set_rgrp_preferences(sdp);
1010
Bob Petersoncf45b752008-01-31 10:31:39 -06001011 sdp->sd_rindex_uptodate = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001012 return 0;
Robert Peterson6c532672007-05-10 16:54:38 -05001013}
David Teiglandb3b94fa2006-01-16 16:50:04 +00001014
Robert Peterson6c532672007-05-10 16:54:38 -05001015/**
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001016 * gfs2_rindex_update - Update the rindex if required
David Teiglandb3b94fa2006-01-16 16:50:04 +00001017 * @sdp: The GFS2 superblock
David Teiglandb3b94fa2006-01-16 16:50:04 +00001018 *
1019 * We grab a lock on the rindex inode to make sure that it doesn't
1020 * change whilst we are performing an operation. We keep this lock
1021 * for quite long periods of time compared to other locks. This
1022 * doesn't matter, since it is shared and it is very, very rarely
1023 * accessed in the exclusive mode (i.e. only when expanding the filesystem).
1024 *
1025 * This makes sure that we're using the latest copy of the resource index
1026 * special file, which might have been updated if someone expanded the
1027 * filesystem (via gfs2_grow utility), which adds new resource groups.
1028 *
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001029 * Returns: 0 on succeess, error code otherwise
David Teiglandb3b94fa2006-01-16 16:50:04 +00001030 */
1031
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001032int gfs2_rindex_update(struct gfs2_sbd *sdp)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001033{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001034 struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001035 struct gfs2_glock *gl = ip->i_gl;
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001036 struct gfs2_holder ri_gh;
1037 int error = 0;
Steven Whitehousea365fbf2012-02-24 15:09:14 +00001038 int unlock_required = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001039
1040 /* Read new copy from disk if we don't have the latest */
Bob Petersoncf45b752008-01-31 10:31:39 -06001041 if (!sdp->sd_rindex_uptodate) {
Steven Whitehousea365fbf2012-02-24 15:09:14 +00001042 if (!gfs2_glock_is_locked_by_me(gl)) {
1043 error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, &ri_gh);
1044 if (error)
Bob Peterson6aad1c32012-03-05 09:20:59 -05001045 return error;
Steven Whitehousea365fbf2012-02-24 15:09:14 +00001046 unlock_required = 1;
1047 }
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001048 if (!sdp->sd_rindex_uptodate)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001049 error = gfs2_ri_update(ip);
Steven Whitehousea365fbf2012-02-24 15:09:14 +00001050 if (unlock_required)
1051 gfs2_glock_dq_uninit(&ri_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001052 }
1053
1054 return error;
1055}
1056
Bob Peterson42d52e32008-01-28 18:38:07 -06001057static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001058{
1059 const struct gfs2_rgrp *str = buf;
Bob Peterson42d52e32008-01-28 18:38:07 -06001060 u32 rg_flags;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001061
Bob Peterson42d52e32008-01-28 18:38:07 -06001062 rg_flags = be32_to_cpu(str->rg_flags);
Steven Whitehouse09010972009-05-20 10:48:47 +01001063 rg_flags &= ~GFS2_RDF_MASK;
Steven Whitehouse1ce97e52009-05-21 15:18:19 +01001064 rgd->rd_flags &= GFS2_RDF_MASK;
1065 rgd->rd_flags |= rg_flags;
Steven Whitehousecfc8b542008-11-04 10:25:13 +00001066 rgd->rd_free = be32_to_cpu(str->rg_free);
Steven Whitehouse73f74942008-11-04 10:32:57 +00001067 rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
Steven Whitehoused8b71f72008-11-04 10:19:03 +00001068 rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
Andrew Price166725d2017-12-12 11:40:05 -06001069 /* rd_data0, rd_data and rd_bitbytes already set from rindex */
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001070}
1071
Bob Peterson3f30f922018-07-26 12:59:13 -05001072static void gfs2_rgrp_ondisk2lvb(struct gfs2_rgrp_lvb *rgl, const void *buf)
1073{
1074 const struct gfs2_rgrp *str = buf;
1075
1076 rgl->rl_magic = cpu_to_be32(GFS2_MAGIC);
1077 rgl->rl_flags = str->rg_flags;
1078 rgl->rl_free = str->rg_free;
1079 rgl->rl_dinodes = str->rg_dinodes;
1080 rgl->rl_igeneration = str->rg_igeneration;
1081 rgl->__pad = 0UL;
1082}
1083
Bob Peterson42d52e32008-01-28 18:38:07 -06001084static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001085{
Andrew Price65adc272017-12-12 11:37:15 -06001086 struct gfs2_rgrpd *next = gfs2_rgrpd_get_next(rgd);
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001087 struct gfs2_rgrp *str = buf;
Andrew Price850d2d92017-12-12 11:42:30 -06001088 u32 crc;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001089
Steven Whitehouse09010972009-05-20 10:48:47 +01001090 str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
Steven Whitehousecfc8b542008-11-04 10:25:13 +00001091 str->rg_free = cpu_to_be32(rgd->rd_free);
Steven Whitehouse73f74942008-11-04 10:32:57 +00001092 str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
Andrew Price65adc272017-12-12 11:37:15 -06001093 if (next == NULL)
1094 str->rg_skip = 0;
1095 else if (next->rd_addr > rgd->rd_addr)
1096 str->rg_skip = cpu_to_be32(next->rd_addr - rgd->rd_addr);
Steven Whitehoused8b71f72008-11-04 10:19:03 +00001097 str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
Andrew Price166725d2017-12-12 11:40:05 -06001098 str->rg_data0 = cpu_to_be64(rgd->rd_data0);
1099 str->rg_data = cpu_to_be32(rgd->rd_data);
1100 str->rg_bitbytes = cpu_to_be32(rgd->rd_bitbytes);
Andrew Price850d2d92017-12-12 11:42:30 -06001101 str->rg_crc = 0;
1102 crc = gfs2_disk_hash(buf, sizeof(struct gfs2_rgrp));
1103 str->rg_crc = cpu_to_be32(crc);
Andrew Price166725d2017-12-12 11:40:05 -06001104
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001105 memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
Bob Peterson3f30f922018-07-26 12:59:13 -05001106 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, buf);
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001107}
1108
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001109static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
1110{
1111 struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
1112 struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;
Bob Petersonf29e62e2019-05-13 09:42:18 -05001113 struct gfs2_sbd *sdp = rgd->rd_sbd;
Bob Peterson72244b62018-08-15 12:09:49 -05001114 int valid = 1;
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001115
Bob Peterson72244b62018-08-15 12:09:49 -05001116 if (rgl->rl_flags != str->rg_flags) {
Bob Petersonf29e62e2019-05-13 09:42:18 -05001117 fs_warn(sdp, "GFS2: rgd: %llu lvb flag mismatch %u/%u",
1118 (unsigned long long)rgd->rd_addr,
Bob Peterson72244b62018-08-15 12:09:49 -05001119 be32_to_cpu(rgl->rl_flags), be32_to_cpu(str->rg_flags));
1120 valid = 0;
1121 }
1122 if (rgl->rl_free != str->rg_free) {
Bob Petersonf29e62e2019-05-13 09:42:18 -05001123 fs_warn(sdp, "GFS2: rgd: %llu lvb free mismatch %u/%u",
1124 (unsigned long long)rgd->rd_addr,
1125 be32_to_cpu(rgl->rl_free), be32_to_cpu(str->rg_free));
Bob Peterson72244b62018-08-15 12:09:49 -05001126 valid = 0;
1127 }
1128 if (rgl->rl_dinodes != str->rg_dinodes) {
Bob Petersonf29e62e2019-05-13 09:42:18 -05001129 fs_warn(sdp, "GFS2: rgd: %llu lvb dinode mismatch %u/%u",
1130 (unsigned long long)rgd->rd_addr,
1131 be32_to_cpu(rgl->rl_dinodes),
1132 be32_to_cpu(str->rg_dinodes));
Bob Peterson72244b62018-08-15 12:09:49 -05001133 valid = 0;
1134 }
1135 if (rgl->rl_igeneration != str->rg_igeneration) {
Bob Petersonf29e62e2019-05-13 09:42:18 -05001136 fs_warn(sdp, "GFS2: rgd: %llu lvb igen mismatch %llu/%llu",
1137 (unsigned long long)rgd->rd_addr,
1138 (unsigned long long)be64_to_cpu(rgl->rl_igeneration),
1139 (unsigned long long)be64_to_cpu(str->rg_igeneration));
Bob Peterson72244b62018-08-15 12:09:49 -05001140 valid = 0;
1141 }
1142 return valid;
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001143}
1144
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001145static u32 count_unlinked(struct gfs2_rgrpd *rgd)
1146{
1147 struct gfs2_bitmap *bi;
1148 const u32 length = rgd->rd_length;
1149 const u8 *buffer = NULL;
1150 u32 i, goal, count = 0;
1151
1152 for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
1153 goal = 0;
1154 buffer = bi->bi_bh->b_data + bi->bi_offset;
1155 WARN_ON(!buffer_uptodate(bi->bi_bh));
Andreas Gruenbacher281b4952018-09-26 23:32:46 +01001156 while (goal < bi->bi_blocks) {
1157 goal = gfs2_bitfit(buffer, bi->bi_bytes, goal,
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001158 GFS2_BLKST_UNLINKED);
1159 if (goal == BFITNOENT)
1160 break;
1161 count++;
1162 goal++;
1163 }
1164 }
1165
1166 return count;
1167}
1168
Andreas Gruenbacher560b8eb2020-10-06 15:26:22 +02001169static void rgrp_set_bitmap_flags(struct gfs2_rgrpd *rgd)
1170{
1171 struct gfs2_bitmap *bi;
1172 int x;
1173
1174 if (rgd->rd_free) {
1175 for (x = 0; x < rgd->rd_length; x++) {
1176 bi = rgd->rd_bits + x;
1177 clear_bit(GBF_FULL, &bi->bi_flags);
1178 }
1179 } else {
1180 for (x = 0; x < rgd->rd_length; x++) {
1181 bi = rgd->rd_bits + x;
1182 set_bit(GBF_FULL, &bi->bi_flags);
1183 }
1184 }
1185}
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001186
David Teiglandb3b94fa2006-01-16 16:50:04 +00001187/**
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001188 * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
1189 * @rgd: the struct gfs2_rgrpd describing the RG to read in
David Teiglandb3b94fa2006-01-16 16:50:04 +00001190 *
1191 * Read in all of a Resource Group's header and bitmap blocks.
Andreas Gruenbacher10283ea2018-11-05 22:57:24 +00001192 * Caller must eventually call gfs2_rgrp_brelse() to free the bitmaps.
David Teiglandb3b94fa2006-01-16 16:50:04 +00001193 *
1194 * Returns: errno
1195 */
1196
Rashika Kheriac2b0b302014-02-09 18:40:19 +05301197static int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001198{
1199 struct gfs2_sbd *sdp = rgd->rd_sbd;
1200 struct gfs2_glock *gl = rgd->rd_gl;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001201 unsigned int length = rgd->rd_length;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001202 struct gfs2_bitmap *bi;
1203 unsigned int x, y;
1204 int error;
1205
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001206 if (rgd->rd_bits[0].bi_bh != NULL)
1207 return 0;
1208
David Teiglandb3b94fa2006-01-16 16:50:04 +00001209 for (x = 0; x < length; x++) {
1210 bi = rgd->rd_bits + x;
Andreas Gruenbacherc8d57702015-11-11 15:00:35 -06001211 error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, 0, &bi->bi_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001212 if (error)
1213 goto fail;
1214 }
1215
1216 for (y = length; y--;) {
1217 bi = rgd->rd_bits + y;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -04001218 error = gfs2_meta_wait(sdp, bi->bi_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001219 if (error)
1220 goto fail;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001221 if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
David Teiglandb3b94fa2006-01-16 16:50:04 +00001222 GFS2_METATYPE_RG)) {
1223 error = -EIO;
1224 goto fail;
1225 }
1226 }
1227
Bob Petersoncf45b752008-01-31 10:31:39 -06001228 if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
Bob Peterson42d52e32008-01-28 18:38:07 -06001229 gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
Andreas Gruenbacher560b8eb2020-10-06 15:26:22 +02001230 rgrp_set_bitmap_flags(rgd);
Steven Whitehouse1ce97e52009-05-21 15:18:19 +01001231 rgd->rd_flags |= (GFS2_RDF_UPTODATE | GFS2_RDF_CHECK);
Bob Peterson7c9ca622011-08-31 09:53:19 +01001232 rgd->rd_free_clone = rgd->rd_free;
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01001233 BUG_ON(rgd->rd_reserved);
Bob Peterson5ea50502013-11-25 11:16:25 +00001234 /* max out the rgrp allocation failure point */
1235 rgd->rd_extfail_pt = rgd->rd_free;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001236 }
Al Viro951b4bd2013-06-02 19:53:40 -04001237 if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001238 rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
1239 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
1240 rgd->rd_bits[0].bi_bh->b_data);
1241 }
1242 else if (sdp->sd_args.ar_rgrplvb) {
1243 if (!gfs2_rgrp_lvb_valid(rgd)){
1244 gfs2_consist_rgrpd(rgd);
1245 error = -EIO;
1246 goto fail;
1247 }
1248 if (rgd->rd_rgl->rl_unlinked == 0)
1249 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1250 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001251 return 0;
1252
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001253fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001254 while (x--) {
1255 bi = rgd->rd_bits + x;
1256 brelse(bi->bi_bh);
1257 bi->bi_bh = NULL;
1258 gfs2_assert_warn(sdp, !bi->bi_clone);
1259 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001260
1261 return error;
1262}
1263
Rashika Kheriac2b0b302014-02-09 18:40:19 +05301264static int update_rgrp_lvb(struct gfs2_rgrpd *rgd)
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001265{
1266 u32 rl_flags;
1267
1268 if (rgd->rd_flags & GFS2_RDF_UPTODATE)
1269 return 0;
1270
Al Viro951b4bd2013-06-02 19:53:40 -04001271 if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001272 return gfs2_rgrp_bh_get(rgd);
1273
1274 rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
1275 rl_flags &= ~GFS2_RDF_MASK;
1276 rgd->rd_flags &= GFS2_RDF_MASK;
Bob Peterson4f36cb32018-08-16 10:32:13 -05001277 rgd->rd_flags |= (rl_flags | GFS2_RDF_CHECK);
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001278 if (rgd->rd_rgl->rl_unlinked == 0)
1279 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1280 rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
Andreas Gruenbacher560b8eb2020-10-06 15:26:22 +02001281 rgrp_set_bitmap_flags(rgd);
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001282 rgd->rd_free_clone = rgd->rd_free;
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01001283 BUG_ON(rgd->rd_reserved);
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02001284 /* max out the rgrp allocation failure point */
1285 rgd->rd_extfail_pt = rgd->rd_free;
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001286 rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
1287 rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
1288 return 0;
1289}
1290
1291int gfs2_rgrp_go_lock(struct gfs2_holder *gh)
1292{
1293 struct gfs2_rgrpd *rgd = gh->gh_gl->gl_object;
1294 struct gfs2_sbd *sdp = rgd->rd_sbd;
1295
1296 if (gh->gh_flags & GL_SKIP && sdp->sd_args.ar_rgrplvb)
1297 return 0;
Bob Peterson8b127d02014-01-16 08:52:16 -05001298 return gfs2_rgrp_bh_get(rgd);
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001299}
1300
David Teiglandb3b94fa2006-01-16 16:50:04 +00001301/**
Bob Peterson39b0f1e2015-06-05 08:38:57 -05001302 * gfs2_rgrp_brelse - Release RG bitmaps read in with gfs2_rgrp_bh_get()
1303 * @rgd: The resource group
David Teiglandb3b94fa2006-01-16 16:50:04 +00001304 *
1305 */
1306
Bob Peterson39b0f1e2015-06-05 08:38:57 -05001307void gfs2_rgrp_brelse(struct gfs2_rgrpd *rgd)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001308{
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001309 int x, length = rgd->rd_length;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001310
David Teiglandb3b94fa2006-01-16 16:50:04 +00001311 for (x = 0; x < length; x++) {
1312 struct gfs2_bitmap *bi = rgd->rd_bits + x;
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001313 if (bi->bi_bh) {
1314 brelse(bi->bi_bh);
1315 bi->bi_bh = NULL;
1316 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001317 }
Bob Peterson39b0f1e2015-06-05 08:38:57 -05001318}
1319
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001320int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
Bob Peterson7c9ca622011-08-31 09:53:19 +01001321 struct buffer_head *bh,
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001322 const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed)
Steven Whitehousef15ab562009-02-09 09:25:01 +00001323{
1324 struct super_block *sb = sdp->sd_vfs;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001325 u64 blk;
Steven Whitehouse64d576b2009-02-12 13:31:58 +00001326 sector_t start = 0;
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001327 sector_t nr_blks = 0;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001328 int rv;
1329 unsigned int x;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001330 u32 trimmed = 0;
1331 u8 diff;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001332
Andreas Gruenbacher281b4952018-09-26 23:32:46 +01001333 for (x = 0; x < bi->bi_bytes; x++) {
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001334 const u8 *clone = bi->bi_clone ? bi->bi_clone : bi->bi_bh->b_data;
1335 clone += bi->bi_offset;
1336 clone += x;
1337 if (bh) {
1338 const u8 *orig = bh->b_data + bi->bi_offset + x;
1339 diff = ~(*orig | (*orig >> 1)) & (*clone | (*clone >> 1));
1340 } else {
1341 diff = ~(*clone | (*clone >> 1));
1342 }
Steven Whitehousef15ab562009-02-09 09:25:01 +00001343 diff &= 0x55;
1344 if (diff == 0)
1345 continue;
1346 blk = offset + ((bi->bi_start + x) * GFS2_NBBY);
Steven Whitehousef15ab562009-02-09 09:25:01 +00001347 while(diff) {
1348 if (diff & 1) {
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001349 if (nr_blks == 0)
Steven Whitehousef15ab562009-02-09 09:25:01 +00001350 goto start_new_extent;
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001351 if ((start + nr_blks) != blk) {
1352 if (nr_blks >= minlen) {
1353 rv = sb_issue_discard(sb,
1354 start, nr_blks,
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001355 GFP_NOFS, 0);
1356 if (rv)
1357 goto fail;
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001358 trimmed += nr_blks;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001359 }
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001360 nr_blks = 0;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001361start_new_extent:
1362 start = blk;
1363 }
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001364 nr_blks++;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001365 }
1366 diff >>= 2;
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001367 blk++;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001368 }
1369 }
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001370 if (nr_blks >= minlen) {
1371 rv = sb_issue_discard(sb, start, nr_blks, GFP_NOFS, 0);
Steven Whitehousef15ab562009-02-09 09:25:01 +00001372 if (rv)
1373 goto fail;
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001374 trimmed += nr_blks;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001375 }
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001376 if (ptrimmed)
1377 *ptrimmed = trimmed;
1378 return 0;
1379
Steven Whitehousef15ab562009-02-09 09:25:01 +00001380fail:
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001381 if (sdp->sd_args.ar_discard)
Andreas Gruenbacheraf388162018-01-30 10:32:30 -07001382 fs_warn(sdp, "error %d on discard request, turning discards off for this filesystem\n", rv);
Steven Whitehousef15ab562009-02-09 09:25:01 +00001383 sdp->sd_args.ar_discard = 0;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001384 return -EIO;
1385}
1386
1387/**
1388 * gfs2_fitrim - Generate discard requests for unused bits of the filesystem
1389 * @filp: Any file on the filesystem
1390 * @argp: Pointer to the arguments (also used to pass result)
1391 *
1392 * Returns: 0 on success, otherwise error code
1393 */
1394
1395int gfs2_fitrim(struct file *filp, void __user *argp)
1396{
Al Viro496ad9a2013-01-23 17:07:38 -05001397 struct inode *inode = file_inode(filp);
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001398 struct gfs2_sbd *sdp = GFS2_SB(inode);
1399 struct request_queue *q = bdev_get_queue(sdp->sd_vfs->s_bdev);
1400 struct buffer_head *bh;
1401 struct gfs2_rgrpd *rgd;
1402 struct gfs2_rgrpd *rgd_end;
1403 struct gfs2_holder gh;
1404 struct fstrim_range r;
1405 int ret = 0;
1406 u64 amt;
1407 u64 trimmed = 0;
Lukas Czerner076f0fa2012-10-16 11:39:08 +02001408 u64 start, end, minlen;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001409 unsigned int x;
Lukas Czerner076f0fa2012-10-16 11:39:08 +02001410 unsigned bs_shift = sdp->sd_sb.sb_bsize_shift;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001411
1412 if (!capable(CAP_SYS_ADMIN))
1413 return -EPERM;
1414
Bob Petersonc5c68722020-10-28 13:42:18 -05001415 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
1416 return -EROFS;
1417
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001418 if (!blk_queue_discard(q))
1419 return -EOPNOTSUPP;
1420
Lukas Czerner3a238ad2012-10-16 11:39:07 +02001421 if (copy_from_user(&r, argp, sizeof(r)))
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001422 return -EFAULT;
1423
Bob Peterson5e2f7d62012-04-04 22:11:16 -04001424 ret = gfs2_rindex_update(sdp);
1425 if (ret)
1426 return ret;
1427
Lukas Czerner076f0fa2012-10-16 11:39:08 +02001428 start = r.start >> bs_shift;
1429 end = start + (r.len >> bs_shift);
1430 minlen = max_t(u64, r.minlen,
1431 q->limits.discard_granularity) >> bs_shift;
1432
Abhijith Das6a98c332013-06-19 17:03:29 -04001433 if (end <= start || minlen > sdp->sd_max_rg_data)
Lukas Czerner076f0fa2012-10-16 11:39:08 +02001434 return -EINVAL;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001435
Abhijith Das6a98c332013-06-19 17:03:29 -04001436 rgd = gfs2_blk2rgrpd(sdp, start, 0);
1437 rgd_end = gfs2_blk2rgrpd(sdp, end, 0);
1438
1439 if ((gfs2_rgrpd_get_first(sdp) == gfs2_rgrpd_get_next(rgd_end))
1440 && (start > rgd_end->rd_data0 + rgd_end->rd_data))
1441 return -EINVAL; /* start is beyond the end of the fs */
1442
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001443 while (1) {
1444
Bob Peterson4fc7ec32018-04-24 10:35:02 -07001445 ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
1446 LM_FLAG_NODE_SCOPE, &gh);
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001447 if (ret)
1448 goto out;
1449
1450 if (!(rgd->rd_flags & GFS2_RGF_TRIMMED)) {
1451 /* Trim each bitmap in the rgrp */
1452 for (x = 0; x < rgd->rd_length; x++) {
1453 struct gfs2_bitmap *bi = rgd->rd_bits + x;
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01001454 rgrp_lock_local(rgd);
Lukas Czerner076f0fa2012-10-16 11:39:08 +02001455 ret = gfs2_rgrp_send_discards(sdp,
1456 rgd->rd_data0, NULL, bi, minlen,
1457 &amt);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01001458 rgrp_unlock_local(rgd);
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001459 if (ret) {
1460 gfs2_glock_dq_uninit(&gh);
1461 goto out;
1462 }
1463 trimmed += amt;
1464 }
1465
1466 /* Mark rgrp as having been trimmed */
1467 ret = gfs2_trans_begin(sdp, RES_RG_HDR, 0);
1468 if (ret == 0) {
1469 bh = rgd->rd_bits[0].bi_bh;
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01001470 rgrp_lock_local(rgd);
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001471 rgd->rd_flags |= GFS2_RGF_TRIMMED;
Steven Whitehouse350a9b02012-12-14 12:36:02 +00001472 gfs2_trans_add_meta(rgd->rd_gl, bh);
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001473 gfs2_rgrp_out(rgd, bh->b_data);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01001474 rgrp_unlock_local(rgd);
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001475 gfs2_trans_end(sdp);
1476 }
1477 }
1478 gfs2_glock_dq_uninit(&gh);
1479
1480 if (rgd == rgd_end)
1481 break;
1482
1483 rgd = gfs2_rgrpd_get_next(rgd);
1484 }
1485
1486out:
Abhijith Das6a98c332013-06-19 17:03:29 -04001487 r.len = trimmed << bs_shift;
Lukas Czerner3a238ad2012-10-16 11:39:07 +02001488 if (copy_to_user(argp, &r, sizeof(r)))
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001489 return -EFAULT;
1490
1491 return ret;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001492}
1493
David Teiglandb3b94fa2006-01-16 16:50:04 +00001494/**
Bob Peterson8e2e0042012-07-19 08:12:40 -04001495 * rs_insert - insert a new multi-block reservation into the rgrp's rb_tree
Bob Peterson8e2e0042012-07-19 08:12:40 -04001496 * @ip: the inode structure
Bob Peterson8e2e0042012-07-19 08:12:40 -04001497 *
Bob Peterson8e2e0042012-07-19 08:12:40 -04001498 */
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001499static void rs_insert(struct gfs2_inode *ip)
Bob Peterson8e2e0042012-07-19 08:12:40 -04001500{
1501 struct rb_node **newn, *parent = NULL;
1502 int rc;
Bob Petersona097dc7e2015-07-16 08:28:04 -05001503 struct gfs2_blkreserv *rs = &ip->i_res;
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02001504 struct gfs2_rgrpd *rgd = rs->rs_rgd;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001505
1506 BUG_ON(gfs2_rs_active(rs));
Bob Peterson8e2e0042012-07-19 08:12:40 -04001507
1508 spin_lock(&rgd->rd_rsspin);
1509 newn = &rgd->rd_rstree.rb_node;
Bob Peterson8e2e0042012-07-19 08:12:40 -04001510 while (*newn) {
1511 struct gfs2_blkreserv *cur =
1512 rb_entry(*newn, struct gfs2_blkreserv, rs_node);
1513
1514 parent = *newn;
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02001515 rc = rs_cmp(rs->rs_start, rs->rs_requested, cur);
Bob Peterson8e2e0042012-07-19 08:12:40 -04001516 if (rc > 0)
1517 newn = &((*newn)->rb_right);
1518 else if (rc < 0)
1519 newn = &((*newn)->rb_left);
1520 else {
1521 spin_unlock(&rgd->rd_rsspin);
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001522 WARN_ON(1);
1523 return;
Bob Peterson8e2e0042012-07-19 08:12:40 -04001524 }
1525 }
1526
Bob Peterson8e2e0042012-07-19 08:12:40 -04001527 rb_link_node(&rs->rs_node, parent, newn);
1528 rb_insert_color(&rs->rs_node, &rgd->rd_rstree);
1529
Bob Peterson8e2e0042012-07-19 08:12:40 -04001530 /* Do our rgrp accounting for the reservation */
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02001531 rgd->rd_requested += rs->rs_requested; /* blocks requested */
Bob Peterson8e2e0042012-07-19 08:12:40 -04001532 spin_unlock(&rgd->rd_rsspin);
Steven Whitehouse9e733d32012-08-23 15:37:59 +01001533 trace_gfs2_rs(rs, TRACE_RS_INSERT);
Bob Peterson8e2e0042012-07-19 08:12:40 -04001534}
1535
1536/**
Lee Jonesc551f662021-03-30 17:44:29 +01001537 * rgd_free - return the number of free blocks we can allocate
Bob Petersonf6753df2018-05-30 14:05:15 -05001538 * @rgd: the resource group
Lee Jonesc551f662021-03-30 17:44:29 +01001539 * @rs: The reservation to free
Bob Petersonf6753df2018-05-30 14:05:15 -05001540 *
1541 * This function returns the number of free blocks for an rgrp.
1542 * That's the clone-free blocks (blocks that are free, not including those
1543 * still being used for unlinked files that haven't been deleted.)
1544 *
1545 * It also subtracts any blocks reserved by someone else, but does not
1546 * include free blocks that are still part of our current reservation,
1547 * because obviously we can (and will) allocate them.
1548 */
1549static inline u32 rgd_free(struct gfs2_rgrpd *rgd, struct gfs2_blkreserv *rs)
1550{
1551 u32 tot_reserved, tot_free;
1552
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02001553 if (WARN_ON_ONCE(rgd->rd_requested < rs->rs_requested))
Bob Petersonf6753df2018-05-30 14:05:15 -05001554 return 0;
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02001555 tot_reserved = rgd->rd_requested - rs->rs_requested;
Bob Petersonf6753df2018-05-30 14:05:15 -05001556
1557 if (rgd->rd_free_clone < tot_reserved)
1558 tot_reserved = 0;
1559
1560 tot_free = rgd->rd_free_clone - tot_reserved;
1561
1562 return tot_free;
1563}
1564
1565/**
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001566 * rg_mblk_search - find a group of multiple free blocks to form a reservation
Bob Peterson8e2e0042012-07-19 08:12:40 -04001567 * @rgd: the resource group descriptor
Bob Peterson8e2e0042012-07-19 08:12:40 -04001568 * @ip: pointer to the inode for which we're reserving blocks
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01001569 * @ap: the allocation parameters
Bob Peterson8e2e0042012-07-19 08:12:40 -04001570 *
Bob Peterson8e2e0042012-07-19 08:12:40 -04001571 */
1572
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001573static void rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01001574 const struct gfs2_alloc_parms *ap)
Bob Peterson8e2e0042012-07-19 08:12:40 -04001575{
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001576 struct gfs2_rbm rbm = { .rgd = rgd, };
1577 u64 goal;
Bob Petersona097dc7e2015-07-16 08:28:04 -05001578 struct gfs2_blkreserv *rs = &ip->i_res;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001579 u32 extlen;
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01001580 u32 free_blocks, blocks_available;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001581 int ret;
Bob Petersonaf21ca82013-05-14 13:04:29 -04001582 struct inode *inode = &ip->i_inode;
Bob Peterson8e2e0042012-07-19 08:12:40 -04001583
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01001584 spin_lock(&rgd->rd_rsspin);
1585 free_blocks = rgd_free(rgd, rs);
1586 if (rgd->rd_free_clone < rgd->rd_requested)
1587 free_blocks = 0;
1588 blocks_available = rgd->rd_free_clone - rgd->rd_reserved;
1589 if (rgd == rs->rs_rgd)
1590 blocks_available += rs->rs_reserved;
1591 spin_unlock(&rgd->rd_rsspin);
1592
Bob Petersonaf21ca82013-05-14 13:04:29 -04001593 if (S_ISDIR(inode->i_mode))
1594 extlen = 1;
1595 else {
Andreas Gruenbacher21f09c42018-08-30 16:01:50 +01001596 extlen = max_t(u32, atomic_read(&ip->i_sizehint), ap->target);
Andreas Gruenbacherad899452018-09-25 12:59:31 +01001597 extlen = clamp(extlen, (u32)RGRP_RSRV_MINBLKS, free_blocks);
Bob Petersonaf21ca82013-05-14 13:04:29 -04001598 }
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01001599 if (free_blocks < extlen || blocks_available < extlen)
Steven Whitehousec743ffd2012-08-25 18:21:47 +01001600 return;
1601
Bob Peterson8e2e0042012-07-19 08:12:40 -04001602 /* Find bitmap block that contains bits for goal block */
1603 if (rgrp_contains_block(rgd, ip->i_goal))
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001604 goal = ip->i_goal;
Bob Peterson8e2e0042012-07-19 08:12:40 -04001605 else
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001606 goal = rgd->rd_last_alloc + rgd->rd_data0;
Steven Whitehousec743ffd2012-08-25 18:21:47 +01001607
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001608 if (WARN_ON(gfs2_rbm_from_block(&rbm, goal)))
1609 return;
Bob Peterson8e2e0042012-07-19 08:12:40 -04001610
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001611 ret = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &extlen, &ip->i_res, true);
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001612 if (ret == 0) {
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02001613 rs->rs_start = gfs2_rbm_to_block(&rbm);
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02001614 rs->rs_requested = extlen;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001615 rs_insert(ip);
Bob Peterson13d2eb02012-12-20 13:23:04 -05001616 } else {
1617 if (goal == rgd->rd_last_alloc + rgd->rd_data0)
1618 rgd->rd_last_alloc = 0;
Bob Peterson8e2e0042012-07-19 08:12:40 -04001619 }
Bob Petersonb3e47ca2011-11-21 11:47:08 -05001620}
1621
David Teiglandb3b94fa2006-01-16 16:50:04 +00001622/**
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001623 * gfs2_next_unreserved_block - Return next block that is not reserved
1624 * @rgd: The resource group
1625 * @block: The starting block
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001626 * @length: The required length
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001627 * @ignore_rs: Reservation to ignore
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001628 *
1629 * If the block does not appear in any reservation, then return the
1630 * block number unchanged. If it does appear in the reservation, then
1631 * keep looking through the tree of reservations in order to find the
1632 * first block number which is not reserved.
1633 */
1634
1635static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block,
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001636 u32 length,
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001637 struct gfs2_blkreserv *ignore_rs)
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001638{
1639 struct gfs2_blkreserv *rs;
1640 struct rb_node *n;
1641 int rc;
1642
1643 spin_lock(&rgd->rd_rsspin);
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001644 n = rgd->rd_rstree.rb_node;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001645 while (n) {
1646 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001647 rc = rs_cmp(block, length, rs);
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001648 if (rc < 0)
1649 n = n->rb_left;
1650 else if (rc > 0)
1651 n = n->rb_right;
1652 else
1653 break;
1654 }
1655
1656 if (n) {
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001657 while (rs_cmp(block, length, rs) == 0 && rs != ignore_rs) {
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02001658 block = rs->rs_start + rs->rs_requested;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001659 n = n->rb_right;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001660 if (n == NULL)
1661 break;
1662 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1663 }
1664 }
1665
1666 spin_unlock(&rgd->rd_rsspin);
1667 return block;
1668}
1669
1670/**
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001671 * gfs2_reservation_check_and_update - Check for reservations during block alloc
1672 * @rbm: The current position in the resource group
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001673 * @rs: Our own reservation
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001674 * @minext: The minimum extent length
Bob Peterson5ce13432013-11-06 10:55:52 -05001675 * @maxext: A pointer to the maximum extent structure
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001676 *
1677 * This checks the current position in the rgrp to see whether there is
1678 * a reservation covering this block. If not then this function is a
1679 * no-op. If there is, then the position is moved to the end of the
1680 * contiguous reservation(s) so that we are pointing at the first
1681 * non-reserved block.
1682 *
1683 * Returns: 0 if no reservation, 1 if @rbm has changed, otherwise an error
1684 */
1685
1686static int gfs2_reservation_check_and_update(struct gfs2_rbm *rbm,
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001687 struct gfs2_blkreserv *rs,
Bob Peterson5ce13432013-11-06 10:55:52 -05001688 u32 minext,
1689 struct gfs2_extent *maxext)
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001690{
1691 u64 block = gfs2_rbm_to_block(rbm);
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001692 u32 extlen = 1;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001693 u64 nblock;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001694
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001695 /*
1696 * If we have a minimum extent length, then skip over any extent
1697 * which is less than the min extent length in size.
1698 */
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02001699 if (minext > 1) {
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001700 extlen = gfs2_free_extlen(rbm, minext);
Bob Peterson5ce13432013-11-06 10:55:52 -05001701 if (extlen <= maxext->len)
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001702 goto fail;
1703 }
1704
1705 /*
1706 * Check the extent which has been found against the reservations
1707 * and skip if parts of it are already reserved
1708 */
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001709 nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, rs);
Bob Peterson5ce13432013-11-06 10:55:52 -05001710 if (nblock == block) {
1711 if (!minext || extlen >= minext)
1712 return 0;
1713
1714 if (extlen > maxext->len) {
1715 maxext->len = extlen;
1716 maxext->rbm = *rbm;
1717 }
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +02001718 } else {
1719 u64 len = nblock - block;
1720 if (len >= (u64)1 << 32)
1721 return -E2BIG;
1722 extlen = len;
Bob Peterson5ce13432013-11-06 10:55:52 -05001723 }
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +02001724fail:
1725 if (gfs2_rbm_add(rbm, extlen))
1726 return -E2BIG;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001727 return 1;
1728}
1729
1730/**
1731 * gfs2_rbm_find - Look for blocks of a particular state
1732 * @rbm: Value/result starting position and final position
1733 * @state: The state which we want to find
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02001734 * @minext: Pointer to the requested extent length
Bob Peterson5ce13432013-11-06 10:55:52 -05001735 * This is updated to be the actual reservation size.
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001736 * @rs: Our own reservation (NULL to skip checking for reservations)
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001737 * @nowrap: Stop looking at the end of the rgrp, rather than wrapping
1738 * around until we've reached the starting point.
1739 *
1740 * Side effects:
1741 * - If looking for free blocks, we set GBF_FULL on each bitmap which
1742 * has no free blocks in it.
Bob Peterson5ea50502013-11-25 11:16:25 +00001743 * - If looking for free blocks, we set rd_extfail_pt on each rgrp which
1744 * has come up short on a free block search.
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001745 *
1746 * Returns: 0 on success, -ENOSPC if there is no block of the requested state
1747 */
1748
Bob Peterson5ce13432013-11-06 10:55:52 -05001749static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 *minext,
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001750 struct gfs2_blkreserv *rs, bool nowrap)
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001751{
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001752 bool scan_from_start = rbm->bii == 0 && rbm->offset == 0;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001753 struct buffer_head *bh;
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001754 int last_bii;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001755 u32 offset;
1756 u8 *buffer;
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001757 bool wrapped = false;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001758 int ret;
Bob Petersone579ed42013-09-17 13:12:15 -04001759 struct gfs2_bitmap *bi;
Bob Peterson5ce13432013-11-06 10:55:52 -05001760 struct gfs2_extent maxext = { .rbm.rgd = rbm->rgd, };
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001761
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001762 /*
1763 * Determine the last bitmap to search. If we're not starting at the
1764 * beginning of a bitmap, we need to search that bitmap twice to scan
1765 * the entire resource group.
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001766 */
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001767 last_bii = rbm->bii - (rbm->offset == 0);
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001768
1769 while(1) {
Bob Petersone579ed42013-09-17 13:12:15 -04001770 bi = rbm_bi(rbm);
Andreas Gruenbacher2fdc2fa2020-10-06 14:29:04 +02001771 if (test_bit(GBF_FULL, &bi->bi_flags) &&
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001772 (state == GFS2_BLKST_FREE))
1773 goto next_bitmap;
1774
Bob Petersone579ed42013-09-17 13:12:15 -04001775 bh = bi->bi_bh;
1776 buffer = bh->b_data + bi->bi_offset;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001777 WARN_ON(!buffer_uptodate(bh));
Bob Petersone579ed42013-09-17 13:12:15 -04001778 if (state != GFS2_BLKST_UNLINKED && bi->bi_clone)
1779 buffer = bi->bi_clone + bi->bi_offset;
Andreas Gruenbacher281b4952018-09-26 23:32:46 +01001780 offset = gfs2_bitfit(buffer, bi->bi_bytes, rbm->offset, state);
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001781 if (offset == BFITNOENT) {
1782 if (state == GFS2_BLKST_FREE && rbm->offset == 0)
1783 set_bit(GBF_FULL, &bi->bi_flags);
1784 goto next_bitmap;
1785 }
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001786 rbm->offset = offset;
Andreas Gruenbacherbea906e2021-04-02 19:51:24 +02001787 if (!rs || !minext)
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001788 return 0;
1789
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001790 ret = gfs2_reservation_check_and_update(rbm, rs, *minext,
Bob Peterson5ce13432013-11-06 10:55:52 -05001791 &maxext);
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001792 if (ret == 0)
1793 return 0;
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001794 if (ret > 0)
Bob Peterson8d8b7522012-08-07 13:28:17 -04001795 goto next_iter;
Steven Whitehouse5d50d532012-08-07 13:47:12 +01001796 if (ret == -E2BIG) {
Bob Petersone579ed42013-09-17 13:12:15 -04001797 rbm->bii = 0;
Steven Whitehouse5d50d532012-08-07 13:47:12 +01001798 rbm->offset = 0;
Steven Whitehouse5d50d532012-08-07 13:47:12 +01001799 goto res_covered_end_of_rgrp;
1800 }
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001801 return ret;
1802
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001803next_bitmap: /* Find next bitmap in the rgrp */
1804 rbm->offset = 0;
Bob Petersone579ed42013-09-17 13:12:15 -04001805 rbm->bii++;
1806 if (rbm->bii == rbm->rgd->rd_length)
1807 rbm->bii = 0;
Steven Whitehouse5d50d532012-08-07 13:47:12 +01001808res_covered_end_of_rgrp:
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001809 if (rbm->bii == 0) {
1810 if (wrapped)
1811 break;
1812 wrapped = true;
1813 if (nowrap)
1814 break;
1815 }
Bob Peterson8d8b7522012-08-07 13:28:17 -04001816next_iter:
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001817 /* Have we scanned the entire resource group? */
1818 if (wrapped && rbm->bii > last_bii)
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001819 break;
1820 }
1821
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02001822 if (state != GFS2_BLKST_FREE)
Bob Peterson5ce13432013-11-06 10:55:52 -05001823 return -ENOSPC;
1824
Bob Peterson5ea50502013-11-25 11:16:25 +00001825 /* If the extent was too small, and it's smaller than the smallest
1826 to have failed before, remember for future reference that it's
1827 useless to search this rgrp again for this amount or more. */
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001828 if (wrapped && (scan_from_start || rbm->bii > last_bii) &&
1829 *minext < rbm->rgd->rd_extfail_pt)
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02001830 rbm->rgd->rd_extfail_pt = *minext - 1;
Bob Peterson5ea50502013-11-25 11:16:25 +00001831
Bob Peterson5ce13432013-11-06 10:55:52 -05001832 /* If the maximum extent we found is big enough to fulfill the
1833 minimum requirements, use it anyway. */
1834 if (maxext.len) {
1835 *rbm = maxext.rbm;
1836 *minext = maxext.len;
1837 return 0;
1838 }
1839
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001840 return -ENOSPC;
1841}
1842
1843/**
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001844 * try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
1845 * @rgd: The rgrp
Bob Peterson886b1412012-04-11 13:03:52 -04001846 * @last_unlinked: block address of the last dinode we unlinked
1847 * @skip: block address we should explicitly not unlink
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001848 *
Bob Peterson1a0eae82010-04-14 11:58:16 -04001849 * Returns: 0 if no error
1850 * The inode, if one has been found, in inode.
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001851 */
1852
Steven Whitehouse044b9412010-11-03 20:01:07 +00001853static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001854{
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001855 u64 block;
Bob Peterson5f3eae72007-08-08 16:52:09 -05001856 struct gfs2_sbd *sdp = rgd->rd_sbd;
Steven Whitehouse044b9412010-11-03 20:01:07 +00001857 struct gfs2_glock *gl;
1858 struct gfs2_inode *ip;
1859 int error;
1860 int found = 0;
Bob Petersone579ed42013-09-17 13:12:15 -04001861 struct gfs2_rbm rbm = { .rgd = rgd, .bii = 0, .offset = 0 };
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001862
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001863 while (1) {
Bob Peterson5ce13432013-11-06 10:55:52 -05001864 error = gfs2_rbm_find(&rbm, GFS2_BLKST_UNLINKED, NULL, NULL,
Bob Peterson8381e602016-05-02 09:42:49 -05001865 true);
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001866 if (error == -ENOSPC)
1867 break;
1868 if (WARN_ON_ONCE(error))
Bob Peterson24c73872007-07-12 16:58:50 -05001869 break;
Bob Petersonb3e47ca2011-11-21 11:47:08 -05001870
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001871 block = gfs2_rbm_to_block(&rbm);
1872 if (gfs2_rbm_from_block(&rbm, block + 1))
1873 break;
1874 if (*last_unlinked != NO_BLOCK && block <= *last_unlinked)
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001875 continue;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001876 if (block == skip)
Steven Whitehouse1e19a192009-07-10 21:13:38 +01001877 continue;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001878 *last_unlinked = block;
Steven Whitehouse044b9412010-11-03 20:01:07 +00001879
Bob Peterson5ea31bc2015-12-04 12:57:00 -06001880 error = gfs2_glock_get(sdp, block, &gfs2_iopen_glops, CREATE, &gl);
Steven Whitehouse044b9412010-11-03 20:01:07 +00001881 if (error)
1882 continue;
1883
1884 /* If the inode is already in cache, we can ignore it here
1885 * because the existing inode disposal code will deal with
1886 * it when all refs have gone away. Accessing gl_object like
1887 * this is not safe in general. Here it is ok because we do
1888 * not dereference the pointer, and we only need an approx
1889 * answer to whether it is NULL or not.
1890 */
1891 ip = gl->gl_object;
1892
Andreas Gruenbachera0e3cc62020-01-16 20:12:26 +01001893 if (ip || !gfs2_queue_delete_work(gl, 0))
Steven Whitehouse044b9412010-11-03 20:01:07 +00001894 gfs2_glock_put(gl);
1895 else
1896 found++;
1897
1898 /* Limit reclaim to sensible number of tasks */
Bob Peterson44ad37d2011-03-17 16:19:58 -04001899 if (found > NR_CPUS)
Steven Whitehouse044b9412010-11-03 20:01:07 +00001900 return;
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001901 }
1902
1903 rgd->rd_flags &= ~GFS2_RDF_CHECK;
Steven Whitehouse044b9412010-11-03 20:01:07 +00001904 return;
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001905}
1906
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001907/**
1908 * gfs2_rgrp_congested - Use stats to figure out whether an rgrp is congested
1909 * @rgd: The rgrp in question
1910 * @loops: An indication of how picky we can be (0=very, 1=less so)
1911 *
1912 * This function uses the recently added glock statistics in order to
1913 * figure out whether a parciular resource group is suffering from
1914 * contention from multiple nodes. This is done purely on the basis
1915 * of timings, since this is the only data we have to work with and
1916 * our aim here is to reject a resource group which is highly contended
1917 * but (very important) not to do this too often in order to ensure that
1918 * we do not land up introducing fragmentation by changing resource
1919 * groups when not actually required.
1920 *
1921 * The calculation is fairly simple, we want to know whether the SRTTB
1922 * (i.e. smoothed round trip time for blocking operations) to acquire
1923 * the lock for this rgrp's glock is significantly greater than the
1924 * time taken for resource groups on average. We introduce a margin in
1925 * the form of the variable @var which is computed as the sum of the two
1926 * respective variences, and multiplied by a factor depending on @loops
1927 * and whether we have a lot of data to base the decision on. This is
1928 * then tested against the square difference of the means in order to
1929 * decide whether the result is statistically significant or not.
1930 *
1931 * Returns: A boolean verdict on the congestion status
1932 */
1933
1934static bool gfs2_rgrp_congested(const struct gfs2_rgrpd *rgd, int loops)
1935{
1936 const struct gfs2_glock *gl = rgd->rd_gl;
Bob Peterson15562c42015-03-16 11:52:05 -05001937 const struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001938 struct gfs2_lkstats *st;
Ben Hutchings4d207132015-08-27 12:51:45 -05001939 u64 r_dcount, l_dcount;
1940 u64 l_srttb, a_srttb = 0;
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001941 s64 srttb_diff;
Ben Hutchings4d207132015-08-27 12:51:45 -05001942 u64 sqr_diff;
1943 u64 var;
Bob Peterson0166b192015-04-22 11:24:12 -05001944 int cpu, nonzero = 0;
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001945
1946 preempt_disable();
Bob Petersonf4a3ae92014-11-19 12:27:11 -06001947 for_each_present_cpu(cpu) {
1948 st = &per_cpu_ptr(sdp->sd_lkstats, cpu)->lkstats[LM_TYPE_RGRP];
Bob Peterson0166b192015-04-22 11:24:12 -05001949 if (st->stats[GFS2_LKS_SRTTB]) {
1950 a_srttb += st->stats[GFS2_LKS_SRTTB];
1951 nonzero++;
1952 }
Bob Petersonf4a3ae92014-11-19 12:27:11 -06001953 }
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001954 st = &this_cpu_ptr(sdp->sd_lkstats)->lkstats[LM_TYPE_RGRP];
Bob Peterson0166b192015-04-22 11:24:12 -05001955 if (nonzero)
1956 do_div(a_srttb, nonzero);
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001957 r_dcount = st->stats[GFS2_LKS_DCOUNT];
1958 var = st->stats[GFS2_LKS_SRTTVARB] +
1959 gl->gl_stats.stats[GFS2_LKS_SRTTVARB];
1960 preempt_enable();
1961
1962 l_srttb = gl->gl_stats.stats[GFS2_LKS_SRTTB];
1963 l_dcount = gl->gl_stats.stats[GFS2_LKS_DCOUNT];
1964
Bob Petersonf4a3ae92014-11-19 12:27:11 -06001965 if ((l_dcount < 1) || (r_dcount < 1) || (a_srttb == 0))
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001966 return false;
1967
Bob Petersonf4a3ae92014-11-19 12:27:11 -06001968 srttb_diff = a_srttb - l_srttb;
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001969 sqr_diff = srttb_diff * srttb_diff;
1970
1971 var *= 2;
1972 if (l_dcount < 8 || r_dcount < 8)
1973 var *= 2;
1974 if (loops == 1)
1975 var *= 2;
1976
1977 return ((srttb_diff < 0) && (sqr_diff > var));
1978}
1979
1980/**
1981 * gfs2_rgrp_used_recently
1982 * @rs: The block reservation with the rgrp to test
1983 * @msecs: The time limit in milliseconds
1984 *
1985 * Returns: True if the rgrp glock has been used within the time limit
1986 */
1987static bool gfs2_rgrp_used_recently(const struct gfs2_blkreserv *rs,
1988 u64 msecs)
1989{
1990 u64 tdiff;
1991
1992 tdiff = ktime_to_ns(ktime_sub(ktime_get_real(),
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02001993 rs->rs_rgd->rd_gl->gl_dstamp));
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001994
1995 return tdiff > (msecs * 1000 * 1000);
1996}
1997
Steven Whitehouse9dbe9612012-10-31 10:37:10 +00001998static u32 gfs2_orlov_skip(const struct gfs2_inode *ip)
1999{
2000 const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
2001 u32 skip;
2002
2003 get_random_bytes(&skip, sizeof(skip));
2004 return skip % sdp->sd_rgrps;
2005}
2006
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002007static bool gfs2_select_rgrp(struct gfs2_rgrpd **pos, const struct gfs2_rgrpd *begin)
2008{
2009 struct gfs2_rgrpd *rgd = *pos;
Steven Whitehouseaa8920c2012-11-13 14:50:35 +00002010 struct gfs2_sbd *sdp = rgd->rd_sbd;
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002011
2012 rgd = gfs2_rgrpd_get_next(rgd);
2013 if (rgd == NULL)
Steven Whitehouseaa8920c2012-11-13 14:50:35 +00002014 rgd = gfs2_rgrpd_get_first(sdp);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002015 *pos = rgd;
2016 if (rgd != begin) /* If we didn't wrap */
2017 return true;
2018 return false;
2019}
2020
Steven Whitehousec8cdf472007-06-08 10:05:33 +01002021/**
Bob Peterson0e27c182014-10-29 08:02:28 -05002022 * fast_to_acquire - determine if a resource group will be fast to acquire
Lee Jonesc551f662021-03-30 17:44:29 +01002023 * @rgd: The rgrp
Bob Peterson0e27c182014-10-29 08:02:28 -05002024 *
2025 * If this is one of our preferred rgrps, it should be quicker to acquire,
2026 * because we tried to set ourselves up as dlm lock master.
2027 */
2028static inline int fast_to_acquire(struct gfs2_rgrpd *rgd)
2029{
2030 struct gfs2_glock *gl = rgd->rd_gl;
2031
2032 if (gl->gl_state != LM_ST_UNLOCKED && list_empty(&gl->gl_holders) &&
2033 !test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags) &&
2034 !test_bit(GLF_DEMOTE, &gl->gl_flags))
2035 return 1;
2036 if (rgd->rd_flags & GFS2_RDF_PREFERRED)
2037 return 1;
2038 return 0;
2039}
2040
2041/**
Bob Peterson666d1d82012-06-13 23:03:56 -04002042 * gfs2_inplace_reserve - Reserve space in the filesystem
David Teiglandb3b94fa2006-01-16 16:50:04 +00002043 * @ip: the inode to reserve space for
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01002044 * @ap: the allocation parameters
David Teiglandb3b94fa2006-01-16 16:50:04 +00002045 *
Abhi Das25435e52015-03-18 12:04:37 -05002046 * We try our best to find an rgrp that has at least ap->target blocks
2047 * available. After a couple of passes (loops == 2), the prospects of finding
2048 * such an rgrp diminish. At this stage, we return the first rgrp that has
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002049 * at least ap->min_target blocks available.
Abhi Das25435e52015-03-18 12:04:37 -05002050 *
2051 * Returns: 0 on success,
2052 * -ENOMEM if a suitable rgrp can't be found
2053 * errno otherwise
David Teiglandb3b94fa2006-01-16 16:50:04 +00002054 */
2055
Abhi Das25435e52015-03-18 12:04:37 -05002056int gfs2_inplace_reserve(struct gfs2_inode *ip, struct gfs2_alloc_parms *ap)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002057{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002058 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Bob Peterson8e2e0042012-07-19 08:12:40 -04002059 struct gfs2_rgrpd *begin = NULL;
Bob Petersona097dc7e2015-07-16 08:28:04 -05002060 struct gfs2_blkreserv *rs = &ip->i_res;
Bob Peterson4fc7ec32018-04-24 10:35:02 -07002061 int error = 0, flags = LM_FLAG_NODE_SCOPE;
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002062 bool rg_locked;
Bob Peterson666d1d82012-06-13 23:03:56 -04002063 u64 last_unlinked = NO_BLOCK;
Andreas Gruenbacher42720062020-03-20 13:31:41 +01002064 u32 target = ap->target;
Bob Peterson7c9ca622011-08-31 09:53:19 +01002065 int loops = 0;
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002066 u32 free_blocks, blocks_available, skip = 0;
2067
2068 BUG_ON(rs->rs_reserved);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002069
Benjamin Marzinski90306c42012-05-29 23:01:09 -05002070 if (sdp->sd_args.ar_rgrplvb)
2071 flags |= GL_SKIP;
Andreas Gruenbacher42720062020-03-20 13:31:41 +01002072 if (gfs2_assert_warn(sdp, target))
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002073 return -EINVAL;
Bob Peterson8e2e0042012-07-19 08:12:40 -04002074 if (gfs2_rs_active(rs)) {
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002075 begin = rs->rs_rgd;
2076 } else if (rs->rs_rgd &&
2077 rgrp_contains_block(rs->rs_rgd, ip->i_goal)) {
2078 begin = rs->rs_rgd;
Bob Peterson8e2e0042012-07-19 08:12:40 -04002079 } else {
Abhi Das00a158b2014-09-18 21:40:28 -05002080 check_and_update_goal(ip);
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002081 rs->rs_rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
Bob Peterson8e2e0042012-07-19 08:12:40 -04002082 }
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01002083 if (S_ISDIR(ip->i_inode.i_mode) && (ap->aflags & GFS2_AF_ORLOV))
Steven Whitehouse9dbe9612012-10-31 10:37:10 +00002084 skip = gfs2_orlov_skip(ip);
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002085 if (rs->rs_rgd == NULL)
Bob Peterson7c9ca622011-08-31 09:53:19 +01002086 return -EBADSLT;
2087
2088 while (loops < 3) {
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002089 struct gfs2_rgrpd *rgd;
2090
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002091 rg_locked = gfs2_glock_is_locked_by_me(rs->rs_rgd->rd_gl);
2092 if (rg_locked) {
2093 rgrp_lock_local(rs->rs_rgd);
2094 } else {
Steven Whitehouse9dbe9612012-10-31 10:37:10 +00002095 if (skip && skip--)
2096 goto next_rgrp;
Bob Peterson0e27c182014-10-29 08:02:28 -05002097 if (!gfs2_rs_active(rs)) {
2098 if (loops == 0 &&
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002099 !fast_to_acquire(rs->rs_rgd))
Bob Peterson0e27c182014-10-29 08:02:28 -05002100 goto next_rgrp;
2101 if ((loops < 2) &&
2102 gfs2_rgrp_used_recently(rs, 1000) &&
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002103 gfs2_rgrp_congested(rs->rs_rgd, loops))
Bob Peterson0e27c182014-10-29 08:02:28 -05002104 goto next_rgrp;
2105 }
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002106 error = gfs2_glock_nq_init(rs->rs_rgd->rd_gl,
Bob Peterson8e2e0042012-07-19 08:12:40 -04002107 LM_ST_EXCLUSIVE, flags,
Andreas Gruenbacher21f09c42018-08-30 16:01:50 +01002108 &ip->i_rgd_gh);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002109 if (unlikely(error))
2110 return error;
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002111 rgrp_lock_local(rs->rs_rgd);
Steven Whitehousebcd97c02012-10-31 09:58:42 +00002112 if (!gfs2_rs_active(rs) && (loops < 2) &&
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002113 gfs2_rgrp_congested(rs->rs_rgd, loops))
Steven Whitehousebcd97c02012-10-31 09:58:42 +00002114 goto skip_rgrp;
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002115 if (sdp->sd_args.ar_rgrplvb) {
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002116 error = update_rgrp_lvb(rs->rs_rgd);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002117 if (unlikely(error)) {
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002118 rgrp_unlock_local(rs->rs_rgd);
Andreas Gruenbacher21f09c42018-08-30 16:01:50 +01002119 gfs2_glock_dq_uninit(&ip->i_rgd_gh);
Benjamin Marzinski90306c42012-05-29 23:01:09 -05002120 return error;
2121 }
2122 }
Abhijith Das292c8c12007-11-29 14:13:54 -06002123 }
Bob Peterson666d1d82012-06-13 23:03:56 -04002124
Andreas Gruenbacher243fea42018-10-02 10:22:41 +01002125 /* Skip unusable resource groups */
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002126 if ((rs->rs_rgd->rd_flags & (GFS2_RGF_NOALLOC |
Bob Peterson5ea50502013-11-25 11:16:25 +00002127 GFS2_RDF_ERROR)) ||
Andreas Gruenbacher42720062020-03-20 13:31:41 +01002128 (loops == 0 && target > rs->rs_rgd->rd_extfail_pt))
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002129 goto skip_rgrp;
2130
2131 if (sdp->sd_args.ar_rgrplvb)
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002132 gfs2_rgrp_bh_get(rs->rs_rgd);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002133
2134 /* Get a reservation if we don't already have one */
2135 if (!gfs2_rs_active(rs))
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002136 rg_mblk_search(rs->rs_rgd, ip, ap);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002137
2138 /* Skip rgrps when we can't get a reservation on first pass */
2139 if (!gfs2_rs_active(rs) && (loops < 1))
2140 goto check_rgrp;
2141
2142 /* If rgrp has enough free space, use it */
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002143 rgd = rs->rs_rgd;
2144 spin_lock(&rgd->rd_rsspin);
2145 free_blocks = rgd_free(rgd, rs);
2146 blocks_available = rgd->rd_free_clone - rgd->rd_reserved;
2147 if (free_blocks < target || blocks_available < target) {
2148 spin_unlock(&rgd->rd_rsspin);
2149 goto check_rgrp;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002150 }
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002151 rs->rs_reserved = ap->target;
2152 if (rs->rs_reserved > blocks_available)
2153 rs->rs_reserved = blocks_available;
2154 rgd->rd_reserved += rs->rs_reserved;
2155 spin_unlock(&rgd->rd_rsspin);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002156 rgrp_unlock_local(rs->rs_rgd);
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002157 return 0;
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002158check_rgrp:
2159 /* Check for unlinked inodes which can be reclaimed */
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002160 if (rs->rs_rgd->rd_flags & GFS2_RDF_CHECK)
2161 try_rgrp_unlink(rs->rs_rgd, &last_unlinked,
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002162 ip->i_no_addr);
2163skip_rgrp:
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002164 rgrp_unlock_local(rs->rs_rgd);
2165
Bob Peterson1330edb2013-11-06 10:58:00 -05002166 /* Drop reservation, if we couldn't use reserved rgrp */
2167 if (gfs2_rs_active(rs))
2168 gfs2_rs_deltree(rs);
2169
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002170 /* Unlock rgrp if required */
2171 if (!rg_locked)
Andreas Gruenbacher21f09c42018-08-30 16:01:50 +01002172 gfs2_glock_dq_uninit(&ip->i_rgd_gh);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002173next_rgrp:
2174 /* Find the next rgrp, and continue looking */
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002175 if (gfs2_select_rgrp(&rs->rs_rgd, begin))
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002176 continue;
Steven Whitehouse9dbe9612012-10-31 10:37:10 +00002177 if (skip)
2178 continue;
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002179
2180 /* If we've scanned all the rgrps, but found no free blocks
2181 * then this checks for some less likely conditions before
2182 * trying again.
2183 */
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002184 loops++;
2185 /* Check that fs hasn't grown if writing to rindex */
2186 if (ip == GFS2_I(sdp->sd_rindex) && !sdp->sd_rindex_uptodate) {
2187 error = gfs2_ri_update(ip);
2188 if (error)
2189 return error;
2190 }
2191 /* Flushing the log may release space */
Andreas Gruenbacher42720062020-03-20 13:31:41 +01002192 if (loops == 2) {
2193 if (ap->min_target)
2194 target = ap->min_target;
Bob Peterson805c09072018-01-08 10:34:17 -05002195 gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
2196 GFS2_LFC_INPLACE_RESERVE);
Andreas Gruenbacher42720062020-03-20 13:31:41 +01002197 }
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002198 }
2199
2200 return -ENOSPC;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002201}
2202
2203/**
2204 * gfs2_inplace_release - release an inplace reservation
2205 * @ip: the inode the reservation was taken out on
2206 *
2207 * Release a reservation made by gfs2_inplace_reserve().
2208 */
2209
2210void gfs2_inplace_release(struct gfs2_inode *ip)
2211{
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002212 struct gfs2_blkreserv *rs = &ip->i_res;
2213
2214 if (rs->rs_reserved) {
2215 struct gfs2_rgrpd *rgd = rs->rs_rgd;
2216
2217 spin_lock(&rgd->rd_rsspin);
2218 BUG_ON(rgd->rd_reserved < rs->rs_reserved);
2219 rgd->rd_reserved -= rs->rs_reserved;
2220 spin_unlock(&rgd->rd_rsspin);
2221 rs->rs_reserved = 0;
2222 }
Andreas Gruenbacher21f09c42018-08-30 16:01:50 +01002223 if (gfs2_holder_initialized(&ip->i_rgd_gh))
2224 gfs2_glock_dq_uninit(&ip->i_rgd_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002225}
2226
2227/**
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002228 * gfs2_alloc_extent - allocate an extent from a given bitmap
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002229 * @rbm: the resource group information
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002230 * @dinode: TRUE if the first block we allocate is for a dinode
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002231 * @n: The extent length (value/result)
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002232 *
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002233 * Add the bitmap buffer to the transaction.
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002234 * Set the found bits to @new_state to change block's allocation state.
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002235 */
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002236static void gfs2_alloc_extent(const struct gfs2_rbm *rbm, bool dinode,
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002237 unsigned int *n)
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002238{
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002239 struct gfs2_rbm pos = { .rgd = rbm->rgd, };
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002240 const unsigned int elen = *n;
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002241 u64 block;
2242 int ret;
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002243
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002244 *n = 1;
2245 block = gfs2_rbm_to_block(rbm);
Bob Petersone579ed42013-09-17 13:12:15 -04002246 gfs2_trans_add_meta(rbm->rgd->rd_gl, rbm_bi(rbm)->bi_bh);
Steven Whitehouse3e6339d2012-08-13 11:37:51 +01002247 gfs2_setbit(rbm, true, dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002248 block++;
Steven Whitehouse60a0b8f2009-05-21 12:23:12 +01002249 while (*n < elen) {
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002250 ret = gfs2_rbm_from_block(&pos, block);
Bob Petersondffe12a2018-08-07 10:07:00 -05002251 if (ret || gfs2_testbit(&pos, true) != GFS2_BLKST_FREE)
Steven Whitehouse60a0b8f2009-05-21 12:23:12 +01002252 break;
Bob Petersone579ed42013-09-17 13:12:15 -04002253 gfs2_trans_add_meta(pos.rgd->rd_gl, rbm_bi(&pos)->bi_bh);
Steven Whitehouse3e6339d2012-08-13 11:37:51 +01002254 gfs2_setbit(&pos, true, GFS2_BLKST_USED);
Steven Whitehouse60a0b8f2009-05-21 12:23:12 +01002255 (*n)++;
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002256 block++;
Steven Whitehouse60a0b8f2009-05-21 12:23:12 +01002257 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00002258}
2259
2260/**
2261 * rgblk_free - Change alloc state of given block(s)
2262 * @sdp: the filesystem
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002263 * @rgd: the resource group the blocks are in
David Teiglandb3b94fa2006-01-16 16:50:04 +00002264 * @bstart: the start of a run of blocks to free
2265 * @blen: the length of the block run (all must lie within ONE RG!)
2266 * @new_state: GFS2_BLKST_XXX the after-allocation block state
David Teiglandb3b94fa2006-01-16 16:50:04 +00002267 */
2268
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002269static void rgblk_free(struct gfs2_sbd *sdp, struct gfs2_rgrpd *rgd,
2270 u64 bstart, u32 blen, unsigned char new_state)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002271{
Steven Whitehouse3b1d0b92012-08-03 11:23:28 +01002272 struct gfs2_rbm rbm;
Bob Petersond24e0562014-10-03 08:38:06 -04002273 struct gfs2_bitmap *bi, *bi_prev = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002274
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002275 rbm.rgd = rgd;
Andreas Gruenbacherf6546832018-09-10 17:31:47 +01002276 if (WARN_ON_ONCE(gfs2_rbm_from_block(&rbm, bstart)))
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002277 return;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002278 while (blen--) {
Bob Petersone579ed42013-09-17 13:12:15 -04002279 bi = rbm_bi(&rbm);
Bob Petersond24e0562014-10-03 08:38:06 -04002280 if (bi != bi_prev) {
2281 if (!bi->bi_clone) {
2282 bi->bi_clone = kmalloc(bi->bi_bh->b_size,
2283 GFP_NOFS | __GFP_NOFAIL);
2284 memcpy(bi->bi_clone + bi->bi_offset,
2285 bi->bi_bh->b_data + bi->bi_offset,
Andreas Gruenbacher281b4952018-09-26 23:32:46 +01002286 bi->bi_bytes);
Bob Petersond24e0562014-10-03 08:38:06 -04002287 }
2288 gfs2_trans_add_meta(rbm.rgd->rd_gl, bi->bi_bh);
2289 bi_prev = bi;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002290 }
Steven Whitehouse3e6339d2012-08-13 11:37:51 +01002291 gfs2_setbit(&rbm, false, new_state);
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +02002292 gfs2_rbm_add(&rbm, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002293 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00002294}
2295
2296/**
Steven Whitehouse09010972009-05-20 10:48:47 +01002297 * gfs2_rgrp_dump - print out an rgrp
2298 * @seq: The iterator
Andrew Price0e539ca2020-10-07 12:30:58 +01002299 * @rgd: The rgrp in question
Bob Peterson3792ce92019-05-09 09:21:48 -05002300 * @fs_id_buf: pointer to file system id (if requested)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002301 *
David Teiglandb3b94fa2006-01-16 16:50:04 +00002302 */
2303
Andrew Price0e539ca2020-10-07 12:30:58 +01002304void gfs2_rgrp_dump(struct seq_file *seq, struct gfs2_rgrpd *rgd,
Bob Peterson3792ce92019-05-09 09:21:48 -05002305 const char *fs_id_buf)
Steven Whitehouse09010972009-05-20 10:48:47 +01002306{
Bob Peterson8e2e0042012-07-19 08:12:40 -04002307 struct gfs2_blkreserv *trs;
2308 const struct rb_node *n;
2309
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002310 spin_lock(&rgd->rd_rsspin);
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002311 gfs2_print_dbg(seq, "%s R: n:%llu f:%02x b:%u/%u i:%u q:%u r:%u e:%u\n",
Bob Peterson3792ce92019-05-09 09:21:48 -05002312 fs_id_buf,
Steven Whitehouse09010972009-05-20 10:48:47 +01002313 (unsigned long long)rgd->rd_addr, rgd->rd_flags,
Bob Peterson8e2e0042012-07-19 08:12:40 -04002314 rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes,
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002315 rgd->rd_requested, rgd->rd_reserved, rgd->rd_extfail_pt);
Bob Peterson72244b62018-08-15 12:09:49 -05002316 if (rgd->rd_sbd->sd_args.ar_rgrplvb) {
2317 struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
2318
Bob Peterson3792ce92019-05-09 09:21:48 -05002319 gfs2_print_dbg(seq, "%s L: f:%02x b:%u i:%u\n", fs_id_buf,
Bob Peterson72244b62018-08-15 12:09:49 -05002320 be32_to_cpu(rgl->rl_flags),
2321 be32_to_cpu(rgl->rl_free),
2322 be32_to_cpu(rgl->rl_dinodes));
2323 }
Bob Peterson8e2e0042012-07-19 08:12:40 -04002324 for (n = rb_first(&rgd->rd_rstree); n; n = rb_next(&trs->rs_node)) {
2325 trs = rb_entry(n, struct gfs2_blkreserv, rs_node);
Bob Peterson3792ce92019-05-09 09:21:48 -05002326 dump_rs(seq, trs, fs_id_buf);
Bob Peterson8e2e0042012-07-19 08:12:40 -04002327 }
2328 spin_unlock(&rgd->rd_rsspin);
Steven Whitehouse09010972009-05-20 10:48:47 +01002329}
2330
Steven Whitehouse6050b9c2009-07-31 16:19:40 +01002331static void gfs2_rgrp_error(struct gfs2_rgrpd *rgd)
2332{
2333 struct gfs2_sbd *sdp = rgd->rd_sbd;
Bob Peterson98fb0572019-08-13 09:25:15 -04002334 char fs_id_buf[sizeof(sdp->sd_fsname) + 7];
Bob Peterson3792ce92019-05-09 09:21:48 -05002335
Steven Whitehouse6050b9c2009-07-31 16:19:40 +01002336 fs_warn(sdp, "rgrp %llu has an error, marking it readonly until umount\n",
Steven Whitehouse86d00632009-09-14 09:50:57 +01002337 (unsigned long long)rgd->rd_addr);
Steven Whitehouse6050b9c2009-07-31 16:19:40 +01002338 fs_warn(sdp, "umount on all nodes and run fsck.gfs2 to fix the error\n");
Bob Peterson3792ce92019-05-09 09:21:48 -05002339 sprintf(fs_id_buf, "fsid=%s: ", sdp->sd_fsname);
Andrew Price0e539ca2020-10-07 12:30:58 +01002340 gfs2_rgrp_dump(NULL, rgd, fs_id_buf);
Steven Whitehouse6050b9c2009-07-31 16:19:40 +01002341 rgd->rd_flags |= GFS2_RDF_ERROR;
2342}
2343
Steven Whitehouse09010972009-05-20 10:48:47 +01002344/**
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002345 * gfs2_adjust_reservation - Adjust (or remove) a reservation after allocation
2346 * @ip: The inode we have just allocated blocks for
2347 * @rbm: The start of the allocated blocks
2348 * @len: The extent length
Bob Peterson8e2e0042012-07-19 08:12:40 -04002349 *
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002350 * Adjusts a reservation after an allocation has taken place. If the
2351 * reservation does not match the allocation, or if it is now empty
2352 * then it is removed.
Bob Peterson8e2e0042012-07-19 08:12:40 -04002353 */
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002354
2355static void gfs2_adjust_reservation(struct gfs2_inode *ip,
2356 const struct gfs2_rbm *rbm, unsigned len)
Bob Peterson8e2e0042012-07-19 08:12:40 -04002357{
Bob Petersona097dc7e2015-07-16 08:28:04 -05002358 struct gfs2_blkreserv *rs = &ip->i_res;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002359 struct gfs2_rgrpd *rgd = rbm->rgd;
Bob Peterson8e2e0042012-07-19 08:12:40 -04002360
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002361 BUG_ON(rs->rs_reserved < len);
2362 rs->rs_reserved -= len;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002363 if (gfs2_rs_active(rs)) {
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002364 u64 start = gfs2_rbm_to_block(rbm);
2365
2366 if (rs->rs_start == start) {
2367 unsigned int rlen;
2368
2369 rs->rs_start += len;
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02002370 rlen = min(rs->rs_requested, len);
2371 rs->rs_requested -= rlen;
2372 rgd->rd_requested -= rlen;
Steven Whitehouse9e733d32012-08-23 15:37:59 +01002373 trace_gfs2_rs(rs, TRACE_RS_CLAIM);
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002374 if (rs->rs_start < rgd->rd_data0 + rgd->rd_data &&
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02002375 rs->rs_requested)
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002376 return;
Bob Peterson1a855032014-10-29 08:02:30 -05002377 /* We used up our block reservation, so we should
2378 reserve more blocks next time. */
Andreas Gruenbacher21f09c42018-08-30 16:01:50 +01002379 atomic_add(RGRP_RSRV_ADDBLKS, &ip->i_sizehint);
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002380 }
Bob Peterson20095212013-03-13 10:26:38 -04002381 __rs_deltree(rs);
Bob Peterson8e2e0042012-07-19 08:12:40 -04002382 }
Bob Peterson8e2e0042012-07-19 08:12:40 -04002383}
2384
2385/**
Steven Whitehouse9e07f2c2013-10-02 14:42:45 +01002386 * gfs2_set_alloc_start - Set starting point for block allocation
2387 * @rbm: The rbm which will be set to the required location
2388 * @ip: The gfs2 inode
2389 * @dinode: Flag to say if allocation includes a new inode
2390 *
2391 * This sets the starting point from the reservation if one is active
2392 * otherwise it falls back to guessing a start point based on the
2393 * inode's goal block or the last allocation point in the rgrp.
2394 */
2395
2396static void gfs2_set_alloc_start(struct gfs2_rbm *rbm,
2397 const struct gfs2_inode *ip, bool dinode)
2398{
2399 u64 goal;
2400
Bob Petersona097dc7e2015-07-16 08:28:04 -05002401 if (gfs2_rs_active(&ip->i_res)) {
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002402 goal = ip->i_res.rs_start;
2403 } else {
2404 if (!dinode && rgrp_contains_block(rbm->rgd, ip->i_goal))
2405 goal = ip->i_goal;
2406 else
2407 goal = rbm->rgd->rd_last_alloc + rbm->rgd->rd_data0;
Steven Whitehouse9e07f2c2013-10-02 14:42:45 +01002408 }
Andreas Gruenbacherf6546832018-09-10 17:31:47 +01002409 if (WARN_ON_ONCE(gfs2_rbm_from_block(rbm, goal))) {
2410 rbm->bii = 0;
2411 rbm->offset = 0;
2412 }
Steven Whitehouse9e07f2c2013-10-02 14:42:45 +01002413}
2414
2415/**
Bob Peterson6e87ed02011-11-18 10:58:32 -05002416 * gfs2_alloc_blocks - Allocate one or more blocks of data and/or a dinode
Steven Whitehouse09010972009-05-20 10:48:47 +01002417 * @ip: the inode to allocate the block for
2418 * @bn: Used to return the starting block number
Bob Peterson8e2e0042012-07-19 08:12:40 -04002419 * @nblocks: requested number of blocks/extent length (value/result)
Bob Peterson6e87ed02011-11-18 10:58:32 -05002420 * @dinode: 1 if we're allocating a dinode block, else 0
Bob Peterson3c5d7852011-11-14 11:17:08 -05002421 * @generation: the generation number of the inode
Steven Whitehouse09010972009-05-20 10:48:47 +01002422 *
2423 * Returns: 0 or error
2424 */
2425
Steven Whitehouse6a8099e2011-11-22 12:18:51 +00002426int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
Bob Peterson6e87ed02011-11-18 10:58:32 -05002427 bool dinode, u64 *generation)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002428{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002429 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Steven Whitehoused9ba7612009-04-23 08:59:41 +01002430 struct buffer_head *dibh;
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002431 struct gfs2_rbm rbm = { .rgd = ip->i_res.rs_rgd, };
Bob Peterson3c5d7852011-11-14 11:17:08 -05002432 u64 block; /* block, within the file system scope */
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02002433 u32 minext = 1;
Andreas Gruenbacherb2598962020-10-12 17:23:50 +02002434 int error = -ENOSPC;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002435
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002436 BUG_ON(ip->i_res.rs_reserved < *nblocks);
2437
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002438 rgrp_lock_local(rbm.rgd);
Andreas Gruenbacherb2598962020-10-12 17:23:50 +02002439 if (gfs2_rs_active(&ip->i_res)) {
2440 gfs2_set_alloc_start(&rbm, ip, dinode);
2441 error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &minext, &ip->i_res, false);
2442 }
Steven Whitehouse137834a2012-08-23 13:43:40 +01002443 if (error == -ENOSPC) {
Steven Whitehouse9e07f2c2013-10-02 14:42:45 +01002444 gfs2_set_alloc_start(&rbm, ip, dinode);
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02002445 error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &minext, NULL, false);
Steven Whitehouse137834a2012-08-23 13:43:40 +01002446 }
2447
Steven Whitehouse62e252e2012-07-30 11:06:08 +01002448 /* Since all blocks are reserved in advance, this shouldn't happen */
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002449 if (error) {
Bob Peterson5ea50502013-11-25 11:16:25 +00002450 fs_warn(sdp, "inum=%llu error=%d, nblocks=%u, full=%d fail_pt=%d\n",
Steven Whitehouse9e733d32012-08-23 15:37:59 +01002451 (unsigned long long)ip->i_no_addr, error, *nblocks,
Bob Peterson5ea50502013-11-25 11:16:25 +00002452 test_bit(GBF_FULL, &rbm.rgd->rd_bits->bi_flags),
2453 rbm.rgd->rd_extfail_pt);
Steven Whitehouse62e252e2012-07-30 11:06:08 +01002454 goto rgrp_error;
2455 }
2456
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002457 gfs2_alloc_extent(&rbm, dinode, nblocks);
2458 block = gfs2_rbm_to_block(&rbm);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002459 rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0;
Bob Peterson3c5d7852011-11-14 11:17:08 -05002460 if (!dinode) {
Andreas Gruenbacher3ed08be2020-03-16 15:36:09 +01002461 ip->i_goal = block + *nblocks - 1;
Bob Peterson3c5d7852011-11-14 11:17:08 -05002462 error = gfs2_meta_inode_buffer(ip, &dibh);
2463 if (error == 0) {
2464 struct gfs2_dinode *di =
2465 (struct gfs2_dinode *)dibh->b_data;
Steven Whitehouse350a9b02012-12-14 12:36:02 +00002466 gfs2_trans_add_meta(ip->i_gl, dibh);
Bob Peterson3c5d7852011-11-14 11:17:08 -05002467 di->di_goal_meta = di->di_goal_data =
2468 cpu_to_be64(ip->i_goal);
2469 brelse(dibh);
2470 }
Steven Whitehoused9ba7612009-04-23 08:59:41 +01002471 }
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002472 spin_lock(&rbm.rgd->rd_rsspin);
2473 gfs2_adjust_reservation(ip, &rbm, *nblocks);
2474 if (rbm.rgd->rd_free < *nblocks || rbm.rgd->rd_reserved < *nblocks) {
Bob Petersone54c78a2018-10-03 08:47:36 -05002475 fs_warn(sdp, "nblocks=%u\n", *nblocks);
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002476 spin_unlock(&rbm.rgd->rd_rsspin);
Steven Whitehouse09010972009-05-20 10:48:47 +01002477 goto rgrp_error;
Bob Peterson8e2e0042012-07-19 08:12:40 -04002478 }
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002479 BUG_ON(rbm.rgd->rd_reserved < *nblocks);
2480 BUG_ON(rbm.rgd->rd_free_clone < *nblocks);
2481 BUG_ON(rbm.rgd->rd_free < *nblocks);
2482 rbm.rgd->rd_reserved -= *nblocks;
2483 rbm.rgd->rd_free_clone -= *nblocks;
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002484 rbm.rgd->rd_free -= *nblocks;
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002485 spin_unlock(&rbm.rgd->rd_rsspin);
Bob Peterson3c5d7852011-11-14 11:17:08 -05002486 if (dinode) {
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002487 rbm.rgd->rd_dinodes++;
2488 *generation = rbm.rgd->rd_igeneration++;
Bob Peterson3c5d7852011-11-14 11:17:08 -05002489 if (*generation == 0)
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002490 *generation = rbm.rgd->rd_igeneration++;
Bob Peterson3c5d7852011-11-14 11:17:08 -05002491 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00002492
Steven Whitehouse350a9b02012-12-14 12:36:02 +00002493 gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.rgd->rd_bits[0].bi_bh);
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002494 gfs2_rgrp_out(rbm.rgd, rbm.rgd->rd_bits[0].bi_bh->b_data);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002495 rgrp_unlock_local(rbm.rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002496
Steven Whitehouse6a8099e2011-11-22 12:18:51 +00002497 gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
Bob Peterson3c5d7852011-11-14 11:17:08 -05002498 if (dinode)
Andreas Gruenbacherfbb27872019-04-05 12:18:23 +01002499 gfs2_trans_remove_revoke(sdp, block, *nblocks);
Steven Whitehouse6a8099e2011-11-22 12:18:51 +00002500
Steven Whitehousefd4b4e02013-02-26 16:15:20 +00002501 gfs2_quota_change(ip, *nblocks, ip->i_inode.i_uid, ip->i_inode.i_gid);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002502
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002503 trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,
Bob Peterson6e87ed02011-11-18 10:58:32 -05002504 dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
Steven Whitehouse6050b9c2009-07-31 16:19:40 +01002505 *bn = block;
2506 return 0;
2507
2508rgrp_error:
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002509 rgrp_unlock_local(rbm.rgd);
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002510 gfs2_rgrp_error(rbm.rgd);
Steven Whitehouse6050b9c2009-07-31 16:19:40 +01002511 return -EIO;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002512}
2513
2514/**
Eric Sandeen46fcb2e2011-06-23 10:39:34 -05002515 * __gfs2_free_blocks - free a contiguous run of block(s)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002516 * @ip: the inode these blocks are being freed from
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002517 * @rgd: the resource group the blocks are in
David Teiglandb3b94fa2006-01-16 16:50:04 +00002518 * @bstart: first block of a run of contiguous blocks
2519 * @blen: the length of the block run
Eric Sandeen46fcb2e2011-06-23 10:39:34 -05002520 * @meta: 1 if the blocks represent metadata
David Teiglandb3b94fa2006-01-16 16:50:04 +00002521 *
2522 */
2523
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002524void __gfs2_free_blocks(struct gfs2_inode *ip, struct gfs2_rgrpd *rgd,
2525 u64 bstart, u32 blen, int meta)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002526{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002527 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002528
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002529 rgrp_lock_local(rgd);
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002530 rgblk_free(sdp, rgd, bstart, blen, GFS2_BLKST_FREE);
Bob Peterson41db1ab2012-05-09 12:11:35 -04002531 trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
Steven Whitehousecfc8b542008-11-04 10:25:13 +00002532 rgd->rd_free += blen;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00002533 rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
Steven Whitehouse350a9b02012-12-14 12:36:02 +00002534 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
Bob Peterson42d52e32008-01-28 18:38:07 -06002535 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002536 rgrp_unlock_local(rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002537
Steven Whitehouse6d3117b2011-05-21 14:05:58 +01002538 /* Directories keep their data in the metadata address space */
Bob Peterson68942872020-07-22 10:27:50 -05002539 if (meta || ip->i_depth || gfs2_is_jdata(ip))
2540 gfs2_journal_wipe(ip, bstart, blen);
Bob Peterson4c16c362011-02-23 16:11:33 -05002541}
David Teiglandb3b94fa2006-01-16 16:50:04 +00002542
Bob Peterson4c16c362011-02-23 16:11:33 -05002543/**
Bob Peterson4c16c362011-02-23 16:11:33 -05002544 * gfs2_free_meta - free a contiguous run of data block(s)
2545 * @ip: the inode these blocks are being freed from
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002546 * @rgd: the resource group the blocks are in
Bob Peterson4c16c362011-02-23 16:11:33 -05002547 * @bstart: first block of a run of contiguous blocks
2548 * @blen: the length of the block run
2549 *
2550 */
2551
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002552void gfs2_free_meta(struct gfs2_inode *ip, struct gfs2_rgrpd *rgd,
2553 u64 bstart, u32 blen)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002554{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002555 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002556
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002557 __gfs2_free_blocks(ip, rgd, bstart, blen, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002558 gfs2_statfs_change(sdp, 0, +blen, 0);
Steven Whitehouse2933f922006-11-01 13:23:29 -05002559 gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002560}
2561
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002562void gfs2_unlink_di(struct inode *inode)
2563{
2564 struct gfs2_inode *ip = GFS2_I(inode);
2565 struct gfs2_sbd *sdp = GFS2_SB(inode);
2566 struct gfs2_rgrpd *rgd;
Steven Whitehousedbb7cae2007-05-15 15:37:50 +01002567 u64 blkno = ip->i_no_addr;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002568
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002569 rgd = gfs2_blk2rgrpd(sdp, blkno, true);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002570 if (!rgd)
2571 return;
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002572 rgrp_lock_local(rgd);
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002573 rgblk_free(sdp, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
Bob Peterson41db1ab2012-05-09 12:11:35 -04002574 trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
Steven Whitehouse350a9b02012-12-14 12:36:02 +00002575 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
Bob Peterson42d52e32008-01-28 18:38:07 -06002576 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
Bob Petersonf5580d02018-08-08 09:53:30 -05002577 be32_add_cpu(&rgd->rd_rgl->rl_unlinked, 1);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002578 rgrp_unlock_local(rgd);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002579}
2580
Bob Petersona18c78c2017-11-22 09:24:14 -06002581void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002582{
2583 struct gfs2_sbd *sdp = rgd->rd_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002584
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002585 rgrp_lock_local(rgd);
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002586 rgblk_free(sdp, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
Steven Whitehouse73f74942008-11-04 10:32:57 +00002587 if (!rgd->rd_dinodes)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002588 gfs2_consist_rgrpd(rgd);
Steven Whitehouse73f74942008-11-04 10:32:57 +00002589 rgd->rd_dinodes--;
Steven Whitehousecfc8b542008-11-04 10:25:13 +00002590 rgd->rd_free++;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002591
Steven Whitehouse350a9b02012-12-14 12:36:02 +00002592 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
Bob Peterson42d52e32008-01-28 18:38:07 -06002593 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002594 rgrp_unlock_local(rgd);
Bob Petersonf5580d02018-08-08 09:53:30 -05002595 be32_add_cpu(&rgd->rd_rgl->rl_unlinked, -1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002596
2597 gfs2_statfs_change(sdp, 0, +1, -1);
Bob Peterson41db1ab2012-05-09 12:11:35 -04002598 trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
Steven Whitehouse2933f922006-11-01 13:23:29 -05002599 gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
Bob Peterson68942872020-07-22 10:27:50 -05002600 gfs2_journal_wipe(ip, ip->i_no_addr, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002601}
2602
2603/**
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002604 * gfs2_check_blk_type - Check the type of a block
2605 * @sdp: The superblock
2606 * @no_addr: The block number to check
2607 * @type: The block type we are looking for
2608 *
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002609 * The inode glock of @no_addr must be held. The @type to check for is either
2610 * GFS2_BLKST_DINODE or GFS2_BLKST_UNLINKED; checking for type GFS2_BLKST_FREE
2611 * or GFS2_BLKST_USED would make no sense.
2612 *
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002613 * Returns: 0 if the block type matches the expected type
2614 * -ESTALE if it doesn't match
2615 * or -ve errno if something went wrong while checking
2616 */
2617
2618int gfs2_check_blk_type(struct gfs2_sbd *sdp, u64 no_addr, unsigned int type)
2619{
2620 struct gfs2_rgrpd *rgd;
Steven Whitehouse8339ee52011-08-31 16:38:29 +01002621 struct gfs2_holder rgd_gh;
Bob Petersondffe12a2018-08-07 10:07:00 -05002622 struct gfs2_rbm rbm;
Bob Peterson58884c42012-03-05 10:19:35 -05002623 int error = -EINVAL;
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002624
Steven Whitehouse66fc0612012-02-08 12:58:32 +00002625 rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002626 if (!rgd)
Steven Whitehouse8339ee52011-08-31 16:38:29 +01002627 goto fail;
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002628
2629 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
2630 if (error)
Steven Whitehouse8339ee52011-08-31 16:38:29 +01002631 goto fail;
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002632
Bob Petersondffe12a2018-08-07 10:07:00 -05002633 rbm.rgd = rgd;
2634 error = gfs2_rbm_from_block(&rbm, no_addr);
Zhang Qilongbc923812020-11-08 17:27:41 +08002635 if (!WARN_ON_ONCE(error)) {
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002636 /*
2637 * No need to take the local resource group lock here; the
2638 * inode glock of @no_addr provides the necessary
2639 * synchronization in case the block is an inode. (In case
2640 * the block is not an inode, the block type will not match
2641 * the @type we are looking for.)
2642 */
Zhang Qilongbc923812020-11-08 17:27:41 +08002643 if (gfs2_testbit(&rbm, false) != type)
2644 error = -ESTALE;
2645 }
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002646
2647 gfs2_glock_dq_uninit(&rgd_gh);
Zhang Qilongbc923812020-11-08 17:27:41 +08002648
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002649fail:
2650 return error;
2651}
2652
2653/**
David Teiglandb3b94fa2006-01-16 16:50:04 +00002654 * gfs2_rlist_add - add a RG to a list of RGs
Steven Whitehouse70b0c362011-09-02 16:08:09 +01002655 * @ip: the inode
David Teiglandb3b94fa2006-01-16 16:50:04 +00002656 * @rlist: the list of resource groups
2657 * @block: the block
2658 *
2659 * Figure out what RG a block belongs to and add that RG to the list
2660 *
2661 * FIXME: Don't use NOFAIL
2662 *
2663 */
2664
Steven Whitehouse70b0c362011-09-02 16:08:09 +01002665void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
Steven Whitehousecd915492006-09-04 12:49:07 -04002666 u64 block)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002667{
Steven Whitehouse70b0c362011-09-02 16:08:09 +01002668 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002669 struct gfs2_rgrpd *rgd;
2670 struct gfs2_rgrpd **tmp;
2671 unsigned int new_space;
2672 unsigned int x;
2673
2674 if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
2675 return;
2676
Andreas Gruenbacher03f8c412018-06-21 07:22:12 -05002677 /*
2678 * The resource group last accessed is kept in the last position.
2679 */
2680
2681 if (rlist->rl_rgrps) {
2682 rgd = rlist->rl_rgd[rlist->rl_rgrps - 1];
2683 if (rgrp_contains_block(rgd, block))
2684 return;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00002685 rgd = gfs2_blk2rgrpd(sdp, block, 1);
Andreas Gruenbacher03f8c412018-06-21 07:22:12 -05002686 } else {
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002687 rgd = ip->i_res.rs_rgd;
Andreas Gruenbacher03f8c412018-06-21 07:22:12 -05002688 if (!rgd || !rgrp_contains_block(rgd, block))
2689 rgd = gfs2_blk2rgrpd(sdp, block, 1);
2690 }
2691
David Teiglandb3b94fa2006-01-16 16:50:04 +00002692 if (!rgd) {
Andreas Gruenbacher03f8c412018-06-21 07:22:12 -05002693 fs_err(sdp, "rlist_add: no rgrp for block %llu\n",
2694 (unsigned long long)block);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002695 return;
2696 }
2697
Andreas Gruenbacher03f8c412018-06-21 07:22:12 -05002698 for (x = 0; x < rlist->rl_rgrps; x++) {
2699 if (rlist->rl_rgd[x] == rgd) {
2700 swap(rlist->rl_rgd[x],
2701 rlist->rl_rgd[rlist->rl_rgrps - 1]);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002702 return;
Andreas Gruenbacher03f8c412018-06-21 07:22:12 -05002703 }
2704 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00002705
2706 if (rlist->rl_rgrps == rlist->rl_space) {
2707 new_space = rlist->rl_space + 10;
2708
2709 tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
Steven Whitehousedd894be2006-07-27 14:29:00 -04002710 GFP_NOFS | __GFP_NOFAIL);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002711
2712 if (rlist->rl_rgd) {
2713 memcpy(tmp, rlist->rl_rgd,
2714 rlist->rl_space * sizeof(struct gfs2_rgrpd *));
2715 kfree(rlist->rl_rgd);
2716 }
2717
2718 rlist->rl_space = new_space;
2719 rlist->rl_rgd = tmp;
2720 }
2721
2722 rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
2723}
2724
2725/**
2726 * gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate
2727 * and initialize an array of glock holders for them
2728 * @rlist: the list of resource groups
David Teiglandb3b94fa2006-01-16 16:50:04 +00002729 *
2730 * FIXME: Don't use NOFAIL
2731 *
2732 */
2733
Bob Petersonc3abc292018-10-04 00:06:23 +01002734void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002735{
2736 unsigned int x;
2737
Kees Cook6da2ec52018-06-12 13:55:00 -07002738 rlist->rl_ghs = kmalloc_array(rlist->rl_rgrps,
2739 sizeof(struct gfs2_holder),
2740 GFP_NOFS | __GFP_NOFAIL);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002741 for (x = 0; x < rlist->rl_rgrps; x++)
Bob Peterson4fc7ec32018-04-24 10:35:02 -07002742 gfs2_holder_init(rlist->rl_rgd[x]->rd_gl, LM_ST_EXCLUSIVE,
2743 LM_FLAG_NODE_SCOPE, &rlist->rl_ghs[x]);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002744}
2745
2746/**
2747 * gfs2_rlist_free - free a resource group list
Fabian Frederick27ff6a02014-07-02 22:05:27 +02002748 * @rlist: the list of resource groups
David Teiglandb3b94fa2006-01-16 16:50:04 +00002749 *
2750 */
2751
2752void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
2753{
2754 unsigned int x;
2755
2756 kfree(rlist->rl_rgd);
2757
2758 if (rlist->rl_ghs) {
2759 for (x = 0; x < rlist->rl_rgrps; x++)
2760 gfs2_holder_uninit(&rlist->rl_ghs[x]);
2761 kfree(rlist->rl_ghs);
Bob Peterson8e2e0042012-07-19 08:12:40 -04002762 rlist->rl_ghs = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002763 }
2764}
2765
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002766void rgrp_lock_local(struct gfs2_rgrpd *rgd)
2767{
2768 BUG_ON(!gfs2_glock_is_held_excl(rgd->rd_gl) &&
2769 !test_bit(SDF_NORECOVERY, &rgd->rd_sbd->sd_flags));
2770 mutex_lock(&rgd->rd_mutex);
2771}
2772
2773void rgrp_unlock_local(struct gfs2_rgrpd *rgd)
2774{
2775 mutex_unlock(&rgd->rd_mutex);
2776}