[mirror_ubuntu-zesty-kernel.git] / fs / gfs2 / unlinked.c

/*
 * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 * Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
 *
 * This copyrighted material is made available to anyone wishing to use,
 * modify, copy, or redistribute it subject to the terms and conditions
 * of the GNU General Public License v.2.
 */

#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/completion.h>
#include <linux/buffer_head.h>
#include <linux/kthread.h>
#include <asm/semaphore.h>

#include "gfs2.h"
#include "bmap.h"
#include "inode.h"
#include "meta_io.h"
#include "trans.h"
#include "unlinked.h"

static int munge_ondisk(struct gfs2_sbd *sdp, unsigned int slot,
			struct gfs2_unlinked_tag *ut)
{
	struct gfs2_inode *ip = get_v2ip(sdp->sd_ut_inode);
	unsigned int block, offset;
	uint64_t dblock;
	int new = 0;
	struct buffer_head *bh;
	int error;

	block = slot / sdp->sd_ut_per_block;
	offset = slot % sdp->sd_ut_per_block;

	error = gfs2_block_map(ip, block, &new, &dblock, NULL);
	if (error)
		return error;
	error = gfs2_meta_read(ip->i_gl, dblock, DIO_START | DIO_WAIT, &bh);
	if (error)
		return error;
	if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_UT)) {
		error = -EIO;
		goto out;
	}

	mutex_lock(&sdp->sd_unlinked_mutex);
	gfs2_trans_add_bh(ip->i_gl, bh, 1);
	gfs2_unlinked_tag_out(ut, bh->b_data +
				  sizeof(struct gfs2_meta_header) +
				  offset * sizeof(struct gfs2_unlinked_tag));
	mutex_unlock(&sdp->sd_unlinked_mutex);

 out:
	brelse(bh);

	return error;
}

static void ul_hash(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul)
{
	spin_lock(&sdp->sd_unlinked_spin);
	list_add(&ul->ul_list, &sdp->sd_unlinked_list);
	gfs2_assert(sdp, ul->ul_count);
	ul->ul_count++;
	atomic_inc(&sdp->sd_unlinked_count);
	spin_unlock(&sdp->sd_unlinked_spin);
}

static void ul_unhash(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul)
{
	spin_lock(&sdp->sd_unlinked_spin);
	list_del_init(&ul->ul_list);
	gfs2_assert(sdp, ul->ul_count > 1);
	ul->ul_count--;
	gfs2_assert_warn(sdp, atomic_read(&sdp->sd_unlinked_count) > 0);
	atomic_dec(&sdp->sd_unlinked_count);
	spin_unlock(&sdp->sd_unlinked_spin);
}

static struct gfs2_unlinked *ul_fish(struct gfs2_sbd *sdp)
{
	struct list_head *head;
	struct gfs2_unlinked *ul;
	int found = 0;

	if (sdp->sd_vfs->s_flags & MS_RDONLY)
		return NULL;

	spin_lock(&sdp->sd_unlinked_spin);

	head = &sdp->sd_unlinked_list;

	list_for_each_entry(ul, head, ul_list) {
		if (test_bit(ULF_LOCKED, &ul->ul_flags))
			continue;

		list_move_tail(&ul->ul_list, head);
		ul->ul_count++;
		set_bit(ULF_LOCKED, &ul->ul_flags);
		found = 1;

		break;
	}

	if (!found)
		ul = NULL;

	spin_unlock(&sdp->sd_unlinked_spin);

	return ul;
}

/**
 * enforce_limit - limit the number of inodes waiting to be deallocated
 * @sdp: the filesystem
 *
 * Returns: errno
 */

static void enforce_limit(struct gfs2_sbd *sdp)
{
	unsigned int tries = 0, min = 0;
	int error;

	if (atomic_read(&sdp->sd_unlinked_count) >=
	    gfs2_tune_get(sdp, gt_ilimit)) {
		tries = gfs2_tune_get(sdp, gt_ilimit_tries);
		min = gfs2_tune_get(sdp, gt_ilimit_min);
	}

	while (tries--) {
		struct gfs2_unlinked *ul = ul_fish(sdp);
		if (!ul)
			break;
		error = gfs2_inode_dealloc(sdp, ul);
		gfs2_unlinked_put(sdp, ul);

		if (!error) {
			if (!--min)
				break;
		} else if (error != 1)
			break;
	}
}

