blob: 3401628d742b6cbfd5b53c9a4ed11f42d3372413 [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Bob Petersonfe6c9912008-01-28 11:13:02 -06003 * Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
9
David Teiglandb3b94fa2006-01-16 16:50:04 +000010#include <linux/slab.h>
11#include <linux/spinlock.h>
12#include <linux/completion.h>
13#include <linux/buffer_head.h>
Steven Whitehousef42faf42006-01-30 18:34:10 +000014#include <linux/fs.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050015#include <linux/gfs2_ondisk.h>
Fabio Massimo Di Nitto7d308592006-09-19 07:56:29 +020016#include <linux/lm_interface.h>
Bob Peterson1f466a42008-03-10 18:17:47 -050017#include <linux/prefetch.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000018
19#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050020#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000021#include "glock.h"
22#include "glops.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000023#include "lops.h"
24#include "meta_io.h"
25#include "quota.h"
26#include "rgrp.h"
27#include "super.h"
28#include "trans.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050029#include "util.h"
Benjamin Marzinski172e0452007-03-23 14:51:56 -060030#include "log.h"
Steven Whitehousec8cdf472007-06-08 10:05:33 +010031#include "inode.h"
Steven Whitehouse51ff87b2007-10-15 14:42:35 +010032#include "ops_address.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000033
Steven Whitehouse2c1e52a2006-09-05 15:41:57 -040034#define BFITNOENT ((u32)~0)
Bob Peterson6760bdc2007-07-24 14:09:32 -050035#define NO_BLOCK ((u64)~0)
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040036
Bob Peterson1f466a42008-03-10 18:17:47 -050037#if BITS_PER_LONG == 32
38#define LBITMASK (0x55555555UL)
39#define LBITSKIP55 (0x55555555UL)
40#define LBITSKIP00 (0x00000000UL)
41#else
42#define LBITMASK (0x5555555555555555UL)
43#define LBITSKIP55 (0x5555555555555555UL)
44#define LBITSKIP00 (0x0000000000000000UL)
45#endif
46
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040047/*
48 * These routines are used by the resource group routines (rgrp.c)
49 * to keep track of block allocation. Each block is represented by two
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040050 * bits. So, each byte represents GFS2_NBBY (i.e. 4) blocks.
51 *
52 * 0 = Free
53 * 1 = Used (not metadata)
54 * 2 = Unlinked (still in use) inode
55 * 3 = Used (metadata)
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040056 */
57
58static const char valid_change[16] = {
59 /* current */
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040060 /* n */ 0, 1, 1, 1,
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040061 /* e */ 1, 0, 0, 0,
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040062 /* w */ 0, 0, 0, 1,
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040063 1, 0, 0, 0
64};
65
Steven Whitehousec8cdf472007-06-08 10:05:33 +010066static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
Steven Whitehouseb45e41d2008-02-06 10:11:15 +000067 unsigned char old_state, unsigned char new_state,
68 unsigned int *n);
Steven Whitehousec8cdf472007-06-08 10:05:33 +010069
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040070/**
71 * gfs2_setbit - Set a bit in the bitmaps
72 * @buffer: the buffer that holds the bitmaps
73 * @buflen: the length (in bytes) of the buffer
74 * @block: the block to set
75 * @new_state: the new state of the block
76 *
77 */
78
Steven Whitehouseb45e41d2008-02-06 10:11:15 +000079static inline void gfs2_setbit(struct gfs2_rgrpd *rgd, unsigned char *buf1,
80 unsigned char *buf2, unsigned int offset,
81 unsigned int buflen, u32 block,
82 unsigned char new_state)
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040083{
Steven Whitehouseb45e41d2008-02-06 10:11:15 +000084 unsigned char *byte1, *byte2, *end, cur_state;
85 const unsigned int bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040086
Steven Whitehouseb45e41d2008-02-06 10:11:15 +000087 byte1 = buf1 + offset + (block / GFS2_NBBY);
88 end = buf1 + offset + buflen;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040089
Steven Whitehouseb45e41d2008-02-06 10:11:15 +000090 BUG_ON(byte1 >= end);
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040091
Steven Whitehouseb45e41d2008-02-06 10:11:15 +000092 cur_state = (*byte1 >> bit) & GFS2_BIT_MASK;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040093
Steven Whitehouseb45e41d2008-02-06 10:11:15 +000094 if (unlikely(!valid_change[new_state * 4 + cur_state])) {
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -040095 gfs2_consist_rgrpd(rgd);
Steven Whitehouseb45e41d2008-02-06 10:11:15 +000096 return;
97 }
98 *byte1 ^= (cur_state ^ new_state) << bit;
99
100 if (buf2) {
101 byte2 = buf2 + offset + (block / GFS2_NBBY);
102 cur_state = (*byte2 >> bit) & GFS2_BIT_MASK;
103 *byte2 ^= (cur_state ^ new_state) << bit;
104 }
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400105}
106
107/**
108 * gfs2_testbit - test a bit in the bitmaps
109 * @buffer: the buffer that holds the bitmaps
110 * @buflen: the length (in bytes) of the buffer
111 * @block: the block to read
112 *
113 */
114
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000115static inline unsigned char gfs2_testbit(struct gfs2_rgrpd *rgd,
116 const unsigned char *buffer,
117 unsigned int buflen, u32 block)
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400118{
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000119 const unsigned char *byte, *end;
120 unsigned char cur_state;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400121 unsigned int bit;
122
123 byte = buffer + (block / GFS2_NBBY);
124 bit = (block % GFS2_NBBY) * GFS2_BIT_SIZE;
125 end = buffer + buflen;
126
127 gfs2_assert(rgd->rd_sbd, byte < end);
128
129 cur_state = (*byte >> bit) & GFS2_BIT_MASK;
130
131 return cur_state;
132}
133
134/**
135 * gfs2_bitfit - Search an rgrp's bitmap buffer to find a bit-pair representing
136 * a block in a given allocation state.
137 * @buffer: the buffer that holds the bitmaps
138 * @buflen: the length (in bytes) of the buffer
139 * @goal: start search at this block's bit-pair (within @buffer)
Bob Peterson6760bdc2007-07-24 14:09:32 -0500140 * @old_state: GFS2_BLKST_XXX the state of the block we're looking for.
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400141 *
142 * Scope of @goal and returned block number is only within this bitmap buffer,
143 * not entire rgrp or filesystem. @buffer will be offset from the actual
144 * beginning of a bitmap block buffer, skipping any header structures.
145 *
146 * Return: the block number (bitmap buffer scope) that was found
147 */
148
Steven Whitehouse110acf32008-01-29 13:30:20 +0000149static u32 gfs2_bitfit(const u8 *buffer, unsigned int buflen, u32 goal,
150 u8 old_state)
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400151{
Bob Peterson1f466a42008-03-10 18:17:47 -0500152 const u8 *byte, *start, *end;
153 int bit, startbit;
154 u32 g1, g2, misaligned;
155 unsigned long *plong;
156 unsigned long lskipval;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400157
Bob Peterson1f466a42008-03-10 18:17:47 -0500158 lskipval = (old_state & GFS2_BLKST_USED) ? LBITSKIP00 : LBITSKIP55;
159 g1 = (goal / GFS2_NBBY);
160 start = buffer + g1;
161 byte = start;
162 end = buffer + buflen;
163 g2 = ALIGN(g1, sizeof(unsigned long));
164 plong = (unsigned long *)(buffer + g2);
165 startbit = bit = (goal % GFS2_NBBY) * GFS2_BIT_SIZE;
166 misaligned = g2 - g1;
167 if (!misaligned)
168 goto ulong_aligned;
169/* parse the bitmap a byte at a time */
170misaligned:
171 while (byte < end) {
172 if (((*byte >> bit) & GFS2_BIT_MASK) == old_state) {
173 return goal +
174 (((byte - start) * GFS2_NBBY) +
175 ((bit - startbit) >> 1));
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400176 }
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400177 bit += GFS2_BIT_SIZE;
Bob Peterson1f466a42008-03-10 18:17:47 -0500178 if (bit >= GFS2_NBBY * GFS2_BIT_SIZE) {
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400179 bit = 0;
180 byte++;
Bob Peterson1f466a42008-03-10 18:17:47 -0500181 misaligned--;
182 if (!misaligned) {
183 plong = (unsigned long *)byte;
184 goto ulong_aligned;
185 }
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400186 }
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400187 }
Bob Peterson1f466a42008-03-10 18:17:47 -0500188 return BFITNOENT;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400189
Bob Peterson1f466a42008-03-10 18:17:47 -0500190/* parse the bitmap a unsigned long at a time */
191ulong_aligned:
192 /* Stop at "end - 1" or else prefetch can go past the end and segfault.
193 We could "if" it but we'd lose some of the performance gained.
194 This way will only slow down searching the very last 4/8 bytes
195 depending on architecture. I've experimented with several ways
196 of writing this section such as using an else before the goto
197 but this one seems to be the fastest. */
Bob Peterson17c15da2008-06-18 11:30:40 -0500198 while ((unsigned char *)plong < end - sizeof(unsigned long)) {
Bob Peterson1f466a42008-03-10 18:17:47 -0500199 prefetch(plong + 1);
200 if (((*plong) & LBITMASK) != lskipval)
201 break;
202 plong++;
203 }
204 if ((unsigned char *)plong < end) {
205 byte = (const u8 *)plong;
206 misaligned += sizeof(unsigned long) - 1;
207 goto misaligned;
208 }
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400209 return BFITNOENT;
210}
211
212/**
213 * gfs2_bitcount - count the number of bits in a certain state
214 * @buffer: the buffer that holds the bitmaps
215 * @buflen: the length (in bytes) of the buffer
216 * @state: the state of the block we're looking for
217 *
218 * Returns: The number of bits
219 */
220
Steven Whitehouse110acf32008-01-29 13:30:20 +0000221static u32 gfs2_bitcount(struct gfs2_rgrpd *rgd, const u8 *buffer,
222 unsigned int buflen, u8 state)
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400223{
Steven Whitehouse110acf32008-01-29 13:30:20 +0000224 const u8 *byte = buffer;
225 const u8 *end = buffer + buflen;
226 const u8 state1 = state << 2;
227 const u8 state2 = state << 4;
228 const u8 state3 = state << 6;
Steven Whitehousecd915492006-09-04 12:49:07 -0400229 u32 count = 0;
Steven Whitehouse88c8ab1f2006-05-18 13:52:39 -0400230
231 for (; byte < end; byte++) {
232 if (((*byte) & 0x03) == state)
233 count++;
234 if (((*byte) & 0x0C) == state1)
235 count++;
236 if (((*byte) & 0x30) == state2)
237 count++;
238 if (((*byte) & 0xC0) == state3)
239 count++;
240 }
241
242 return count;
243}
244
David Teiglandb3b94fa2006-01-16 16:50:04 +0000245/**
246 * gfs2_rgrp_verify - Verify that a resource group is consistent
247 * @sdp: the filesystem
248 * @rgd: the rgrp
249 *
250 */
251
252void gfs2_rgrp_verify(struct gfs2_rgrpd *rgd)
253{
254 struct gfs2_sbd *sdp = rgd->rd_sbd;
255 struct gfs2_bitmap *bi = NULL;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100256 u32 length = rgd->rd_length;
Steven Whitehousecd915492006-09-04 12:49:07 -0400257 u32 count[4], tmp;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000258 int buf, x;
259
Steven Whitehousecd915492006-09-04 12:49:07 -0400260 memset(count, 0, 4 * sizeof(u32));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000261
262 /* Count # blocks in each of 4 possible allocation states */
263 for (buf = 0; buf < length; buf++) {
264 bi = rgd->rd_bits + buf;
265 for (x = 0; x < 4; x++)
266 count[x] += gfs2_bitcount(rgd,
267 bi->bi_bh->b_data +
268 bi->bi_offset,
269 bi->bi_len, x);
270 }
271
272 if (count[0] != rgd->rd_rg.rg_free) {
273 if (gfs2_consist_rgrpd(rgd))
274 fs_err(sdp, "free data mismatch: %u != %u\n",
275 count[0], rgd->rd_rg.rg_free);
276 return;
277 }
278
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100279 tmp = rgd->rd_data -
David Teiglandb3b94fa2006-01-16 16:50:04 +0000280 rgd->rd_rg.rg_free -
281 rgd->rd_rg.rg_dinodes;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400282 if (count[1] + count[2] != tmp) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000283 if (gfs2_consist_rgrpd(rgd))
284 fs_err(sdp, "used data mismatch: %u != %u\n",
285 count[1], tmp);
286 return;
287 }
288
David Teiglandb3b94fa2006-01-16 16:50:04 +0000289 if (count[3] != rgd->rd_rg.rg_dinodes) {
290 if (gfs2_consist_rgrpd(rgd))
291 fs_err(sdp, "used metadata mismatch: %u != %u\n",
292 count[3], rgd->rd_rg.rg_dinodes);
293 return;
294 }
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400295
296 if (count[2] > count[3]) {
297 if (gfs2_consist_rgrpd(rgd))
298 fs_err(sdp, "unlinked inodes > inodes: %u\n",
299 count[2]);
300 return;
301 }
302
David Teiglandb3b94fa2006-01-16 16:50:04 +0000303}
304
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100305static inline int rgrp_contains_block(struct gfs2_rgrpd *rgd, u64 block)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000306{
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100307 u64 first = rgd->rd_data0;
308 u64 last = first + rgd->rd_data;
Steven Whitehouse16910422006-09-05 11:15:45 -0400309 return first <= block && block < last;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000310}
311
312/**
313 * gfs2_blk2rgrpd - Find resource group for a given data/meta block number
314 * @sdp: The GFS2 superblock
315 * @n: The data block number
316 *
317 * Returns: The resource group, or NULL if not found
318 */
319
Steven Whitehousecd915492006-09-04 12:49:07 -0400320struct gfs2_rgrpd *gfs2_blk2rgrpd(struct gfs2_sbd *sdp, u64 blk)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000321{
322 struct gfs2_rgrpd *rgd;
323
324 spin_lock(&sdp->sd_rindex_spin);
325
326 list_for_each_entry(rgd, &sdp->sd_rindex_mru_list, rd_list_mru) {
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100327 if (rgrp_contains_block(rgd, blk)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000328 list_move(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list);
329 spin_unlock(&sdp->sd_rindex_spin);
330 return rgd;
331 }
332 }
333
334 spin_unlock(&sdp->sd_rindex_spin);
335
336 return NULL;
337}
338
339/**
340 * gfs2_rgrpd_get_first - get the first Resource Group in the filesystem
341 * @sdp: The GFS2 superblock
342 *
343 * Returns: The first rgrp in the filesystem
344 */
345
346struct gfs2_rgrpd *gfs2_rgrpd_get_first(struct gfs2_sbd *sdp)
347{
348 gfs2_assert(sdp, !list_empty(&sdp->sd_rindex_list));
349 return list_entry(sdp->sd_rindex_list.next, struct gfs2_rgrpd, rd_list);
350}
351
352/**
353 * gfs2_rgrpd_get_next - get the next RG
354 * @rgd: A RG
355 *
356 * Returns: The next rgrp
357 */
358
359struct gfs2_rgrpd *gfs2_rgrpd_get_next(struct gfs2_rgrpd *rgd)
360{
361 if (rgd->rd_list.next == &rgd->rd_sbd->sd_rindex_list)
362 return NULL;
363 return list_entry(rgd->rd_list.next, struct gfs2_rgrpd, rd_list);
364}
365
366static void clear_rgrpdi(struct gfs2_sbd *sdp)
367{
368 struct list_head *head;
369 struct gfs2_rgrpd *rgd;
370 struct gfs2_glock *gl;
371
372 spin_lock(&sdp->sd_rindex_spin);
373 sdp->sd_rindex_forward = NULL;
374 head = &sdp->sd_rindex_recent_list;
375 while (!list_empty(head)) {
376 rgd = list_entry(head->next, struct gfs2_rgrpd, rd_recent);
377 list_del(&rgd->rd_recent);
378 }
379 spin_unlock(&sdp->sd_rindex_spin);
380
381 head = &sdp->sd_rindex_list;
382 while (!list_empty(head)) {
383 rgd = list_entry(head->next, struct gfs2_rgrpd, rd_list);
384 gl = rgd->rd_gl;
385
386 list_del(&rgd->rd_list);
387 list_del(&rgd->rd_list_mru);
388
389 if (gl) {
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500390 gl->gl_object = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000391 gfs2_glock_put(gl);
392 }
393
394 kfree(rgd->rd_bits);
Bob Peterson6bdd9be2008-01-28 17:20:26 -0600395 kmem_cache_free(gfs2_rgrpd_cachep, rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000396 }
397}
398
399void gfs2_clear_rgrpd(struct gfs2_sbd *sdp)
400{
Steven Whitehousef55ab262006-02-21 12:51:39 +0000401 mutex_lock(&sdp->sd_rindex_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000402 clear_rgrpdi(sdp);
Steven Whitehousef55ab262006-02-21 12:51:39 +0000403 mutex_unlock(&sdp->sd_rindex_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000404}
405
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100406static void gfs2_rindex_print(const struct gfs2_rgrpd *rgd)
407{
408 printk(KERN_INFO " ri_addr = %llu\n", (unsigned long long)rgd->rd_addr);
409 printk(KERN_INFO " ri_length = %u\n", rgd->rd_length);
410 printk(KERN_INFO " ri_data0 = %llu\n", (unsigned long long)rgd->rd_data0);
411 printk(KERN_INFO " ri_data = %u\n", rgd->rd_data);
412 printk(KERN_INFO " ri_bitbytes = %u\n", rgd->rd_bitbytes);
413}
414
David Teiglandb3b94fa2006-01-16 16:50:04 +0000415/**
416 * gfs2_compute_bitstructs - Compute the bitmap sizes
417 * @rgd: The resource group descriptor
418 *
419 * Calculates bitmap descriptors, one for each block that contains bitmap data
420 *
421 * Returns: errno
422 */
423
424static int compute_bitstructs(struct gfs2_rgrpd *rgd)
425{
426 struct gfs2_sbd *sdp = rgd->rd_sbd;
427 struct gfs2_bitmap *bi;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100428 u32 length = rgd->rd_length; /* # blocks in hdr & bitmap */
Steven Whitehousecd915492006-09-04 12:49:07 -0400429 u32 bytes_left, bytes;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000430 int x;
431
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400432 if (!length)
433 return -EINVAL;
434
Steven Whitehousedd894be2006-07-27 14:29:00 -0400435 rgd->rd_bits = kcalloc(length, sizeof(struct gfs2_bitmap), GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000436 if (!rgd->rd_bits)
437 return -ENOMEM;
438
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100439 bytes_left = rgd->rd_bitbytes;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000440
441 for (x = 0; x < length; x++) {
442 bi = rgd->rd_bits + x;
443
444 /* small rgrp; bitmap stored completely in header block */
445 if (length == 1) {
446 bytes = bytes_left;
447 bi->bi_offset = sizeof(struct gfs2_rgrp);
448 bi->bi_start = 0;
449 bi->bi_len = bytes;
450 /* header block */
451 } else if (x == 0) {
452 bytes = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_rgrp);
453 bi->bi_offset = sizeof(struct gfs2_rgrp);
454 bi->bi_start = 0;
455 bi->bi_len = bytes;
456 /* last block */
457 } else if (x + 1 == length) {
458 bytes = bytes_left;
459 bi->bi_offset = sizeof(struct gfs2_meta_header);
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100460 bi->bi_start = rgd->rd_bitbytes - bytes_left;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000461 bi->bi_len = bytes;
462 /* other blocks */
463 } else {
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500464 bytes = sdp->sd_sb.sb_bsize -
465 sizeof(struct gfs2_meta_header);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000466 bi->bi_offset = sizeof(struct gfs2_meta_header);
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100467 bi->bi_start = rgd->rd_bitbytes - bytes_left;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000468 bi->bi_len = bytes;
469 }
470
471 bytes_left -= bytes;
472 }
473
474 if (bytes_left) {
475 gfs2_consist_rgrpd(rgd);
476 return -EIO;
477 }
478 bi = rgd->rd_bits + (length - 1);
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100479 if ((bi->bi_start + bi->bi_len) * GFS2_NBBY != rgd->rd_data) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000480 if (gfs2_consist_rgrpd(rgd)) {
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100481 gfs2_rindex_print(rgd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000482 fs_err(sdp, "start=%u len=%u offset=%u\n",
483 bi->bi_start, bi->bi_len, bi->bi_offset);
484 }
485 return -EIO;
486 }
487
488 return 0;
489}
490
491/**
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500492 * gfs2_ri_total - Total up the file system space, according to the rindex.
493 *
494 */
495u64 gfs2_ri_total(struct gfs2_sbd *sdp)
496{
497 u64 total_data = 0;
498 struct inode *inode = sdp->sd_rindex;
499 struct gfs2_inode *ip = GFS2_I(inode);
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500500 char buf[sizeof(struct gfs2_rindex)];
501 struct file_ra_state ra_state;
502 int error, rgrps;
503
504 mutex_lock(&sdp->sd_rindex_mutex);
505 file_ra_state_init(&ra_state, inode->i_mapping);
506 for (rgrps = 0;; rgrps++) {
507 loff_t pos = rgrps * sizeof(struct gfs2_rindex);
508
509 if (pos + sizeof(struct gfs2_rindex) >= ip->i_di.di_size)
510 break;
511 error = gfs2_internal_read(ip, &ra_state, buf, &pos,
512 sizeof(struct gfs2_rindex));
513 if (error != sizeof(struct gfs2_rindex))
514 break;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100515 total_data += be32_to_cpu(((struct gfs2_rindex *)buf)->ri_data);
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500516 }
517 mutex_unlock(&sdp->sd_rindex_mutex);
518 return total_data;
519}
520
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100521static void gfs2_rindex_in(struct gfs2_rgrpd *rgd, const void *buf)
522{
523 const struct gfs2_rindex *str = buf;
524
525 rgd->rd_addr = be64_to_cpu(str->ri_addr);
526 rgd->rd_length = be32_to_cpu(str->ri_length);
527 rgd->rd_data0 = be64_to_cpu(str->ri_data0);
528 rgd->rd_data = be32_to_cpu(str->ri_data);
529 rgd->rd_bitbytes = be32_to_cpu(str->ri_bitbytes);
530}
531
Robert Peterson7ae8fa82007-05-09 09:37:57 -0500532/**
Robert Peterson6c532672007-05-10 16:54:38 -0500533 * read_rindex_entry - Pull in a new resource index entry from the disk
David Teiglandb3b94fa2006-01-16 16:50:04 +0000534 * @gl: The glock covering the rindex inode
535 *
Robert Peterson6c532672007-05-10 16:54:38 -0500536 * Returns: 0 on success, error code otherwise
537 */
538
539static int read_rindex_entry(struct gfs2_inode *ip,
540 struct file_ra_state *ra_state)
541{
542 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
543 loff_t pos = sdp->sd_rgrps * sizeof(struct gfs2_rindex);
544 char buf[sizeof(struct gfs2_rindex)];
545 int error;
546 struct gfs2_rgrpd *rgd;
547
548 error = gfs2_internal_read(ip, ra_state, buf, &pos,
549 sizeof(struct gfs2_rindex));
550 if (!error)
551 return 0;
552 if (error != sizeof(struct gfs2_rindex)) {
553 if (error > 0)
554 error = -EIO;
555 return error;
556 }
557
Bob Peterson6bdd9be2008-01-28 17:20:26 -0600558 rgd = kmem_cache_zalloc(gfs2_rgrpd_cachep, GFP_NOFS);
Robert Peterson6c532672007-05-10 16:54:38 -0500559 error = -ENOMEM;
560 if (!rgd)
561 return error;
562
563 mutex_init(&rgd->rd_mutex);
564 lops_init_le(&rgd->rd_le, &gfs2_rg_lops);
565 rgd->rd_sbd = sdp;
566
567 list_add_tail(&rgd->rd_list, &sdp->sd_rindex_list);
568 list_add_tail(&rgd->rd_list_mru, &sdp->sd_rindex_mru_list);
569
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100570 gfs2_rindex_in(rgd, buf);
Robert Peterson6c532672007-05-10 16:54:38 -0500571 error = compute_bitstructs(rgd);
572 if (error)
573 return error;
574
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100575 error = gfs2_glock_get(sdp, rgd->rd_addr,
Robert Peterson6c532672007-05-10 16:54:38 -0500576 &gfs2_rgrp_glops, CREATE, &rgd->rd_gl);
577 if (error)
578 return error;
579
580 rgd->rd_gl->gl_object = rgd;
Bob Petersoncf45b752008-01-31 10:31:39 -0600581 rgd->rd_flags &= ~GFS2_RDF_UPTODATE;
Steven Whitehousec8cdf472007-06-08 10:05:33 +0100582 rgd->rd_flags |= GFS2_RDF_CHECK;
Robert Peterson6c532672007-05-10 16:54:38 -0500583 return error;
584}
585
586/**
587 * gfs2_ri_update - Pull in a new resource index from the disk
588 * @ip: pointer to the rindex inode
589 *
David Teiglandb3b94fa2006-01-16 16:50:04 +0000590 * Returns: 0 on successful update, error code otherwise
591 */
592
593static int gfs2_ri_update(struct gfs2_inode *ip)
594{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400595 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
596 struct inode *inode = &ip->i_inode;
Steven Whitehousef42faf42006-01-30 18:34:10 +0000597 struct file_ra_state ra_state;
Robert Petersoncd81a4b2007-05-14 12:42:18 -0500598 u64 rgrp_count = ip->i_di.di_size;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000599 int error;
600
Robert Petersoncd81a4b2007-05-14 12:42:18 -0500601 if (do_div(rgrp_count, sizeof(struct gfs2_rindex))) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000602 gfs2_consist_inode(ip);
603 return -EIO;
604 }
605
606 clear_rgrpdi(sdp);
607
Steven Whitehousef42faf42006-01-30 18:34:10 +0000608 file_ra_state_init(&ra_state, inode->i_mapping);
Robert Petersoncd81a4b2007-05-14 12:42:18 -0500609 for (sdp->sd_rgrps = 0; sdp->sd_rgrps < rgrp_count; sdp->sd_rgrps++) {
Robert Peterson6c532672007-05-10 16:54:38 -0500610 error = read_rindex_entry(ip, &ra_state);
611 if (error) {
612 clear_rgrpdi(sdp);
613 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000614 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000615 }
616
Bob Petersoncf45b752008-01-31 10:31:39 -0600617 sdp->sd_rindex_uptodate = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000618 return 0;
Robert Peterson6c532672007-05-10 16:54:38 -0500619}
David Teiglandb3b94fa2006-01-16 16:50:04 +0000620
Robert Peterson6c532672007-05-10 16:54:38 -0500621/**
622 * gfs2_ri_update_special - Pull in a new resource index from the disk
623 *
624 * This is a special version that's safe to call from gfs2_inplace_reserve_i.
625 * In this case we know that we don't have any resource groups in memory yet.
626 *
627 * @ip: pointer to the rindex inode
628 *
629 * Returns: 0 on successful update, error code otherwise
630 */
631static int gfs2_ri_update_special(struct gfs2_inode *ip)
632{
633 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
634 struct inode *inode = &ip->i_inode;
635 struct file_ra_state ra_state;
636 int error;
637
638 file_ra_state_init(&ra_state, inode->i_mapping);
639 for (sdp->sd_rgrps = 0;; sdp->sd_rgrps++) {
640 /* Ignore partials */
641 if ((sdp->sd_rgrps + 1) * sizeof(struct gfs2_rindex) >
642 ip->i_di.di_size)
643 break;
644 error = read_rindex_entry(ip, &ra_state);
645 if (error) {
646 clear_rgrpdi(sdp);
647 return error;
648 }
649 }
650
Bob Petersoncf45b752008-01-31 10:31:39 -0600651 sdp->sd_rindex_uptodate = 1;
Robert Peterson6c532672007-05-10 16:54:38 -0500652 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000653}
654
655/**
656 * gfs2_rindex_hold - Grab a lock on the rindex
657 * @sdp: The GFS2 superblock
658 * @ri_gh: the glock holder
659 *
660 * We grab a lock on the rindex inode to make sure that it doesn't
661 * change whilst we are performing an operation. We keep this lock
662 * for quite long periods of time compared to other locks. This
663 * doesn't matter, since it is shared and it is very, very rarely
664 * accessed in the exclusive mode (i.e. only when expanding the filesystem).
665 *
666 * This makes sure that we're using the latest copy of the resource index
667 * special file, which might have been updated if someone expanded the
668 * filesystem (via gfs2_grow utility), which adds new resource groups.
669 *
670 * Returns: 0 on success, error code otherwise
671 */
672
673int gfs2_rindex_hold(struct gfs2_sbd *sdp, struct gfs2_holder *ri_gh)
674{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400675 struct gfs2_inode *ip = GFS2_I(sdp->sd_rindex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000676 struct gfs2_glock *gl = ip->i_gl;
677 int error;
678
679 error = gfs2_glock_nq_init(gl, LM_ST_SHARED, 0, ri_gh);
680 if (error)
681 return error;
682
683 /* Read new copy from disk if we don't have the latest */
Bob Petersoncf45b752008-01-31 10:31:39 -0600684 if (!sdp->sd_rindex_uptodate) {
Steven Whitehousef55ab262006-02-21 12:51:39 +0000685 mutex_lock(&sdp->sd_rindex_mutex);
Bob Petersoncf45b752008-01-31 10:31:39 -0600686 if (!sdp->sd_rindex_uptodate) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000687 error = gfs2_ri_update(ip);
688 if (error)
689 gfs2_glock_dq_uninit(ri_gh);
690 }
Steven Whitehousef55ab262006-02-21 12:51:39 +0000691 mutex_unlock(&sdp->sd_rindex_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000692 }
693
694 return error;
695}
696
Bob Peterson42d52e32008-01-28 18:38:07 -0600697static void gfs2_rgrp_in(struct gfs2_rgrpd *rgd, const void *buf)
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100698{
699 const struct gfs2_rgrp *str = buf;
Bob Peterson42d52e32008-01-28 18:38:07 -0600700 struct gfs2_rgrp_host *rg = &rgd->rd_rg;
701 u32 rg_flags;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100702
Bob Peterson42d52e32008-01-28 18:38:07 -0600703 rg_flags = be32_to_cpu(str->rg_flags);
704 if (rg_flags & GFS2_RGF_NOALLOC)
705 rgd->rd_flags |= GFS2_RDF_NOALLOC;
706 else
707 rgd->rd_flags &= ~GFS2_RDF_NOALLOC;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100708 rg->rg_free = be32_to_cpu(str->rg_free);
709 rg->rg_dinodes = be32_to_cpu(str->rg_dinodes);
710 rg->rg_igeneration = be64_to_cpu(str->rg_igeneration);
711}
712
Bob Peterson42d52e32008-01-28 18:38:07 -0600713static void gfs2_rgrp_out(struct gfs2_rgrpd *rgd, void *buf)
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100714{
715 struct gfs2_rgrp *str = buf;
Bob Peterson42d52e32008-01-28 18:38:07 -0600716 struct gfs2_rgrp_host *rg = &rgd->rd_rg;
717 u32 rg_flags = 0;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100718
Bob Peterson42d52e32008-01-28 18:38:07 -0600719 if (rgd->rd_flags & GFS2_RDF_NOALLOC)
720 rg_flags |= GFS2_RGF_NOALLOC;
721 str->rg_flags = cpu_to_be32(rg_flags);
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100722 str->rg_free = cpu_to_be32(rg->rg_free);
723 str->rg_dinodes = cpu_to_be32(rg->rg_dinodes);
724 str->__pad = cpu_to_be32(0);
725 str->rg_igeneration = cpu_to_be64(rg->rg_igeneration);
726 memset(&str->rg_reserved, 0, sizeof(str->rg_reserved));
727}
728
David Teiglandb3b94fa2006-01-16 16:50:04 +0000729/**
730 * gfs2_rgrp_bh_get - Read in a RG's header and bitmaps
731 * @rgd: the struct gfs2_rgrpd describing the RG to read in
732 *
733 * Read in all of a Resource Group's header and bitmap blocks.
734 * Caller must eventually call gfs2_rgrp_relse() to free the bitmaps.
735 *
736 * Returns: errno
737 */
738
739int gfs2_rgrp_bh_get(struct gfs2_rgrpd *rgd)
740{
741 struct gfs2_sbd *sdp = rgd->rd_sbd;
742 struct gfs2_glock *gl = rgd->rd_gl;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100743 unsigned int length = rgd->rd_length;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000744 struct gfs2_bitmap *bi;
745 unsigned int x, y;
746 int error;
747
Steven Whitehousef55ab262006-02-21 12:51:39 +0000748 mutex_lock(&rgd->rd_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000749
750 spin_lock(&sdp->sd_rindex_spin);
751 if (rgd->rd_bh_count) {
752 rgd->rd_bh_count++;
753 spin_unlock(&sdp->sd_rindex_spin);
Steven Whitehousef55ab262006-02-21 12:51:39 +0000754 mutex_unlock(&rgd->rd_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000755 return 0;
756 }
757 spin_unlock(&sdp->sd_rindex_spin);
758
759 for (x = 0; x < length; x++) {
760 bi = rgd->rd_bits + x;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100761 error = gfs2_meta_read(gl, rgd->rd_addr + x, 0, &bi->bi_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000762 if (error)
763 goto fail;
764 }
765
766 for (y = length; y--;) {
767 bi = rgd->rd_bits + y;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400768 error = gfs2_meta_wait(sdp, bi->bi_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000769 if (error)
770 goto fail;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400771 if (gfs2_metatype_check(sdp, bi->bi_bh, y ? GFS2_METATYPE_RB :
David Teiglandb3b94fa2006-01-16 16:50:04 +0000772 GFS2_METATYPE_RG)) {
773 error = -EIO;
774 goto fail;
775 }
776 }
777
Bob Petersoncf45b752008-01-31 10:31:39 -0600778 if (!(rgd->rd_flags & GFS2_RDF_UPTODATE)) {
Bob Peterson42d52e32008-01-28 18:38:07 -0600779 gfs2_rgrp_in(rgd, (rgd->rd_bits[0].bi_bh)->b_data);
Bob Petersoncf45b752008-01-31 10:31:39 -0600780 rgd->rd_flags |= GFS2_RDF_UPTODATE;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000781 }
782
783 spin_lock(&sdp->sd_rindex_spin);
784 rgd->rd_free_clone = rgd->rd_rg.rg_free;
785 rgd->rd_bh_count++;
786 spin_unlock(&sdp->sd_rindex_spin);
787
Steven Whitehousef55ab262006-02-21 12:51:39 +0000788 mutex_unlock(&rgd->rd_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000789
790 return 0;
791
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400792fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000793 while (x--) {
794 bi = rgd->rd_bits + x;
795 brelse(bi->bi_bh);
796 bi->bi_bh = NULL;
797 gfs2_assert_warn(sdp, !bi->bi_clone);
798 }
Steven Whitehousef55ab262006-02-21 12:51:39 +0000799 mutex_unlock(&rgd->rd_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000800
801 return error;
802}
803
804void gfs2_rgrp_bh_hold(struct gfs2_rgrpd *rgd)
805{
806 struct gfs2_sbd *sdp = rgd->rd_sbd;
807
808 spin_lock(&sdp->sd_rindex_spin);
809 gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count);
810 rgd->rd_bh_count++;
811 spin_unlock(&sdp->sd_rindex_spin);
812}
813
814/**
815 * gfs2_rgrp_bh_put - Release RG bitmaps read in with gfs2_rgrp_bh_get()
816 * @rgd: the struct gfs2_rgrpd describing the RG to read in
817 *
818 */
819
820void gfs2_rgrp_bh_put(struct gfs2_rgrpd *rgd)
821{
822 struct gfs2_sbd *sdp = rgd->rd_sbd;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100823 int x, length = rgd->rd_length;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000824
825 spin_lock(&sdp->sd_rindex_spin);
826 gfs2_assert_warn(rgd->rd_sbd, rgd->rd_bh_count);
827 if (--rgd->rd_bh_count) {
828 spin_unlock(&sdp->sd_rindex_spin);
829 return;
830 }
831
832 for (x = 0; x < length; x++) {
833 struct gfs2_bitmap *bi = rgd->rd_bits + x;
834 kfree(bi->bi_clone);
835 bi->bi_clone = NULL;
836 brelse(bi->bi_bh);
837 bi->bi_bh = NULL;
838 }
839
840 spin_unlock(&sdp->sd_rindex_spin);
841}
842
843void gfs2_rgrp_repolish_clones(struct gfs2_rgrpd *rgd)
844{
845 struct gfs2_sbd *sdp = rgd->rd_sbd;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100846 unsigned int length = rgd->rd_length;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000847 unsigned int x;
848
849 for (x = 0; x < length; x++) {
850 struct gfs2_bitmap *bi = rgd->rd_bits + x;
851 if (!bi->bi_clone)
852 continue;
853 memcpy(bi->bi_clone + bi->bi_offset,
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400854 bi->bi_bh->b_data + bi->bi_offset, bi->bi_len);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000855 }
856
857 spin_lock(&sdp->sd_rindex_spin);
858 rgd->rd_free_clone = rgd->rd_rg.rg_free;
859 spin_unlock(&sdp->sd_rindex_spin);
860}
861
862/**
863 * gfs2_alloc_get - get the struct gfs2_alloc structure for an inode
864 * @ip: the incore GFS2 inode structure
865 *
866 * Returns: the struct gfs2_alloc
867 */
868
869struct gfs2_alloc *gfs2_alloc_get(struct gfs2_inode *ip)
870{
Steven Whitehouse6dbd8222008-01-10 15:18:55 +0000871 BUG_ON(ip->i_alloc != NULL);
872 ip->i_alloc = kzalloc(sizeof(struct gfs2_alloc), GFP_KERNEL);
873 return ip->i_alloc;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000874}
875
876/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000877 * try_rgrp_fit - See if a given reservation will fit in a given RG
878 * @rgd: the RG data
879 * @al: the struct gfs2_alloc structure describing the reservation
880 *
881 * If there's room for the requested blocks to be allocated from the RG:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000882 * Sets the $al_rgd field in @al.
883 *
884 * Returns: 1 on success (it fits), 0 on failure (it doesn't fit)
885 */
886
887static int try_rgrp_fit(struct gfs2_rgrpd *rgd, struct gfs2_alloc *al)
888{
889 struct gfs2_sbd *sdp = rgd->rd_sbd;
890 int ret = 0;
891
Bob Peterson42d52e32008-01-28 18:38:07 -0600892 if (rgd->rd_flags & GFS2_RDF_NOALLOC)
Steven Whitehousea43a4902007-04-02 10:48:17 +0100893 return 0;
894
David Teiglandb3b94fa2006-01-16 16:50:04 +0000895 spin_lock(&sdp->sd_rindex_spin);
896 if (rgd->rd_free_clone >= al->al_requested) {
897 al->al_rgd = rgd;
898 ret = 1;
899 }
900 spin_unlock(&sdp->sd_rindex_spin);
901
902 return ret;
903}
904
905/**
Steven Whitehousec8cdf472007-06-08 10:05:33 +0100906 * try_rgrp_unlink - Look for any unlinked, allocated, but unused inodes
907 * @rgd: The rgrp
908 *
909 * Returns: The inode, if one has been found
910 */
911
912static struct inode *try_rgrp_unlink(struct gfs2_rgrpd *rgd, u64 *last_unlinked)
913{
914 struct inode *inode;
Bob Peterson6760bdc2007-07-24 14:09:32 -0500915 u32 goal = 0, block;
Wendy Chengbb9bcf02007-06-27 17:07:08 -0400916 u64 no_addr;
Bob Peterson5f3eae72007-08-08 16:52:09 -0500917 struct gfs2_sbd *sdp = rgd->rd_sbd;
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000918 unsigned int n;
Steven Whitehousec8cdf472007-06-08 10:05:33 +0100919
920 for(;;) {
Bob Peterson24c73872007-07-12 16:58:50 -0500921 if (goal >= rgd->rd_data)
922 break;
Bob Peterson5f3eae72007-08-08 16:52:09 -0500923 down_write(&sdp->sd_log_flush_lock);
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000924 n = 1;
Bob Peterson6760bdc2007-07-24 14:09:32 -0500925 block = rgblk_search(rgd, goal, GFS2_BLKST_UNLINKED,
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000926 GFS2_BLKST_UNLINKED, &n);
Bob Peterson5f3eae72007-08-08 16:52:09 -0500927 up_write(&sdp->sd_log_flush_lock);
Bob Peterson6760bdc2007-07-24 14:09:32 -0500928 if (block == BFITNOENT)
Bob Peterson24c73872007-07-12 16:58:50 -0500929 break;
Bob Peterson6760bdc2007-07-24 14:09:32 -0500930 /* rgblk_search can return a block < goal, so we need to
931 keep it marching forward. */
932 no_addr = block + rgd->rd_data0;
Bob Peterson24c73872007-07-12 16:58:50 -0500933 goal++;
Bob Peterson6760bdc2007-07-24 14:09:32 -0500934 if (*last_unlinked != NO_BLOCK && no_addr <= *last_unlinked)
Steven Whitehousec8cdf472007-06-08 10:05:33 +0100935 continue;
Wendy Chengbb9bcf02007-06-27 17:07:08 -0400936 *last_unlinked = no_addr;
937 inode = gfs2_inode_lookup(rgd->rd_sbd->sd_vfs, DT_UNKNOWN,
Benjamin Marzinski7a9f53b2007-09-18 13:33:18 -0500938 no_addr, -1, 1);
Steven Whitehousec8cdf472007-06-08 10:05:33 +0100939 if (!IS_ERR(inode))
940 return inode;
941 }
942
943 rgd->rd_flags &= ~GFS2_RDF_CHECK;
944 return NULL;
945}
946
947/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000948 * recent_rgrp_first - get first RG from "recent" list
949 * @sdp: The GFS2 superblock
950 * @rglast: address of the rgrp used last
951 *
952 * Returns: The first rgrp in the recent list
953 */
954
955static struct gfs2_rgrpd *recent_rgrp_first(struct gfs2_sbd *sdp,
Steven Whitehousecd915492006-09-04 12:49:07 -0400956 u64 rglast)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000957{
Steven Whitehousece276b02008-02-06 09:25:45 +0000958 struct gfs2_rgrpd *rgd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000959
960 spin_lock(&sdp->sd_rindex_spin);
961
Steven Whitehousece276b02008-02-06 09:25:45 +0000962 if (rglast) {
963 list_for_each_entry(rgd, &sdp->sd_rindex_recent_list, rd_recent) {
964 if (rgrp_contains_block(rgd, rglast))
965 goto out;
966 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000967 }
Steven Whitehousece276b02008-02-06 09:25:45 +0000968 rgd = NULL;
969 if (!list_empty(&sdp->sd_rindex_recent_list))
970 rgd = list_entry(sdp->sd_rindex_recent_list.next,
971 struct gfs2_rgrpd, rd_recent);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400972out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000973 spin_unlock(&sdp->sd_rindex_spin);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000974 return rgd;
975}
976
977/**
978 * recent_rgrp_next - get next RG from "recent" list
979 * @cur_rgd: current rgrp
980 * @remove:
981 *
982 * Returns: The next rgrp in the recent list
983 */
984
985static struct gfs2_rgrpd *recent_rgrp_next(struct gfs2_rgrpd *cur_rgd,
986 int remove)
987{
988 struct gfs2_sbd *sdp = cur_rgd->rd_sbd;
989 struct list_head *head;
990 struct gfs2_rgrpd *rgd;
991
992 spin_lock(&sdp->sd_rindex_spin);
993
994 head = &sdp->sd_rindex_recent_list;
995
996 list_for_each_entry(rgd, head, rd_recent) {
997 if (rgd == cur_rgd) {
998 if (cur_rgd->rd_recent.next != head)
999 rgd = list_entry(cur_rgd->rd_recent.next,
1000 struct gfs2_rgrpd, rd_recent);
1001 else
1002 rgd = NULL;
1003
1004 if (remove)
1005 list_del(&cur_rgd->rd_recent);
1006
1007 goto out;
1008 }
1009 }
1010
1011 rgd = NULL;
1012 if (!list_empty(head))
1013 rgd = list_entry(head->next, struct gfs2_rgrpd, rd_recent);
1014
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001015out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001016 spin_unlock(&sdp->sd_rindex_spin);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001017 return rgd;
1018}
1019
1020/**
1021 * recent_rgrp_add - add an RG to tail of "recent" list
1022 * @new_rgd: The rgrp to add
1023 *
1024 */
1025
1026static void recent_rgrp_add(struct gfs2_rgrpd *new_rgd)
1027{
1028 struct gfs2_sbd *sdp = new_rgd->rd_sbd;
1029 struct gfs2_rgrpd *rgd;
1030 unsigned int count = 0;
1031 unsigned int max = sdp->sd_rgrps / gfs2_jindex_size(sdp);
1032
1033 spin_lock(&sdp->sd_rindex_spin);
1034
1035 list_for_each_entry(rgd, &sdp->sd_rindex_recent_list, rd_recent) {
1036 if (rgd == new_rgd)
1037 goto out;
1038
1039 if (++count >= max)
1040 goto out;
1041 }
1042 list_add_tail(&new_rgd->rd_recent, &sdp->sd_rindex_recent_list);
1043
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001044out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001045 spin_unlock(&sdp->sd_rindex_spin);
1046}
1047
1048/**
1049 * forward_rgrp_get - get an rgrp to try next from full list
1050 * @sdp: The GFS2 superblock
1051 *
1052 * Returns: The rgrp to try next
1053 */
1054
1055static struct gfs2_rgrpd *forward_rgrp_get(struct gfs2_sbd *sdp)
1056{
1057 struct gfs2_rgrpd *rgd;
1058 unsigned int journals = gfs2_jindex_size(sdp);
1059 unsigned int rg = 0, x;
1060
1061 spin_lock(&sdp->sd_rindex_spin);
1062
1063 rgd = sdp->sd_rindex_forward;
1064 if (!rgd) {
1065 if (sdp->sd_rgrps >= journals)
1066 rg = sdp->sd_rgrps * sdp->sd_jdesc->jd_jid / journals;
1067
Steven Whitehouseb8e1aab2006-08-22 16:25:50 -04001068 for (x = 0, rgd = gfs2_rgrpd_get_first(sdp); x < rg;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001069 x++, rgd = gfs2_rgrpd_get_next(rgd))
1070 /* Do Nothing */;
1071
1072 sdp->sd_rindex_forward = rgd;
1073 }
1074
1075 spin_unlock(&sdp->sd_rindex_spin);
1076
1077 return rgd;
1078}
1079
1080/**
1081 * forward_rgrp_set - set the forward rgrp pointer
1082 * @sdp: the filesystem
1083 * @rgd: The new forward rgrp
1084 *
1085 */
1086
1087static void forward_rgrp_set(struct gfs2_sbd *sdp, struct gfs2_rgrpd *rgd)
1088{
1089 spin_lock(&sdp->sd_rindex_spin);
1090 sdp->sd_rindex_forward = rgd;
1091 spin_unlock(&sdp->sd_rindex_spin);
1092}
1093
1094/**
1095 * get_local_rgrp - Choose and lock a rgrp for allocation
1096 * @ip: the inode to reserve space for
1097 * @rgp: the chosen and locked rgrp
1098 *
1099 * Try to acquire rgrp in way which avoids contending with others.
1100 *
1101 * Returns: errno
1102 */
1103
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001104static struct inode *get_local_rgrp(struct gfs2_inode *ip, u64 *last_unlinked)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001105{
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001106 struct inode *inode = NULL;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001107 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001108 struct gfs2_rgrpd *rgd, *begin = NULL;
Steven Whitehouse6dbd8222008-01-10 15:18:55 +00001109 struct gfs2_alloc *al = ip->i_alloc;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001110 int flags = LM_FLAG_TRY;
1111 int skipped = 0;
1112 int loops = 0;
Abhijith Das292c8c12007-11-29 14:13:54 -06001113 int error, rg_locked;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001114
1115 /* Try recently successful rgrps */
1116
Steven Whitehousece276b02008-02-06 09:25:45 +00001117 rgd = recent_rgrp_first(sdp, ip->i_goal);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001118
1119 while (rgd) {
Abhijith Das292c8c12007-11-29 14:13:54 -06001120 rg_locked = 0;
1121
1122 if (gfs2_glock_is_locked_by_me(rgd->rd_gl)) {
1123 rg_locked = 1;
1124 error = 0;
1125 } else {
1126 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE,
1127 LM_FLAG_TRY, &al->al_rgd_gh);
1128 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001129 switch (error) {
1130 case 0:
1131 if (try_rgrp_fit(rgd, al))
1132 goto out;
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001133 if (rgd->rd_flags & GFS2_RDF_CHECK)
1134 inode = try_rgrp_unlink(rgd, last_unlinked);
Abhijith Das292c8c12007-11-29 14:13:54 -06001135 if (!rg_locked)
1136 gfs2_glock_dq_uninit(&al->al_rgd_gh);
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001137 if (inode)
1138 return inode;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001139 rgd = recent_rgrp_next(rgd, 1);
1140 break;
1141
1142 case GLR_TRYFAILED:
1143 rgd = recent_rgrp_next(rgd, 0);
1144 break;
1145
1146 default:
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001147 return ERR_PTR(error);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001148 }
1149 }
1150
1151 /* Go through full list of rgrps */
1152
1153 begin = rgd = forward_rgrp_get(sdp);
1154
1155 for (;;) {
Abhijith Das292c8c12007-11-29 14:13:54 -06001156 rg_locked = 0;
1157
1158 if (gfs2_glock_is_locked_by_me(rgd->rd_gl)) {
1159 rg_locked = 1;
1160 error = 0;
1161 } else {
1162 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, flags,
1163 &al->al_rgd_gh);
1164 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001165 switch (error) {
1166 case 0:
1167 if (try_rgrp_fit(rgd, al))
1168 goto out;
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001169 if (rgd->rd_flags & GFS2_RDF_CHECK)
1170 inode = try_rgrp_unlink(rgd, last_unlinked);
Abhijith Das292c8c12007-11-29 14:13:54 -06001171 if (!rg_locked)
1172 gfs2_glock_dq_uninit(&al->al_rgd_gh);
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001173 if (inode)
1174 return inode;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001175 break;
1176
1177 case GLR_TRYFAILED:
1178 skipped++;
1179 break;
1180
1181 default:
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001182 return ERR_PTR(error);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001183 }
1184
1185 rgd = gfs2_rgrpd_get_next(rgd);
1186 if (!rgd)
1187 rgd = gfs2_rgrpd_get_first(sdp);
1188
1189 if (rgd == begin) {
Benjamin Marzinski172e0452007-03-23 14:51:56 -06001190 if (++loops >= 3)
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001191 return ERR_PTR(-ENOSPC);
Benjamin Marzinski172e0452007-03-23 14:51:56 -06001192 if (!skipped)
1193 loops++;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001194 flags = 0;
Benjamin Marzinski172e0452007-03-23 14:51:56 -06001195 if (loops == 2)
1196 gfs2_log_flush(sdp, NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001197 }
1198 }
1199
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001200out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001201 if (begin) {
1202 recent_rgrp_add(rgd);
1203 rgd = gfs2_rgrpd_get_next(rgd);
1204 if (!rgd)
1205 rgd = gfs2_rgrpd_get_first(sdp);
1206 forward_rgrp_set(sdp, rgd);
1207 }
1208
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001209 return NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001210}
1211
1212/**
1213 * gfs2_inplace_reserve_i - Reserve space in the filesystem
1214 * @ip: the inode to reserve space for
1215 *
1216 * Returns: errno
1217 */
1218
1219int gfs2_inplace_reserve_i(struct gfs2_inode *ip, char *file, unsigned int line)
1220{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001221 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Steven Whitehouse6dbd8222008-01-10 15:18:55 +00001222 struct gfs2_alloc *al = ip->i_alloc;
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001223 struct inode *inode;
Robert Peterson7ae8fa82007-05-09 09:37:57 -05001224 int error = 0;
Bob Peterson6760bdc2007-07-24 14:09:32 -05001225 u64 last_unlinked = NO_BLOCK;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001226
1227 if (gfs2_assert_warn(sdp, al->al_requested))
1228 return -EINVAL;
1229
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001230try_again:
Robert Peterson7ae8fa82007-05-09 09:37:57 -05001231 /* We need to hold the rindex unless the inode we're using is
1232 the rindex itself, in which case it's already held. */
1233 if (ip != GFS2_I(sdp->sd_rindex))
1234 error = gfs2_rindex_hold(sdp, &al->al_ri_gh);
1235 else if (!sdp->sd_rgrps) /* We may not have the rindex read in, so: */
Robert Peterson6c532672007-05-10 16:54:38 -05001236 error = gfs2_ri_update_special(ip);
Robert Peterson7ae8fa82007-05-09 09:37:57 -05001237
David Teiglandb3b94fa2006-01-16 16:50:04 +00001238 if (error)
1239 return error;
1240
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001241 inode = get_local_rgrp(ip, &last_unlinked);
1242 if (inode) {
Robert Peterson7ae8fa82007-05-09 09:37:57 -05001243 if (ip != GFS2_I(sdp->sd_rindex))
1244 gfs2_glock_dq_uninit(&al->al_ri_gh);
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001245 if (IS_ERR(inode))
1246 return PTR_ERR(inode);
1247 iput(inode);
1248 gfs2_log_flush(sdp, NULL);
1249 goto try_again;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001250 }
1251
1252 al->al_file = file;
1253 al->al_line = line;
1254
1255 return 0;
1256}
1257
1258/**
1259 * gfs2_inplace_release - release an inplace reservation
1260 * @ip: the inode the reservation was taken out on
1261 *
1262 * Release a reservation made by gfs2_inplace_reserve().
1263 */
1264
1265void gfs2_inplace_release(struct gfs2_inode *ip)
1266{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001267 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Steven Whitehouse6dbd8222008-01-10 15:18:55 +00001268 struct gfs2_alloc *al = ip->i_alloc;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001269
1270 if (gfs2_assert_warn(sdp, al->al_alloced <= al->al_requested) == -1)
1271 fs_warn(sdp, "al_alloced = %u, al_requested = %u "
1272 "al_file = %s, al_line = %u\n",
1273 al->al_alloced, al->al_requested, al->al_file,
1274 al->al_line);
1275
1276 al->al_rgd = NULL;
Abhijith Das292c8c12007-11-29 14:13:54 -06001277 if (al->al_rgd_gh.gh_gl)
1278 gfs2_glock_dq_uninit(&al->al_rgd_gh);
Robert Peterson7ae8fa82007-05-09 09:37:57 -05001279 if (ip != GFS2_I(sdp->sd_rindex))
1280 gfs2_glock_dq_uninit(&al->al_ri_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001281}
1282
1283/**
1284 * gfs2_get_block_type - Check a block in a RG is of given type
1285 * @rgd: the resource group holding the block
1286 * @block: the block number
1287 *
1288 * Returns: The block type (GFS2_BLKST_*)
1289 */
1290
Steven Whitehousecd915492006-09-04 12:49:07 -04001291unsigned char gfs2_get_block_type(struct gfs2_rgrpd *rgd, u64 block)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001292{
1293 struct gfs2_bitmap *bi = NULL;
Steven Whitehousecd915492006-09-04 12:49:07 -04001294 u32 length, rgrp_block, buf_block;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001295 unsigned int buf;
1296 unsigned char type;
1297
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001298 length = rgd->rd_length;
1299 rgrp_block = block - rgd->rd_data0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001300
1301 for (buf = 0; buf < length; buf++) {
1302 bi = rgd->rd_bits + buf;
1303 if (rgrp_block < (bi->bi_start + bi->bi_len) * GFS2_NBBY)
1304 break;
1305 }
1306
1307 gfs2_assert(rgd->rd_sbd, buf < length);
1308 buf_block = rgrp_block - bi->bi_start * GFS2_NBBY;
1309
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001310 type = gfs2_testbit(rgd, bi->bi_bh->b_data + bi->bi_offset,
David Teiglandb3b94fa2006-01-16 16:50:04 +00001311 bi->bi_len, buf_block);
1312
1313 return type;
1314}
1315
1316/**
1317 * rgblk_search - find a block in @old_state, change allocation
1318 * state to @new_state
1319 * @rgd: the resource group descriptor
1320 * @goal: the goal block within the RG (start here to search for avail block)
1321 * @old_state: GFS2_BLKST_XXX the before-allocation state to find
1322 * @new_state: GFS2_BLKST_XXX the after-allocation block state
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001323 * @n: The extent length
David Teiglandb3b94fa2006-01-16 16:50:04 +00001324 *
1325 * Walk rgrp's bitmap to find bits that represent a block in @old_state.
1326 * Add the found bitmap buffer to the transaction.
1327 * Set the found bits to @new_state to change block's allocation state.
1328 *
1329 * This function never fails, because we wouldn't call it unless we
1330 * know (from reservation results, etc.) that a block is available.
1331 *
1332 * Scope of @goal and returned block is just within rgrp, not the whole
1333 * filesystem.
1334 *
1335 * Returns: the block number allocated
1336 */
1337
Steven Whitehousecd915492006-09-04 12:49:07 -04001338static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001339 unsigned char old_state, unsigned char new_state,
1340 unsigned int *n)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001341{
1342 struct gfs2_bitmap *bi = NULL;
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001343 const u32 length = rgd->rd_length;
Steven Whitehousecd915492006-09-04 12:49:07 -04001344 u32 blk = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001345 unsigned int buf, x;
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001346 const unsigned int elen = *n;
1347 const u8 *buffer;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001348
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001349 *n = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001350 /* Find bitmap block that contains bits for goal block */
1351 for (buf = 0; buf < length; buf++) {
1352 bi = rgd->rd_bits + buf;
1353 if (goal < (bi->bi_start + bi->bi_len) * GFS2_NBBY)
1354 break;
1355 }
1356
1357 gfs2_assert(rgd->rd_sbd, buf < length);
1358
1359 /* Convert scope of "goal" from rgrp-wide to within found bit block */
1360 goal -= bi->bi_start * GFS2_NBBY;
1361
1362 /* Search (up to entire) bitmap in this rgrp for allocatable block.
1363 "x <= length", instead of "x < length", because we typically start
1364 the search in the middle of a bit block, but if we can't find an
1365 allocatable block anywhere else, we want to be able wrap around and
1366 search in the first part of our first-searched bit block. */
1367 for (x = 0; x <= length; x++) {
Bob Peterson5f3eae72007-08-08 16:52:09 -05001368 /* The GFS2_BLKST_UNLINKED state doesn't apply to the clone
1369 bitmaps, so we must search the originals for that. */
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001370 buffer = bi->bi_bh->b_data + bi->bi_offset;
Bob Peterson5f3eae72007-08-08 16:52:09 -05001371 if (old_state != GFS2_BLKST_UNLINKED && bi->bi_clone)
Steven Whitehouse110acf32008-01-29 13:30:20 +00001372 buffer = bi->bi_clone + bi->bi_offset;
1373
1374 blk = gfs2_bitfit(buffer, bi->bi_len, goal, old_state);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001375 if (blk != BFITNOENT)
1376 break;
1377
1378 /* Try next bitmap block (wrap back to rgrp header if at end) */
1379 buf = (buf + 1) % length;
1380 bi = rgd->rd_bits + buf;
1381 goal = 0;
1382 }
1383
Bob Peterson6760bdc2007-07-24 14:09:32 -05001384 if (blk != BFITNOENT && old_state != new_state) {
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001385 *n = 1;
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001386 gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001387 gfs2_setbit(rgd, bi->bi_bh->b_data, bi->bi_clone, bi->bi_offset,
David Teiglandb3b94fa2006-01-16 16:50:04 +00001388 bi->bi_len, blk, new_state);
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +00001389 goal = blk;
1390 while (*n < elen) {
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001391 goal++;
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +00001392 if (goal >= (bi->bi_len * GFS2_NBBY))
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001393 break;
1394 if (gfs2_testbit(rgd, buffer, bi->bi_len, goal) !=
1395 GFS2_BLKST_FREE)
1396 break;
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001397 gfs2_setbit(rgd, bi->bi_bh->b_data, bi->bi_clone,
Steven Whitehouse9b8c81d2008-02-22 16:09:31 +00001398 bi->bi_offset, bi->bi_len, goal,
1399 new_state);
1400 (*n)++;
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001401 }
Steven Whitehousec8cdf472007-06-08 10:05:33 +01001402 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001403
Steven Whitehouse6eefaf62007-07-17 10:26:56 +01001404 return (blk == BFITNOENT) ? blk : (bi->bi_start * GFS2_NBBY) + blk;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001405}
1406
1407/**
1408 * rgblk_free - Change alloc state of given block(s)
1409 * @sdp: the filesystem
1410 * @bstart: the start of a run of blocks to free
1411 * @blen: the length of the block run (all must lie within ONE RG!)
1412 * @new_state: GFS2_BLKST_XXX the after-allocation block state
1413 *
1414 * Returns: Resource group containing the block(s)
1415 */
1416
Steven Whitehousecd915492006-09-04 12:49:07 -04001417static struct gfs2_rgrpd *rgblk_free(struct gfs2_sbd *sdp, u64 bstart,
1418 u32 blen, unsigned char new_state)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001419{
1420 struct gfs2_rgrpd *rgd;
1421 struct gfs2_bitmap *bi = NULL;
Steven Whitehousecd915492006-09-04 12:49:07 -04001422 u32 length, rgrp_blk, buf_blk;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001423 unsigned int buf;
1424
1425 rgd = gfs2_blk2rgrpd(sdp, bstart);
1426 if (!rgd) {
1427 if (gfs2_consist(sdp))
Steven Whitehouse382066d2006-05-24 10:22:09 -04001428 fs_err(sdp, "block = %llu\n", (unsigned long long)bstart);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001429 return NULL;
1430 }
1431
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001432 length = rgd->rd_length;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001433
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001434 rgrp_blk = bstart - rgd->rd_data0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001435
1436 while (blen--) {
1437 for (buf = 0; buf < length; buf++) {
1438 bi = rgd->rd_bits + buf;
1439 if (rgrp_blk < (bi->bi_start + bi->bi_len) * GFS2_NBBY)
1440 break;
1441 }
1442
1443 gfs2_assert(rgd->rd_sbd, buf < length);
1444
1445 buf_blk = rgrp_blk - bi->bi_start * GFS2_NBBY;
1446 rgrp_blk++;
1447
1448 if (!bi->bi_clone) {
1449 bi->bi_clone = kmalloc(bi->bi_bh->b_size,
Steven Whitehousedd894be2006-07-27 14:29:00 -04001450 GFP_NOFS | __GFP_NOFAIL);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001451 memcpy(bi->bi_clone + bi->bi_offset,
1452 bi->bi_bh->b_data + bi->bi_offset,
1453 bi->bi_len);
1454 }
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001455 gfs2_trans_add_bh(rgd->rd_gl, bi->bi_bh, 1);
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001456 gfs2_setbit(rgd, bi->bi_bh->b_data, NULL, bi->bi_offset,
David Teiglandb3b94fa2006-01-16 16:50:04 +00001457 bi->bi_len, buf_blk, new_state);
1458 }
1459
1460 return rgd;
1461}
1462
1463/**
Steven Whitehouse16394312008-02-01 14:52:30 +00001464 * gfs2_alloc_block - Allocate a block
1465 * @ip: the inode to allocate the block for
David Teiglandb3b94fa2006-01-16 16:50:04 +00001466 *
1467 * Returns: the allocated block
1468 */
1469
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001470u64 gfs2_alloc_block(struct gfs2_inode *ip, unsigned int *n)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001471{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001472 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Steven Whitehouse6dbd8222008-01-10 15:18:55 +00001473 struct gfs2_alloc *al = ip->i_alloc;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001474 struct gfs2_rgrpd *rgd = al->al_rgd;
Steven Whitehousecd915492006-09-04 12:49:07 -04001475 u32 goal, blk;
1476 u64 block;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001477
Steven Whitehousece276b02008-02-06 09:25:45 +00001478 if (rgrp_contains_block(rgd, ip->i_goal))
1479 goal = ip->i_goal - rgd->rd_data0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001480 else
Steven Whitehouseac576cc2008-02-01 10:34:15 +00001481 goal = rgd->rd_last_alloc;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001482
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001483 blk = rgblk_search(rgd, goal, GFS2_BLKST_FREE, GFS2_BLKST_USED, n);
Steven Whitehouse6eefaf62007-07-17 10:26:56 +01001484 BUG_ON(blk == BFITNOENT);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001485
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001486 rgd->rd_last_alloc = blk;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001487 block = rgd->rd_data0 + blk;
Steven Whitehousece276b02008-02-06 09:25:45 +00001488 ip->i_goal = block;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001489
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001490 gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free >= *n);
1491 rgd->rd_rg.rg_free -= *n;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001492
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001493 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
Bob Peterson42d52e32008-01-28 18:38:07 -06001494 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001495
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001496 al->al_alloced += *n;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001497
Andrew Pricead99f772008-05-01 11:55:38 +01001498 gfs2_statfs_change(sdp, 0, -(s64)*n, 0);
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001499 gfs2_quota_change(ip, *n, ip->i_inode.i_uid, ip->i_inode.i_gid);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001500
1501 spin_lock(&sdp->sd_rindex_spin);
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001502 rgd->rd_free_clone -= *n;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001503 spin_unlock(&sdp->sd_rindex_spin);
1504
1505 return block;
1506}
1507
1508/**
1509 * gfs2_alloc_di - Allocate a dinode
1510 * @dip: the directory that the inode is going in
1511 *
1512 * Returns: the block allocated
1513 */
1514
Steven Whitehouse4340fe62006-07-11 09:46:33 -04001515u64 gfs2_alloc_di(struct gfs2_inode *dip, u64 *generation)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001516{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001517 struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
Steven Whitehouse6dbd8222008-01-10 15:18:55 +00001518 struct gfs2_alloc *al = dip->i_alloc;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001519 struct gfs2_rgrpd *rgd = al->al_rgd;
Steven Whitehouse4340fe62006-07-11 09:46:33 -04001520 u32 blk;
1521 u64 block;
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001522 unsigned int n = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001523
Steven Whitehouseac576cc2008-02-01 10:34:15 +00001524 blk = rgblk_search(rgd, rgd->rd_last_alloc,
Steven Whitehouseb45e41d2008-02-06 10:11:15 +00001525 GFS2_BLKST_FREE, GFS2_BLKST_DINODE, &n);
Steven Whitehouse6eefaf62007-07-17 10:26:56 +01001526 BUG_ON(blk == BFITNOENT);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001527
Steven Whitehouseac576cc2008-02-01 10:34:15 +00001528 rgd->rd_last_alloc = blk;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001529
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001530 block = rgd->rd_data0 + blk;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001531
1532 gfs2_assert_withdraw(sdp, rgd->rd_rg.rg_free);
1533 rgd->rd_rg.rg_free--;
1534 rgd->rd_rg.rg_dinodes++;
Steven Whitehouse4340fe62006-07-11 09:46:33 -04001535 *generation = rgd->rd_rg.rg_igeneration++;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001536 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
Bob Peterson42d52e32008-01-28 18:38:07 -06001537 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001538
1539 al->al_alloced++;
1540
1541 gfs2_statfs_change(sdp, 0, -1, +1);
Steven Whitehouse5731be52008-02-01 13:16:55 +00001542 gfs2_trans_add_unrevoke(sdp, block, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001543
1544 spin_lock(&sdp->sd_rindex_spin);
1545 rgd->rd_free_clone--;
1546 spin_unlock(&sdp->sd_rindex_spin);
1547
1548 return block;
1549}
1550
1551/**
1552 * gfs2_free_data - free a contiguous run of data block(s)
1553 * @ip: the inode these blocks are being freed from
1554 * @bstart: first block of a run of contiguous blocks
1555 * @blen: the length of the block run
1556 *
1557 */
1558
Steven Whitehousecd915492006-09-04 12:49:07 -04001559void gfs2_free_data(struct gfs2_inode *ip, u64 bstart, u32 blen)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001560{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001561 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001562 struct gfs2_rgrpd *rgd;
1563
1564 rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
1565 if (!rgd)
1566 return;
1567
1568 rgd->rd_rg.rg_free += blen;
1569
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001570 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
Bob Peterson42d52e32008-01-28 18:38:07 -06001571 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001572
1573 gfs2_trans_add_rg(rgd);
1574
1575 gfs2_statfs_change(sdp, 0, +blen, 0);
Steven Whitehouse2933f922006-11-01 13:23:29 -05001576 gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001577}
1578
1579/**
1580 * gfs2_free_meta - free a contiguous run of data block(s)
1581 * @ip: the inode these blocks are being freed from
1582 * @bstart: first block of a run of contiguous blocks
1583 * @blen: the length of the block run
1584 *
1585 */
1586
Steven Whitehousecd915492006-09-04 12:49:07 -04001587void gfs2_free_meta(struct gfs2_inode *ip, u64 bstart, u32 blen)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001588{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001589 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001590 struct gfs2_rgrpd *rgd;
1591
1592 rgd = rgblk_free(sdp, bstart, blen, GFS2_BLKST_FREE);
1593 if (!rgd)
1594 return;
1595
1596 rgd->rd_rg.rg_free += blen;
1597
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001598 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
Bob Peterson42d52e32008-01-28 18:38:07 -06001599 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001600
1601 gfs2_trans_add_rg(rgd);
1602
1603 gfs2_statfs_change(sdp, 0, +blen, 0);
Steven Whitehouse2933f922006-11-01 13:23:29 -05001604 gfs2_quota_change(ip, -(s64)blen, ip->i_inode.i_uid, ip->i_inode.i_gid);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001605 gfs2_meta_wipe(ip, bstart, blen);
1606}
1607
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001608void gfs2_unlink_di(struct inode *inode)
1609{
1610 struct gfs2_inode *ip = GFS2_I(inode);
1611 struct gfs2_sbd *sdp = GFS2_SB(inode);
1612 struct gfs2_rgrpd *rgd;
Steven Whitehousedbb7cae2007-05-15 15:37:50 +01001613 u64 blkno = ip->i_no_addr;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001614
1615 rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_UNLINKED);
1616 if (!rgd)
1617 return;
1618 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
Bob Peterson42d52e32008-01-28 18:38:07 -06001619 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001620 gfs2_trans_add_rg(rgd);
1621}
1622
Steven Whitehousecd915492006-09-04 12:49:07 -04001623static void gfs2_free_uninit_di(struct gfs2_rgrpd *rgd, u64 blkno)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001624{
1625 struct gfs2_sbd *sdp = rgd->rd_sbd;
1626 struct gfs2_rgrpd *tmp_rgd;
1627
1628 tmp_rgd = rgblk_free(sdp, blkno, 1, GFS2_BLKST_FREE);
1629 if (!tmp_rgd)
1630 return;
1631 gfs2_assert_withdraw(sdp, rgd == tmp_rgd);
1632
1633 if (!rgd->rd_rg.rg_dinodes)
1634 gfs2_consist_rgrpd(rgd);
1635 rgd->rd_rg.rg_dinodes--;
1636 rgd->rd_rg.rg_free++;
1637
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001638 gfs2_trans_add_bh(rgd->rd_gl, rgd->rd_bits[0].bi_bh, 1);
Bob Peterson42d52e32008-01-28 18:38:07 -06001639 gfs2_rgrp_out(rgd, rgd->rd_bits[0].bi_bh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001640
1641 gfs2_statfs_change(sdp, 0, +1, -1);
1642 gfs2_trans_add_rg(rgd);
1643}
1644
David Teiglandb3b94fa2006-01-16 16:50:04 +00001645
1646void gfs2_free_di(struct gfs2_rgrpd *rgd, struct gfs2_inode *ip)
1647{
Steven Whitehousedbb7cae2007-05-15 15:37:50 +01001648 gfs2_free_uninit_di(rgd, ip->i_no_addr);
Steven Whitehouse2933f922006-11-01 13:23:29 -05001649 gfs2_quota_change(ip, -1, ip->i_inode.i_uid, ip->i_inode.i_gid);
Steven Whitehousedbb7cae2007-05-15 15:37:50 +01001650 gfs2_meta_wipe(ip, ip->i_no_addr, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001651}
1652
1653/**
1654 * gfs2_rlist_add - add a RG to a list of RGs
1655 * @sdp: the filesystem
1656 * @rlist: the list of resource groups
1657 * @block: the block
1658 *
1659 * Figure out what RG a block belongs to and add that RG to the list
1660 *
1661 * FIXME: Don't use NOFAIL
1662 *
1663 */
1664
1665void gfs2_rlist_add(struct gfs2_sbd *sdp, struct gfs2_rgrp_list *rlist,
Steven Whitehousecd915492006-09-04 12:49:07 -04001666 u64 block)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001667{
1668 struct gfs2_rgrpd *rgd;
1669 struct gfs2_rgrpd **tmp;
1670 unsigned int new_space;
1671 unsigned int x;
1672
1673 if (gfs2_assert_warn(sdp, !rlist->rl_ghs))
1674 return;
1675
1676 rgd = gfs2_blk2rgrpd(sdp, block);
1677 if (!rgd) {
1678 if (gfs2_consist(sdp))
Steven Whitehouse382066d2006-05-24 10:22:09 -04001679 fs_err(sdp, "block = %llu\n", (unsigned long long)block);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001680 return;
1681 }
1682
1683 for (x = 0; x < rlist->rl_rgrps; x++)
1684 if (rlist->rl_rgd[x] == rgd)
1685 return;
1686
1687 if (rlist->rl_rgrps == rlist->rl_space) {
1688 new_space = rlist->rl_space + 10;
1689
1690 tmp = kcalloc(new_space, sizeof(struct gfs2_rgrpd *),
Steven Whitehousedd894be2006-07-27 14:29:00 -04001691 GFP_NOFS | __GFP_NOFAIL);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001692
1693 if (rlist->rl_rgd) {
1694 memcpy(tmp, rlist->rl_rgd,
1695 rlist->rl_space * sizeof(struct gfs2_rgrpd *));
1696 kfree(rlist->rl_rgd);
1697 }
1698
1699 rlist->rl_space = new_space;
1700 rlist->rl_rgd = tmp;
1701 }
1702
1703 rlist->rl_rgd[rlist->rl_rgrps++] = rgd;
1704}
1705
1706/**
1707 * gfs2_rlist_alloc - all RGs have been added to the rlist, now allocate
1708 * and initialize an array of glock holders for them
1709 * @rlist: the list of resource groups
1710 * @state: the lock state to acquire the RG lock in
1711 * @flags: the modifier flags for the holder structures
1712 *
1713 * FIXME: Don't use NOFAIL
1714 *
1715 */
1716
Bob Petersonfe6c9912008-01-28 11:13:02 -06001717void gfs2_rlist_alloc(struct gfs2_rgrp_list *rlist, unsigned int state)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001718{
1719 unsigned int x;
1720
1721 rlist->rl_ghs = kcalloc(rlist->rl_rgrps, sizeof(struct gfs2_holder),
Steven Whitehousedd894be2006-07-27 14:29:00 -04001722 GFP_NOFS | __GFP_NOFAIL);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001723 for (x = 0; x < rlist->rl_rgrps; x++)
1724 gfs2_holder_init(rlist->rl_rgd[x]->rd_gl,
Bob Petersonfe6c9912008-01-28 11:13:02 -06001725 state, 0,
David Teiglandb3b94fa2006-01-16 16:50:04 +00001726 &rlist->rl_ghs[x]);
1727}
1728
1729/**
1730 * gfs2_rlist_free - free a resource group list
1731 * @list: the list of resource groups
1732 *
1733 */
1734
1735void gfs2_rlist_free(struct gfs2_rgrp_list *rlist)
1736{
1737 unsigned int x;
1738
1739 kfree(rlist->rl_rgd);
1740
1741 if (rlist->rl_ghs) {
1742 for (x = 0; x < rlist->rl_rgrps; x++)
1743 gfs2_holder_uninit(&rlist->rl_ghs[x]);
1744 kfree(rlist->rl_ghs);
1745 }
1746}
1747