blob: 801ad9f4f2bef9cc4b0ec335cc794a6c572d733f [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
683 *
684 */
Andreas Gruenbacher73369052021-12-10 14:43:36 +0100685void gfs2_rs_delete(struct gfs2_inode *ip)
Bob Peterson0a305e42012-06-06 11:17:59 +0100686{
Andreas Gruenbacher73369052021-12-10 14:43:36 +0100687 struct inode *inode = &ip->i_inode;
688
Bob Peterson0a305e42012-06-06 11:17:59 +0100689 down_write(&ip->i_rw_mutex);
Andreas Gruenbacher73369052021-12-10 14:43:36 +0100690 if (atomic_read(&inode->i_writecount) <= 1)
Bob Petersona097dc7e2015-07-16 08:28:04 -0500691 gfs2_rs_deltree(&ip->i_res);
Bob Peterson0a305e42012-06-06 11:17:59 +0100692 up_write(&ip->i_rw_mutex);
693}
694
Bob Peterson8e2e0042012-07-19 08:12:40 -0400695/**
696 * return_all_reservations - return all reserved blocks back to the rgrp.
697 * @rgd: the rgrp that needs its space back
698 *
699 * We previously reserved a bunch of blocks for allocation. Now we need to
700 * give them back. This leave the reservation structures in tact, but removes
701 * all of their corresponding "no-fly zones".
702 */
703static void return_all_reservations(struct gfs2_rgrpd *rgd)
704{
705 struct rb_node *n;
706 struct gfs2_blkreserv *rs;
707
708 spin_lock(&rgd->rd_rsspin);
709 while ((n = rb_first(&rgd->rd_rstree))) {
710 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
Bob Peterson20095212013-03-13 10:26:38 -0400711 __rs_deltree(rs);
Bob Peterson8e2e0042012-07-19 08:12:40 -0400712 }
713 spin_unlock(&rgd->rd_rsspin);
714}
715
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100716void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000717{
Bob Peterson7c9ca622011-08-31 09:53:19 +0100718 struct rb_node *n;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000719 struct gfs2_rgrpd *rgd;
720 struct gfs2_glock *gl;
721
Bob Peterson7c9ca622011-08-31 09:53:19 +0100722 while ((n = rb_first(&sdp->sd_rindex_tree))) {
723 rgd = rb_entry(n, struct gfs2_rgrpd, rd_node);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000724 gl = rgd->rd_gl;
725
Bob Peterson7c9ca622011-08-31 09:53:19 +0100726 rb_erase(n, &sdp->sd_rindex_tree);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000727
728 if (gl) {
Bob Petersonb3422ca2019-11-13 11:50:30 -0600729 if (gl->gl_state != LM_ST_UNLOCKED) {
730 gfs2_glock_cb(gl, LM_ST_UNLOCKED);
731 flush_delayed_work(&gl->gl_work);
732 }
Andreas Gruenbacher10283ea2018-11-05 22:57:24 +0000733 gfs2_rgrp_brelse(rgd);
Bob Petersonb3422ca2019-11-13 11:50:30 -0600734 glock_clear_object(gl, rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000735 gfs2_glock_put(gl);
736 }
737
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100738 gfs2_free_clones(rgd);
Bob Petersond0f17d32020-10-27 10:10:01 -0500739 return_all_reservations(rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000740 kfree(rgd->rd_bits);
Bob Peterson36e4ad02016-06-09 14:24:07 -0500741 rgd->rd_bits = NULL;
Bob Peterson6bdd9be2008-01-28 17:20:26 -0600742 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000743 }
744}
745
David Teiglandb3b94fa2006-01-16 16:50:04 +0000746/**
Lee Jonesc551f662021-03-30 17:44:29 +0100747 * compute_bitstructs - Compute the bitmap sizes
David Teiglandb3b94fa2006-01-16 16:50:04 +0000748 * @rgd: The resource group descriptor
749 *
750 * Calculates bitmap descriptors, one for each block that contains bitmap data
751 *
752 * Returns: errno
753 */
754
755static int compute_bitstructs(struct gfs2_rgrpd *rgd)
756{
757 struct gfs2_sbd *sdp = rgd->rd_sbd;
758 struct gfs2_bitmap *bi;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100759 u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
Steven Whitehousecd915492006-09-04 12:49:07 -0400760 u32 bytes_left, bytes;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000761 int x;
762
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400763 if (!length)
764 return -EINVAL;
765
Steven Whitehousedd894be2006-07-27 14:29:00 -0400766 rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000767 if (!rgd->rd_bits)
768 return -ENOMEM;
769
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100770 bytes_left = rgd->rd_bitbytes;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000771
772 for (x = 0; x < length; x++) {
773 bi = rgd->rd_bits + x;
774
Steven Whitehouse60a0b8f2009-05-21 12:23:12 +0100775 bi->bi_flags = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000776 /* small rgrp; bitmap stored completely in header block */
777 if (length == 1) {
778 bytes = bytes_left;
779 bi->bi_offset = sizeof(struct gfs2_rgrp);
780 bi->bi_start = 0;
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100781 bi->bi_bytes = bytes;
Bob Peterson7e230f52013-09-11 13:44:02 -0500782 bi->bi_blocks = bytes * GFS2_NBBY;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000783 /* header block */
784 } else if (x == 0) {
785 bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
786 bi->bi_offset = sizeof(struct gfs2_rgrp);
787 bi->bi_start = 0;
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100788 bi->bi_bytes = bytes;
Bob Peterson7e230f52013-09-11 13:44:02 -0500789 bi->bi_blocks = bytes * GFS2_NBBY;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000790 /* last block */
791 } else if (x + 1 == length) {
792 bytes = bytes_left;
793 bi->bi_offset = sizeof(struct gfs2_meta_header);
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100794 bi->bi_start = rgd->rd_bitbytes - bytes_left;
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100795 bi->bi_bytes = bytes;
Bob Peterson7e230f52013-09-11 13:44:02 -0500796 bi->bi_blocks = bytes * GFS2_NBBY;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000797 /* other blocks */
798 } else {
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500799 bytes = sdp->sd_sb.sb_bsize -
800 sizeof(struct gfs2_meta_header);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000801 bi->bi_offset = sizeof(struct gfs2_meta_header);
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100802 bi->bi_start = rgd->rd_bitbytes - bytes_left;
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100803 bi->bi_bytes = bytes;
Bob Peterson7e230f52013-09-11 13:44:02 -0500804 bi->bi_blocks = bytes * GFS2_NBBY;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000805 }
806
807 bytes_left -= bytes;
808 }
809
810 if (bytes_left) {
811 gfs2_consist_rgrpd(rgd);
812 return -EIO;
813 }
814 bi = rgd->rd_bits + (length - 1);
Andreas Gruenbacher281b4952018-09-26 23:32:46 +0100815 if ((bi->bi_start + bi->bi_bytes) * GFS2_NBBY != rgd->rd_data) {
Andreas Gruenbacher8dc88ac2020-01-23 19:19:38 +0100816 gfs2_lm(sdp,
817 "ri_addr = %llu\n"
818 "ri_length = %u\n"
819 "ri_data0 = %llu\n"
820 "ri_data = %u\n"
821 "ri_bitbytes = %u\n"
822 "start=%u len=%u offset=%u\n",
823 (unsigned long long)rgd->rd_addr,
824 rgd->rd_length,
825 (unsigned long long)rgd->rd_data0,
826 rgd->rd_data,
827 rgd->rd_bitbytes,
828 bi->bi_start, bi->bi_bytes, bi->bi_offset);
829 gfs2_consist_rgrpd(rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000830 return -EIO;
831 }
832
833 return 0;
834}
835
836/**
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500837 * gfs2_ri_total - Total up the file system space, according to the rindex.
Bob Peterson886b1412012-04-11 13:03:52 -0400838 * @sdp: the filesystem
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500839 *
840 */
841u64 gfs2_ri_total(struct gfs2_sbd *sdp)
842{
843 u64 total_data = 0;
844 struct inode *inode = sdp->sd_rindex;
845 struct gfs2_inode *ip = GFS2_I(inode);
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500846 char buf[sizeof(struct gfs2_rindex)];
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500847 int error, rgrps;
848
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500849 for (rgrps = 0;; rgrps++) {
850 loff_t pos = rgrps * sizeof(struct gfs2_rindex);
851
Bob Petersonbcd72782010-12-07 13:58:56 -0500852 if (pos + sizeof(struct gfs2_rindex) > i_size_read(inode))
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500853 break;
Andrew Price43066292012-04-16 16:40:55 +0100854 error = gfs2_internal_read(ip, buf, &pos,
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500855 sizeof(struct gfs2_rindex));
856 if (error != sizeof(struct gfs2_rindex))
857 break;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100858 total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500859 }
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500860 return total_data;
861}
862
Bob Peterson6aad1c32012-03-05 09:20:59 -0500863static int rgd_insert(struct gfs2_rgrpd *rgd)
Bob Peterson7c9ca622011-08-31 09:53:19 +0100864{
865 struct gfs2_sbd *sdp = rgd->rd_sbd;
866 struct rb_node **newn = &sdp->sd_rindex_tree.rb_node, *parent = NULL;
867
868 /* Figure out where to put new node */
869 while (*newn) {
870 struct gfs2_rgrpd *cur = rb_entry(*newn, struct gfs2_rgrpd,
871 rd_node);
872
873 parent = *newn;
874 if (rgd->rd_addr < cur->rd_addr)
875 newn = &((*newn)->rb_left);
876 else if (rgd->rd_addr > cur->rd_addr)
877 newn = &((*newn)->rb_right);
878 else
Bob Peterson6aad1c32012-03-05 09:20:59 -0500879 return -EEXIST;
Bob Peterson7c9ca622011-08-31 09:53:19 +0100880 }
881
882 rb_link_node(&rgd->rd_node, parent, newn);
883 rb_insert_color(&rgd->rd_node, &sdp->sd_rindex_tree);
Bob Peterson6aad1c32012-03-05 09:20:59 -0500884 sdp->sd_rgrps++;
885 return 0;
Bob Peterson7c9ca622011-08-31 09:53:19 +0100886}
887
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500888/**
Robert Peterson6c532672007-05-10 16:54:38 -0500889 * read_rindex_entry - Pull in a new resource index entry from the disk
Andrew Price43066292012-04-16 16:40:55 +0100890 * @ip: Pointer to the rindex inode
David Teiglandb3b94fa2006-01-16 16:50:04 +0000891 *
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100892 * Returns: 0 on success, > 0 on EOF, error code otherwise
Robert Peterson6c532672007-05-10 16:54:38 -0500893 */
894
Andrew Price43066292012-04-16 16:40:55 +0100895static int read_rindex_entry(struct gfs2_inode *ip)
Robert Peterson6c532672007-05-10 16:54:38 -0500896{
897 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
898 loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100899 struct gfs2_rindex buf;
Robert Peterson6c532672007-05-10 16:54:38 -0500900 int error;
901 struct gfs2_rgrpd *rgd;
902
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100903 if (pos >= i_size_read(&ip->i_inode))
904 return 1;
905
Andrew Price43066292012-04-16 16:40:55 +0100906 error = gfs2_internal_read(ip, (char *)&buf, &pos,
Robert Peterson6c532672007-05-10 16:54:38 -0500907 sizeof(struct gfs2_rindex));
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100908
909 if (error != sizeof(struct gfs2_rindex))
910 return (error == 0) ? 1 : error;
Robert Peterson6c532672007-05-10 16:54:38 -0500911
Bob Peterson6bdd9be2008-01-28 17:20:26 -0600912 rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
Robert Peterson6c532672007-05-10 16:54:38 -0500913 error = -ENOMEM;
914 if (!rgd)
915 return error;
916
Robert Peterson6c532672007-05-10 16:54:38 -0500917 rgd->rd_sbd = sdp;
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100918 rgd->rd_addr = be64_to_cpu(buf.ri_addr);
919 rgd->rd_length = be32_to_cpu(buf.ri_length);
920 rgd->rd_data0 = be64_to_cpu(buf.ri_data0);
921 rgd->rd_data = be32_to_cpu(buf.ri_data);
922 rgd->rd_bitbytes = be32_to_cpu(buf.ri_bitbytes);
Bob Peterson8e2e0042012-07-19 08:12:40 -0400923 spin_lock_init(&rgd->rd_rsspin);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +0100924 mutex_init(&rgd->rd_mutex);
Bob Peterson7c9ca622011-08-31 09:53:19 +0100925
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100926 error = gfs2_glock_get(sdp, rgd->rd_addr,
Robert Peterson6c532672007-05-10 16:54:38 -0500927 &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
928 if (error)
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100929 goto fail;
Robert Peterson6c532672007-05-10 16:54:38 -0500930
Bob Peterson428f6512022-01-17 10:25:07 -0500931 error = compute_bitstructs(rgd);
932 if (error)
933 goto fail_glock;
934
David Teigland4e2f8842012-11-14 13:47:37 -0500935 rgd->rd_rgl = (struct gfs2_rgrp_lvb *)rgd->rd_gl->gl_lksb.sb_lvbptr;
Bob Peterson4b3113a2021-10-05 09:28:17 -0500936 rgd->rd_flags &= ~GFS2_RDF_PREFERRED;
Bob Peterson7c9ca622011-08-31 09:53:19 +0100937 if (rgd->rd_data > sdp->sd_max_rg_data)
938 sdp->sd_max_rg_data = rgd->rd_data;
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100939 spin_lock(&sdp->sd_rindex_spin);
Bob Peterson6aad1c32012-03-05 09:20:59 -0500940 error = rgd_insert(rgd);
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100941 spin_unlock(&sdp->sd_rindex_spin);
Bob Peterson36e4ad02016-06-09 14:24:07 -0500942 if (!error) {
Andreas Gruenbacher6f6597ba2017-06-30 07:55:08 -0500943 glock_set_object(rgd->rd_gl, rgd);
Bob Peterson6aad1c32012-03-05 09:20:59 -0500944 return 0;
Bob Peterson36e4ad02016-06-09 14:24:07 -0500945 }
Bob Peterson6aad1c32012-03-05 09:20:59 -0500946
947 error = 0; /* someone else read in the rgrp; free it and ignore it */
Bob Peterson428f6512022-01-17 10:25:07 -0500948fail_glock:
Bob Petersonc1ac5392012-03-22 08:58:30 -0400949 gfs2_glock_put(rgd->rd_gl);
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100950
951fail:
952 kfree(rgd->rd_bits);
Bob Peterson36e4ad02016-06-09 14:24:07 -0500953 rgd->rd_bits = NULL;
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100954 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
Robert Peterson6c532672007-05-10 16:54:38 -0500955 return error;
956}
957
958/**
Bob Peterson0e27c182014-10-29 08:02:28 -0500959 * set_rgrp_preferences - Run all the rgrps, selecting some we prefer to use
960 * @sdp: the GFS2 superblock
961 *
962 * The purpose of this function is to select a subset of the resource groups
963 * and mark them as PREFERRED. We do it in such a way that each node prefers
964 * to use a unique set of rgrps to minimize glock contention.
965 */
966static void set_rgrp_preferences(struct gfs2_sbd *sdp)
967{
968 struct gfs2_rgrpd *rgd, *first;
969 int i;
970
971 /* Skip an initial number of rgrps, based on this node's journal ID.
972 That should start each node out on its own set. */
973 rgd = gfs2_rgrpd_get_first(sdp);
974 for (i = 0; i < sdp->sd_lockstruct.ls_jid; i++)
975 rgd = gfs2_rgrpd_get_next(rgd);
976 first = rgd;
977
978 do {
979 rgd->rd_flags |= GFS2_RDF_PREFERRED;
980 for (i = 0; i < sdp->sd_journals; i++) {
981 rgd = gfs2_rgrpd_get_next(rgd);
Abhi Das959b6712015-05-05 11:26:04 -0500982 if (!rgd || rgd == first)
Bob Peterson0e27c182014-10-29 08:02:28 -0500983 break;
984 }
Abhi Das959b6712015-05-05 11:26:04 -0500985 } while (rgd && rgd != first);
Bob Peterson0e27c182014-10-29 08:02:28 -0500986}
987
988/**
Robert Peterson6c532672007-05-10 16:54:38 -0500989 * gfs2_ri_update - Pull in a new resource index from the disk
990 * @ip: pointer to the rindex inode
991 *
David Teiglandb3b94fa2006-01-16 16:50:04 +0000992 * Returns: 0 on successful update, error code otherwise
993 */
994
Steven Whitehouse8339ee52011-08-31 16:38:29 +0100995static int gfs2_ri_update(struct gfs2_inode *ip)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000996{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400997 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000998 int error;
999
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001000 do {
Andrew Price43066292012-04-16 16:40:55 +01001001 error = read_rindex_entry(ip);
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001002 } while (error == 0);
1003
1004 if (error < 0)
1005 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001006
Bob Peterson77872152020-11-24 10:44:36 -05001007 if (RB_EMPTY_ROOT(&sdp->sd_rindex_tree)) {
1008 fs_err(sdp, "no resource groups found in the file system.\n");
1009 return -ENOENT;
1010 }
Bob Peterson0e27c182014-10-29 08:02:28 -05001011 set_rgrp_preferences(sdp);
1012
Bob Petersoncf45b752008-01-31 10:31:39 -06001013 sdp->sd_rindex_uptodate = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001014 return 0;
Robert Peterson6c532672007-05-10 16:54:38 -05001015}
David Teiglandb3b94fa2006-01-16 16:50:04 +00001016
Robert Peterson6c532672007-05-10 16:54:38 -05001017/**
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001018 * gfs2_rindex_update - Update the rindex if required
David Teiglandb3b94fa2006-01-16 16:50:04 +00001019 * @sdp: The GFS2 superblock
David Teiglandb3b94fa2006-01-16 16:50:04 +00001020 *
1021 * We grab a lock on the rindex inode to make sure that it doesn't
1022 * change whilst we are performing an operation. We keep this lock
1023 * for quite long periods of time compared to other locks. This
1024 * doesn't matter, since it is shared and it is very, very rarely
1025 * accessed in the exclusive mode (i.e. only when expanding the filesystem).
1026 *
1027 * This makes sure that we're using the latest copy of the resource index
1028 * special file, which might have been updated if someone expanded the
1029 * filesystem (via gfs2_grow utility), which adds new resource groups.
1030 *
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001031 * Returns: 0 on succeess, error code otherwise
David Teiglandb3b94fa2006-01-16 16:50:04 +00001032 */
1033
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001034int gfs2_rindex_update(struct gfs2_sbd *sdp)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001035{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001036 struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001037 struct gfs2_glock *gl = ip->i_gl;
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001038 struct gfs2_holder ri_gh;
1039 int error = 0;
Steven Whitehousea365fbf2012-02-24 15:09:14 +00001040 int unlock_required = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001041
1042 /* Read new copy from disk if we don't have the latest */
Bob Petersoncf45b752008-01-31 10:31:39 -06001043 if (!sdp->sd_rindex_uptodate) {
Steven Whitehousea365fbf2012-02-24 15:09:14 +00001044 if (!gfs2_glock_is_locked_by_me(gl)) {
1045 error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, &ri_gh);
1046 if (error)
Bob Peterson6aad1c32012-03-05 09:20:59 -05001047 return error;
Steven Whitehousea365fbf2012-02-24 15:09:14 +00001048 unlock_required = 1;
1049 }
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001050 if (!sdp->sd_rindex_uptodate)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001051 error = gfs2_ri_update(ip);
Steven Whitehousea365fbf2012-02-24 15:09:14 +00001052 if (unlock_required)
1053 gfs2_glock_dq_uninit(&ri_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001054 }
1055
1056 return error;
1057}
1058
Bob Peterson42d52e32008-01-28 18:38:07 -06001059static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001060{
1061 const struct gfs2_rgrp *str = buf;
Bob Peterson42d52e32008-01-28 18:38:07 -06001062 u32 rg_flags;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001063
Bob Peterson42d52e32008-01-28 18:38:07 -06001064 rg_flags = be32_to_cpu(str->rg_flags);
Steven Whitehouse09010972009-05-20 10:48:47 +01001065 rg_flags &= ~GFS2_RDF_MASK;
Steven Whitehouse1ce97e52009-05-21 15:18:19 +01001066 rgd->rd_flags &= GFS2_RDF_MASK;
1067 rgd->rd_flags |= rg_flags;
Steven Whitehousecfc8b542008-11-04 10:25:13 +00001068 rgd->rd_free = be32_to_cpu(str->rg_free);
Steven Whitehouse73f74942008-11-04 10:32:57 +00001069 rgd->rd_dinodes = be32_to_cpu(str->rg_dinodes);
Steven Whitehoused8b71f72008-11-04 10:19:03 +00001070 rgd->rd_igeneration = be64_to_cpu(str->rg_igeneration);
Andrew Price166725d2017-12-12 11:40:05 -06001071 /* rd_data0, rd_data and rd_bitbytes already set from rindex */
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001072}
1073
Bob Peterson3f30f922018-07-26 12:59:13 -05001074static void gfs2_rgrp_ondisk2lvb(struct gfs2_rgrp_lvb *rgl, const void *buf)
1075{
1076 const struct gfs2_rgrp *str = buf;
1077
1078 rgl->rl_magic = cpu_to_be32(GFS2_MAGIC);
1079 rgl->rl_flags = str->rg_flags;
1080 rgl->rl_free = str->rg_free;
1081 rgl->rl_dinodes = str->rg_dinodes;
1082 rgl->rl_igeneration = str->rg_igeneration;
1083 rgl->__pad = 0UL;
1084}
1085
Bob Peterson42d52e32008-01-28 18:38:07 -06001086static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001087{
Andrew Price65adc272017-12-12 11:37:15 -06001088 struct gfs2_rgrpd *next = gfs2_rgrpd_get_next(rgd);
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001089 struct gfs2_rgrp *str = buf;
Andrew Price850d2d92017-12-12 11:42:30 -06001090 u32 crc;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001091
Steven Whitehouse09010972009-05-20 10:48:47 +01001092 str->rg_flags = cpu_to_be32(rgd->rd_flags & ~GFS2_RDF_MASK);
Steven Whitehousecfc8b542008-11-04 10:25:13 +00001093 str->rg_free = cpu_to_be32(rgd->rd_free);
Steven Whitehouse73f74942008-11-04 10:32:57 +00001094 str->rg_dinodes = cpu_to_be32(rgd->rd_dinodes);
Andrew Price65adc272017-12-12 11:37:15 -06001095 if (next == NULL)
1096 str->rg_skip = 0;
1097 else if (next->rd_addr > rgd->rd_addr)
1098 str->rg_skip = cpu_to_be32(next->rd_addr - rgd->rd_addr);
Steven Whitehoused8b71f72008-11-04 10:19:03 +00001099 str->rg_igeneration = cpu_to_be64(rgd->rd_igeneration);
Andrew Price166725d2017-12-12 11:40:05 -06001100 str->rg_data0 = cpu_to_be64(rgd->rd_data0);
1101 str->rg_data = cpu_to_be32(rgd->rd_data);
1102 str->rg_bitbytes = cpu_to_be32(rgd->rd_bitbytes);
Andrew Price850d2d92017-12-12 11:42:30 -06001103 str->rg_crc = 0;
1104 crc = gfs2_disk_hash(buf, sizeof(struct gfs2_rgrp));
1105 str->rg_crc = cpu_to_be32(crc);
Andrew Price166725d2017-12-12 11:40:05 -06001106
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001107 memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
Bob Peterson3f30f922018-07-26 12:59:13 -05001108 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl, buf);
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001109}
1110
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001111static int gfs2_rgrp_lvb_valid(struct gfs2_rgrpd *rgd)
1112{
1113 struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
1114 struct gfs2_rgrp *str = (struct gfs2_rgrp *)rgd->rd_bits[0].bi_bh->b_data;
Bob Petersonf29e62e2019-05-13 09:42:18 -05001115 struct gfs2_sbd *sdp = rgd->rd_sbd;
Bob Peterson72244b62018-08-15 12:09:49 -05001116 int valid = 1;
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001117
Bob Peterson72244b62018-08-15 12:09:49 -05001118 if (rgl->rl_flags != str->rg_flags) {
Bob Petersonf29e62e2019-05-13 09:42:18 -05001119 fs_warn(sdp, "GFS2: rgd: %llu lvb flag mismatch %u/%u",
1120 (unsigned long long)rgd->rd_addr,
Bob Peterson72244b62018-08-15 12:09:49 -05001121 be32_to_cpu(rgl->rl_flags), be32_to_cpu(str->rg_flags));
1122 valid = 0;
1123 }
1124 if (rgl->rl_free != str->rg_free) {
Bob Petersonf29e62e2019-05-13 09:42:18 -05001125 fs_warn(sdp, "GFS2: rgd: %llu lvb free mismatch %u/%u",
1126 (unsigned long long)rgd->rd_addr,
1127 be32_to_cpu(rgl->rl_free), be32_to_cpu(str->rg_free));
Bob Peterson72244b62018-08-15 12:09:49 -05001128 valid = 0;
1129 }
1130 if (rgl->rl_dinodes != str->rg_dinodes) {
Bob Petersonf29e62e2019-05-13 09:42:18 -05001131 fs_warn(sdp, "GFS2: rgd: %llu lvb dinode mismatch %u/%u",
1132 (unsigned long long)rgd->rd_addr,
1133 be32_to_cpu(rgl->rl_dinodes),
1134 be32_to_cpu(str->rg_dinodes));
Bob Peterson72244b62018-08-15 12:09:49 -05001135 valid = 0;
1136 }
1137 if (rgl->rl_igeneration != str->rg_igeneration) {
Bob Petersonf29e62e2019-05-13 09:42:18 -05001138 fs_warn(sdp, "GFS2: rgd: %llu lvb igen mismatch %llu/%llu",
1139 (unsigned long long)rgd->rd_addr,
1140 (unsigned long long)be64_to_cpu(rgl->rl_igeneration),
1141 (unsigned long long)be64_to_cpu(str->rg_igeneration));
Bob Peterson72244b62018-08-15 12:09:49 -05001142 valid = 0;
1143 }
1144 return valid;
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001145}
1146
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001147static u32 count_unlinked(struct gfs2_rgrpd *rgd)
1148{
1149 struct gfs2_bitmap *bi;
1150 const u32 length = rgd->rd_length;
1151 const u8 *buffer = NULL;
1152 u32 i, goal, count = 0;
1153
1154 for (i = 0, bi = rgd->rd_bits; i < length; i++, bi++) {
1155 goal = 0;
1156 buffer = bi->bi_bh->b_data + bi->bi_offset;
1157 WARN_ON(!buffer_uptodate(bi->bi_bh));
Andreas Gruenbacher281b4952018-09-26 23:32:46 +01001158 while (goal < bi->bi_blocks) {
1159 goal = gfs2_bitfit(buffer, bi->bi_bytes, goal,
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001160 GFS2_BLKST_UNLINKED);
1161 if (goal == BFITNOENT)
1162 break;
1163 count++;
1164 goal++;
1165 }
1166 }
1167
1168 return count;
1169}
1170
Andreas Gruenbacher560b8eb2020-10-06 15:26:22 +02001171static void rgrp_set_bitmap_flags(struct gfs2_rgrpd *rgd)
1172{
1173 struct gfs2_bitmap *bi;
1174 int x;
1175
1176 if (rgd->rd_free) {
1177 for (x = 0; x < rgd->rd_length; x++) {
1178 bi = rgd->rd_bits + x;
1179 clear_bit(GBF_FULL, &bi->bi_flags);
1180 }
1181 } else {
1182 for (x = 0; x < rgd->rd_length; x++) {
1183 bi = rgd->rd_bits + x;
1184 set_bit(GBF_FULL, &bi->bi_flags);
1185 }
1186 }
1187}
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001188
David Teiglandb3b94fa2006-01-16 16:50:04 +00001189/**
Bob Peterson4b3113a2021-10-05 09:28:17 -05001190 * gfs2_rgrp_go_instantiate - Read in a RG's header and bitmaps
1191 * @gh: the glock holder representing the rgrpd to read in
David Teiglandb3b94fa2006-01-16 16:50:04 +00001192 *
1193 * Read in all of a Resource Group's header and bitmap blocks.
Andreas Gruenbacher10283ea2018-11-05 22:57:24 +00001194 * Caller must eventually call gfs2_rgrp_brelse() to free the bitmaps.
David Teiglandb3b94fa2006-01-16 16:50:04 +00001195 *
1196 * Returns: errno
1197 */
1198
Bob Peterson4b3113a2021-10-05 09:28:17 -05001199int gfs2_rgrp_go_instantiate(struct gfs2_holder *gh)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001200{
Bob Peterson4b3113a2021-10-05 09:28:17 -05001201 struct gfs2_glock *gl = gh->gh_gl;
1202 struct gfs2_rgrpd *rgd = gl->gl_object;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001203 struct gfs2_sbd *sdp = rgd->rd_sbd;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001204 unsigned int length = rgd->rd_length;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001205 struct gfs2_bitmap *bi;
1206 unsigned int x, y;
1207 int error;
1208
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001209 if (rgd->rd_bits[0].bi_bh != NULL)
1210 return 0;
1211
David Teiglandb3b94fa2006-01-16 16:50:04 +00001212 for (x = 0; x < length; x++) {
1213 bi = rgd->rd_bits + x;
Andreas Gruenbacherc8d57702015-11-11 15:00:35 -06001214 error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, 0, &bi->bi_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001215 if (error)
1216 goto fail;
1217 }
1218
1219 for (y = length; y--;) {
1220 bi = rgd->rd_bits + y;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -04001221 error = gfs2_meta_wait(sdp, bi->bi_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001222 if (error)
1223 goto fail;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001224 if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
David Teiglandb3b94fa2006-01-16 16:50:04 +00001225 GFS2_METATYPE_RG)) {
1226 error = -EIO;
1227 goto fail;
1228 }
1229 }
1230
Bob Peterson4b3113a2021-10-05 09:28:17 -05001231 gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
1232 rgrp_set_bitmap_flags(rgd);
1233 rgd->rd_flags |= GFS2_RDF_CHECK;
1234 rgd->rd_free_clone = rgd->rd_free;
1235 GLOCK_BUG_ON(rgd->rd_gl, rgd->rd_reserved);
1236 /* max out the rgrp allocation failure point */
1237 rgd->rd_extfail_pt = rgd->rd_free;
Al Viro951b4bd2013-06-02 19:53:40 -04001238 if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic) {
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001239 rgd->rd_rgl->rl_unlinked = cpu_to_be32(count_unlinked(rgd));
1240 gfs2_rgrp_ondisk2lvb(rgd->rd_rgl,
1241 rgd->rd_bits[0].bi_bh->b_data);
Bob Petersonf2e70d82021-10-06 09:29:18 -05001242 } else if (sdp->sd_args.ar_rgrplvb) {
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001243 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 return error;
1261}
1262
Bob Petersonf2e70d82021-10-06 09:29:18 -05001263static int update_rgrp_lvb(struct gfs2_rgrpd *rgd, struct gfs2_holder *gh)
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001264{
1265 u32 rl_flags;
1266
Bob Peterson4b3113a2021-10-05 09:28:17 -05001267 if (!test_bit(GLF_INSTANTIATE_NEEDED, &gh->gh_gl->gl_flags))
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001268 return 0;
1269
Al Viro951b4bd2013-06-02 19:53:40 -04001270 if (cpu_to_be32(GFS2_MAGIC) != rgd->rd_rgl->rl_magic)
Bob Petersonf2e70d82021-10-06 09:29:18 -05001271 return gfs2_instantiate(gh);
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001272
1273 rl_flags = be32_to_cpu(rgd->rd_rgl->rl_flags);
1274 rl_flags &= ~GFS2_RDF_MASK;
1275 rgd->rd_flags &= GFS2_RDF_MASK;
Bob Peterson4f36cb32018-08-16 10:32:13 -05001276 rgd->rd_flags |= (rl_flags | GFS2_RDF_CHECK);
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001277 if (rgd->rd_rgl->rl_unlinked == 0)
1278 rgd->rd_flags &= ~GFS2_RDF_CHECK;
1279 rgd->rd_free = be32_to_cpu(rgd->rd_rgl->rl_free);
Andreas Gruenbacher560b8eb2020-10-06 15:26:22 +02001280 rgrp_set_bitmap_flags(rgd);
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001281 rgd->rd_free_clone = rgd->rd_free;
Bob Petersonc98c2ca2021-09-14 08:16:58 -05001282 GLOCK_BUG_ON(rgd->rd_gl, rgd->rd_reserved);
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02001283 /* max out the rgrp allocation failure point */
1284 rgd->rd_extfail_pt = rgd->rd_free;
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001285 rgd->rd_dinodes = be32_to_cpu(rgd->rd_rgl->rl_dinodes);
1286 rgd->rd_igeneration = be64_to_cpu(rgd->rd_rgl->rl_igeneration);
1287 return 0;
1288}
1289
David Teiglandb3b94fa2006-01-16 16:50:04 +00001290/**
Bob Peterson39b0f1e2015-06-05 08:38:57 -05001291 * gfs2_rgrp_brelse - Release RG bitmaps read in with gfs2_rgrp_bh_get()
1292 * @rgd: The resource group
David Teiglandb3b94fa2006-01-16 16:50:04 +00001293 *
1294 */
1295
Bob Peterson39b0f1e2015-06-05 08:38:57 -05001296void gfs2_rgrp_brelse(struct gfs2_rgrpd *rgd)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001297{
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001298 int x, length = rgd->rd_length;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001299
David Teiglandb3b94fa2006-01-16 16:50:04 +00001300 for (x = 0; x < length; x++) {
1301 struct gfs2_bitmap *bi = rgd->rd_bits + x;
Benjamin Marzinski90306c42012-05-29 23:01:09 -05001302 if (bi->bi_bh) {
1303 brelse(bi->bi_bh);
1304 bi->bi_bh = NULL;
1305 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001306 }
Bob Petersonf2e70d82021-10-06 09:29:18 -05001307 set_bit(GLF_INSTANTIATE_NEEDED, &rgd->rd_gl->gl_flags);
Bob Peterson39b0f1e2015-06-05 08:38:57 -05001308}
1309
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001310int gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
Bob Peterson7c9ca622011-08-31 09:53:19 +01001311 struct buffer_head *bh,
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001312 const struct gfs2_bitmap *bi, unsigned minlen, u64 *ptrimmed)
Steven Whitehousef15ab562009-02-09 09:25:01 +00001313{
1314 struct super_block *sb = sdp->sd_vfs;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001315 u64 blk;
Steven Whitehouse64d576b2009-02-12 13:31:58 +00001316 sector_t start = 0;
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001317 sector_t nr_blks = 0;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001318 int rv;
1319 unsigned int x;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001320 u32 trimmed = 0;
1321 u8 diff;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001322
Andreas Gruenbacher281b4952018-09-26 23:32:46 +01001323 for (x = 0; x < bi->bi_bytes; x++) {
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001324 const u8 *clone = bi->bi_clone ? bi->bi_clone : bi->bi_bh->b_data;
1325 clone += bi->bi_offset;
1326 clone += x;
1327 if (bh) {
1328 const u8 *orig = bh->b_data + bi->bi_offset + x;
1329 diff = ~(*orig | (*orig >> 1)) & (*clone | (*clone >> 1));
1330 } else {
1331 diff = ~(*clone | (*clone >> 1));
1332 }
Steven Whitehousef15ab562009-02-09 09:25:01 +00001333 diff &= 0x55;
1334 if (diff == 0)
1335 continue;
1336 blk = offset + ((bi->bi_start + x) * GFS2_NBBY);
Steven Whitehousef15ab562009-02-09 09:25:01 +00001337 while(diff) {
1338 if (diff & 1) {
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001339 if (nr_blks == 0)
Steven Whitehousef15ab562009-02-09 09:25:01 +00001340 goto start_new_extent;
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001341 if ((start + nr_blks) != blk) {
1342 if (nr_blks >= minlen) {
1343 rv = sb_issue_discard(sb,
1344 start, nr_blks,
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001345 GFP_NOFS, 0);
1346 if (rv)
1347 goto fail;
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001348 trimmed += nr_blks;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001349 }
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001350 nr_blks = 0;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001351start_new_extent:
1352 start = blk;
1353 }
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001354 nr_blks++;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001355 }
1356 diff >>= 2;
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001357 blk++;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001358 }
1359 }
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001360 if (nr_blks >= minlen) {
1361 rv = sb_issue_discard(sb, start, nr_blks, GFP_NOFS, 0);
Steven Whitehousef15ab562009-02-09 09:25:01 +00001362 if (rv)
1363 goto fail;
Bob Petersonb2c87ca2013-03-22 10:07:24 -04001364 trimmed += nr_blks;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001365 }
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001366 if (ptrimmed)
1367 *ptrimmed = trimmed;
1368 return 0;
1369
Steven Whitehousef15ab562009-02-09 09:25:01 +00001370fail:
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001371 if (sdp->sd_args.ar_discard)
Andreas Gruenbacheraf388162018-01-30 10:32:30 -07001372 fs_warn(sdp, "error %d on discard request, turning discards off for this filesystem\n", rv);
Steven Whitehousef15ab562009-02-09 09:25:01 +00001373 sdp->sd_args.ar_discard = 0;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001374 return -EIO;
1375}
1376
1377/**
1378 * gfs2_fitrim - Generate discard requests for unused bits of the filesystem
1379 * @filp: Any file on the filesystem
1380 * @argp: Pointer to the arguments (also used to pass result)
1381 *
1382 * Returns: 0 on success, otherwise error code
1383 */
1384
1385int gfs2_fitrim(struct file *filp, void __user *argp)
1386{
Al Viro496ad9a2013-01-23 17:07:38 -05001387 struct inode *inode = file_inode(filp);
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001388 struct gfs2_sbd *sdp = GFS2_SB(inode);
1389 struct request_queue *q = bdev_get_queue(sdp->sd_vfs->s_bdev);
1390 struct buffer_head *bh;
1391 struct gfs2_rgrpd *rgd;
1392 struct gfs2_rgrpd *rgd_end;
1393 struct gfs2_holder gh;
1394 struct fstrim_range r;
1395 int ret = 0;
1396 u64 amt;
1397 u64 trimmed = 0;
Lukas Czerner076f0fa2012-10-16 11:39:08 +02001398 u64 start, end, minlen;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001399 unsigned int x;
Lukas Czerner076f0fa2012-10-16 11:39:08 +02001400 unsigned bs_shift = sdp->sd_sb.sb_bsize_shift;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001401
1402 if (!capable(CAP_SYS_ADMIN))
1403 return -EPERM;
1404
Bob Petersonc5c68722020-10-28 13:42:18 -05001405 if (!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))
1406 return -EROFS;
1407
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001408 if (!blk_queue_discard(q))
1409 return -EOPNOTSUPP;
1410
Lukas Czerner3a238ad2012-10-16 11:39:07 +02001411 if (copy_from_user(&r, argp, sizeof(r)))
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001412 return -EFAULT;
1413
Bob Peterson5e2f7d62012-04-04 22:11:16 -04001414 ret = gfs2_rindex_update(sdp);
1415 if (ret)
1416 return ret;
1417
Lukas Czerner076f0fa2012-10-16 11:39:08 +02001418 start = r.start >> bs_shift;
1419 end = start + (r.len >> bs_shift);
Andrew Price27ca8272022-03-22 19:05:51 +00001420 minlen = max_t(u64, r.minlen, sdp->sd_sb.sb_bsize);
1421 minlen = max_t(u64, minlen,
Lukas Czerner076f0fa2012-10-16 11:39:08 +02001422 q->limits.discard_granularity) >> bs_shift;
1423
Abhijith Das6a98c332013-06-19 17:03:29 -04001424 if (end <= start || minlen > sdp->sd_max_rg_data)
Lukas Czerner076f0fa2012-10-16 11:39:08 +02001425 return -EINVAL;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001426
Abhijith Das6a98c332013-06-19 17:03:29 -04001427 rgd = gfs2_blk2rgrpd(sdp, start, 0);
1428 rgd_end = gfs2_blk2rgrpd(sdp, end, 0);
1429
1430 if ((gfs2_rgrpd_get_first(sdp) == gfs2_rgrpd_get_next(rgd_end))
1431 && (start > rgd_end->rd_data0 + rgd_end->rd_data))
1432 return -EINVAL; /* start is beyond the end of the fs */
1433
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001434 while (1) {
1435
Bob Peterson4fc7ec32018-04-24 10:35:02 -07001436 ret = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
1437 LM_FLAG_NODE_SCOPE, &gh);
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001438 if (ret)
1439 goto out;
1440
1441 if (!(rgd->rd_flags & GFS2_RGF_TRIMMED)) {
1442 /* Trim each bitmap in the rgrp */
1443 for (x = 0; x < rgd->rd_length; x++) {
1444 struct gfs2_bitmap *bi = rgd->rd_bits + x;
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01001445 rgrp_lock_local(rgd);
Lukas Czerner076f0fa2012-10-16 11:39:08 +02001446 ret = gfs2_rgrp_send_discards(sdp,
1447 rgd->rd_data0, NULL, bi, minlen,
1448 &amt);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01001449 rgrp_unlock_local(rgd);
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001450 if (ret) {
1451 gfs2_glock_dq_uninit(&gh);
1452 goto out;
1453 }
1454 trimmed += amt;
1455 }
1456
1457 /* Mark rgrp as having been trimmed */
1458 ret = gfs2_trans_begin(sdp, RES_RG_HDR, 0);
1459 if (ret == 0) {
1460 bh = rgd->rd_bits[0].bi_bh;
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01001461 rgrp_lock_local(rgd);
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001462 rgd->rd_flags |= GFS2_RGF_TRIMMED;
Steven Whitehouse350a9b02012-12-14 12:36:02 +00001463 gfs2_trans_add_meta(rgd->rd_gl, bh);
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001464 gfs2_rgrp_out(rgd, bh->b_data);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01001465 rgrp_unlock_local(rgd);
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001466 gfs2_trans_end(sdp);
1467 }
1468 }
1469 gfs2_glock_dq_uninit(&gh);
1470
1471 if (rgd == rgd_end)
1472 break;
1473
1474 rgd = gfs2_rgrpd_get_next(rgd);
1475 }
1476
1477out:
Abhijith Das6a98c332013-06-19 17:03:29 -04001478 r.len = trimmed << bs_shift;
Lukas Czerner3a238ad2012-10-16 11:39:07 +02001479 if (copy_to_user(argp, &r, sizeof(r)))
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001480 return -EFAULT;
1481
1482 return ret;
Steven Whitehousef15ab562009-02-09 09:25:01 +00001483}
1484
David Teiglandb3b94fa2006-01-16 16:50:04 +00001485/**
Bob Peterson8e2e0042012-07-19 08:12:40 -04001486 * rs_insert - insert a new multi-block reservation into the rgrp's rb_tree
Bob Peterson8e2e0042012-07-19 08:12:40 -04001487 * @ip: the inode structure
Bob Peterson8e2e0042012-07-19 08:12:40 -04001488 *
Bob Peterson8e2e0042012-07-19 08:12:40 -04001489 */
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001490static void rs_insert(struct gfs2_inode *ip)
Bob Peterson8e2e0042012-07-19 08:12:40 -04001491{
1492 struct rb_node **newn, *parent = NULL;
1493 int rc;
Bob Petersona097dc7e2015-07-16 08:28:04 -05001494 struct gfs2_blkreserv *rs = &ip->i_res;
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02001495 struct gfs2_rgrpd *rgd = rs->rs_rgd;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001496
1497 BUG_ON(gfs2_rs_active(rs));
Bob Peterson8e2e0042012-07-19 08:12:40 -04001498
1499 spin_lock(&rgd->rd_rsspin);
1500 newn = &rgd->rd_rstree.rb_node;
Bob Peterson8e2e0042012-07-19 08:12:40 -04001501 while (*newn) {
1502 struct gfs2_blkreserv *cur =
1503 rb_entry(*newn, struct gfs2_blkreserv, rs_node);
1504
1505 parent = *newn;
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02001506 rc = rs_cmp(rs->rs_start, rs->rs_requested, cur);
Bob Peterson8e2e0042012-07-19 08:12:40 -04001507 if (rc > 0)
1508 newn = &((*newn)->rb_right);
1509 else if (rc < 0)
1510 newn = &((*newn)->rb_left);
1511 else {
1512 spin_unlock(&rgd->rd_rsspin);
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001513 WARN_ON(1);
1514 return;
Bob Peterson8e2e0042012-07-19 08:12:40 -04001515 }
1516 }
1517
Bob Peterson8e2e0042012-07-19 08:12:40 -04001518 rb_link_node(&rs->rs_node, parent, newn);
1519 rb_insert_color(&rs->rs_node, &rgd->rd_rstree);
1520
Bob Peterson8e2e0042012-07-19 08:12:40 -04001521 /* Do our rgrp accounting for the reservation */
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02001522 rgd->rd_requested += rs->rs_requested; /* blocks requested */
Bob Peterson8e2e0042012-07-19 08:12:40 -04001523 spin_unlock(&rgd->rd_rsspin);
Steven Whitehouse9e733d32012-08-23 15:37:59 +01001524 trace_gfs2_rs(rs, TRACE_RS_INSERT);
Bob Peterson8e2e0042012-07-19 08:12:40 -04001525}
1526
1527/**
Lee Jonesc551f662021-03-30 17:44:29 +01001528 * rgd_free - return the number of free blocks we can allocate
Bob Petersonf6753df2018-05-30 14:05:15 -05001529 * @rgd: the resource group
Lee Jonesc551f662021-03-30 17:44:29 +01001530 * @rs: The reservation to free
Bob Petersonf6753df2018-05-30 14:05:15 -05001531 *
1532 * This function returns the number of free blocks for an rgrp.
1533 * That's the clone-free blocks (blocks that are free, not including those
1534 * still being used for unlinked files that haven't been deleted.)
1535 *
1536 * It also subtracts any blocks reserved by someone else, but does not
1537 * include free blocks that are still part of our current reservation,
1538 * because obviously we can (and will) allocate them.
1539 */
1540static inline u32 rgd_free(struct gfs2_rgrpd *rgd, struct gfs2_blkreserv *rs)
1541{
1542 u32 tot_reserved, tot_free;
1543
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02001544 if (WARN_ON_ONCE(rgd->rd_requested < rs->rs_requested))
Bob Petersonf6753df2018-05-30 14:05:15 -05001545 return 0;
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02001546 tot_reserved = rgd->rd_requested - rs->rs_requested;
Bob Petersonf6753df2018-05-30 14:05:15 -05001547
1548 if (rgd->rd_free_clone < tot_reserved)
1549 tot_reserved = 0;
1550
1551 tot_free = rgd->rd_free_clone - tot_reserved;
1552
1553 return tot_free;
1554}
1555
1556/**
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001557 * rg_mblk_search - find a group of multiple free blocks to form a reservation
Bob Peterson8e2e0042012-07-19 08:12:40 -04001558 * @rgd: the resource group descriptor
Bob Peterson8e2e0042012-07-19 08:12:40 -04001559 * @ip: pointer to the inode for which we're reserving blocks
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01001560 * @ap: the allocation parameters
Bob Peterson8e2e0042012-07-19 08:12:40 -04001561 *
Bob Peterson8e2e0042012-07-19 08:12:40 -04001562 */
1563
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001564static void rg_mblk_search(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip,
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01001565 const struct gfs2_alloc_parms *ap)
Bob Peterson8e2e0042012-07-19 08:12:40 -04001566{
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001567 struct gfs2_rbm rbm = { .rgd = rgd, };
1568 u64 goal;
Bob Petersona097dc7e2015-07-16 08:28:04 -05001569 struct gfs2_blkreserv *rs = &ip->i_res;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001570 u32 extlen;
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01001571 u32 free_blocks, blocks_available;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001572 int ret;
Bob Petersonaf21ca82013-05-14 13:04:29 -04001573 struct inode *inode = &ip->i_inode;
Bob Peterson8e2e0042012-07-19 08:12:40 -04001574
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01001575 spin_lock(&rgd->rd_rsspin);
1576 free_blocks = rgd_free(rgd, rs);
1577 if (rgd->rd_free_clone < rgd->rd_requested)
1578 free_blocks = 0;
1579 blocks_available = rgd->rd_free_clone - rgd->rd_reserved;
1580 if (rgd == rs->rs_rgd)
1581 blocks_available += rs->rs_reserved;
1582 spin_unlock(&rgd->rd_rsspin);
1583
Bob Petersonaf21ca82013-05-14 13:04:29 -04001584 if (S_ISDIR(inode->i_mode))
1585 extlen = 1;
1586 else {
Andreas Gruenbacher21f09c42018-08-30 16:01:50 +01001587 extlen = max_t(u32, atomic_read(&ip->i_sizehint), ap->target);
Andreas Gruenbacherad899452018-09-25 12:59:31 +01001588 extlen = clamp(extlen, (u32)RGRP_RSRV_MINBLKS, free_blocks);
Bob Petersonaf21ca82013-05-14 13:04:29 -04001589 }
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01001590 if (free_blocks < extlen || blocks_available < extlen)
Steven Whitehousec743ffd2012-08-25 18:21:47 +01001591 return;
1592
Bob Peterson8e2e0042012-07-19 08:12:40 -04001593 /* Find bitmap block that contains bits for goal block */
1594 if (rgrp_contains_block(rgd, ip->i_goal))
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001595 goal = ip->i_goal;
Bob Peterson8e2e0042012-07-19 08:12:40 -04001596 else
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001597 goal = rgd->rd_last_alloc + rgd->rd_data0;
Steven Whitehousec743ffd2012-08-25 18:21:47 +01001598
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001599 if (WARN_ON(gfs2_rbm_from_block(&rbm, goal)))
1600 return;
Bob Peterson8e2e0042012-07-19 08:12:40 -04001601
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001602 ret = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &extlen, &ip->i_res, true);
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001603 if (ret == 0) {
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02001604 rs->rs_start = gfs2_rbm_to_block(&rbm);
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02001605 rs->rs_requested = extlen;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001606 rs_insert(ip);
Bob Peterson13d2eb012012-12-20 13:23:04 -05001607 } else {
1608 if (goal == rgd->rd_last_alloc + rgd->rd_data0)
1609 rgd->rd_last_alloc = 0;
Bob Peterson8e2e0042012-07-19 08:12:40 -04001610 }
Bob Petersonb3e47ca2011-11-21 11:47:08 -05001611}
1612
David Teiglandb3b94fa2006-01-16 16:50:04 +00001613/**
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001614 * gfs2_next_unreserved_block - Return next block that is not reserved
1615 * @rgd: The resource group
1616 * @block: The starting block
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001617 * @length: The required length
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001618 * @ignore_rs: Reservation to ignore
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001619 *
1620 * If the block does not appear in any reservation, then return the
1621 * block number unchanged. If it does appear in the reservation, then
1622 * keep looking through the tree of reservations in order to find the
1623 * first block number which is not reserved.
1624 */
1625
1626static u64 gfs2_next_unreserved_block(struct gfs2_rgrpd *rgd, u64 block,
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001627 u32 length,
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001628 struct gfs2_blkreserv *ignore_rs)
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001629{
1630 struct gfs2_blkreserv *rs;
1631 struct rb_node *n;
1632 int rc;
1633
1634 spin_lock(&rgd->rd_rsspin);
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001635 n = rgd->rd_rstree.rb_node;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001636 while (n) {
1637 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001638 rc = rs_cmp(block, length, rs);
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001639 if (rc < 0)
1640 n = n->rb_left;
1641 else if (rc > 0)
1642 n = n->rb_right;
1643 else
1644 break;
1645 }
1646
1647 if (n) {
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001648 while (rs_cmp(block, length, rs) == 0 && rs != ignore_rs) {
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02001649 block = rs->rs_start + rs->rs_requested;
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001650 n = n->rb_right;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001651 if (n == NULL)
1652 break;
1653 rs = rb_entry(n, struct gfs2_blkreserv, rs_node);
1654 }
1655 }
1656
1657 spin_unlock(&rgd->rd_rsspin);
1658 return block;
1659}
1660
1661/**
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001662 * gfs2_reservation_check_and_update - Check for reservations during block alloc
1663 * @rbm: The current position in the resource group
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001664 * @rs: Our own reservation
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001665 * @minext: The minimum extent length
Bob Peterson5ce13432013-11-06 10:55:52 -05001666 * @maxext: A pointer to the maximum extent structure
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001667 *
1668 * This checks the current position in the rgrp to see whether there is
1669 * a reservation covering this block. If not then this function is a
1670 * no-op. If there is, then the position is moved to the end of the
1671 * contiguous reservation(s) so that we are pointing at the first
1672 * non-reserved block.
1673 *
1674 * Returns: 0 if no reservation, 1 if @rbm has changed, otherwise an error
1675 */
1676
1677static int gfs2_reservation_check_and_update(struct gfs2_rbm *rbm,
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001678 struct gfs2_blkreserv *rs,
Bob Peterson5ce13432013-11-06 10:55:52 -05001679 u32 minext,
1680 struct gfs2_extent *maxext)
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001681{
1682 u64 block = gfs2_rbm_to_block(rbm);
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001683 u32 extlen = 1;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001684 u64 nblock;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001685
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001686 /*
1687 * If we have a minimum extent length, then skip over any extent
1688 * which is less than the min extent length in size.
1689 */
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02001690 if (minext > 1) {
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001691 extlen = gfs2_free_extlen(rbm, minext);
Bob Peterson5ce13432013-11-06 10:55:52 -05001692 if (extlen <= maxext->len)
Steven Whitehouseff7f4cb2012-09-10 10:03:50 +01001693 goto fail;
1694 }
1695
1696 /*
1697 * Check the extent which has been found against the reservations
1698 * and skip if parts of it are already reserved
1699 */
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001700 nblock = gfs2_next_unreserved_block(rbm->rgd, block, extlen, rs);
Bob Peterson5ce13432013-11-06 10:55:52 -05001701 if (nblock == block) {
1702 if (!minext || extlen >= minext)
1703 return 0;
1704
1705 if (extlen > maxext->len) {
1706 maxext->len = extlen;
1707 maxext->rbm = *rbm;
1708 }
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +02001709 } else {
1710 u64 len = nblock - block;
1711 if (len >= (u64)1 << 32)
1712 return -E2BIG;
1713 extlen = len;
Bob Peterson5ce13432013-11-06 10:55:52 -05001714 }
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +02001715fail:
1716 if (gfs2_rbm_add(rbm, extlen))
1717 return -E2BIG;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001718 return 1;
1719}
1720
1721/**
1722 * gfs2_rbm_find - Look for blocks of a particular state
1723 * @rbm: Value/result starting position and final position
1724 * @state: The state which we want to find
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02001725 * @minext: Pointer to the requested extent length
Bob Peterson5ce13432013-11-06 10:55:52 -05001726 * This is updated to be the actual reservation size.
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001727 * @rs: Our own reservation (NULL to skip checking for reservations)
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001728 * @nowrap: Stop looking at the end of the rgrp, rather than wrapping
1729 * around until we've reached the starting point.
1730 *
1731 * Side effects:
1732 * - If looking for free blocks, we set GBF_FULL on each bitmap which
1733 * has no free blocks in it.
Bob Peterson5ea50502013-11-25 11:16:25 +00001734 * - If looking for free blocks, we set rd_extfail_pt on each rgrp which
1735 * has come up short on a free block search.
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001736 *
1737 * Returns: 0 on success, -ENOSPC if there is no block of the requested state
1738 */
1739
Bob Peterson5ce13432013-11-06 10:55:52 -05001740static int gfs2_rbm_find(struct gfs2_rbm *rbm, u8 state, u32 *minext,
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001741 struct gfs2_blkreserv *rs, bool nowrap)
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001742{
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001743 bool scan_from_start = rbm->bii == 0 && rbm->offset == 0;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001744 struct buffer_head *bh;
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001745 int last_bii;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001746 u32 offset;
1747 u8 *buffer;
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001748 bool wrapped = false;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001749 int ret;
Bob Petersone579ed42013-09-17 13:12:15 -04001750 struct gfs2_bitmap *bi;
Bob Peterson5ce13432013-11-06 10:55:52 -05001751 struct gfs2_extent maxext = { .rbm.rgd = rbm->rgd, };
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001752
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001753 /*
1754 * Determine the last bitmap to search. If we're not starting at the
1755 * beginning of a bitmap, we need to search that bitmap twice to scan
1756 * the entire resource group.
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001757 */
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001758 last_bii = rbm->bii - (rbm->offset == 0);
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001759
1760 while(1) {
Bob Petersone579ed42013-09-17 13:12:15 -04001761 bi = rbm_bi(rbm);
Andreas Gruenbacher2fdc2fa2020-10-06 14:29:04 +02001762 if (test_bit(GBF_FULL, &bi->bi_flags) &&
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001763 (state == GFS2_BLKST_FREE))
1764 goto next_bitmap;
1765
Bob Petersone579ed42013-09-17 13:12:15 -04001766 bh = bi->bi_bh;
1767 buffer = bh->b_data + bi->bi_offset;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001768 WARN_ON(!buffer_uptodate(bh));
Bob Petersone579ed42013-09-17 13:12:15 -04001769 if (state != GFS2_BLKST_UNLINKED && bi->bi_clone)
1770 buffer = bi->bi_clone + bi->bi_offset;
Andreas Gruenbacher281b4952018-09-26 23:32:46 +01001771 offset = gfs2_bitfit(buffer, bi->bi_bytes, rbm->offset, state);
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001772 if (offset == BFITNOENT) {
1773 if (state == GFS2_BLKST_FREE && rbm->offset == 0)
1774 set_bit(GBF_FULL, &bi->bi_flags);
1775 goto next_bitmap;
1776 }
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001777 rbm->offset = offset;
Andreas Gruenbacherbea906e2021-04-02 19:51:24 +02001778 if (!rs || !minext)
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001779 return 0;
1780
Andreas Gruenbacher3d39fcd2020-10-09 19:30:16 +02001781 ret = gfs2_reservation_check_and_update(rbm, rs, *minext,
Bob Peterson5ce13432013-11-06 10:55:52 -05001782 &maxext);
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001783 if (ret == 0)
1784 return 0;
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001785 if (ret > 0)
Bob Peterson8d8b7522012-08-07 13:28:17 -04001786 goto next_iter;
Steven Whitehouse5d50d532012-08-07 13:47:12 +01001787 if (ret == -E2BIG) {
Bob Petersone579ed42013-09-17 13:12:15 -04001788 rbm->bii = 0;
Steven Whitehouse5d50d532012-08-07 13:47:12 +01001789 rbm->offset = 0;
Steven Whitehouse5d50d532012-08-07 13:47:12 +01001790 goto res_covered_end_of_rgrp;
1791 }
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001792 return ret;
1793
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001794next_bitmap: /* Find next bitmap in the rgrp */
1795 rbm->offset = 0;
Bob Petersone579ed42013-09-17 13:12:15 -04001796 rbm->bii++;
1797 if (rbm->bii == rbm->rgd->rd_length)
1798 rbm->bii = 0;
Steven Whitehouse5d50d532012-08-07 13:47:12 +01001799res_covered_end_of_rgrp:
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001800 if (rbm->bii == 0) {
1801 if (wrapped)
1802 break;
1803 wrapped = true;
1804 if (nowrap)
1805 break;
1806 }
Bob Peterson8d8b7522012-08-07 13:28:17 -04001807next_iter:
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001808 /* Have we scanned the entire resource group? */
1809 if (wrapped && rbm->bii > last_bii)
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001810 break;
1811 }
1812
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02001813 if (state != GFS2_BLKST_FREE)
Bob Peterson5ce13432013-11-06 10:55:52 -05001814 return -ENOSPC;
1815
Bob Peterson5ea50502013-11-25 11:16:25 +00001816 /* If the extent was too small, and it's smaller than the smallest
1817 to have failed before, remember for future reference that it's
1818 useless to search this rgrp again for this amount or more. */
Andreas Gruenbacher71921ef2019-03-14 16:48:48 +01001819 if (wrapped && (scan_from_start || rbm->bii > last_bii) &&
1820 *minext < rbm->rgd->rd_extfail_pt)
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02001821 rbm->rgd->rd_extfail_pt = *minext - 1;
Bob Peterson5ea50502013-11-25 11:16:25 +00001822
Bob Peterson5ce13432013-11-06 10:55:52 -05001823 /* If the maximum extent we found is big enough to fulfill the
1824 minimum requirements, use it anyway. */
1825 if (maxext.len) {
1826 *rbm = maxext.rbm;
1827 *minext = maxext.len;
1828 return 0;
1829 }
1830
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001831 return -ENOSPC;
1832}
1833
1834/**
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001835 * try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
1836 * @rgd: The rgrp
Bob Peterson886b1412012-04-11 13:03:52 -04001837 * @last_unlinked: block address of the last dinode we unlinked
1838 * @skip: block address we should explicitly not unlink
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001839 *
Bob Peterson1a0eae82010-04-14 11:58:16 -04001840 * Returns: 0 if no error
1841 * The inode, if one has been found, in inode.
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001842 */
1843
Steven Whitehouse044b9412010-11-03 20:01:07 +00001844static void try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked, u64 skip)
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001845{
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001846 u64 block;
Bob Peterson5f3eae72007-08-08 16:52:09 -05001847 struct gfs2_sbd *sdp = rgd->rd_sbd;
Steven Whitehouse044b9412010-11-03 20:01:07 +00001848 struct gfs2_glock *gl;
1849 struct gfs2_inode *ip;
1850 int error;
1851 int found = 0;
Bob Petersone579ed42013-09-17 13:12:15 -04001852 struct gfs2_rbm rbm = { .rgd = rgd, .bii = 0, .offset = 0 };
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001853
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001854 while (1) {
Bob Peterson5ce13432013-11-06 10:55:52 -05001855 error = gfs2_rbm_find(&rbm, GFS2_BLKST_UNLINKED, NULL, NULL,
Bob Peterson8381e602016-05-02 09:42:49 -05001856 true);
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001857 if (error == -ENOSPC)
1858 break;
1859 if (WARN_ON_ONCE(error))
Bob Peterson24c73872007-07-12 16:58:50 -05001860 break;
Bob Petersonb3e47ca2011-11-21 11:47:08 -05001861
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001862 block = gfs2_rbm_to_block(&rbm);
1863 if (gfs2_rbm_from_block(&rbm, block + 1))
1864 break;
1865 if (*last_unlinked != NO_BLOCK && block <= *last_unlinked)
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001866 continue;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001867 if (block == skip)
Steven Whitehouse1e19a192009-07-10 21:13:38 +01001868 continue;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01001869 *last_unlinked = block;
Steven Whitehouse044b9412010-11-03 20:01:07 +00001870
Bob Peterson5ea31bc2015-12-04 12:57:00 -06001871 error = gfs2_glock_get(sdp, block, &gfs2_iopen_glops, CREATE, &gl);
Steven Whitehouse044b9412010-11-03 20:01:07 +00001872 if (error)
1873 continue;
1874
1875 /* If the inode is already in cache, we can ignore it here
1876 * because the existing inode disposal code will deal with
1877 * it when all refs have gone away. Accessing gl_object like
1878 * this is not safe in general. Here it is ok because we do
1879 * not dereference the pointer, and we only need an approx
1880 * answer to whether it is NULL or not.
1881 */
1882 ip = gl->gl_object;
1883
Andreas Gruenbachera0e3cc62020-01-16 20:12:26 +01001884 if (ip || !gfs2_queue_delete_work(gl, 0))
Steven Whitehouse044b9412010-11-03 20:01:07 +00001885 gfs2_glock_put(gl);
1886 else
1887 found++;
1888
1889 /* Limit reclaim to sensible number of tasks */
Bob Peterson44ad37d2011-03-17 16:19:58 -04001890 if (found > NR_CPUS)
Steven Whitehouse044b9412010-11-03 20:01:07 +00001891 return;
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001892 }
1893
1894 rgd->rd_flags &= ~GFS2_RDF_CHECK;
Steven Whitehouse044b9412010-11-03 20:01:07 +00001895 return;
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001896}
1897
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001898/**
1899 * gfs2_rgrp_congested - Use stats to figure out whether an rgrp is congested
1900 * @rgd: The rgrp in question
1901 * @loops: An indication of how picky we can be (0=very, 1=less so)
1902 *
1903 * This function uses the recently added glock statistics in order to
1904 * figure out whether a parciular resource group is suffering from
1905 * contention from multiple nodes. This is done purely on the basis
1906 * of timings, since this is the only data we have to work with and
1907 * our aim here is to reject a resource group which is highly contended
1908 * but (very important) not to do this too often in order to ensure that
1909 * we do not land up introducing fragmentation by changing resource
1910 * groups when not actually required.
1911 *
1912 * The calculation is fairly simple, we want to know whether the SRTTB
1913 * (i.e. smoothed round trip time for blocking operations) to acquire
1914 * the lock for this rgrp's glock is significantly greater than the
1915 * time taken for resource groups on average. We introduce a margin in
1916 * the form of the variable @var which is computed as the sum of the two
1917 * respective variences, and multiplied by a factor depending on @loops
1918 * and whether we have a lot of data to base the decision on. This is
1919 * then tested against the square difference of the means in order to
1920 * decide whether the result is statistically significant or not.
1921 *
1922 * Returns: A boolean verdict on the congestion status
1923 */
1924
1925static bool gfs2_rgrp_congested(const struct gfs2_rgrpd *rgd, int loops)
1926{
1927 const struct gfs2_glock *gl = rgd->rd_gl;
Bob Peterson15562c42015-03-16 11:52:05 -05001928 const struct gfs2_sbd *sdp = gl->gl_name.ln_sbd;
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001929 struct gfs2_lkstats *st;
Ben Hutchings4d207132015-08-27 12:51:45 -05001930 u64 r_dcount, l_dcount;
1931 u64 l_srttb, a_srttb = 0;
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001932 s64 srttb_diff;
Ben Hutchings4d207132015-08-27 12:51:45 -05001933 u64 sqr_diff;
1934 u64 var;
Bob Peterson0166b192015-04-22 11:24:12 -05001935 int cpu, nonzero = 0;
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001936
1937 preempt_disable();
Bob Petersonf4a3ae92014-11-19 12:27:11 -06001938 for_each_present_cpu(cpu) {
1939 st = &per_cpu_ptr(sdp->sd_lkstats, cpu)->lkstats[LM_TYPE_RGRP];
Bob Peterson0166b192015-04-22 11:24:12 -05001940 if (st->stats[GFS2_LKS_SRTTB]) {
1941 a_srttb += st->stats[GFS2_LKS_SRTTB];
1942 nonzero++;
1943 }
Bob Petersonf4a3ae92014-11-19 12:27:11 -06001944 }
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001945 st = &this_cpu_ptr(sdp->sd_lkstats)->lkstats[LM_TYPE_RGRP];
Bob Peterson0166b192015-04-22 11:24:12 -05001946 if (nonzero)
1947 do_div(a_srttb, nonzero);
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001948 r_dcount = st->stats[GFS2_LKS_DCOUNT];
1949 var = st->stats[GFS2_LKS_SRTTVARB] +
1950 gl->gl_stats.stats[GFS2_LKS_SRTTVARB];
1951 preempt_enable();
1952
1953 l_srttb = gl->gl_stats.stats[GFS2_LKS_SRTTB];
1954 l_dcount = gl->gl_stats.stats[GFS2_LKS_DCOUNT];
1955
Bob Petersonf4a3ae92014-11-19 12:27:11 -06001956 if ((l_dcount < 1) || (r_dcount < 1) || (a_srttb == 0))
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001957 return false;
1958
Bob Petersonf4a3ae92014-11-19 12:27:11 -06001959 srttb_diff = a_srttb - l_srttb;
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001960 sqr_diff = srttb_diff * srttb_diff;
1961
1962 var *= 2;
1963 if (l_dcount < 8 || r_dcount < 8)
1964 var *= 2;
1965 if (loops == 1)
1966 var *= 2;
1967
1968 return ((srttb_diff < 0) && (sqr_diff > var));
1969}
1970
1971/**
1972 * gfs2_rgrp_used_recently
1973 * @rs: The block reservation with the rgrp to test
1974 * @msecs: The time limit in milliseconds
1975 *
1976 * Returns: True if the rgrp glock has been used within the time limit
1977 */
1978static bool gfs2_rgrp_used_recently(const struct gfs2_blkreserv *rs,
1979 u64 msecs)
1980{
1981 u64 tdiff;
1982
1983 tdiff = ktime_to_ns(ktime_sub(ktime_get_real(),
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02001984 rs->rs_rgd->rd_gl->gl_dstamp));
Steven Whitehousebcd97c02012-10-31 09:58:42 +00001985
1986 return tdiff > (msecs * 1000 * 1000);
1987}
1988
Steven Whitehouse9dbe9612012-10-31 10:37:10 +00001989static u32 gfs2_orlov_skip(const struct gfs2_inode *ip)
1990{
1991 const struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1992 u32 skip;
1993
1994 get_random_bytes(&skip, sizeof(skip));
1995 return skip % sdp->sd_rgrps;
1996}
1997
Steven Whitehousec743ffd2012-08-25 18:21:47 +01001998static bool gfs2_select_rgrp(struct gfs2_rgrpd **pos, const struct gfs2_rgrpd *begin)
1999{
2000 struct gfs2_rgrpd *rgd = *pos;
Steven Whitehouseaa8920c2012-11-13 14:50:35 +00002001 struct gfs2_sbd *sdp = rgd->rd_sbd;
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002002
2003 rgd = gfs2_rgrpd_get_next(rgd);
2004 if (rgd == NULL)
Steven Whitehouseaa8920c2012-11-13 14:50:35 +00002005 rgd = gfs2_rgrpd_get_first(sdp);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002006 *pos = rgd;
2007 if (rgd != begin) /* If we didn't wrap */
2008 return true;
2009 return false;
2010}
2011
Steven Whitehousec8cdf472007-06-08 10:05:33 +01002012/**
Bob Peterson0e27c182014-10-29 08:02:28 -05002013 * fast_to_acquire - determine if a resource group will be fast to acquire
Lee Jonesc551f662021-03-30 17:44:29 +01002014 * @rgd: The rgrp
Bob Peterson0e27c182014-10-29 08:02:28 -05002015 *
2016 * If this is one of our preferred rgrps, it should be quicker to acquire,
2017 * because we tried to set ourselves up as dlm lock master.
2018 */
2019static inline int fast_to_acquire(struct gfs2_rgrpd *rgd)
2020{
2021 struct gfs2_glock *gl = rgd->rd_gl;
2022
2023 if (gl->gl_state != LM_ST_UNLOCKED && list_empty(&gl->gl_holders) &&
2024 !test_bit(GLF_DEMOTE_IN_PROGRESS, &gl->gl_flags) &&
2025 !test_bit(GLF_DEMOTE, &gl->gl_flags))
2026 return 1;
2027 if (rgd->rd_flags & GFS2_RDF_PREFERRED)
2028 return 1;
2029 return 0;
2030}
2031
2032/**
Bob Peterson666d1d82012-06-13 23:03:56 -04002033 * gfs2_inplace_reserve - Reserve space in the filesystem
David Teiglandb3b94fa2006-01-16 16:50:04 +00002034 * @ip: the inode to reserve space for
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01002035 * @ap: the allocation parameters
David Teiglandb3b94fa2006-01-16 16:50:04 +00002036 *
Abhi Das25435e52015-03-18 12:04:37 -05002037 * We try our best to find an rgrp that has at least ap->target blocks
2038 * available. After a couple of passes (loops == 2), the prospects of finding
2039 * such an rgrp diminish. At this stage, we return the first rgrp that has
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002040 * at least ap->min_target blocks available.
Abhi Das25435e52015-03-18 12:04:37 -05002041 *
2042 * Returns: 0 on success,
2043 * -ENOMEM if a suitable rgrp can't be found
2044 * errno otherwise
David Teiglandb3b94fa2006-01-16 16:50:04 +00002045 */
2046
Abhi Das25435e52015-03-18 12:04:37 -05002047int gfs2_inplace_reserve(struct gfs2_inode *ip, struct gfs2_alloc_parms *ap)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002048{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002049 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Bob Peterson8e2e0042012-07-19 08:12:40 -04002050 struct gfs2_rgrpd *begin = NULL;
Bob Petersona097dc7e2015-07-16 08:28:04 -05002051 struct gfs2_blkreserv *rs = &ip->i_res;
Bob Peterson4fc7ec32018-04-24 10:35:02 -07002052 int error = 0, flags = LM_FLAG_NODE_SCOPE;
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002053 bool rg_locked;
Bob Peterson666d1d82012-06-13 23:03:56 -04002054 u64 last_unlinked = NO_BLOCK;
Andreas Gruenbacher42720062020-03-20 13:31:41 +01002055 u32 target = ap->target;
Bob Peterson7c9ca622011-08-31 09:53:19 +01002056 int loops = 0;
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002057 u32 free_blocks, blocks_available, skip = 0;
2058
2059 BUG_ON(rs->rs_reserved);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002060
Benjamin Marzinski90306c42012-05-29 23:01:09 -05002061 if (sdp->sd_args.ar_rgrplvb)
2062 flags |= GL_SKIP;
Andreas Gruenbacher42720062020-03-20 13:31:41 +01002063 if (gfs2_assert_warn(sdp, target))
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002064 return -EINVAL;
Bob Peterson8e2e0042012-07-19 08:12:40 -04002065 if (gfs2_rs_active(rs)) {
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002066 begin = rs->rs_rgd;
2067 } else if (rs->rs_rgd &&
2068 rgrp_contains_block(rs->rs_rgd, ip->i_goal)) {
2069 begin = rs->rs_rgd;
Bob Peterson8e2e0042012-07-19 08:12:40 -04002070 } else {
Abhi Das00a158b2014-09-18 21:40:28 -05002071 check_and_update_goal(ip);
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002072 rs->rs_rgd = begin = gfs2_blk2rgrpd(sdp, ip->i_goal, 1);
Bob Peterson8e2e0042012-07-19 08:12:40 -04002073 }
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01002074 if (S_ISDIR(ip->i_inode.i_mode) && (ap->aflags & GFS2_AF_ORLOV))
Steven Whitehouse9dbe9612012-10-31 10:37:10 +00002075 skip = gfs2_orlov_skip(ip);
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002076 if (rs->rs_rgd == NULL)
Bob Peterson7c9ca622011-08-31 09:53:19 +01002077 return -EBADSLT;
2078
2079 while (loops < 3) {
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002080 struct gfs2_rgrpd *rgd;
2081
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002082 rg_locked = gfs2_glock_is_locked_by_me(rs->rs_rgd->rd_gl);
2083 if (rg_locked) {
2084 rgrp_lock_local(rs->rs_rgd);
2085 } else {
Steven Whitehouse9dbe9612012-10-31 10:37:10 +00002086 if (skip && skip--)
2087 goto next_rgrp;
Bob Peterson0e27c182014-10-29 08:02:28 -05002088 if (!gfs2_rs_active(rs)) {
2089 if (loops == 0 &&
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002090 !fast_to_acquire(rs->rs_rgd))
Bob Peterson0e27c182014-10-29 08:02:28 -05002091 goto next_rgrp;
2092 if ((loops < 2) &&
2093 gfs2_rgrp_used_recently(rs, 1000) &&
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002094 gfs2_rgrp_congested(rs->rs_rgd, loops))
Bob Peterson0e27c182014-10-29 08:02:28 -05002095 goto next_rgrp;
2096 }
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002097 error = gfs2_glock_nq_init(rs->rs_rgd->rd_gl,
Bob Peterson8e2e0042012-07-19 08:12:40 -04002098 LM_ST_EXCLUSIVE, flags,
Andreas Gruenbacher21f09c42018-08-30 16:01:50 +01002099 &ip->i_rgd_gh);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002100 if (unlikely(error))
2101 return error;
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002102 rgrp_lock_local(rs->rs_rgd);
Steven Whitehousebcd97c02012-10-31 09:58:42 +00002103 if (!gfs2_rs_active(rs) && (loops < 2) &&
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002104 gfs2_rgrp_congested(rs->rs_rgd, loops))
Steven Whitehousebcd97c02012-10-31 09:58:42 +00002105 goto skip_rgrp;
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002106 if (sdp->sd_args.ar_rgrplvb) {
Bob Petersonf2e70d82021-10-06 09:29:18 -05002107 error = update_rgrp_lvb(rs->rs_rgd,
2108 &ip->i_rgd_gh);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002109 if (unlikely(error)) {
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002110 rgrp_unlock_local(rs->rs_rgd);
Andreas Gruenbacher21f09c42018-08-30 16:01:50 +01002111 gfs2_glock_dq_uninit(&ip->i_rgd_gh);
Benjamin Marzinski90306c42012-05-29 23:01:09 -05002112 return error;
2113 }
2114 }
Abhijith Das292c8c12007-11-29 14:13:54 -06002115 }
Bob Peterson666d1d82012-06-13 23:03:56 -04002116
Andreas Gruenbacher243fea42018-10-02 10:22:41 +01002117 /* Skip unusable resource groups */
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002118 if ((rs->rs_rgd->rd_flags & (GFS2_RGF_NOALLOC |
Bob Peterson5ea50502013-11-25 11:16:25 +00002119 GFS2_RDF_ERROR)) ||
Andreas Gruenbacher42720062020-03-20 13:31:41 +01002120 (loops == 0 && target > rs->rs_rgd->rd_extfail_pt))
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002121 goto skip_rgrp;
2122
Bob Petersonf2e70d82021-10-06 09:29:18 -05002123 if (sdp->sd_args.ar_rgrplvb) {
2124 error = gfs2_instantiate(&ip->i_rgd_gh);
2125 if (error)
2126 goto skip_rgrp;
2127 }
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002128
2129 /* Get a reservation if we don't already have one */
2130 if (!gfs2_rs_active(rs))
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002131 rg_mblk_search(rs->rs_rgd, ip, ap);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002132
2133 /* Skip rgrps when we can't get a reservation on first pass */
2134 if (!gfs2_rs_active(rs) && (loops < 1))
2135 goto check_rgrp;
2136
2137 /* If rgrp has enough free space, use it */
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002138 rgd = rs->rs_rgd;
2139 spin_lock(&rgd->rd_rsspin);
2140 free_blocks = rgd_free(rgd, rs);
2141 blocks_available = rgd->rd_free_clone - rgd->rd_reserved;
2142 if (free_blocks < target || blocks_available < target) {
2143 spin_unlock(&rgd->rd_rsspin);
2144 goto check_rgrp;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002145 }
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002146 rs->rs_reserved = ap->target;
2147 if (rs->rs_reserved > blocks_available)
2148 rs->rs_reserved = blocks_available;
2149 rgd->rd_reserved += rs->rs_reserved;
2150 spin_unlock(&rgd->rd_rsspin);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002151 rgrp_unlock_local(rs->rs_rgd);
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002152 return 0;
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002153check_rgrp:
2154 /* Check for unlinked inodes which can be reclaimed */
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002155 if (rs->rs_rgd->rd_flags & GFS2_RDF_CHECK)
2156 try_rgrp_unlink(rs->rs_rgd, &last_unlinked,
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002157 ip->i_no_addr);
2158skip_rgrp:
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002159 rgrp_unlock_local(rs->rs_rgd);
2160
Bob Peterson1330edb2013-11-06 10:58:00 -05002161 /* Drop reservation, if we couldn't use reserved rgrp */
2162 if (gfs2_rs_active(rs))
2163 gfs2_rs_deltree(rs);
2164
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002165 /* Unlock rgrp if required */
2166 if (!rg_locked)
Andreas Gruenbacher21f09c42018-08-30 16:01:50 +01002167 gfs2_glock_dq_uninit(&ip->i_rgd_gh);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002168next_rgrp:
2169 /* Find the next rgrp, and continue looking */
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002170 if (gfs2_select_rgrp(&rs->rs_rgd, begin))
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002171 continue;
Steven Whitehouse9dbe9612012-10-31 10:37:10 +00002172 if (skip)
2173 continue;
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002174
2175 /* If we've scanned all the rgrps, but found no free blocks
2176 * then this checks for some less likely conditions before
2177 * trying again.
2178 */
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002179 loops++;
2180 /* Check that fs hasn't grown if writing to rindex */
2181 if (ip == GFS2_I(sdp->sd_rindex) && !sdp->sd_rindex_uptodate) {
2182 error = gfs2_ri_update(ip);
2183 if (error)
2184 return error;
2185 }
2186 /* Flushing the log may release space */
Andreas Gruenbacher42720062020-03-20 13:31:41 +01002187 if (loops == 2) {
2188 if (ap->min_target)
2189 target = ap->min_target;
Bob Peterson805c09072018-01-08 10:34:17 -05002190 gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL |
2191 GFS2_LFC_INPLACE_RESERVE);
Andreas Gruenbacher42720062020-03-20 13:31:41 +01002192 }
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002193 }
2194
2195 return -ENOSPC;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002196}
2197
2198/**
2199 * gfs2_inplace_release - release an inplace reservation
2200 * @ip: the inode the reservation was taken out on
2201 *
2202 * Release a reservation made by gfs2_inplace_reserve().
2203 */
2204
2205void gfs2_inplace_release(struct gfs2_inode *ip)
2206{
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002207 struct gfs2_blkreserv *rs = &ip->i_res;
2208
2209 if (rs->rs_reserved) {
2210 struct gfs2_rgrpd *rgd = rs->rs_rgd;
2211
2212 spin_lock(&rgd->rd_rsspin);
Bob Petersonc98c2ca2021-09-14 08:16:58 -05002213 GLOCK_BUG_ON(rgd->rd_gl, rgd->rd_reserved < rs->rs_reserved);
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002214 rgd->rd_reserved -= rs->rs_reserved;
2215 spin_unlock(&rgd->rd_rsspin);
2216 rs->rs_reserved = 0;
2217 }
Andreas Gruenbacher21f09c42018-08-30 16:01:50 +01002218 if (gfs2_holder_initialized(&ip->i_rgd_gh))
2219 gfs2_glock_dq_uninit(&ip->i_rgd_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002220}
2221
2222/**
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002223 * gfs2_alloc_extent - allocate an extent from a given bitmap
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002224 * @rbm: the resource group information
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002225 * @dinode: TRUE if the first block we allocate is for a dinode
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002226 * @n: The extent length (value/result)
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002227 *
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002228 * Add the bitmap buffer to the transaction.
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002229 * Set the found bits to @new_state to change block's allocation state.
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002230 */
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002231static void gfs2_alloc_extent(const struct gfs2_rbm *rbm, bool dinode,
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002232 unsigned int *n)
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002233{
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002234 struct gfs2_rbm pos = { .rgd = rbm->rgd, };
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002235 const unsigned int elen = *n;
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002236 u64 block;
2237 int ret;
Bob Petersonb3e47ca2011-11-21 11:47:08 -05002238
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002239 *n = 1;
2240 block = gfs2_rbm_to_block(rbm);
Bob Petersone579ed42013-09-17 13:12:15 -04002241 gfs2_trans_add_meta(rbm->rgd->rd_gl, rbm_bi(rbm)->bi_bh);
Steven Whitehouse3e6339d2012-08-13 11:37:51 +01002242 gfs2_setbit(rbm, true, dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002243 block++;
Steven Whitehouse60a0b8f2009-05-21 12:23:12 +01002244 while (*n < elen) {
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002245 ret = gfs2_rbm_from_block(&pos, block);
Bob Petersondffe12a2018-08-07 10:07:00 -05002246 if (ret || gfs2_testbit(&pos, true) != GFS2_BLKST_FREE)
Steven Whitehouse60a0b8f2009-05-21 12:23:12 +01002247 break;
Bob Petersone579ed42013-09-17 13:12:15 -04002248 gfs2_trans_add_meta(pos.rgd->rd_gl, rbm_bi(&pos)->bi_bh);
Steven Whitehouse3e6339d2012-08-13 11:37:51 +01002249 gfs2_setbit(&pos, true, GFS2_BLKST_USED);
Steven Whitehouse60a0b8f2009-05-21 12:23:12 +01002250 (*n)++;
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002251 block++;
Steven Whitehouse60a0b8f2009-05-21 12:23:12 +01002252 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00002253}
2254
2255/**
2256 * rgblk_free - Change alloc state of given block(s)
2257 * @sdp: the filesystem
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002258 * @rgd: the resource group the blocks are in
David Teiglandb3b94fa2006-01-16 16:50:04 +00002259 * @bstart: the start of a run of blocks to free
2260 * @blen: the length of the block run (all must lie within ONE RG!)
2261 * @new_state: GFS2_BLKST_XXX the after-allocation block state
David Teiglandb3b94fa2006-01-16 16:50:04 +00002262 */
2263
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002264static void rgblk_free(struct gfs2_sbd *sdp, struct gfs2_rgrpd *rgd,
2265 u64 bstart, u32 blen, unsigned char new_state)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002266{
Steven Whitehouse3b1d0b92012-08-03 11:23:28 +01002267 struct gfs2_rbm rbm;
Bob Petersond24e0562014-10-03 08:38:06 -04002268 struct gfs2_bitmap *bi, *bi_prev = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002269
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002270 rbm.rgd = rgd;
Andreas Gruenbacherf6546832018-09-10 17:31:47 +01002271 if (WARN_ON_ONCE(gfs2_rbm_from_block(&rbm, bstart)))
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002272 return;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002273 while (blen--) {
Bob Petersone579ed42013-09-17 13:12:15 -04002274 bi = rbm_bi(&rbm);
Bob Petersond24e0562014-10-03 08:38:06 -04002275 if (bi != bi_prev) {
2276 if (!bi->bi_clone) {
2277 bi->bi_clone = kmalloc(bi->bi_bh->b_size,
2278 GFP_NOFS | __GFP_NOFAIL);
2279 memcpy(bi->bi_clone + bi->bi_offset,
2280 bi->bi_bh->b_data + bi->bi_offset,
Andreas Gruenbacher281b4952018-09-26 23:32:46 +01002281 bi->bi_bytes);
Bob Petersond24e0562014-10-03 08:38:06 -04002282 }
2283 gfs2_trans_add_meta(rbm.rgd->rd_gl, bi->bi_bh);
2284 bi_prev = bi;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002285 }
Steven Whitehouse3e6339d2012-08-13 11:37:51 +01002286 gfs2_setbit(&rbm, false, new_state);
Andreas Gruenbacher0eacdd162020-10-08 00:48:22 +02002287 gfs2_rbm_add(&rbm, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002288 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00002289}
2290
2291/**
Steven Whitehouse09010972009-05-20 10:48:47 +01002292 * gfs2_rgrp_dump - print out an rgrp
2293 * @seq: The iterator
Andrew Price0e539ca2020-10-07 12:30:58 +01002294 * @rgd: The rgrp in question
Bob Peterson3792ce92019-05-09 09:21:48 -05002295 * @fs_id_buf: pointer to file system id (if requested)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002296 *
David Teiglandb3b94fa2006-01-16 16:50:04 +00002297 */
2298
Andrew Price0e539ca2020-10-07 12:30:58 +01002299void gfs2_rgrp_dump(struct seq_file *seq, struct gfs2_rgrpd *rgd,
Bob Peterson3792ce92019-05-09 09:21:48 -05002300 const char *fs_id_buf)
Steven Whitehouse09010972009-05-20 10:48:47 +01002301{
Bob Peterson8e2e0042012-07-19 08:12:40 -04002302 struct gfs2_blkreserv *trs;
2303 const struct rb_node *n;
2304
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002305 spin_lock(&rgd->rd_rsspin);
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002306 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 -05002307 fs_id_buf,
Steven Whitehouse09010972009-05-20 10:48:47 +01002308 (unsigned long long)rgd->rd_addr, rgd->rd_flags,
Bob Peterson8e2e0042012-07-19 08:12:40 -04002309 rgd->rd_free, rgd->rd_free_clone, rgd->rd_dinodes,
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002310 rgd->rd_requested, rgd->rd_reserved, rgd->rd_extfail_pt);
Bob Peterson72244b62018-08-15 12:09:49 -05002311 if (rgd->rd_sbd->sd_args.ar_rgrplvb) {
2312 struct gfs2_rgrp_lvb *rgl = rgd->rd_rgl;
2313
Bob Peterson3792ce92019-05-09 09:21:48 -05002314 gfs2_print_dbg(seq, "%s L: f:%02x b:%u i:%u\n", fs_id_buf,
Bob Peterson72244b62018-08-15 12:09:49 -05002315 be32_to_cpu(rgl->rl_flags),
2316 be32_to_cpu(rgl->rl_free),
2317 be32_to_cpu(rgl->rl_dinodes));
2318 }
Bob Peterson8e2e0042012-07-19 08:12:40 -04002319 for (n = rb_first(&rgd->rd_rstree); n; n = rb_next(&trs->rs_node)) {
2320 trs = rb_entry(n, struct gfs2_blkreserv, rs_node);
Bob Peterson3792ce92019-05-09 09:21:48 -05002321 dump_rs(seq, trs, fs_id_buf);
Bob Peterson8e2e0042012-07-19 08:12:40 -04002322 }
2323 spin_unlock(&rgd->rd_rsspin);
Steven Whitehouse09010972009-05-20 10:48:47 +01002324}
2325
Steven Whitehouse6050b9c2009-07-31 16:19:40 +01002326static void gfs2_rgrp_error(struct gfs2_rgrpd *rgd)
2327{
2328 struct gfs2_sbd *sdp = rgd->rd_sbd;
Bob Peterson98fb0572019-08-13 09:25:15 -04002329 char fs_id_buf[sizeof(sdp->sd_fsname) + 7];
Bob Peterson3792ce92019-05-09 09:21:48 -05002330
Steven Whitehouse6050b9c2009-07-31 16:19:40 +01002331 fs_warn(sdp, "rgrp %llu has an error, marking it readonly until umount\n",
Steven Whitehouse86d00632009-09-14 09:50:57 +01002332 (unsigned long long)rgd->rd_addr);
Steven Whitehouse6050b9c2009-07-31 16:19:40 +01002333 fs_warn(sdp, "umount on all nodes and run fsck.gfs2 to fix the error\n");
Bob Peterson3792ce92019-05-09 09:21:48 -05002334 sprintf(fs_id_buf, "fsid=%s: ", sdp->sd_fsname);
Andrew Price0e539ca2020-10-07 12:30:58 +01002335 gfs2_rgrp_dump(NULL, rgd, fs_id_buf);
Steven Whitehouse6050b9c2009-07-31 16:19:40 +01002336 rgd->rd_flags |= GFS2_RDF_ERROR;
2337}
2338
Steven Whitehouse09010972009-05-20 10:48:47 +01002339/**
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002340 * gfs2_adjust_reservation - Adjust (or remove) a reservation after allocation
2341 * @ip: The inode we have just allocated blocks for
2342 * @rbm: The start of the allocated blocks
2343 * @len: The extent length
Bob Peterson8e2e0042012-07-19 08:12:40 -04002344 *
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002345 * Adjusts a reservation after an allocation has taken place. If the
2346 * reservation does not match the allocation, or if it is now empty
2347 * then it is removed.
Bob Peterson8e2e0042012-07-19 08:12:40 -04002348 */
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002349
2350static void gfs2_adjust_reservation(struct gfs2_inode *ip,
2351 const struct gfs2_rbm *rbm, unsigned len)
Bob Peterson8e2e0042012-07-19 08:12:40 -04002352{
Bob Petersona097dc7e2015-07-16 08:28:04 -05002353 struct gfs2_blkreserv *rs = &ip->i_res;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002354 struct gfs2_rgrpd *rgd = rbm->rgd;
Bob Peterson8e2e0042012-07-19 08:12:40 -04002355
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002356 BUG_ON(rs->rs_reserved < len);
2357 rs->rs_reserved -= len;
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002358 if (gfs2_rs_active(rs)) {
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002359 u64 start = gfs2_rbm_to_block(rbm);
2360
2361 if (rs->rs_start == start) {
2362 unsigned int rlen;
2363
2364 rs->rs_start += len;
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02002365 rlen = min(rs->rs_requested, len);
2366 rs->rs_requested -= rlen;
2367 rgd->rd_requested -= rlen;
Steven Whitehouse9e733d32012-08-23 15:37:59 +01002368 trace_gfs2_rs(rs, TRACE_RS_CLAIM);
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002369 if (rs->rs_start < rgd->rd_data0 + rgd->rd_data &&
Andreas Gruenbacher07974d22020-10-22 20:34:29 +02002370 rs->rs_requested)
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002371 return;
Bob Peterson1a855032014-10-29 08:02:30 -05002372 /* We used up our block reservation, so we should
2373 reserve more blocks next time. */
Andreas Gruenbacher21f09c42018-08-30 16:01:50 +01002374 atomic_add(RGRP_RSRV_ADDBLKS, &ip->i_sizehint);
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002375 }
Bob Peterson20095212013-03-13 10:26:38 -04002376 __rs_deltree(rs);
Bob Peterson8e2e0042012-07-19 08:12:40 -04002377 }
Bob Peterson8e2e0042012-07-19 08:12:40 -04002378}
2379
2380/**
Steven Whitehouse9e07f2c2013-10-02 14:42:45 +01002381 * gfs2_set_alloc_start - Set starting point for block allocation
2382 * @rbm: The rbm which will be set to the required location
2383 * @ip: The gfs2 inode
2384 * @dinode: Flag to say if allocation includes a new inode
2385 *
2386 * This sets the starting point from the reservation if one is active
2387 * otherwise it falls back to guessing a start point based on the
2388 * inode's goal block or the last allocation point in the rgrp.
2389 */
2390
2391static void gfs2_set_alloc_start(struct gfs2_rbm *rbm,
2392 const struct gfs2_inode *ip, bool dinode)
2393{
2394 u64 goal;
2395
Bob Petersona097dc7e2015-07-16 08:28:04 -05002396 if (gfs2_rs_active(&ip->i_res)) {
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002397 goal = ip->i_res.rs_start;
2398 } else {
2399 if (!dinode && rgrp_contains_block(rbm->rgd, ip->i_goal))
2400 goal = ip->i_goal;
2401 else
2402 goal = rbm->rgd->rd_last_alloc + rbm->rgd->rd_data0;
Steven Whitehouse9e07f2c2013-10-02 14:42:45 +01002403 }
Andreas Gruenbacherf6546832018-09-10 17:31:47 +01002404 if (WARN_ON_ONCE(gfs2_rbm_from_block(rbm, goal))) {
2405 rbm->bii = 0;
2406 rbm->offset = 0;
2407 }
Steven Whitehouse9e07f2c2013-10-02 14:42:45 +01002408}
2409
2410/**
Bob Peterson6e87ed02011-11-18 10:58:32 -05002411 * gfs2_alloc_blocks - Allocate one or more blocks of data and/or a dinode
Steven Whitehouse09010972009-05-20 10:48:47 +01002412 * @ip: the inode to allocate the block for
2413 * @bn: Used to return the starting block number
Bob Peterson8e2e0042012-07-19 08:12:40 -04002414 * @nblocks: requested number of blocks/extent length (value/result)
Bob Peterson6e87ed02011-11-18 10:58:32 -05002415 * @dinode: 1 if we're allocating a dinode block, else 0
Bob Peterson3c5d7852011-11-14 11:17:08 -05002416 * @generation: the generation number of the inode
Steven Whitehouse09010972009-05-20 10:48:47 +01002417 *
2418 * Returns: 0 or error
2419 */
2420
Steven Whitehouse6a8099e2011-11-22 12:18:51 +00002421int gfs2_alloc_blocks(struct gfs2_inode *ip, u64 *bn, unsigned int *nblocks,
Bob Peterson6e87ed02011-11-18 10:58:32 -05002422 bool dinode, u64 *generation)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002423{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002424 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Steven Whitehoused9ba7612009-04-23 08:59:41 +01002425 struct buffer_head *dibh;
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002426 struct gfs2_rbm rbm = { .rgd = ip->i_res.rs_rgd, };
Bob Peterson3c5d7852011-11-14 11:17:08 -05002427 u64 block; /* block, within the file system scope */
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02002428 u32 minext = 1;
Andreas Gruenbacherb2598962020-10-12 17:23:50 +02002429 int error = -ENOSPC;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002430
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002431 BUG_ON(ip->i_res.rs_reserved < *nblocks);
2432
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002433 rgrp_lock_local(rbm.rgd);
Andreas Gruenbacherb2598962020-10-12 17:23:50 +02002434 if (gfs2_rs_active(&ip->i_res)) {
2435 gfs2_set_alloc_start(&rbm, ip, dinode);
2436 error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &minext, &ip->i_res, false);
2437 }
Steven Whitehouse137834a2012-08-23 13:43:40 +01002438 if (error == -ENOSPC) {
Steven Whitehouse9e07f2c2013-10-02 14:42:45 +01002439 gfs2_set_alloc_start(&rbm, ip, dinode);
Andreas Gruenbacherf38e9982020-10-05 19:39:18 +02002440 error = gfs2_rbm_find(&rbm, GFS2_BLKST_FREE, &minext, NULL, false);
Steven Whitehouse137834a2012-08-23 13:43:40 +01002441 }
2442
Steven Whitehouse62e252e2012-07-30 11:06:08 +01002443 /* Since all blocks are reserved in advance, this shouldn't happen */
Steven Whitehouse5b924ae2012-08-01 20:35:05 +01002444 if (error) {
Bob Peterson5ea50502013-11-25 11:16:25 +00002445 fs_warn(sdp, "inum=%llu error=%d, nblocks=%u, full=%d fail_pt=%d\n",
Steven Whitehouse9e733d32012-08-23 15:37:59 +01002446 (unsigned long long)ip->i_no_addr, error, *nblocks,
Bob Peterson5ea50502013-11-25 11:16:25 +00002447 test_bit(GBF_FULL, &rbm.rgd->rd_bits->bi_flags),
2448 rbm.rgd->rd_extfail_pt);
Steven Whitehouse62e252e2012-07-30 11:06:08 +01002449 goto rgrp_error;
2450 }
2451
Steven Whitehousec04a2ef2012-08-13 11:14:57 +01002452 gfs2_alloc_extent(&rbm, dinode, nblocks);
2453 block = gfs2_rbm_to_block(&rbm);
Steven Whitehousec743ffd2012-08-25 18:21:47 +01002454 rbm.rgd->rd_last_alloc = block - rbm.rgd->rd_data0;
Bob Peterson3c5d7852011-11-14 11:17:08 -05002455 if (!dinode) {
Andreas Gruenbacher3ed08be2020-03-16 15:36:09 +01002456 ip->i_goal = block + *nblocks - 1;
Bob Peterson3c5d7852011-11-14 11:17:08 -05002457 error = gfs2_meta_inode_buffer(ip, &dibh);
2458 if (error == 0) {
2459 struct gfs2_dinode *di =
2460 (struct gfs2_dinode *)dibh->b_data;
Steven Whitehouse350a9b02012-12-14 12:36:02 +00002461 gfs2_trans_add_meta(ip->i_gl, dibh);
Bob Peterson3c5d7852011-11-14 11:17:08 -05002462 di->di_goal_meta = di->di_goal_data =
2463 cpu_to_be64(ip->i_goal);
2464 brelse(dibh);
2465 }
Steven Whitehoused9ba7612009-04-23 08:59:41 +01002466 }
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002467 spin_lock(&rbm.rgd->rd_rsspin);
2468 gfs2_adjust_reservation(ip, &rbm, *nblocks);
2469 if (rbm.rgd->rd_free < *nblocks || rbm.rgd->rd_reserved < *nblocks) {
Bob Petersone54c78a2018-10-03 08:47:36 -05002470 fs_warn(sdp, "nblocks=%u\n", *nblocks);
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002471 spin_unlock(&rbm.rgd->rd_rsspin);
Steven Whitehouse09010972009-05-20 10:48:47 +01002472 goto rgrp_error;
Bob Peterson8e2e0042012-07-19 08:12:40 -04002473 }
Bob Petersonc98c2ca2021-09-14 08:16:58 -05002474 GLOCK_BUG_ON(rbm.rgd->rd_gl, rbm.rgd->rd_reserved < *nblocks);
2475 GLOCK_BUG_ON(rbm.rgd->rd_gl, rbm.rgd->rd_free_clone < *nblocks);
2476 GLOCK_BUG_ON(rbm.rgd->rd_gl, rbm.rgd->rd_free < *nblocks);
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002477 rbm.rgd->rd_reserved -= *nblocks;
2478 rbm.rgd->rd_free_clone -= *nblocks;
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002479 rbm.rgd->rd_free -= *nblocks;
Andreas Gruenbacher725d0e92018-10-02 14:59:54 +01002480 spin_unlock(&rbm.rgd->rd_rsspin);
Bob Peterson3c5d7852011-11-14 11:17:08 -05002481 if (dinode) {
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002482 rbm.rgd->rd_dinodes++;
2483 *generation = rbm.rgd->rd_igeneration++;
Bob Peterson3c5d7852011-11-14 11:17:08 -05002484 if (*generation == 0)
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002485 *generation = rbm.rgd->rd_igeneration++;
Bob Peterson3c5d7852011-11-14 11:17:08 -05002486 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00002487
Steven Whitehouse350a9b02012-12-14 12:36:02 +00002488 gfs2_trans_add_meta(rbm.rgd->rd_gl, rbm.rgd->rd_bits[0].bi_bh);
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002489 gfs2_rgrp_out(rbm.rgd, rbm.rgd->rd_bits[0].bi_bh->b_data);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002490 rgrp_unlock_local(rbm.rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002491
Steven Whitehouse6a8099e2011-11-22 12:18:51 +00002492 gfs2_statfs_change(sdp, 0, -(s64)*nblocks, dinode ? 1 : 0);
Bob Peterson3c5d7852011-11-14 11:17:08 -05002493 if (dinode)
Andreas Gruenbacherfbb27872019-04-05 12:18:23 +01002494 gfs2_trans_remove_revoke(sdp, block, *nblocks);
Steven Whitehouse6a8099e2011-11-22 12:18:51 +00002495
Steven Whitehousefd4b4e02013-02-26 16:15:20 +00002496 gfs2_quota_change(ip, *nblocks, ip->i_inode.i_uid, ip->i_inode.i_gid);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002497
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002498 trace_gfs2_block_alloc(ip, rbm.rgd, block, *nblocks,
Bob Peterson6e87ed02011-11-18 10:58:32 -05002499 dinode ? GFS2_BLKST_DINODE : GFS2_BLKST_USED);
Steven Whitehouse6050b9c2009-07-31 16:19:40 +01002500 *bn = block;
2501 return 0;
2502
2503rgrp_error:
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002504 rgrp_unlock_local(rbm.rgd);
Steven Whitehouse4a993fb2012-07-31 15:21:20 +01002505 gfs2_rgrp_error(rbm.rgd);
Steven Whitehouse6050b9c2009-07-31 16:19:40 +01002506 return -EIO;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002507}
2508
2509/**
Eric Sandeen46fcb2ed2011-06-23 10:39:34 -05002510 * __gfs2_free_blocks - free a contiguous run of block(s)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002511 * @ip: the inode these blocks are being freed from
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002512 * @rgd: the resource group the blocks are in
David Teiglandb3b94fa2006-01-16 16:50:04 +00002513 * @bstart: first block of a run of contiguous blocks
2514 * @blen: the length of the block run
Eric Sandeen46fcb2ed2011-06-23 10:39:34 -05002515 * @meta: 1 if the blocks represent metadata
David Teiglandb3b94fa2006-01-16 16:50:04 +00002516 *
2517 */
2518
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002519void __gfs2_free_blocks(struct gfs2_inode *ip, struct gfs2_rgrpd *rgd,
2520 u64 bstart, u32 blen, int meta)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002521{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002522 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002523
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002524 rgrp_lock_local(rgd);
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002525 rgblk_free(sdp, rgd, bstart, blen, GFS2_BLKST_FREE);
Bob Peterson41db1ab2012-05-09 12:11:35 -04002526 trace_gfs2_block_alloc(ip, rgd, bstart, blen, GFS2_BLKST_FREE);
Steven Whitehousecfc8b542008-11-04 10:25:13 +00002527 rgd->rd_free += blen;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00002528 rgd->rd_flags &= ~GFS2_RGF_TRIMMED;
Steven Whitehouse350a9b02012-12-14 12:36:02 +00002529 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
Bob Peterson42d52e32008-01-28 18:38:07 -06002530 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002531 rgrp_unlock_local(rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002532
Steven Whitehouse6d3117b2011-05-21 14:05:58 +01002533 /* Directories keep their data in the metadata address space */
Bob Peterson68942872020-07-22 10:27:50 -05002534 if (meta || ip->i_depth || gfs2_is_jdata(ip))
2535 gfs2_journal_wipe(ip, bstart, blen);
Bob Peterson4c16c362011-02-23 16:11:33 -05002536}
David Teiglandb3b94fa2006-01-16 16:50:04 +00002537
Bob Peterson4c16c362011-02-23 16:11:33 -05002538/**
Bob Peterson4c16c362011-02-23 16:11:33 -05002539 * gfs2_free_meta - free a contiguous run of data block(s)
2540 * @ip: the inode these blocks are being freed from
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002541 * @rgd: the resource group the blocks are in
Bob Peterson4c16c362011-02-23 16:11:33 -05002542 * @bstart: first block of a run of contiguous blocks
2543 * @blen: the length of the block run
2544 *
2545 */
2546
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002547void gfs2_free_meta(struct gfs2_inode *ip, struct gfs2_rgrpd *rgd,
2548 u64 bstart, u32 blen)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002549{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002550 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002551
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002552 __gfs2_free_blocks(ip, rgd, bstart, blen, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002553 gfs2_statfs_change(sdp, 0, +blen, 0);
Steven Whitehouse2933f922006-11-01 13:23:29 -05002554 gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002555}
2556
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002557void gfs2_unlink_di(struct inode *inode)
2558{
2559 struct gfs2_inode *ip = GFS2_I(inode);
2560 struct gfs2_sbd *sdp = GFS2_SB(inode);
2561 struct gfs2_rgrpd *rgd;
Steven Whitehousedbb7cae2007-05-15 15:37:50 +01002562 u64 blkno = ip->i_no_addr;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002563
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002564 rgd = gfs2_blk2rgrpd(sdp, blkno, true);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002565 if (!rgd)
2566 return;
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002567 rgrp_lock_local(rgd);
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002568 rgblk_free(sdp, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
Bob Peterson41db1ab2012-05-09 12:11:35 -04002569 trace_gfs2_block_alloc(ip, rgd, blkno, 1, GFS2_BLKST_UNLINKED);
Steven Whitehouse350a9b02012-12-14 12:36:02 +00002570 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
Bob Peterson42d52e32008-01-28 18:38:07 -06002571 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
Bob Petersonf5580d02018-08-08 09:53:30 -05002572 be32_add_cpu(&rgd->rd_rgl->rl_unlinked, 1);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002573 rgrp_unlock_local(rgd);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04002574}
2575
Bob Petersona18c78c2017-11-22 09:24:14 -06002576void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002577{
2578 struct gfs2_sbd *sdp = rgd->rd_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002579
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002580 rgrp_lock_local(rgd);
Andreas Gruenbacher0ddeded2018-10-04 15:36:02 +01002581 rgblk_free(sdp, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
Steven Whitehouse73f74942008-11-04 10:32:57 +00002582 if (!rgd->rd_dinodes)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002583 gfs2_consist_rgrpd(rgd);
Steven Whitehouse73f74942008-11-04 10:32:57 +00002584 rgd->rd_dinodes--;
Steven Whitehousecfc8b542008-11-04 10:25:13 +00002585 rgd->rd_free++;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002586
Steven Whitehouse350a9b02012-12-14 12:36:02 +00002587 gfs2_trans_add_meta(rgd->rd_gl, rgd->rd_bits[0].bi_bh);
Bob Peterson42d52e32008-01-28 18:38:07 -06002588 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002589 rgrp_unlock_local(rgd);
Bob Petersonf5580d02018-08-08 09:53:30 -05002590 be32_add_cpu(&rgd->rd_rgl->rl_unlinked, -1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002591
2592 gfs2_statfs_change(sdp, 0, +1, -1);
Bob Peterson41db1ab2012-05-09 12:11:35 -04002593 trace_gfs2_block_alloc(ip, rgd, ip->i_no_addr, 1, GFS2_BLKST_FREE);
Steven Whitehouse2933f922006-11-01 13:23:29 -05002594 gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
Bob Peterson68942872020-07-22 10:27:50 -05002595 gfs2_journal_wipe(ip, ip->i_no_addr, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002596}
2597
2598/**
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002599 * gfs2_check_blk_type - Check the type of a block
2600 * @sdp: The superblock
2601 * @no_addr: The block number to check
2602 * @type: The block type we are looking for
2603 *
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002604 * The inode glock of @no_addr must be held. The @type to check for is either
2605 * GFS2_BLKST_DINODE or GFS2_BLKST_UNLINKED; checking for type GFS2_BLKST_FREE
2606 * or GFS2_BLKST_USED would make no sense.
2607 *
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002608 * Returns: 0 if the block type matches the expected type
2609 * -ESTALE if it doesn't match
2610 * or -ve errno if something went wrong while checking
2611 */
2612
2613int gfs2_check_blk_type(struct gfs2_sbd *sdp, u64 no_addr, unsigned int type)
2614{
2615 struct gfs2_rgrpd *rgd;
Steven Whitehouse8339ee52011-08-31 16:38:29 +01002616 struct gfs2_holder rgd_gh;
Bob Petersondffe12a2018-08-07 10:07:00 -05002617 struct gfs2_rbm rbm;
Bob Peterson58884c42012-03-05 10:19:35 -05002618 int error = -EINVAL;
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002619
Steven Whitehouse66fc0612012-02-08 12:58:32 +00002620 rgd = gfs2_blk2rgrpd(sdp, no_addr, 1);
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002621 if (!rgd)
Steven Whitehouse8339ee52011-08-31 16:38:29 +01002622 goto fail;
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002623
2624 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_SHARED, 0, &rgd_gh);
2625 if (error)
Steven Whitehouse8339ee52011-08-31 16:38:29 +01002626 goto fail;
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002627
Bob Petersondffe12a2018-08-07 10:07:00 -05002628 rbm.rgd = rgd;
2629 error = gfs2_rbm_from_block(&rbm, no_addr);
Zhang Qilongbc923812020-11-08 17:27:41 +08002630 if (!WARN_ON_ONCE(error)) {
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002631 /*
2632 * No need to take the local resource group lock here; the
2633 * inode glock of @no_addr provides the necessary
2634 * synchronization in case the block is an inode. (In case
2635 * the block is not an inode, the block type will not match
2636 * the @type we are looking for.)
2637 */
Zhang Qilongbc923812020-11-08 17:27:41 +08002638 if (gfs2_testbit(&rbm, false) != type)
2639 error = -ESTALE;
2640 }
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002641
2642 gfs2_glock_dq_uninit(&rgd_gh);
Zhang Qilongbc923812020-11-08 17:27:41 +08002643
Steven Whitehouseacf7e242009-09-08 18:00:30 +01002644fail:
2645 return error;
2646}
2647
2648/**
David Teiglandb3b94fa2006-01-16 16:50:04 +00002649 * gfs2_rlist_add - add a RG to a list of RGs
Steven Whitehouse70b0c362011-09-02 16:08:09 +01002650 * @ip: the inode
David Teiglandb3b94fa2006-01-16 16:50:04 +00002651 * @rlist: the list of resource groups
2652 * @block: the block
2653 *
2654 * Figure out what RG a block belongs to and add that RG to the list
2655 *
2656 * FIXME: Don't use NOFAIL
2657 *
2658 */
2659
Steven Whitehouse70b0c362011-09-02 16:08:09 +01002660void gfs2_rlist_add(struct gfs2_inode *ip, struct gfs2_rgrp_list *rlist,
Steven Whitehousecd915492006-09-04 12:49:07 -04002661 u64 block)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002662{
Steven Whitehouse70b0c362011-09-02 16:08:09 +01002663 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002664 struct gfs2_rgrpd *rgd;
2665 struct gfs2_rgrpd **tmp;
2666 unsigned int new_space;
2667 unsigned int x;
2668
2669 if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
2670 return;
2671
Andreas Gruenbacher03f8c412018-06-21 07:22:12 -05002672 /*
2673 * The resource group last accessed is kept in the last position.
2674 */
2675
2676 if (rlist->rl_rgrps) {
2677 rgd = rlist->rl_rgd[rlist->rl_rgrps - 1];
2678 if (rgrp_contains_block(rgd, block))
2679 return;
Steven Whitehouse66fc0612012-02-08 12:58:32 +00002680 rgd = gfs2_blk2rgrpd(sdp, block, 1);
Andreas Gruenbacher03f8c412018-06-21 07:22:12 -05002681 } else {
Andreas Gruenbacherc65b76b2018-10-11 18:56:40 +02002682 rgd = ip->i_res.rs_rgd;
Andreas Gruenbacher03f8c412018-06-21 07:22:12 -05002683 if (!rgd || !rgrp_contains_block(rgd, block))
2684 rgd = gfs2_blk2rgrpd(sdp, block, 1);
2685 }
2686
David Teiglandb3b94fa2006-01-16 16:50:04 +00002687 if (!rgd) {
Andreas Gruenbacher03f8c412018-06-21 07:22:12 -05002688 fs_err(sdp, "rlist_add: no rgrp for block %llu\n",
2689 (unsigned long long)block);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002690 return;
2691 }
2692
Andreas Gruenbacher03f8c412018-06-21 07:22:12 -05002693 for (x = 0; x < rlist->rl_rgrps; x++) {
2694 if (rlist->rl_rgd[x] == rgd) {
2695 swap(rlist->rl_rgd[x],
2696 rlist->rl_rgd[rlist->rl_rgrps - 1]);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002697 return;
Andreas Gruenbacher03f8c412018-06-21 07:22:12 -05002698 }
2699 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00002700
2701 if (rlist->rl_rgrps == rlist->rl_space) {
2702 new_space = rlist->rl_space + 10;
2703
2704 tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
Steven Whitehousedd894be2006-07-27 14:29:00 -04002705 GFP_NOFS | __GFP_NOFAIL);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002706
2707 if (rlist->rl_rgd) {
2708 memcpy(tmp, rlist->rl_rgd,
2709 rlist->rl_space * sizeof(struct gfs2_rgrpd *));
2710 kfree(rlist->rl_rgd);
2711 }
2712
2713 rlist->rl_space = new_space;
2714 rlist->rl_rgd = tmp;
2715 }
2716
2717 rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
2718}
2719
2720/**
2721 * gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate
2722 * and initialize an array of glock holders for them
2723 * @rlist: the list of resource groups
David Teiglandb3b94fa2006-01-16 16:50:04 +00002724 *
2725 * FIXME: Don't use NOFAIL
2726 *
2727 */
2728
Bob Petersonc3abc292018-10-04 00:06:23 +01002729void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist)
David Teiglandb3b94fa2006-01-16 16:50:04 +00002730{
2731 unsigned int x;
2732
Kees Cook6da2ec52018-06-12 13:55:00 -07002733 rlist->rl_ghs = kmalloc_array(rlist->rl_rgrps,
2734 sizeof(struct gfs2_holder),
2735 GFP_NOFS | __GFP_NOFAIL);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002736 for (x = 0; x < rlist->rl_rgrps; x++)
Bob Peterson4fc7ec32018-04-24 10:35:02 -07002737 gfs2_holder_init(rlist->rl_rgd[x]->rd_gl, LM_ST_EXCLUSIVE,
2738 LM_FLAG_NODE_SCOPE, &rlist->rl_ghs[x]);
David Teiglandb3b94fa2006-01-16 16:50:04 +00002739}
2740
2741/**
2742 * gfs2_rlist_free - free a resource group list
Fabian Frederick27ff6a02014-07-02 22:05:27 +02002743 * @rlist: the list of resource groups
David Teiglandb3b94fa2006-01-16 16:50:04 +00002744 *
2745 */
2746
2747void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
2748{
2749 unsigned int x;
2750
2751 kfree(rlist->rl_rgd);
2752
2753 if (rlist->rl_ghs) {
2754 for (x = 0; x < rlist->rl_rgrps; x++)
2755 gfs2_holder_uninit(&rlist->rl_ghs[x]);
2756 kfree(rlist->rl_ghs);
Bob Peterson8e2e0042012-07-19 08:12:40 -04002757 rlist->rl_ghs = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +00002758 }
2759}
2760
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002761void rgrp_lock_local(struct gfs2_rgrpd *rgd)
2762{
Andreas Gruenbacher9e5146052021-02-08 20:44:26 +01002763 mutex_lock(&rgd->rd_mutex);
2764}
2765
2766void rgrp_unlock_local(struct gfs2_rgrpd *rgd)
2767{
2768 mutex_unlock(&rgd->rd_mutex);
2769}