static struct gfs2_unlinked *ul_alloc(struct gfs2_sbd *sdp)
{
	struct gfs2_unlinked *ul;

	ul = kzalloc(sizeof(struct gfs2_unlinked), GFP_KERNEL);
	if (ul) {
		INIT_LIST_HEAD(&ul->ul_list);
		ul->ul_count = 1;
		set_bit(ULF_LOCKED, &ul->ul_flags);
	}

	return ul;
}

int gfs2_unlinked_get(struct gfs2_sbd *sdp, struct gfs2_unlinked **ul)
{
	unsigned int c, o = 0, b;
	unsigned char byte = 0;

	enforce_limit(sdp);

	*ul = ul_alloc(sdp);
	if (!*ul)
		return -ENOMEM;

	spin_lock(&sdp->sd_unlinked_spin);

	for (c = 0; c < sdp->sd_unlinked_chunks; c++)
		for (o = 0; o < PAGE_SIZE; o++) {
			byte = sdp->sd_unlinked_bitmap[c][o];
			if (byte != 0xFF)
				goto found;
		}

	goto fail;

 found:
	for (b = 0; b < 8; b++)
		if (!(byte & (1 << b)))
			break;
	(*ul)->ul_slot = c * (8 * PAGE_SIZE) + o * 8 + b;

	if ((*ul)->ul_slot >= sdp->sd_unlinked_slots)
		goto fail;

	sdp->sd_unlinked_bitmap[c][o] |= 1 << b;

	spin_unlock(&sdp->sd_unlinked_spin);

	return 0;

 fail:
	spin_unlock(&sdp->sd_unlinked_spin);
	kfree(*ul);
	return -ENOSPC;
}

void gfs2_unlinked_put(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul)
{
	gfs2_assert_warn(sdp, test_and_clear_bit(ULF_LOCKED, &ul->ul_flags));

	spin_lock(&sdp->sd_unlinked_spin);
	gfs2_assert(sdp, ul->ul_count);
	ul->ul_count--;
	if (!ul->ul_count) {
		gfs2_icbit_munge(sdp, sdp->sd_unlinked_bitmap, ul->ul_slot, 0);
		spin_unlock(&sdp->sd_unlinked_spin);
		kfree(ul);
	} else
		spin_unlock(&sdp->sd_unlinked_spin);
}

int gfs2_unlinked_ondisk_add(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul)
{
	int error;

	gfs2_assert_warn(sdp, test_bit(ULF_LOCKED, &ul->ul_flags));
	gfs2_assert_warn(sdp, list_empty(&ul->ul_list));

	error = munge_ondisk(sdp, ul->ul_slot, &ul->ul_ut);
	if (!error)
		ul_hash(sdp, ul);

	return error;
}

int gfs2_unlinked_ondisk_munge(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul)
{
	int error;

	gfs2_assert_warn(sdp, test_bit(ULF_LOCKED, &ul->ul_flags));
	gfs2_assert_warn(sdp, !list_empty(&ul->ul_list));

	error = munge_ondisk(sdp, ul->ul_slot, &ul->ul_ut);

	return error;
}

int gfs2_unlinked_ondisk_rm(struct gfs2_sbd *sdp, struct gfs2_unlinked *ul)
{
	struct gfs2_unlinked_tag ut;
	int error;

	gfs2_assert_warn(sdp, test_bit(ULF_LOCKED, &ul->ul_flags));
	gfs2_assert_warn(sdp, !list_empty(&ul->ul_list));

	memset(&ut, 0, sizeof(struct gfs2_unlinked_tag));

	error = munge_ondisk(sdp, ul->ul_slot, &ut);
	if (error)
		return error;

	ul_unhash(sdp, ul);

	return 0;
}

/**
 * gfs2_unlinked_dealloc - Go through the list of inodes to be deallocated
 * @sdp: the filesystem
 *
 * Returns: errno
 */

int gfs2_unlinked_dealloc(struct gfs2_sbd *sdp)
{
	unsigned int hits, strikes;
	int error;

	for (;;) {
		hits = 0;
		strikes = 0;

		for (;;) {
			struct gfs2_unlinked *ul = ul_fish(sdp);
			if (!ul)
				return 0;
			error = gfs2_inode_dealloc(sdp, ul);
			gfs2_unlinked_put(sdp, ul);

			if (!error) {
				hits++;
				if (strikes)
					strikes--;
			} else if (error == 1) {
				strikes++;
				if (strikes >=
				    atomic_read(&sdp->sd_unlinked_count)) {
					error = 0;
					break;
				}
			} else
				return error;
		}

		if (!hits || kthread_should_stop())
			break;

		cond_resched();
	}

	return 0;
}

int gfs2_unlinked_init(struct gfs2_sbd *sdp)
{
	struct gfs2_inode *ip = get_v2ip(sdp->sd_ut_inode);
	unsigned int blocks = ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift;
	unsigned int x, slot = 0;
	unsigned int found = 0;
	uint64_t dblock;
	uint32_t extlen = 0;
	int error;

	if (!ip->i_di.di_size ||
	    ip->i_di.di_size > (64 << 20) ||
	    ip->i_di.di_size & (sdp->sd_sb.sb_bsize - 1)) {
		gfs2_consist_inode(ip);
		return -EIO;		
	}
	sdp->sd_unlinked_slots = blocks * sdp->sd_ut_per_block;
	sdp->sd_unlinked_chunks = DIV_RU(sdp->sd_unlinked_slots, 8 * PAGE_SIZE);

	error = -ENOMEM;

	sdp->sd_unlinked_bitmap = kcalloc(sdp->sd_unlinked_chunks,
					  sizeof(unsigned char *),
					  GFP_KERNEL);
	if (!sdp->sd_unlinked_bitmap)
		return error;

	for (x = 0; x < sdp->sd_unlinked_chunks; x++) {
		sdp->sd_unlinked_bitmap[x] = kzalloc(PAGE_SIZE, GFP_KERNEL);
		if (!sdp->sd_unlinked_bitmap[x])
			goto fail;
	}

	for (x = 0; x < blocks; x++) {
		struct buffer_head *bh;
		unsigned int y;

		if (!extlen) {
			int new = 0;
			error = gfs2_block_map(ip, x, &new, &dblock, &extlen);
			if (error)
				goto fail;
		}
		gfs2_meta_ra(ip->i_gl, dblock, extlen);
		error = gfs2_meta_read(ip->i_gl, dblock, DIO_START | DIO_WAIT,
				       &bh);
		if (error)
			goto fail;
		error = -EIO;
		if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_UT)) {
			brelse(bh);
			goto fail;
		}

		for (y = 0;
		     y < sdp->sd_ut_per_block && slot < sdp->sd_unlinked_slots;
		     y++, slot++) {
			struct gfs2_unlinked_tag ut;
			struct gfs2_unlinked *ul;

			gfs2_unlinked_tag_in(&ut, bh->b_data +
					  sizeof(struct gfs2_meta_header) +
					  y * sizeof(struct gfs2_unlinked_tag));
			if (!ut.ut_inum.no_addr)
				continue;

			error = -ENOMEM;
			ul = ul_alloc(sdp);
			if (!ul) {
				brelse(bh);
				goto fail;
			}
			ul->ul_ut = ut;
			ul->ul_slot = slot;

			spin_lock(&sdp->sd_unlinked_spin);
			gfs2_icbit_munge(sdp, sdp->sd_unlinked_bitmap, slot, 1);
			spin_unlock(&sdp->sd_unlinked_spin);
			ul_hash(sdp, ul);

			gfs2_unlinked_put(sdp, ul);
			found++;
		}

		brelse(bh);
		dblock++;
		extlen--;
	}

	if (found)
		fs_info(sdp, "found %u unlinked inodes\n", found);

	return 0;

 fail:
	gfs2_unlinked_cleanup(sdp);
	return error;
}

/**
 * gfs2_unlinked_cleanup - get rid of any extra struct gfs2_unlinked structures
 * @sdp: the filesystem
 *
 */

void gfs2_unlinked_cleanup(struct gfs2_sbd *sdp)
{
	struct list_head *head = &sdp->sd_unlinked_list;
	struct gfs2_unlinked *ul;
	unsigned int x;

	spin_lock(&sdp->sd_unlinked_spin);
	while (!list_empty(head)) {
		ul = list_entry(head->next, struct gfs2_unlinked, ul_list);

		if (ul->ul_count > 1) {
			list_move_tail(&ul->ul_list, head);
			spin_unlock(&sdp->sd_unlinked_spin);
			schedule();
			spin_lock(&sdp->sd_unlinked_spin);
			continue;
		}

		list_del_init(&ul->ul_list);
		atomic_dec(&sdp->sd_unlinked_count);

		gfs2_assert_warn(sdp, ul->ul_count == 1);
		gfs2_assert_warn(sdp, !test_bit(ULF_LOCKED, &ul->ul_flags));
		kfree(ul);
	}
	spin_unlock(&sdp->sd_unlinked_spin);

	gfs2_assert_warn(sdp, !atomic_read(&sdp->sd_unlinked_count));

	if (sdp->sd_unlinked_bitmap) {
		for (x = 0; x < sdp->sd_unlinked_chunks; x++)
			kfree(sdp->sd_unlinked_bitmap[x]);
		kfree(sdp->sd_unlinked_bitmap);
	}
}
Commit	Line	Data
b3b94faa DT	1	/*
	2	* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
	3	* Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved.
	4	*
	5	* This copyrighted material is made available to anyone wishing to use,
	6	* modify, copy, or redistribute it subject to the terms and conditions
	7	* of the GNU General Public License v.2.
	8	*/
	9
	10	#include <linux/sched.h>
	11	#include <linux/slab.h>
	12	#include <linux/spinlock.h>
	13	#include <linux/completion.h>
	14	#include <linux/buffer_head.h>
	15	#include <linux/kthread.h>
	16	#include <asm/semaphore.h>
	17
	18	#include "gfs2.h"
	19	#include "bmap.h"
	20	#include "inode.h"
	21	#include "meta_io.h"
	22	#include "trans.h"
	23	#include "unlinked.h"
	24
	25	static int munge_ondisk(struct gfs2_sbd *sdp, unsigned int slot,
	26	struct gfs2_unlinked_tag *ut)
	27	{
f42faf4f	28	struct gfs2_inode *ip = get_v2ip(sdp->sd_ut_inode);
b3b94faa DT	29	unsigned int block, offset;
	30	uint64_t dblock;
	31	int new = 0;
	32	struct buffer_head *bh;
	33	int error;
	34
	35	block = slot / sdp->sd_ut_per_block;
	36	offset = slot % sdp->sd_ut_per_block;
	37
	38	error = gfs2_block_map(ip, block, &new, &dblock, NULL);
	39	if (error)
	40	return error;
	41	error = gfs2_meta_read(ip->i_gl, dblock, DIO_START \| DIO_WAIT, &bh);
	42	if (error)
	43	return error;
	44	if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_UT)) {
	45	error = -EIO;
	46	goto out;
	47	}
	48
f55ab26a	49	mutex_lock(&sdp->sd_unlinked_mutex);
d4e9c4c3	50	gfs2_trans_add_bh(ip->i_gl, bh, 1);
b3b94faa DT	51	gfs2_unlinked_tag_out(ut, bh->b_data +
	52	sizeof(struct gfs2_meta_header) +
	53	offset * sizeof(struct gfs2_unlinked_tag));
f55ab26a	54	mutex_unlock(&sdp->sd_unlinked_mutex);
b3b94faa DT	55
	56	out:
	57	brelse(bh);
	58
	59	return error;
	60	}
	61
	62	static void ul_hash(struct gfs2_sbd sdp, struct gfs2_unlinked ul)
	63	{
	64	spin_lock(&sdp->sd_unlinked_spin);
	65	list_add(&ul->ul_list, &sdp->sd_unlinked_list);
	66	gfs2_assert(sdp, ul->ul_count);
	67	ul->ul_count++;
	68	atomic_inc(&sdp->sd_unlinked_count);
	69	spin_unlock(&sdp->sd_unlinked_spin);
	70	}
	71
	72	static void ul_unhash(struct gfs2_sbd sdp, struct gfs2_unlinked ul)
	73	{
	74	spin_lock(&sdp->sd_unlinked_spin);
	75	list_del_init(&ul->ul_list);
	76	gfs2_assert(sdp, ul->ul_count > 1);
	77	ul->ul_count--;
	78	gfs2_assert_warn(sdp, atomic_read(&sdp->sd_unlinked_count) > 0);
	79	atomic_dec(&sdp->sd_unlinked_count);
	80	spin_unlock(&sdp->sd_unlinked_spin);
	81	}
	82
	83	static struct gfs2_unlinked ul_fish(struct gfs2_sbd sdp)
	84	{
	85	struct list_head *head;
	86	struct gfs2_unlinked *ul;
	87	int found = 0;
	88
	89	if (sdp->sd_vfs->s_flags & MS_RDONLY)
	90	return NULL;
	91
	92	spin_lock(&sdp->sd_unlinked_spin);
	93
	94	head = &sdp->sd_unlinked_list;
	95
	96	list_for_each_entry(ul, head, ul_list) {
	97	if (test_bit(ULF_LOCKED, &ul->ul_flags))
	98	continue;
	99
	100	list_move_tail(&ul->ul_list, head);
	101	ul->ul_count++;
	102	set_bit(ULF_LOCKED, &ul->ul_flags);
	103	found = 1;
	104
	105	break;
	106	}
	107
	108	if (!found)
	109	ul = NULL;
	110
	111	spin_unlock(&sdp->sd_unlinked_spin);
	112
	113	return ul;
	114	}
	115
	116	/**
	117	* enforce_limit - limit the number of inodes waiting to be deallocated
	118	* @sdp: the filesystem
119	*
120	* Returns: errno
121	*/
122
123	static void enforce_limit(struct gfs2_sbd *sdp)
124	{
125	unsigned int tries = 0, min = 0;
126	int error;
127
128	if (atomic_read(&sdp->sd_unlinked_count) >=
129	gfs2_tune_get(sdp, gt_ilimit)) {
130	tries = gfs2_tune_get(sdp, gt_ilimit_tries);
131	min = gfs2_tune_get(sdp, gt_ilimit_min);
132	}
133
134	while (tries--) {
135	struct gfs2_unlinked *ul = ul_fish(sdp);
136	if (!ul)
137	break;
138	error = gfs2_inode_dealloc(sdp, ul);
139	gfs2_unlinked_put(sdp, ul);
140
141	if (!error) {
142	if (!--min)
143	break;
144	} else if (error != 1)
145	break;
146	}
147	}
148
149	static struct gfs2_unlinked ul_alloc(struct gfs2_sbd sdp)
150	{
151	struct gfs2_unlinked *ul;
152
153	ul = kzalloc(sizeof(struct gfs2_unlinked), GFP_KERNEL);
154	if (ul) {
155	INIT_LIST_HEAD(&ul->ul_list);
156	ul->ul_count = 1;
157	set_bit(ULF_LOCKED, &ul->ul_flags);
158	}
159
160	return ul;
161	}
162
163	int gfs2_unlinked_get(struct gfs2_sbd sdp, struct gfs2_unlinked *ul)
164	{
165	unsigned int c, o = 0, b;
166	unsigned char byte = 0;
167
168	enforce_limit(sdp);
169
170	*ul = ul_alloc(sdp);
171	if (!*ul)
172	return -ENOMEM;
173
174	spin_lock(&sdp->sd_unlinked_spin);
175
176	for (c = 0; c < sdp->sd_unlinked_chunks; c++)
177	for (o = 0; o < PAGE_SIZE; o++) {
178	byte = sdp->sd_unlinked_bitmap[c][o];
179	if (byte != 0xFF)
180	goto found;
181	}
182
183	goto fail;
184
185	found:
186	for (b = 0; b < 8; b++)
187	if (!(byte & (1 << b)))
188	break;
189	(ul)->ul_slot = c (8 * PAGE_SIZE) + o * 8 + b;
190
191	if ((*ul)->ul_slot >= sdp->sd_unlinked_slots)
192	goto fail;
193
194	sdp->sd_unlinked_bitmap[c][o] \|= 1 << b;
195
196	spin_unlock(&sdp->sd_unlinked_spin);
197
198	return 0;
199
200	fail:
201	spin_unlock(&sdp->sd_unlinked_spin);
202	kfree(*ul);
203	return -ENOSPC;
204	}
205
206	void gfs2_unlinked_put(struct gfs2_sbd sdp, struct gfs2_unlinked ul)
207	{
208	gfs2_assert_warn(sdp, test_and_clear_bit(ULF_LOCKED, &ul->ul_flags));
209
210	spin_lock(&sdp->sd_unlinked_spin);
211	gfs2_assert(sdp, ul->ul_count);
212	ul->ul_count--;
213	if (!ul->ul_count) {
214	gfs2_icbit_munge(sdp, sdp->sd_unlinked_bitmap, ul->ul_slot, 0);
215	spin_unlock(&sdp->sd_unlinked_spin);
216	kfree(ul);
217	} else
218	spin_unlock(&sdp->sd_unlinked_spin);
219	}
220
221	int gfs2_unlinked_ondisk_add(struct gfs2_sbd sdp, struct gfs2_unlinked ul)
222	{
223	int error;
224
225	gfs2_assert_warn(sdp, test_bit(ULF_LOCKED, &ul->ul_flags));
226	gfs2_assert_warn(sdp, list_empty(&ul->ul_list));
227
228	error = munge_ondisk(sdp, ul->ul_slot, &ul->ul_ut);
229	if (!error)
230	ul_hash(sdp, ul);
231
232	return error;
233	}
234
235	int gfs2_unlinked_ondisk_munge(struct gfs2_sbd sdp, struct gfs2_unlinked ul)
236	{
237	int error;
238
239	gfs2_assert_warn(sdp, test_bit(ULF_LOCKED, &ul->ul_flags));
240	gfs2_assert_warn(sdp, !list_empty(&ul->ul_list));
241
242	error = munge_ondisk(sdp, ul->ul_slot, &ul->ul_ut);
243
244	return error;
245	}
246
247	int gfs2_unlinked_ondisk_rm(struct gfs2_sbd sdp, struct gfs2_unlinked ul)
248	{
249	struct gfs2_unlinked_tag ut;
250	int error;
251
252	gfs2_assert_warn(sdp, test_bit(ULF_LOCKED, &ul->ul_flags));
253	gfs2_assert_warn(sdp, !list_empty(&ul->ul_list));
254
255	memset(&ut, 0, sizeof(struct gfs2_unlinked_tag));
256
257	error = munge_ondisk(sdp, ul->ul_slot, &ut);
258	if (error)
259	return error;
260
261	ul_unhash(sdp, ul);
262
263	return 0;
264	}
265
266	/**
267	* gfs2_unlinked_dealloc - Go through the list of inodes to be deallocated
268	* @sdp: the filesystem
269	*
270	* Returns: errno
271	*/
272
273	int gfs2_unlinked_dealloc(struct gfs2_sbd *sdp)
274	{
275	unsigned int hits, strikes;
276	int error;
277
278	for (;;) {
279	hits = 0;
280	strikes = 0;
281
282	for (;;) {
283	struct gfs2_unlinked *ul = ul_fish(sdp);
284	if (!ul)
285	return 0;
286	error = gfs2_inode_dealloc(sdp, ul);
287	gfs2_unlinked_put(sdp, ul);
288
289	if (!error) {
290	hits++;
291	if (strikes)
292	strikes--;
293	} else if (error == 1) {
294	strikes++;
295	if (strikes >=
296	atomic_read(&sdp->sd_unlinked_count)) {
297	error = 0;
298	break;
299	}
300	} else
301	return error;
302	}
303
304	if (!hits \|\| kthread_should_stop())
305	break;
306
307	cond_resched();
308	}
309
310	return 0;
311	}
312
313	int gfs2_unlinked_init(struct gfs2_sbd *sdp)
314	{
f42faf4f	315	struct gfs2_inode *ip = get_v2ip(sdp->sd_ut_inode);
b3b94faa DT	316	unsigned int blocks = ip->i_di.di_size >> sdp->sd_sb.sb_bsize_shift;
	317	unsigned int x, slot = 0;
	318	unsigned int found = 0;
	319	uint64_t dblock;
	320	uint32_t extlen = 0;
	321	int error;
	322
	323	if (!ip->i_di.di_size \|\|
	324	ip->i_di.di_size > (64 << 20) \|\|
	325	ip->i_di.di_size & (sdp->sd_sb.sb_bsize - 1)) {
	326	gfs2_consist_inode(ip);
	327	return -EIO;
	328	}
	329	sdp->sd_unlinked_slots = blocks * sdp->sd_ut_per_block;
	330	sdp->sd_unlinked_chunks = DIV_RU(sdp->sd_unlinked_slots, 8 * PAGE_SIZE);
	331
	332	error = -ENOMEM;
	333
	334	sdp->sd_unlinked_bitmap = kcalloc(sdp->sd_unlinked_chunks,
	335	sizeof(unsigned char *),
	336	GFP_KERNEL);
	337	if (!sdp->sd_unlinked_bitmap)
	338	return error;
	339
	340	for (x = 0; x < sdp->sd_unlinked_chunks; x++) {
	341	sdp->sd_unlinked_bitmap[x] = kzalloc(PAGE_SIZE, GFP_KERNEL);
	342	if (!sdp->sd_unlinked_bitmap[x])
	343	goto fail;
	344	}
	345
	346	for (x = 0; x < blocks; x++) {
	347	struct buffer_head *bh;
	348	unsigned int y;
	349
	350	if (!extlen) {
	351	int new = 0;
	352	error = gfs2_block_map(ip, x, &new, &dblock, &extlen);
	353	if (error)
	354	goto fail;
	355	}
	356	gfs2_meta_ra(ip->i_gl, dblock, extlen);
	357	error = gfs2_meta_read(ip->i_gl, dblock, DIO_START \| DIO_WAIT,
	358	&bh);
	359	if (error)
	360	goto fail;
	361	error = -EIO;
	362	if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_UT)) {
	363	brelse(bh);
	364	goto fail;
	365	}
	366
	367	for (y = 0;
	368	y < sdp->sd_ut_per_block && slot < sdp->sd_unlinked_slots;
	369	y++, slot++) {
	370	struct gfs2_unlinked_tag ut;
	371	struct gfs2_unlinked *ul;
	372
	373	gfs2_unlinked_tag_in(&ut, bh->b_data +
	374	sizeof(struct gfs2_meta_header) +
	375	y * sizeof(struct gfs2_unlinked_tag));
	376	if (!ut.ut_inum.no_addr)
	377	continue;
	378
	379	error = -ENOMEM;
380	ul = ul_alloc(sdp);
381	if (!ul) {
382	brelse(bh);
383	goto fail;
384	}
385	ul->ul_ut = ut;
386	ul->ul_slot = slot;
387
388	spin_lock(&sdp->sd_unlinked_spin);
389	gfs2_icbit_munge(sdp, sdp->sd_unlinked_bitmap, slot, 1);
390	spin_unlock(&sdp->sd_unlinked_spin);
391	ul_hash(sdp, ul);
392
393	gfs2_unlinked_put(sdp, ul);
394	found++;
395	}
396
397	brelse(bh);
398	dblock++;
399	extlen--;
400	}
401
402	if (found)
403	fs_info(sdp, "found %u unlinked inodes\n", found);
404
405	return 0;
406
407	fail:
408	gfs2_unlinked_cleanup(sdp);
409	return error;
410	}
411
412	/**
413	* gfs2_unlinked_cleanup - get rid of any extra struct gfs2_unlinked structures
414	* @sdp: the filesystem
415	*
416	*/
417
418	void gfs2_unlinked_cleanup(struct gfs2_sbd *sdp)
419	{
420	struct list_head *head = &sdp->sd_unlinked_list;
421	struct gfs2_unlinked *ul;
422	unsigned int x;
423
424	spin_lock(&sdp->sd_unlinked_spin);
425	while (!list_empty(head)) {
426	ul = list_entry(head->next, struct gfs2_unlinked, ul_list);
427
428	if (ul->ul_count > 1) {
429	list_move_tail(&ul->ul_list, head);
430	spin_unlock(&sdp->sd_unlinked_spin);
431	schedule();
432	spin_lock(&sdp->sd_unlinked_spin);
433	continue;
434	}
435
436	list_del_init(&ul->ul_list);
437	atomic_dec(&sdp->sd_unlinked_count);
438
439	gfs2_assert_warn(sdp, ul->ul_count == 1);
440	gfs2_assert_warn(sdp, !test_bit(ULF_LOCKED, &ul->ul_flags));
441	kfree(ul);
442	}
443	spin_unlock(&sdp->sd_unlinked_spin);
444
445	gfs2_assert_warn(sdp, !atomic_read(&sdp->sd_unlinked_count));
446
447	if (sdp->sd_unlinked_bitmap) {
448	for (x = 0; x < sdp->sd_unlinked_chunks; x++)
449	kfree(sdp->sd_unlinked_bitmap[x]);
450	kfree(sdp->sd_unlinked_bitmap);
451	}
452	}
453