Eric Lee / linux-smarc-t335x-v3.2

Commit 5ee581483246e832ca5a9fc1ac669bba0b6ec468

Authored by Jiro SEKIBA 2009-12-06 14:43:56 +0800

Committed by Ryusuke Konishi 2009-12-25 12:01:50 +0800

Exists in master and in 4 other branches

nilfs2: trivial coding style fix

This is a trivial style fix patch to mend errors/warnings
reported by "checkpatch.pl --file".

Signed-off-by: Jiro SEKIBA <jir@unicus.jp>
Signed-off-by: Ryusuke Konishi <konishi.ryusuke@lab.ntt.co.jp>

Showing 3 changed files with 29 additions and 23 deletions Inline Diff

fs/nilfs2/bmap.c
fs/nilfs2/cpfile.c
fs/nilfs2/direct.c

fs/nilfs2/bmap.c

Diff comments View file @ 5ee5814

1	/*	1	/*
2	* bmap.c - NILFS block mapping.	2	* bmap.c - NILFS block mapping.
3	*	3	*
4	* Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.	4	* Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
5	*	5	*
6	* This program is free software; you can redistribute it and/or modify	6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by	7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or	8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.	9	* (at your option) any later version.
10	*	10	*
11	* This program is distributed in the hope that it will be useful,	11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.	14	* GNU General Public License for more details.
15	*	15	*
16	* You should have received a copy of the GNU General Public License	16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software	17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19	*	19	*
20	* Written by Koji Sato <koji@osrg.net>.	20	* Written by Koji Sato <koji@osrg.net>.
21	*/	21	*/
22		22
23	#include <linux/fs.h>	23	#include <linux/fs.h>
24	#include <linux/string.h>	24	#include <linux/string.h>
25	#include <linux/errno.h>	25	#include <linux/errno.h>
26	#include "nilfs.h"	26	#include "nilfs.h"
27	#include "bmap.h"	27	#include "bmap.h"
28	#include "sb.h"	28	#include "sb.h"
29	#include "btnode.h"	29	#include "btnode.h"
30	#include "mdt.h"	30	#include "mdt.h"
31	#include "dat.h"	31	#include "dat.h"
32	#include "alloc.h"	32	#include "alloc.h"
33		33
34	struct inode nilfs_bmap_get_dat(const struct nilfs_bmap bmap)	34	struct inode nilfs_bmap_get_dat(const struct nilfs_bmap bmap)
35	{	35	{
36	return nilfs_dat_inode(NILFS_I_NILFS(bmap->b_inode));	36	return nilfs_dat_inode(NILFS_I_NILFS(bmap->b_inode));
37	}	37	}
38		38
39	/**	39	/**
40	* nilfs_bmap_lookup_at_level - find a data block or node block	40	* nilfs_bmap_lookup_at_level - find a data block or node block
41	* @bmap: bmap	41	* @bmap: bmap
42	* @key: key	42	* @key: key
43	* @level: level	43	* @level: level
44	* @ptrp: place to store the value associated to @key	44	* @ptrp: place to store the value associated to @key
45	*	45	*
46	* Description: nilfs_bmap_lookup_at_level() finds a record whose key	46	* Description: nilfs_bmap_lookup_at_level() finds a record whose key
47	* matches @key in the block at @level of the bmap.	47	* matches @key in the block at @level of the bmap.
48	*	48	*
49	* Return Value: On success, 0 is returned and the record associated with @key	49	* Return Value: On success, 0 is returned and the record associated with @key
50	* is stored in the place pointed by @ptrp. On error, one of the following	50	* is stored in the place pointed by @ptrp. On error, one of the following
51	* negative error codes is returned.	51	* negative error codes is returned.
52	*	52	*
53	* %-EIO - I/O error.	53	* %-EIO - I/O error.
54	*	54	*
55	* %-ENOMEM - Insufficient amount of memory available.	55	* %-ENOMEM - Insufficient amount of memory available.
56	*	56	*
57	* %-ENOENT - A record associated with @key does not exist.	57	* %-ENOENT - A record associated with @key does not exist.
58	*/	58	*/
59	int nilfs_bmap_lookup_at_level(struct nilfs_bmap *bmap, __u64 key, int level,	59	int nilfs_bmap_lookup_at_level(struct nilfs_bmap *bmap, __u64 key, int level,
60	__u64 *ptrp)	60	__u64 *ptrp)
61	{	61	{
62	sector_t blocknr;	62	sector_t blocknr;
63	int ret;	63	int ret;
64		64
65	down_read(&bmap->b_sem);	65	down_read(&bmap->b_sem);
66	ret = bmap->b_ops->bop_lookup(bmap, key, level, ptrp);	66	ret = bmap->b_ops->bop_lookup(bmap, key, level, ptrp);
67	if (ret < 0)	67	if (ret < 0)
68	goto out;	68	goto out;
69	if (NILFS_BMAP_USE_VBN(bmap)) {	69	if (NILFS_BMAP_USE_VBN(bmap)) {
70	ret = nilfs_dat_translate(nilfs_bmap_get_dat(bmap), *ptrp,	70	ret = nilfs_dat_translate(nilfs_bmap_get_dat(bmap), *ptrp,
71	&blocknr);	71	&blocknr);
72	if (!ret)	72	if (!ret)
73	*ptrp = blocknr;	73	*ptrp = blocknr;
74	}	74	}
75		75
76	out:	76	out:
77	up_read(&bmap->b_sem);	77	up_read(&bmap->b_sem);
78	return ret;	78	return ret;
79	}	79	}
80		80
81	int nilfs_bmap_lookup_contig(struct nilfs_bmap bmap, __u64 key, __u64 ptrp,	81	int nilfs_bmap_lookup_contig(struct nilfs_bmap bmap, __u64 key, __u64 ptrp,
82	unsigned maxblocks)	82	unsigned maxblocks)
83	{	83	{
84	int ret;	84	int ret;
85		85
86	down_read(&bmap->b_sem);	86	down_read(&bmap->b_sem);
87	ret = bmap->b_ops->bop_lookup_contig(bmap, key, ptrp, maxblocks);	87	ret = bmap->b_ops->bop_lookup_contig(bmap, key, ptrp, maxblocks);
88	up_read(&bmap->b_sem);	88	up_read(&bmap->b_sem);
89	return ret;	89	return ret;
90	}	90	}
91		91
92	static int nilfs_bmap_do_insert(struct nilfs_bmap *bmap, __u64 key, __u64 ptr)	92	static int nilfs_bmap_do_insert(struct nilfs_bmap *bmap, __u64 key, __u64 ptr)
93	{	93	{
94	__u64 keys[NILFS_BMAP_SMALL_HIGH + 1];	94	__u64 keys[NILFS_BMAP_SMALL_HIGH + 1];
95	__u64 ptrs[NILFS_BMAP_SMALL_HIGH + 1];	95	__u64 ptrs[NILFS_BMAP_SMALL_HIGH + 1];
96	int ret, n;	96	int ret, n;
97		97
98	if (bmap->b_ops->bop_check_insert != NULL) {	98	if (bmap->b_ops->bop_check_insert != NULL) {
99	ret = bmap->b_ops->bop_check_insert(bmap, key);	99	ret = bmap->b_ops->bop_check_insert(bmap, key);
100	if (ret > 0) {	100	if (ret > 0) {
101	n = bmap->b_ops->bop_gather_data(	101	n = bmap->b_ops->bop_gather_data(
102	bmap, keys, ptrs, NILFS_BMAP_SMALL_HIGH + 1);	102	bmap, keys, ptrs, NILFS_BMAP_SMALL_HIGH + 1);
103	if (n < 0)	103	if (n < 0)
104	return n;	104	return n;
105	ret = nilfs_btree_convert_and_insert(	105	ret = nilfs_btree_convert_and_insert(
106	bmap, key, ptr, keys, ptrs, n);	106	bmap, key, ptr, keys, ptrs, n);
107	if (ret == 0)	107	if (ret == 0)
108	bmap->b_u.u_flags \|= NILFS_BMAP_LARGE;	108	bmap->b_u.u_flags \|= NILFS_BMAP_LARGE;
109		109
110	return ret;	110	return ret;
111	} else if (ret < 0)	111	} else if (ret < 0)
112	return ret;	112	return ret;
113	}	113	}
114		114
115	return bmap->b_ops->bop_insert(bmap, key, ptr);	115	return bmap->b_ops->bop_insert(bmap, key, ptr);
116	}	116	}
117		117
118	/**	118	/**
119	* nilfs_bmap_insert - insert a new key-record pair into a bmap	119	* nilfs_bmap_insert - insert a new key-record pair into a bmap
120	* @bmap: bmap	120	* @bmap: bmap
121	* @key: key	121	* @key: key
122	* @rec: record	122	* @rec: record
123	*	123	*
124	* Description: nilfs_bmap_insert() inserts the new key-record pair specified	124	* Description: nilfs_bmap_insert() inserts the new key-record pair specified
125	* by @key and @rec into @bmap.	125	* by @key and @rec into @bmap.
126	*	126	*
127	* Return Value: On success, 0 is returned. On error, one of the following	127	* Return Value: On success, 0 is returned. On error, one of the following
128	* negative error codes is returned.	128	* negative error codes is returned.
129	*	129	*
130	* %-EIO - I/O error.	130	* %-EIO - I/O error.
131	*	131	*
132	* %-ENOMEM - Insufficient amount of memory available.	132	* %-ENOMEM - Insufficient amount of memory available.
133	*	133	*
134	* %-EEXIST - A record associated with @key already exist.	134	* %-EEXIST - A record associated with @key already exist.
135	*/	135	*/
136	int nilfs_bmap_insert(struct nilfs_bmap *bmap,	136	int nilfs_bmap_insert(struct nilfs_bmap *bmap,
137	unsigned long key,	137	unsigned long key,
138	unsigned long rec)	138	unsigned long rec)
139	{	139	{
140	int ret;	140	int ret;
141		141
142	down_write(&bmap->b_sem);	142	down_write(&bmap->b_sem);
143	ret = nilfs_bmap_do_insert(bmap, key, rec);	143	ret = nilfs_bmap_do_insert(bmap, key, rec);
144	up_write(&bmap->b_sem);	144	up_write(&bmap->b_sem);
145	return ret;	145	return ret;
146	}	146	}
147		147
148	static int nilfs_bmap_do_delete(struct nilfs_bmap *bmap, __u64 key)	148	static int nilfs_bmap_do_delete(struct nilfs_bmap *bmap, __u64 key)
149	{	149	{
150	__u64 keys[NILFS_BMAP_LARGE_LOW + 1];	150	__u64 keys[NILFS_BMAP_LARGE_LOW + 1];
151	__u64 ptrs[NILFS_BMAP_LARGE_LOW + 1];	151	__u64 ptrs[NILFS_BMAP_LARGE_LOW + 1];
152	int ret, n;	152	int ret, n;
153		153
154	if (bmap->b_ops->bop_check_delete != NULL) {	154	if (bmap->b_ops->bop_check_delete != NULL) {
155	ret = bmap->b_ops->bop_check_delete(bmap, key);	155	ret = bmap->b_ops->bop_check_delete(bmap, key);
156	if (ret > 0) {	156	if (ret > 0) {
157	n = bmap->b_ops->bop_gather_data(	157	n = bmap->b_ops->bop_gather_data(
158	bmap, keys, ptrs, NILFS_BMAP_LARGE_LOW + 1);	158	bmap, keys, ptrs, NILFS_BMAP_LARGE_LOW + 1);
159	if (n < 0)	159	if (n < 0)
160	return n;	160	return n;
161	ret = nilfs_direct_delete_and_convert(	161	ret = nilfs_direct_delete_and_convert(
162	bmap, key, keys, ptrs, n);	162	bmap, key, keys, ptrs, n);
163	if (ret == 0)	163	if (ret == 0)
164	bmap->b_u.u_flags &= ~NILFS_BMAP_LARGE;	164	bmap->b_u.u_flags &= ~NILFS_BMAP_LARGE;
165		165
166	return ret;	166	return ret;
167	} else if (ret < 0)	167	} else if (ret < 0)
168	return ret;	168	return ret;
169	}	169	}
170		170
171	return bmap->b_ops->bop_delete(bmap, key);	171	return bmap->b_ops->bop_delete(bmap, key);
172	}	172	}
173		173
174	int nilfs_bmap_last_key(struct nilfs_bmap bmap, unsigned long key)	174	int nilfs_bmap_last_key(struct nilfs_bmap bmap, unsigned long key)
175	{	175	{
176	__u64 lastkey;	176	__u64 lastkey;
177	int ret;	177	int ret;
178		178
179	down_read(&bmap->b_sem);	179	down_read(&bmap->b_sem);
180	ret = bmap->b_ops->bop_last_key(bmap, &lastkey);	180	ret = bmap->b_ops->bop_last_key(bmap, &lastkey);
181	if (!ret)	181	if (!ret)
182	*key = lastkey;	182	*key = lastkey;
183	up_read(&bmap->b_sem);	183	up_read(&bmap->b_sem);
184	return ret;	184	return ret;
185	}	185	}
186		186
187	/**	187	/**
188	* nilfs_bmap_delete - delete a key-record pair from a bmap	188	* nilfs_bmap_delete - delete a key-record pair from a bmap
189	* @bmap: bmap	189	* @bmap: bmap
190	* @key: key	190	* @key: key
191	*	191	*
192	* Description: nilfs_bmap_delete() deletes the key-record pair specified by	192	* Description: nilfs_bmap_delete() deletes the key-record pair specified by
193	* @key from @bmap.	193	* @key from @bmap.
194	*	194	*
195	* Return Value: On success, 0 is returned. On error, one of the following	195	* Return Value: On success, 0 is returned. On error, one of the following
196	* negative error codes is returned.	196	* negative error codes is returned.
197	*	197	*
198	* %-EIO - I/O error.	198	* %-EIO - I/O error.
199	*	199	*
200	* %-ENOMEM - Insufficient amount of memory available.	200	* %-ENOMEM - Insufficient amount of memory available.
201	*	201	*
202	* %-ENOENT - A record associated with @key does not exist.	202	* %-ENOENT - A record associated with @key does not exist.
203	*/	203	*/
204	int nilfs_bmap_delete(struct nilfs_bmap *bmap, unsigned long key)	204	int nilfs_bmap_delete(struct nilfs_bmap *bmap, unsigned long key)
205	{	205	{
206	int ret;	206	int ret;
207		207
208	down_write(&bmap->b_sem);	208	down_write(&bmap->b_sem);
209	ret = nilfs_bmap_do_delete(bmap, key);	209	ret = nilfs_bmap_do_delete(bmap, key);
210	up_write(&bmap->b_sem);	210	up_write(&bmap->b_sem);
211	return ret;	211	return ret;
212	}	212	}
213		213
214	static int nilfs_bmap_do_truncate(struct nilfs_bmap *bmap, unsigned long key)	214	static int nilfs_bmap_do_truncate(struct nilfs_bmap *bmap, unsigned long key)
215	{	215	{
216	__u64 lastkey;	216	__u64 lastkey;
217	int ret;	217	int ret;
218		218
219	ret = bmap->b_ops->bop_last_key(bmap, &lastkey);	219	ret = bmap->b_ops->bop_last_key(bmap, &lastkey);
220	if (ret < 0) {	220	if (ret < 0) {
221	if (ret == -ENOENT)	221	if (ret == -ENOENT)
222	ret = 0;	222	ret = 0;
223	return ret;	223	return ret;
224	}	224	}
225		225
226	while (key <= lastkey) {	226	while (key <= lastkey) {
227	ret = nilfs_bmap_do_delete(bmap, lastkey);	227	ret = nilfs_bmap_do_delete(bmap, lastkey);
228	if (ret < 0)	228	if (ret < 0)
229	return ret;	229	return ret;
230	ret = bmap->b_ops->bop_last_key(bmap, &lastkey);	230	ret = bmap->b_ops->bop_last_key(bmap, &lastkey);
231	if (ret < 0) {	231	if (ret < 0) {
232	if (ret == -ENOENT)	232	if (ret == -ENOENT)
233	ret = 0;	233	ret = 0;
234	return ret;	234	return ret;
235	}	235	}
236	}	236	}
237	return 0;	237	return 0;
238	}	238	}
239		239
240	/**	240	/**
241	* nilfs_bmap_truncate - truncate a bmap to a specified key	241	* nilfs_bmap_truncate - truncate a bmap to a specified key
242	* @bmap: bmap	242	* @bmap: bmap
243	* @key: key	243	* @key: key
244	*	244	*
245	* Description: nilfs_bmap_truncate() removes key-record pairs whose keys are	245	* Description: nilfs_bmap_truncate() removes key-record pairs whose keys are
246	* greater than or equal to @key from @bmap.	246	* greater than or equal to @key from @bmap.
247	*	247	*
248	* Return Value: On success, 0 is returned. On error, one of the following	248	* Return Value: On success, 0 is returned. On error, one of the following
249	* negative error codes is returned.	249	* negative error codes is returned.
250	*	250	*
251	* %-EIO - I/O error.	251	* %-EIO - I/O error.
252	*	252	*
253	* %-ENOMEM - Insufficient amount of memory available.	253	* %-ENOMEM - Insufficient amount of memory available.
254	*/	254	*/
255	int nilfs_bmap_truncate(struct nilfs_bmap *bmap, unsigned long key)	255	int nilfs_bmap_truncate(struct nilfs_bmap *bmap, unsigned long key)
256	{	256	{
257	int ret;	257	int ret;
258		258
259	down_write(&bmap->b_sem);	259	down_write(&bmap->b_sem);
260	ret = nilfs_bmap_do_truncate(bmap, key);	260	ret = nilfs_bmap_do_truncate(bmap, key);
261	up_write(&bmap->b_sem);	261	up_write(&bmap->b_sem);
262	return ret;	262	return ret;
263	}	263	}
264		264
265	/**	265	/**
266	* nilfs_bmap_clear - free resources a bmap holds	266	* nilfs_bmap_clear - free resources a bmap holds
267	* @bmap: bmap	267	* @bmap: bmap
268	*	268	*
269	* Description: nilfs_bmap_clear() frees resources associated with @bmap.	269	* Description: nilfs_bmap_clear() frees resources associated with @bmap.
270	*/	270	*/
271	void nilfs_bmap_clear(struct nilfs_bmap *bmap)	271	void nilfs_bmap_clear(struct nilfs_bmap *bmap)
272	{	272	{
273	down_write(&bmap->b_sem);	273	down_write(&bmap->b_sem);
274	if (bmap->b_ops->bop_clear != NULL)	274	if (bmap->b_ops->bop_clear != NULL)
275	bmap->b_ops->bop_clear(bmap);	275	bmap->b_ops->bop_clear(bmap);
276	up_write(&bmap->b_sem);	276	up_write(&bmap->b_sem);
277	}	277	}
278		278
279	/**	279	/**
280	* nilfs_bmap_propagate - propagate dirty state	280	* nilfs_bmap_propagate - propagate dirty state
281	* @bmap: bmap	281	* @bmap: bmap
282	* @bh: buffer head	282	* @bh: buffer head
283	*	283	*
284	* Description: nilfs_bmap_propagate() marks the buffers that directly or	284	* Description: nilfs_bmap_propagate() marks the buffers that directly or
285	* indirectly refer to the block specified by @bh dirty.	285	* indirectly refer to the block specified by @bh dirty.
286	*	286	*
287	* Return Value: On success, 0 is returned. On error, one of the following	287	* Return Value: On success, 0 is returned. On error, one of the following
288	* negative error codes is returned.	288	* negative error codes is returned.
289	*	289	*
290	* %-EIO - I/O error.	290	* %-EIO - I/O error.
291	*	291	*
292	* %-ENOMEM - Insufficient amount of memory available.	292	* %-ENOMEM - Insufficient amount of memory available.
293	*/	293	*/
294	int nilfs_bmap_propagate(struct nilfs_bmap bmap, struct buffer_head bh)	294	int nilfs_bmap_propagate(struct nilfs_bmap bmap, struct buffer_head bh)
295	{	295	{
296	int ret;	296	int ret;
297		297
298	down_write(&bmap->b_sem);	298	down_write(&bmap->b_sem);
299	ret = bmap->b_ops->bop_propagate(bmap, bh);	299	ret = bmap->b_ops->bop_propagate(bmap, bh);
300	up_write(&bmap->b_sem);	300	up_write(&bmap->b_sem);
301	return ret;	301	return ret;
302	}	302	}
303		303
304	/**	304	/**
305	* nilfs_bmap_lookup_dirty_buffers -	305	* nilfs_bmap_lookup_dirty_buffers -
306	* @bmap: bmap	306	* @bmap: bmap
307	* @listp: pointer to buffer head list	307	* @listp: pointer to buffer head list
308	*/	308	*/
309	void nilfs_bmap_lookup_dirty_buffers(struct nilfs_bmap *bmap,	309	void nilfs_bmap_lookup_dirty_buffers(struct nilfs_bmap *bmap,
310	struct list_head *listp)	310	struct list_head *listp)
311	{	311	{
312	if (bmap->b_ops->bop_lookup_dirty_buffers != NULL)	312	if (bmap->b_ops->bop_lookup_dirty_buffers != NULL)
313	bmap->b_ops->bop_lookup_dirty_buffers(bmap, listp);	313	bmap->b_ops->bop_lookup_dirty_buffers(bmap, listp);
314	}	314	}
315		315
316	/**	316	/**
317	* nilfs_bmap_assign - assign a new block number to a block	317	* nilfs_bmap_assign - assign a new block number to a block
318	* @bmap: bmap	318	* @bmap: bmap
319	* @bhp: pointer to buffer head	319	* @bhp: pointer to buffer head
320	* @blocknr: block number	320	* @blocknr: block number
321	* @binfo: block information	321	* @binfo: block information
322	*	322	*
323	* Description: nilfs_bmap_assign() assigns the block number @blocknr to the	323	* Description: nilfs_bmap_assign() assigns the block number @blocknr to the
324	* buffer specified by @bh.	324	* buffer specified by @bh.
325	*	325	*
326	* Return Value: On success, 0 is returned and the buffer head of a newly	326	* Return Value: On success, 0 is returned and the buffer head of a newly
327	* create buffer and the block information associated with the buffer are	327	* create buffer and the block information associated with the buffer are
328	* stored in the place pointed by @bh and @binfo, respectively. On error, one	328	* stored in the place pointed by @bh and @binfo, respectively. On error, one
329	* of the following negative error codes is returned.	329	* of the following negative error codes is returned.
330	*	330	*
331	* %-EIO - I/O error.	331	* %-EIO - I/O error.
332	*	332	*
333	* %-ENOMEM - Insufficient amount of memory available.	333	* %-ENOMEM - Insufficient amount of memory available.
334	*/	334	*/
335	int nilfs_bmap_assign(struct nilfs_bmap *bmap,	335	int nilfs_bmap_assign(struct nilfs_bmap *bmap,
336	struct buffer_head **bh,	336	struct buffer_head **bh,
337	unsigned long blocknr,	337	unsigned long blocknr,
338	union nilfs_binfo *binfo)	338	union nilfs_binfo *binfo)
339	{	339	{
340	int ret;	340	int ret;
341		341
342	down_write(&bmap->b_sem);	342	down_write(&bmap->b_sem);
343	ret = bmap->b_ops->bop_assign(bmap, bh, blocknr, binfo);	343	ret = bmap->b_ops->bop_assign(bmap, bh, blocknr, binfo);
344	up_write(&bmap->b_sem);	344	up_write(&bmap->b_sem);
345	return ret;	345	return ret;
346	}	346	}
347		347
348	/**	348	/**
349	* nilfs_bmap_mark - mark block dirty	349	* nilfs_bmap_mark - mark block dirty
350	* @bmap: bmap	350	* @bmap: bmap
351	* @key: key	351	* @key: key
352	* @level: level	352	* @level: level
353	*	353	*
354	* Description: nilfs_bmap_mark() marks the block specified by @key and @level	354	* Description: nilfs_bmap_mark() marks the block specified by @key and @level
355	* as dirty.	355	* as dirty.
356	*	356	*
357	* Return Value: On success, 0 is returned. On error, one of the following	357	* Return Value: On success, 0 is returned. On error, one of the following
358	* negative error codes is returned.	358	* negative error codes is returned.
359	*	359	*
360	* %-EIO - I/O error.	360	* %-EIO - I/O error.
361	*	361	*
362	* %-ENOMEM - Insufficient amount of memory available.	362	* %-ENOMEM - Insufficient amount of memory available.
363	*/	363	*/
364	int nilfs_bmap_mark(struct nilfs_bmap *bmap, __u64 key, int level)	364	int nilfs_bmap_mark(struct nilfs_bmap *bmap, __u64 key, int level)
365	{	365	{
366	int ret;	366	int ret;
367		367
368	if (bmap->b_ops->bop_mark == NULL)	368	if (bmap->b_ops->bop_mark == NULL)
369	return 0;	369	return 0;
370		370
371	down_write(&bmap->b_sem);	371	down_write(&bmap->b_sem);
372	ret = bmap->b_ops->bop_mark(bmap, key, level);	372	ret = bmap->b_ops->bop_mark(bmap, key, level);
373	up_write(&bmap->b_sem);	373	up_write(&bmap->b_sem);
374	return ret;	374	return ret;
375	}	375	}
376		376
377	/**	377	/**
378	* nilfs_bmap_test_and_clear_dirty - test and clear a bmap dirty state	378	* nilfs_bmap_test_and_clear_dirty - test and clear a bmap dirty state
379	* @bmap: bmap	379	* @bmap: bmap
380	*	380	*
381	* Description: nilfs_test_and_clear() is the atomic operation to test and	381	* Description: nilfs_test_and_clear() is the atomic operation to test and
382	* clear the dirty state of @bmap.	382	* clear the dirty state of @bmap.
383	*	383	*
384	* Return Value: 1 is returned if @bmap is dirty, or 0 if clear.	384	* Return Value: 1 is returned if @bmap is dirty, or 0 if clear.
385	*/	385	*/
386	int nilfs_bmap_test_and_clear_dirty(struct nilfs_bmap *bmap)	386	int nilfs_bmap_test_and_clear_dirty(struct nilfs_bmap *bmap)
387	{	387	{
388	int ret;	388	int ret;
389		389
390	down_write(&bmap->b_sem);	390	down_write(&bmap->b_sem);
391	ret = nilfs_bmap_dirty(bmap);	391	ret = nilfs_bmap_dirty(bmap);
392	nilfs_bmap_clear_dirty(bmap);	392	nilfs_bmap_clear_dirty(bmap);
393	up_write(&bmap->b_sem);	393	up_write(&bmap->b_sem);
394	return ret;	394	return ret;
395	}	395	}
396		396
397		397
398	/*	398	/*
399	* Internal use only	399	* Internal use only
400	*/	400	*/
401		401
402	void nilfs_bmap_add_blocks(const struct nilfs_bmap *bmap, int n)	402	void nilfs_bmap_add_blocks(const struct nilfs_bmap *bmap, int n)
403	{	403	{
404	inode_add_bytes(bmap->b_inode, (1 << bmap->b_inode->i_blkbits) * n);	404	inode_add_bytes(bmap->b_inode, (1 << bmap->b_inode->i_blkbits) * n);
405	}	405	}
406		406
407	void nilfs_bmap_sub_blocks(const struct nilfs_bmap *bmap, int n)	407	void nilfs_bmap_sub_blocks(const struct nilfs_bmap *bmap, int n)
408	{	408	{
409	inode_sub_bytes(bmap->b_inode, (1 << bmap->b_inode->i_blkbits) * n);	409	inode_sub_bytes(bmap->b_inode, (1 << bmap->b_inode->i_blkbits) * n);
410	}	410	}
411		411
412	__u64 nilfs_bmap_data_get_key(const struct nilfs_bmap *bmap,	412	__u64 nilfs_bmap_data_get_key(const struct nilfs_bmap *bmap,
413	const struct buffer_head *bh)	413	const struct buffer_head *bh)
414	{	414	{
415	struct buffer_head *pbh;	415	struct buffer_head *pbh;
416	__u64 key;	416	__u64 key;
417		417
418	key = page_index(bh->b_page) << (PAGE_CACHE_SHIFT -	418	key = page_index(bh->b_page) << (PAGE_CACHE_SHIFT -
419	bmap->b_inode->i_blkbits);	419	bmap->b_inode->i_blkbits);
420	for (pbh = page_buffers(bh->b_page); pbh != bh;	420	for (pbh = page_buffers(bh->b_page); pbh != bh; pbh = pbh->b_this_page)
421	pbh = pbh->b_this_page, key++);	421	key++;
422		422
423	return key;	423	return key;
424	}	424	}
425		425
426	__u64 nilfs_bmap_find_target_seq(const struct nilfs_bmap *bmap, __u64 key)	426	__u64 nilfs_bmap_find_target_seq(const struct nilfs_bmap *bmap, __u64 key)
427	{	427	{
428	__s64 diff;	428	__s64 diff;
429		429
430	diff = key - bmap->b_last_allocated_key;	430	diff = key - bmap->b_last_allocated_key;
431	if ((nilfs_bmap_keydiff_abs(diff) < NILFS_INODE_BMAP_SIZE) &&	431	if ((nilfs_bmap_keydiff_abs(diff) < NILFS_INODE_BMAP_SIZE) &&
432	(bmap->b_last_allocated_ptr != NILFS_BMAP_INVALID_PTR) &&	432	(bmap->b_last_allocated_ptr != NILFS_BMAP_INVALID_PTR) &&
433	(bmap->b_last_allocated_ptr + diff > 0))	433	(bmap->b_last_allocated_ptr + diff > 0))
434	return bmap->b_last_allocated_ptr + diff;	434	return bmap->b_last_allocated_ptr + diff;
435	else	435	else
436	return NILFS_BMAP_INVALID_PTR;	436	return NILFS_BMAP_INVALID_PTR;
437	}	437	}
438		438
439	#define NILFS_BMAP_GROUP_DIV 8	439	#define NILFS_BMAP_GROUP_DIV 8
440	__u64 nilfs_bmap_find_target_in_group(const struct nilfs_bmap *bmap)	440	__u64 nilfs_bmap_find_target_in_group(const struct nilfs_bmap *bmap)
441	{	441	{
442	struct inode *dat = nilfs_bmap_get_dat(bmap);	442	struct inode *dat = nilfs_bmap_get_dat(bmap);
443	unsigned long entries_per_group = nilfs_palloc_entries_per_group(dat);	443	unsigned long entries_per_group = nilfs_palloc_entries_per_group(dat);
444	unsigned long group = bmap->b_inode->i_ino / entries_per_group;	444	unsigned long group = bmap->b_inode->i_ino / entries_per_group;
445		445
446	return group * entries_per_group +	446	return group * entries_per_group +
447	(bmap->b_inode->i_ino % NILFS_BMAP_GROUP_DIV) *	447	(bmap->b_inode->i_ino % NILFS_BMAP_GROUP_DIV) *
448	(entries_per_group / NILFS_BMAP_GROUP_DIV);	448	(entries_per_group / NILFS_BMAP_GROUP_DIV);
449	}	449	}
450		450
451	static struct lock_class_key nilfs_bmap_dat_lock_key;	451	static struct lock_class_key nilfs_bmap_dat_lock_key;
452	static struct lock_class_key nilfs_bmap_mdt_lock_key;	452	static struct lock_class_key nilfs_bmap_mdt_lock_key;
453		453
454	/**	454	/**
455	* nilfs_bmap_read - read a bmap from an inode	455	* nilfs_bmap_read - read a bmap from an inode
456	* @bmap: bmap	456	* @bmap: bmap
457	* @raw_inode: on-disk inode	457	* @raw_inode: on-disk inode
458	*	458	*
459	* Description: nilfs_bmap_read() initializes the bmap @bmap.	459	* Description: nilfs_bmap_read() initializes the bmap @bmap.
460	*	460	*
461	* Return Value: On success, 0 is returned. On error, the following negative	461	* Return Value: On success, 0 is returned. On error, the following negative
462	* error code is returned.	462	* error code is returned.
463	*	463	*
464	* %-ENOMEM - Insufficient amount of memory available.	464	* %-ENOMEM - Insufficient amount of memory available.
465	*/	465	*/
466	int nilfs_bmap_read(struct nilfs_bmap bmap, struct nilfs_inode raw_inode)	466	int nilfs_bmap_read(struct nilfs_bmap bmap, struct nilfs_inode raw_inode)
467	{	467	{
468	if (raw_inode == NULL)	468	if (raw_inode == NULL)
469	memset(bmap->b_u.u_data, 0, NILFS_BMAP_SIZE);	469	memset(bmap->b_u.u_data, 0, NILFS_BMAP_SIZE);
470	else	470	else
471	memcpy(bmap->b_u.u_data, raw_inode->i_bmap, NILFS_BMAP_SIZE);	471	memcpy(bmap->b_u.u_data, raw_inode->i_bmap, NILFS_BMAP_SIZE);
472		472
473	init_rwsem(&bmap->b_sem);	473	init_rwsem(&bmap->b_sem);
474	bmap->b_state = 0;	474	bmap->b_state = 0;
475	bmap->b_inode = &NILFS_BMAP_I(bmap)->vfs_inode;	475	bmap->b_inode = &NILFS_BMAP_I(bmap)->vfs_inode;
476	switch (bmap->b_inode->i_ino) {	476	switch (bmap->b_inode->i_ino) {
477	case NILFS_DAT_INO:	477	case NILFS_DAT_INO:
478	bmap->b_ptr_type = NILFS_BMAP_PTR_P;	478	bmap->b_ptr_type = NILFS_BMAP_PTR_P;
479	bmap->b_last_allocated_key = 0;	479	bmap->b_last_allocated_key = 0;
480	bmap->b_last_allocated_ptr = NILFS_BMAP_NEW_PTR_INIT;	480	bmap->b_last_allocated_ptr = NILFS_BMAP_NEW_PTR_INIT;
481	lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key);	481	lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key);
482	break;	482	break;
483	case NILFS_CPFILE_INO:	483	case NILFS_CPFILE_INO:
484	case NILFS_SUFILE_INO:	484	case NILFS_SUFILE_INO:
485	bmap->b_ptr_type = NILFS_BMAP_PTR_VS;	485	bmap->b_ptr_type = NILFS_BMAP_PTR_VS;
486	bmap->b_last_allocated_key = 0;	486	bmap->b_last_allocated_key = 0;
487	bmap->b_last_allocated_ptr = NILFS_BMAP_INVALID_PTR;	487	bmap->b_last_allocated_ptr = NILFS_BMAP_INVALID_PTR;
488	lockdep_set_class(&bmap->b_sem, &nilfs_bmap_mdt_lock_key);	488	lockdep_set_class(&bmap->b_sem, &nilfs_bmap_mdt_lock_key);
489	break;	489	break;
490	case NILFS_IFILE_INO:	490	case NILFS_IFILE_INO:
491	lockdep_set_class(&bmap->b_sem, &nilfs_bmap_mdt_lock_key);	491	lockdep_set_class(&bmap->b_sem, &nilfs_bmap_mdt_lock_key);
492	/* Fall through */	492	/* Fall through */
493	default:	493	default:
494	bmap->b_ptr_type = NILFS_BMAP_PTR_VM;	494	bmap->b_ptr_type = NILFS_BMAP_PTR_VM;
495	bmap->b_last_allocated_key = 0;	495	bmap->b_last_allocated_key = 0;
496	bmap->b_last_allocated_ptr = NILFS_BMAP_INVALID_PTR;	496	bmap->b_last_allocated_ptr = NILFS_BMAP_INVALID_PTR;
497	break;	497	break;
498	}	498	}
499		499
500	return (bmap->b_u.u_flags & NILFS_BMAP_LARGE) ?	500	return (bmap->b_u.u_flags & NILFS_BMAP_LARGE) ?
501	nilfs_btree_init(bmap) : nilfs_direct_init(bmap);	501	nilfs_btree_init(bmap) : nilfs_direct_init(bmap);
502	}	502	}
503		503
504	/**	504	/**
505	* nilfs_bmap_write - write back a bmap to an inode	505	* nilfs_bmap_write - write back a bmap to an inode
506	* @bmap: bmap	506	* @bmap: bmap
507	* @raw_inode: on-disk inode	507	* @raw_inode: on-disk inode
508	*	508	*
509	* Description: nilfs_bmap_write() stores @bmap in @raw_inode.	509	* Description: nilfs_bmap_write() stores @bmap in @raw_inode.
510	*/	510	*/
511	void nilfs_bmap_write(struct nilfs_bmap bmap, struct nilfs_inode raw_inode)	511	void nilfs_bmap_write(struct nilfs_bmap bmap, struct nilfs_inode raw_inode)
512	{	512	{
513	down_write(&bmap->b_sem);	513	down_write(&bmap->b_sem);
514	memcpy(raw_inode->i_bmap, bmap->b_u.u_data,	514	memcpy(raw_inode->i_bmap, bmap->b_u.u_data,
515	NILFS_INODE_BMAP_SIZE * sizeof(__le64));	515	NILFS_INODE_BMAP_SIZE * sizeof(__le64));
516	if (bmap->b_inode->i_ino == NILFS_DAT_INO)	516	if (bmap->b_inode->i_ino == NILFS_DAT_INO)
517	bmap->b_last_allocated_ptr = NILFS_BMAP_NEW_PTR_INIT;	517	bmap->b_last_allocated_ptr = NILFS_BMAP_NEW_PTR_INIT;
518		518
519	up_write(&bmap->b_sem);	519	up_write(&bmap->b_sem);
520	}	520	}
521		521
522	void nilfs_bmap_init_gc(struct nilfs_bmap *bmap)	522	void nilfs_bmap_init_gc(struct nilfs_bmap *bmap)
523	{	523	{
524	memset(&bmap->b_u, 0, NILFS_BMAP_SIZE);	524	memset(&bmap->b_u, 0, NILFS_BMAP_SIZE);
525	init_rwsem(&bmap->b_sem);	525	init_rwsem(&bmap->b_sem);
526	bmap->b_inode = &NILFS_BMAP_I(bmap)->vfs_inode;	526	bmap->b_inode = &NILFS_BMAP_I(bmap)->vfs_inode;
527	bmap->b_ptr_type = NILFS_BMAP_PTR_U;	527	bmap->b_ptr_type = NILFS_BMAP_PTR_U;
528	bmap->b_last_allocated_key = 0;	528	bmap->b_last_allocated_key = 0;
529	bmap->b_last_allocated_ptr = NILFS_BMAP_INVALID_PTR;	529	bmap->b_last_allocated_ptr = NILFS_BMAP_INVALID_PTR;
530	bmap->b_state = 0;	530	bmap->b_state = 0;
531	nilfs_btree_init_gc(bmap);	531	nilfs_btree_init_gc(bmap);
532	}	532	}
533		533
534	void nilfs_bmap_init_gcdat(struct nilfs_bmap gcbmap, struct nilfs_bmap bmap)	534	void nilfs_bmap_init_gcdat(struct nilfs_bmap gcbmap, struct nilfs_bmap bmap)
535	{	535	{
536	memcpy(gcbmap, bmap, sizeof(union nilfs_bmap_union));	536	memcpy(gcbmap, bmap, sizeof(union nilfs_bmap_union));
537	init_rwsem(&gcbmap->b_sem);	537	init_rwsem(&gcbmap->b_sem);
538	lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key);	538	lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key);
539	gcbmap->b_inode = &NILFS_BMAP_I(gcbmap)->vfs_inode;	539	gcbmap->b_inode = &NILFS_BMAP_I(gcbmap)->vfs_inode;
540	}	540	}
541		541
542	void nilfs_bmap_commit_gcdat(struct nilfs_bmap gcbmap, struct nilfs_bmap bmap)	542	void nilfs_bmap_commit_gcdat(struct nilfs_bmap gcbmap, struct nilfs_bmap bmap)
543	{	543	{
544	memcpy(bmap, gcbmap, sizeof(union nilfs_bmap_union));	544	memcpy(bmap, gcbmap, sizeof(union nilfs_bmap_union));
545	init_rwsem(&bmap->b_sem);	545	init_rwsem(&bmap->b_sem);
546	lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key);	546	lockdep_set_class(&bmap->b_sem, &nilfs_bmap_dat_lock_key);
547	bmap->b_inode = &NILFS_BMAP_I(bmap)->vfs_inode;	547	bmap->b_inode = &NILFS_BMAP_I(bmap)->vfs_inode;
548	}	548	}
549		549

fs/nilfs2/cpfile.c

Diff comments View file @ 5ee5814

 /*
  * cpfile.c - NILFS checkpoint file.
  *
  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  * Written by Koji Sato <koji@osrg.net>.
  */
 #include <linux/kernel.h>
 #include <linux/fs.h>
 #include <linux/string.h>
 #include <linux/buffer_head.h>
 #include <linux/errno.h>
 #include <linux/nilfs2_fs.h>
 #include "mdt.h"
 #include "cpfile.h"
 static inline unsigned long
 nilfs_cpfile_checkpoints_per_block(const struct inode *cpfile)
 {
 	return NILFS_MDT(cpfile)->mi_entries_per_block;
 }
 /* block number from the beginning of the file */
 static unsigned long
 nilfs_cpfile_get_blkoff(const struct inode *cpfile, __u64 cno)
 {
 	__u64 tcno = cno + NILFS_MDT(cpfile)->mi_first_entry_offset - 1;
 	do_div(tcno, nilfs_cpfile_checkpoints_per_block(cpfile));
 	return (unsigned long)tcno;
 }
 /* offset in block */
 static unsigned long
 nilfs_cpfile_get_offset(const struct inode *cpfile, __u64 cno)
 {
 	__u64 tcno = cno + NILFS_MDT(cpfile)->mi_first_entry_offset - 1;
 	return do_div(tcno, nilfs_cpfile_checkpoints_per_block(cpfile));
 }
 static unsigned long
 nilfs_cpfile_checkpoints_in_block(const struct inode *cpfile,
 				  __u64 curr,
 				  __u64 max)
 {
 	return min_t(__u64,
 		     nilfs_cpfile_checkpoints_per_block(cpfile) -
 		     nilfs_cpfile_get_offset(cpfile, curr),
 		     max - curr);
 }
 static inline int nilfs_cpfile_is_in_first(const struct inode *cpfile,
 					   __u64 cno)
 {
 	return nilfs_cpfile_get_blkoff(cpfile, cno) == 0;
 }
 static unsigned int
 nilfs_cpfile_block_add_valid_checkpoints(const struct inode *cpfile,
 					 struct buffer_head *bh,
 					 void *kaddr,
 					 unsigned int n)
 {
 	struct nilfs_checkpoint *cp = kaddr + bh_offset(bh);
 	unsigned int count;
 	count = le32_to_cpu(cp->cp_checkpoints_count) + n;
 	cp->cp_checkpoints_count = cpu_to_le32(count);
 	return count;
 }
 static unsigned int
 nilfs_cpfile_block_sub_valid_checkpoints(const struct inode *cpfile,
 					 struct buffer_head *bh,
 					 void *kaddr,
 					 unsigned int n)
 {
 	struct nilfs_checkpoint *cp = kaddr + bh_offset(bh);
 	unsigned int count;
 	WARN_ON(le32_to_cpu(cp->cp_checkpoints_count) < n);
 	count = le32_to_cpu(cp->cp_checkpoints_count) - n;
 	cp->cp_checkpoints_count = cpu_to_le32(count);
 	return count;
 }
 static inline struct nilfs_cpfile_header *
 nilfs_cpfile_block_get_header(const struct inode *cpfile,
 			      struct buffer_head *bh,
 			      void *kaddr)
 {
 	return kaddr + bh_offset(bh);
 }
 static struct nilfs_checkpoint *
 nilfs_cpfile_block_get_checkpoint(const struct inode *cpfile, __u64 cno,
 				  struct buffer_head *bh,
 				  void *kaddr)
 {
 	return kaddr + bh_offset(bh) + nilfs_cpfile_get_offset(cpfile, cno) *
 		NILFS_MDT(cpfile)->mi_entry_size;
 }
 static void nilfs_cpfile_block_init(struct inode *cpfile,
 				    struct buffer_head *bh,
 				    void *kaddr)
 {
 	struct nilfs_checkpoint *cp = kaddr + bh_offset(bh);
 	size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;
 	int n = nilfs_cpfile_checkpoints_per_block(cpfile);
 	while (n-- > 0) {
 		nilfs_checkpoint_set_invalid(cp);
 		cp = (void *)cp + cpsz;
 	}
 }
 static inline int nilfs_cpfile_get_header_block(struct inode *cpfile,
 						struct buffer_head **bhp)
 {
 	return nilfs_mdt_get_block(cpfile, 0, 0, NULL, bhp);
 }
 static inline int nilfs_cpfile_get_checkpoint_block(struct inode *cpfile,
 						    __u64 cno,
 						    int create,
 						    struct buffer_head **bhp)
 {
 	return nilfs_mdt_get_block(cpfile,
 				   nilfs_cpfile_get_blkoff(cpfile, cno),
 				   create, nilfs_cpfile_block_init, bhp);
 }
 static inline int nilfs_cpfile_delete_checkpoint_block(struct inode *cpfile,
 						       __u64 cno)
 {
 	return nilfs_mdt_delete_block(cpfile,
 				      nilfs_cpfile_get_blkoff(cpfile, cno));
 }
 /**
  * nilfs_cpfile_get_checkpoint - get a checkpoint
  * @cpfile: inode of checkpoint file
  * @cno: checkpoint number
  * @create: create flag
  * @cpp: pointer to a checkpoint
  * @bhp: pointer to a buffer head
  *
  * Description: nilfs_cpfile_get_checkpoint() acquires the checkpoint
  * specified by @cno. A new checkpoint will be created if @cno is the current
  * checkpoint number and @create is nonzero.
  *
  * Return Value: On success, 0 is returned, and the checkpoint and the
  * buffer head of the buffer on which the checkpoint is located are stored in
  * the place pointed by @cpp and @bhp, respectively. On error, one of the
  * following negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-ENOENT - No such checkpoint.
  *
  * %-EINVAL - invalid checkpoint.
  */
 int nilfs_cpfile_get_checkpoint(struct inode *cpfile,
 				__u64 cno,
 				int create,
 				struct nilfs_checkpoint **cpp,
 				struct buffer_head **bhp)
 {
 	struct buffer_head *header_bh, *cp_bh;
 	struct nilfs_cpfile_header *header;
 	struct nilfs_checkpoint *cp;
 	void *kaddr;
 	int ret;
 	if (unlikely(cno < 1 || cno > nilfs_mdt_cno(cpfile) ||
 		     (cno < nilfs_mdt_cno(cpfile) && create)))
 		return -EINVAL;
 	down_write(&NILFS_MDT(cpfile)->mi_sem);
 	ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
 	if (ret < 0)
 		goto out_sem;
 	ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, create, &cp_bh);
 	if (ret < 0)
 		goto out_header;
 	kaddr = kmap(cp_bh->b_page);
 	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
 	if (nilfs_checkpoint_invalid(cp)) {
 		if (!create) {
 			kunmap(cp_bh->b_page);
 			brelse(cp_bh);
 			ret = -ENOENT;
 			goto out_header;
 		}
 		/* a newly-created checkpoint */
 		nilfs_checkpoint_clear_invalid(cp);
 		if (!nilfs_cpfile_is_in_first(cpfile, cno))
 			nilfs_cpfile_block_add_valid_checkpoints(cpfile, cp_bh,
 								 kaddr, 1);
 		nilfs_mdt_mark_buffer_dirty(cp_bh);
 		kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 		header = nilfs_cpfile_block_get_header(cpfile, header_bh,
 						       kaddr);
 		le64_add_cpu(&header->ch_ncheckpoints, 1);
 		kunmap_atomic(kaddr, KM_USER0);
 		nilfs_mdt_mark_buffer_dirty(header_bh);
 		nilfs_mdt_mark_dirty(cpfile);
 	}
 	if (cpp != NULL)
 		*cpp = cp;
 	*bhp = cp_bh;
  out_header:
 	brelse(header_bh);
  out_sem:
 	up_write(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 /**
  * nilfs_cpfile_put_checkpoint - put a checkpoint
  * @cpfile: inode of checkpoint file
  * @cno: checkpoint number
  * @bh: buffer head
  *
  * Description: nilfs_cpfile_put_checkpoint() releases the checkpoint
  * specified by @cno. @bh must be the buffer head which has been returned by
  * a previous call to nilfs_cpfile_get_checkpoint() with @cno.
  */
 void nilfs_cpfile_put_checkpoint(struct inode *cpfile, __u64 cno,
 				 struct buffer_head *bh)
 {
 	kunmap(bh->b_page);
 	brelse(bh);
 }
 /**
  * nilfs_cpfile_delete_checkpoints - delete checkpoints
  * @cpfile: inode of checkpoint file
  * @start: start checkpoint number
  * @end: end checkpoint numer
  *
  * Description: nilfs_cpfile_delete_checkpoints() deletes the checkpoints in
  * the period from @start to @end, excluding @end itself. The checkpoints
  * which have been already deleted are ignored.
  *
  * Return Value: On success, 0 is returned. On error, one of the following
  * negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-EINVAL - invalid checkpoints.
  */
 int nilfs_cpfile_delete_checkpoints(struct inode *cpfile,
 				    __u64 start,
 				    __u64 end)
 {
 	struct buffer_head *header_bh, *cp_bh;
 	struct nilfs_cpfile_header *header;
 	struct nilfs_checkpoint *cp;
 	size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;
 	__u64 cno;
 	void *kaddr;
 	unsigned long tnicps;
 	int ret, ncps, nicps, count, i;
 	if (unlikely(start == 0 || start > end)) {
 		printk(KERN_ERR "%s: invalid range of checkpoint numbers: "
 		       "[%llu, %llu)\n", __func__,
 		       (unsigned long long)start, (unsigned long long)end);
 		return -EINVAL;
 	}
 	down_write(&NILFS_MDT(cpfile)->mi_sem);
 	ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
 	if (ret < 0)
 		goto out_sem;
 	tnicps = 0;
 	for (cno = start; cno < end; cno += ncps) {
 		ncps = nilfs_cpfile_checkpoints_in_block(cpfile, cno, end);
 		ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);
 		if (ret < 0) {
 			if (ret != -ENOENT)
 				break;
 			/* skip hole */
 			ret = 0;
 			continue;
 		}
 		kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
 		cp = nilfs_cpfile_block_get_checkpoint(
 			cpfile, cno, cp_bh, kaddr);
 		nicps = 0;
 		for (i = 0; i < ncps; i++, cp = (void *)cp + cpsz) {
 			WARN_ON(nilfs_checkpoint_snapshot(cp));
 			if (!nilfs_checkpoint_invalid(cp)) {
 				nilfs_checkpoint_set_invalid(cp);
 				nicps++;
 			}
 		}
 		if (nicps > 0) {
 			tnicps += nicps;
 			nilfs_mdt_mark_buffer_dirty(cp_bh);
 			nilfs_mdt_mark_dirty(cpfile);
-			if (!nilfs_cpfile_is_in_first(cpfile, cno) &&
+			if (!nilfs_cpfile_is_in_first(cpfile, cno)) {
-			    (count = nilfs_cpfile_block_sub_valid_checkpoints(
+				count =
-				    cpfile, cp_bh, kaddr, nicps)) == 0) {
+				  nilfs_cpfile_block_sub_valid_checkpoints(
-				/* make hole */
+						cpfile, cp_bh, kaddr, nicps);
-				kunmap_atomic(kaddr, KM_USER0);
+				if (count == 0) {
-				brelse(cp_bh);
+					/* make hole */
-				ret = nilfs_cpfile_delete_checkpoint_block(
+					kunmap_atomic(kaddr, KM_USER0);
-					cpfile, cno);
+					brelse(cp_bh);
-				if (ret == 0)
+					ret =
-					continue;
+					  nilfs_cpfile_delete_checkpoint_block(
-				printk(KERN_ERR "%s: cannot delete block\n",
+								   cpfile, cno);
-				       __func__);
+					if (ret == 0)
-				break;
+						continue;
+					printk(KERN_ERR
+					       "%s: cannot delete block\n",
+					       __func__);
+					break;
+				}
 			}
 		}
 		kunmap_atomic(kaddr, KM_USER0);
 		brelse(cp_bh);
 	}
 	if (tnicps > 0) {
 		kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 		header = nilfs_cpfile_block_get_header(cpfile, header_bh,
 						       kaddr);
 		le64_add_cpu(&header->ch_ncheckpoints, -(u64)tnicps);
 		nilfs_mdt_mark_buffer_dirty(header_bh);
 		nilfs_mdt_mark_dirty(cpfile);
 		kunmap_atomic(kaddr, KM_USER0);
 	}
 	brelse(header_bh);
  out_sem:
 	up_write(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 static void nilfs_cpfile_checkpoint_to_cpinfo(struct inode *cpfile,
 					      struct nilfs_checkpoint *cp,
 					      struct nilfs_cpinfo *ci)
 {
 	ci->ci_flags = le32_to_cpu(cp->cp_flags);
 	ci->ci_cno = le64_to_cpu(cp->cp_cno);
 	ci->ci_create = le64_to_cpu(cp->cp_create);
 	ci->ci_nblk_inc = le64_to_cpu(cp->cp_nblk_inc);
 	ci->ci_inodes_count = le64_to_cpu(cp->cp_inodes_count);
 	ci->ci_blocks_count = le64_to_cpu(cp->cp_blocks_count);
 	ci->ci_next = le64_to_cpu(cp->cp_snapshot_list.ssl_next);
 }
 static ssize_t nilfs_cpfile_do_get_cpinfo(struct inode *cpfile, __u64 *cnop,
 					  void *buf, unsigned cisz, size_t nci)
 {
 	struct nilfs_checkpoint *cp;
 	struct nilfs_cpinfo *ci = buf;
 	struct buffer_head *bh;
 	size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;
 	__u64 cur_cno = nilfs_mdt_cno(cpfile), cno = *cnop;
 	void *kaddr;
 	int n, ret;
 	int ncps, i;
 	if (cno == 0)
 		return -ENOENT; /* checkpoint number 0 is invalid */
 	down_read(&NILFS_MDT(cpfile)->mi_sem);
 	for (n = 0; cno < cur_cno && n < nci; cno += ncps) {
 		ncps = nilfs_cpfile_checkpoints_in_block(cpfile, cno, cur_cno);
 		ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &bh);
 		if (ret < 0) {
 			if (ret != -ENOENT)
 				goto out;
 			continue; /* skip hole */
 		}
 		kaddr = kmap_atomic(bh->b_page, KM_USER0);
 		cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);
 		for (i = 0; i < ncps && n < nci; i++, cp = (void *)cp + cpsz) {
 			if (!nilfs_checkpoint_invalid(cp)) {
 				nilfs_cpfile_checkpoint_to_cpinfo(cpfile, cp,
 								  ci);
 				ci = (void *)ci + cisz;
 				n++;
 			}
 		}
 		kunmap_atomic(kaddr, KM_USER0);
 		brelse(bh);
 	}
 	ret = n;
 	if (n > 0) {
 		ci = (void *)ci - cisz;
 		*cnop = ci->ci_cno + 1;
 	}
  out:
 	up_read(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop,
 					  void *buf, unsigned cisz, size_t nci)
 {
 	struct buffer_head *bh;
 	struct nilfs_cpfile_header *header;
 	struct nilfs_checkpoint *cp;
 	struct nilfs_cpinfo *ci = buf;
 	__u64 curr = *cnop, next;
 	unsigned long curr_blkoff, next_blkoff;
 	void *kaddr;
 	int n = 0, ret;
 	down_read(&NILFS_MDT(cpfile)->mi_sem);
 	if (curr == 0) {
 		ret = nilfs_cpfile_get_header_block(cpfile, &bh);
 		if (ret < 0)
 			goto out;
 		kaddr = kmap_atomic(bh->b_page, KM_USER0);
 		header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);
 		curr = le64_to_cpu(header->ch_snapshot_list.ssl_next);
 		kunmap_atomic(kaddr, KM_USER0);
 		brelse(bh);
 		if (curr == 0) {
 			ret = 0;
 			goto out;
 		}
 	} else if (unlikely(curr == ~(__u64)0)) {
 		ret = 0;
 		goto out;
 	}
 	curr_blkoff = nilfs_cpfile_get_blkoff(cpfile, curr);
 	ret = nilfs_cpfile_get_checkpoint_block(cpfile, curr, 0, &bh);
 	if (unlikely(ret < 0)) {
 		if (ret == -ENOENT)
 			ret = 0; /* No snapshots (started from a hole block) */
 		goto out;
 	}
 	kaddr = kmap_atomic(bh->b_page, KM_USER0);
 	while (n < nci) {
 		cp = nilfs_cpfile_block_get_checkpoint(cpfile, curr, bh, kaddr);
 		curr = ~(__u64)0; /* Terminator */
 		if (unlikely(nilfs_checkpoint_invalid(cp) ||
 			     !nilfs_checkpoint_snapshot(cp)))
 			break;
 		nilfs_cpfile_checkpoint_to_cpinfo(cpfile, cp, ci);
 		ci = (void *)ci + cisz;
 		n++;
 		next = le64_to_cpu(cp->cp_snapshot_list.ssl_next);
 		if (next == 0)
 			break; /* reach end of the snapshot list */
 		next_blkoff = nilfs_cpfile_get_blkoff(cpfile, next);
 		if (curr_blkoff != next_blkoff) {
 			kunmap_atomic(kaddr, KM_USER0);
 			brelse(bh);
 			ret = nilfs_cpfile_get_checkpoint_block(cpfile, next,
 								0, &bh);
 			if (unlikely(ret < 0)) {
 				WARN_ON(ret == -ENOENT);
 				goto out;
 			}
 			kaddr = kmap_atomic(bh->b_page, KM_USER0);
 		}
 		curr = next;
 		curr_blkoff = next_blkoff;
 	}
 	kunmap_atomic(kaddr, KM_USER0);
 	brelse(bh);
 	*cnop = curr;
 	ret = n;
  out:
 	up_read(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 /**
  * nilfs_cpfile_get_cpinfo -
  * @cpfile:
  * @cno:
  * @ci:
  * @nci:
  */
 ssize_t nilfs_cpfile_get_cpinfo(struct inode *cpfile, __u64 *cnop, int mode,
 				void *buf, unsigned cisz, size_t nci)
 {
 	switch (mode) {
 	case NILFS_CHECKPOINT:
 		return nilfs_cpfile_do_get_cpinfo(cpfile, cnop, buf, cisz, nci);
 	case NILFS_SNAPSHOT:
 		return nilfs_cpfile_do_get_ssinfo(cpfile, cnop, buf, cisz, nci);
 	default:
 		return -EINVAL;
 	}
 }
 /**
  * nilfs_cpfile_delete_checkpoint -
  * @cpfile:
  * @cno:
  */
 int nilfs_cpfile_delete_checkpoint(struct inode *cpfile, __u64 cno)
 {
 	struct nilfs_cpinfo ci;
 	__u64 tcno = cno;
 	ssize_t nci;
 	nci = nilfs_cpfile_do_get_cpinfo(cpfile, &tcno, &ci, sizeof(ci), 1);
 	if (nci < 0)
 		return nci;
 	else if (nci == 0 || ci.ci_cno != cno)
 		return -ENOENT;
 	else if (nilfs_cpinfo_snapshot(&ci))
 		return -EBUSY;
 	return nilfs_cpfile_delete_checkpoints(cpfile, cno, cno + 1);
 }
 static struct nilfs_snapshot_list *
 nilfs_cpfile_block_get_snapshot_list(const struct inode *cpfile,
 				     __u64 cno,
 				     struct buffer_head *bh,
 				     void *kaddr)
 {
 	struct nilfs_cpfile_header *header;
 	struct nilfs_checkpoint *cp;
 	struct nilfs_snapshot_list *list;
 	if (cno != 0) {
 		cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);
 		list = &cp->cp_snapshot_list;
 	} else {
 		header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);
 		list = &header->ch_snapshot_list;
 	}
 	return list;
 }
 static int nilfs_cpfile_set_snapshot(struct inode *cpfile, __u64 cno)
 {
 	struct buffer_head *header_bh, *curr_bh, *prev_bh, *cp_bh;
 	struct nilfs_cpfile_header *header;
 	struct nilfs_checkpoint *cp;
 	struct nilfs_snapshot_list *list;
 	__u64 curr, prev;
 	unsigned long curr_blkoff, prev_blkoff;
 	void *kaddr;
 	int ret;
 	if (cno == 0)
 		return -ENOENT; /* checkpoint number 0 is invalid */
 	down_write(&NILFS_MDT(cpfile)->mi_sem);
 	ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);
 	if (ret < 0)
 		goto out_sem;
 	kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
 	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
 	if (nilfs_checkpoint_invalid(cp)) {
 		ret = -ENOENT;
 		kunmap_atomic(kaddr, KM_USER0);
 		goto out_cp;
 	}
 	if (nilfs_checkpoint_snapshot(cp)) {
 		ret = 0;
 		kunmap_atomic(kaddr, KM_USER0);
 		goto out_cp;
 	}
 	kunmap_atomic(kaddr, KM_USER0);
 	ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
 	if (ret < 0)
 		goto out_cp;
 	kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 	header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);
 	list = &header->ch_snapshot_list;
 	curr_bh = header_bh;
 	get_bh(curr_bh);
 	curr = 0;
 	curr_blkoff = 0;
 	prev = le64_to_cpu(list->ssl_prev);
 	while (prev > cno) {
 		prev_blkoff = nilfs_cpfile_get_blkoff(cpfile, prev);
 		curr = prev;
 		if (curr_blkoff != prev_blkoff) {
 			kunmap_atomic(kaddr, KM_USER0);
 			brelse(curr_bh);
 			ret = nilfs_cpfile_get_checkpoint_block(cpfile, curr,
 								0, &curr_bh);
 			if (ret < 0)
 				goto out_header;
 			kaddr = kmap_atomic(curr_bh->b_page, KM_USER0);
 		}
 		curr_blkoff = prev_blkoff;
 		cp = nilfs_cpfile_block_get_checkpoint(
 			cpfile, curr, curr_bh, kaddr);
 		list = &cp->cp_snapshot_list;
 		prev = le64_to_cpu(list->ssl_prev);
 	}
 	kunmap_atomic(kaddr, KM_USER0);
 	if (prev != 0) {
 		ret = nilfs_cpfile_get_checkpoint_block(cpfile, prev, 0,
 							&prev_bh);
 		if (ret < 0)
 			goto out_curr;
 	} else {
 		prev_bh = header_bh;
 		get_bh(prev_bh);
 	}
 	kaddr = kmap_atomic(curr_bh->b_page, KM_USER0);
 	list = nilfs_cpfile_block_get_snapshot_list(
 		cpfile, curr, curr_bh, kaddr);
 	list->ssl_prev = cpu_to_le64(cno);
 	kunmap_atomic(kaddr, KM_USER0);
 	kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
 	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
 	cp->cp_snapshot_list.ssl_next = cpu_to_le64(curr);
 	cp->cp_snapshot_list.ssl_prev = cpu_to_le64(prev);
 	nilfs_checkpoint_set_snapshot(cp);
 	kunmap_atomic(kaddr, KM_USER0);
 	kaddr = kmap_atomic(prev_bh->b_page, KM_USER0);
 	list = nilfs_cpfile_block_get_snapshot_list(
 		cpfile, prev, prev_bh, kaddr);
 	list->ssl_next = cpu_to_le64(cno);
 	kunmap_atomic(kaddr, KM_USER0);
 	kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 	header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);
 	le64_add_cpu(&header->ch_nsnapshots, 1);
 	kunmap_atomic(kaddr, KM_USER0);
 	nilfs_mdt_mark_buffer_dirty(prev_bh);
 	nilfs_mdt_mark_buffer_dirty(curr_bh);
 	nilfs_mdt_mark_buffer_dirty(cp_bh);
 	nilfs_mdt_mark_buffer_dirty(header_bh);
 	nilfs_mdt_mark_dirty(cpfile);
 	brelse(prev_bh);
  out_curr:
 	brelse(curr_bh);
  out_header:
 	brelse(header_bh);
  out_cp:
 	brelse(cp_bh);
  out_sem:
 	up_write(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 static int nilfs_cpfile_clear_snapshot(struct inode *cpfile, __u64 cno)
 {
 	struct buffer_head *header_bh, *next_bh, *prev_bh, *cp_bh;
 	struct nilfs_cpfile_header *header;
 	struct nilfs_checkpoint *cp;
 	struct nilfs_snapshot_list *list;
 	__u64 next, prev;
 	void *kaddr;
 	int ret;
 	if (cno == 0)
 		return -ENOENT; /* checkpoint number 0 is invalid */
 	down_write(&NILFS_MDT(cpfile)->mi_sem);
 	ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);
 	if (ret < 0)
 		goto out_sem;
 	kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
 	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
 	if (nilfs_checkpoint_invalid(cp)) {
 		ret = -ENOENT;
 		kunmap_atomic(kaddr, KM_USER0);
 		goto out_cp;
 	}
 	if (!nilfs_checkpoint_snapshot(cp)) {
 		ret = 0;
 		kunmap_atomic(kaddr, KM_USER0);
 		goto out_cp;
 	}
 	list = &cp->cp_snapshot_list;
 	next = le64_to_cpu(list->ssl_next);
 	prev = le64_to_cpu(list->ssl_prev);
 	kunmap_atomic(kaddr, KM_USER0);
 	ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
 	if (ret < 0)
 		goto out_cp;
 	if (next != 0) {
 		ret = nilfs_cpfile_get_checkpoint_block(cpfile, next, 0,
 							&next_bh);
 		if (ret < 0)
 			goto out_header;
 	} else {
 		next_bh = header_bh;
 		get_bh(next_bh);
 	}
 	if (prev != 0) {
 		ret = nilfs_cpfile_get_checkpoint_block(cpfile, prev, 0,
 							&prev_bh);
 		if (ret < 0)
 			goto out_next;
 	} else {
 		prev_bh = header_bh;
 		get_bh(prev_bh);
 	}
 	kaddr = kmap_atomic(next_bh->b_page, KM_USER0);
 	list = nilfs_cpfile_block_get_snapshot_list(
 		cpfile, next, next_bh, kaddr);
 	list->ssl_prev = cpu_to_le64(prev);
 	kunmap_atomic(kaddr, KM_USER0);
 	kaddr = kmap_atomic(prev_bh->b_page, KM_USER0);
 	list = nilfs_cpfile_block_get_snapshot_list(
 		cpfile, prev, prev_bh, kaddr);
 	list->ssl_next = cpu_to_le64(next);
 	kunmap_atomic(kaddr, KM_USER0);
 	kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
 	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
 	cp->cp_snapshot_list.ssl_next = cpu_to_le64(0);
 	cp->cp_snapshot_list.ssl_prev = cpu_to_le64(0);
 	nilfs_checkpoint_clear_snapshot(cp);
 	kunmap_atomic(kaddr, KM_USER0);
 	kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
 	header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);
 	le64_add_cpu(&header->ch_nsnapshots, -1);
 	kunmap_atomic(kaddr, KM_USER0);
 	nilfs_mdt_mark_buffer_dirty(next_bh);
 	nilfs_mdt_mark_buffer_dirty(prev_bh);
 	nilfs_mdt_mark_buffer_dirty(cp_bh);
 	nilfs_mdt_mark_buffer_dirty(header_bh);
 	nilfs_mdt_mark_dirty(cpfile);
 	brelse(prev_bh);
  out_next:
 	brelse(next_bh);
  out_header:
 	brelse(header_bh);
  out_cp:
 	brelse(cp_bh);
  out_sem:
 	up_write(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 /**
  * nilfs_cpfile_is_snapshot -
  * @cpfile: inode of checkpoint file
  * @cno: checkpoint number
  *
  * Description:
  *
  * Return Value: On success, 1 is returned if the checkpoint specified by
  * @cno is a snapshot, or 0 if not. On error, one of the following negative
  * error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-ENOENT - No such checkpoint.
  */
 int nilfs_cpfile_is_snapshot(struct inode *cpfile, __u64 cno)
 {
 	struct buffer_head *bh;
 	struct nilfs_checkpoint *cp;
 	void *kaddr;
 	int ret;
 	/* CP number is invalid if it's zero or larger than the
 	largest	exist one.*/
 	if (cno == 0 || cno >= nilfs_mdt_cno(cpfile))
 		return -ENOENT;
 	down_read(&NILFS_MDT(cpfile)->mi_sem);
 	ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &bh);
 	if (ret < 0)
 		goto out;
 	kaddr = kmap_atomic(bh->b_page, KM_USER0);
 	cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);
 	if (nilfs_checkpoint_invalid(cp))
 		ret = -ENOENT;
 	else
 		ret = nilfs_checkpoint_snapshot(cp);
 	kunmap_atomic(kaddr, KM_USER0);
 	brelse(bh);
  out:
 	up_read(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 /**
  * nilfs_cpfile_change_cpmode - change checkpoint mode
  * @cpfile: inode of checkpoint file
  * @cno: checkpoint number
  * @status: mode of checkpoint
  *
  * Description: nilfs_change_cpmode() changes the mode of the checkpoint
  * specified by @cno. The mode @mode is NILFS_CHECKPOINT or NILFS_SNAPSHOT.
  *
  * Return Value: On success, 0 is returned. On error, one of the following
  * negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  *
  * %-ENOENT - No such checkpoint.
  */
 int nilfs_cpfile_change_cpmode(struct inode *cpfile, __u64 cno, int mode)
 {
 	struct the_nilfs *nilfs;
 	int ret;
 	nilfs = NILFS_MDT(cpfile)->mi_nilfs;
 	switch (mode) {
 	case NILFS_CHECKPOINT:
 		/*
 		 * Check for protecting existing snapshot mounts:
 		 * ns_mount_mutex is used to make this operation atomic and
 		 * exclusive with a new mount job.  Though it doesn't cover
 		 * umount, it's enough for the purpose.
 		 */
 		if (nilfs_checkpoint_is_mounted(nilfs, cno, 1)) {
 			/* Current implementation does not have to protect
 			   plain read-only mounts since they are exclusive
 			   with a read/write mount and are protected from the
 			   cleaner. */
 			ret = -EBUSY;
 		} else
 			ret = nilfs_cpfile_clear_snapshot(cpfile, cno);
 		return ret;
 	case NILFS_SNAPSHOT:
 		return nilfs_cpfile_set_snapshot(cpfile, cno);
 	default:
 		return -EINVAL;
 	}
 }
 /**
  * nilfs_cpfile_get_stat - get checkpoint statistics
  * @cpfile: inode of checkpoint file
  * @stat: pointer to a structure of checkpoint statistics
  *
  * Description: nilfs_cpfile_get_stat() returns information about checkpoints.
  *
  * Return Value: On success, 0 is returned, and checkpoints information is
  * stored in the place pointed by @stat. On error, one of the following
  * negative error codes is returned.
  *
  * %-EIO - I/O error.
  *
  * %-ENOMEM - Insufficient amount of memory available.
  */
 int nilfs_cpfile_get_stat(struct inode *cpfile, struct nilfs_cpstat *cpstat)
 {
 	struct buffer_head *bh;
 	struct nilfs_cpfile_header *header;
 	void *kaddr;
 	int ret;
 	down_read(&NILFS_MDT(cpfile)->mi_sem);
 	ret = nilfs_cpfile_get_header_block(cpfile, &bh);
 	if (ret < 0)
 		goto out_sem;
 	kaddr = kmap_atomic(bh->b_page, KM_USER0);
 	header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);
 	cpstat->cs_cno = nilfs_mdt_cno(cpfile);
 	cpstat->cs_ncps = le64_to_cpu(header->ch_ncheckpoints);
 	cpstat->cs_nsss = le64_to_cpu(header->ch_nsnapshots);
 	kunmap_atomic(kaddr, KM_USER0);
 	brelse(bh);
  out_sem:
 	up_read(&NILFS_MDT(cpfile)->mi_sem);
 	return ret;
 }
 /**
  * nilfs_cpfile_read - read cpfile inode
  * @cpfile: cpfile inode
  * @raw_inode: on-disk cpfile inode
  */
 int nilfs_cpfile_read(struct inode *cpfile, struct nilfs_inode *raw_inode)
 {
 	return nilfs_read_inode_common(cpfile, raw_inode);
 }
 /**
  * nilfs_cpfile_new - create cpfile
  * @nilfs: nilfs object
  * @cpsize: size of a checkpoint entry
  */
 struct inode *nilfs_cpfile_new(struct the_nilfs *nilfs, size_t cpsize)
 {
 	struct inode *cpfile;
 	cpfile = nilfs_mdt_new(nilfs, NULL, NILFS_CPFILE_INO, 0);
 	if (cpfile)
 		nilfs_mdt_set_entry_size(cpfile, cpsize,
 					 sizeof(struct nilfs_cpfile_header));
 	return cpfile;
 }

fs/nilfs2/direct.c

Diff comments View file @ 5ee5814

 /*
  * direct.c - NILFS direct block pointer.
  *
  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  * Written by Koji Sato <koji@osrg.net>.
  */
 #include <linux/errno.h>
 #include "nilfs.h"
 #include "page.h"
 #include "direct.h"
 #include "alloc.h"
 #include "dat.h"
 static inline __le64 *nilfs_direct_dptrs(const struct nilfs_direct *direct)
 {
 	return (__le64 *)
 		((struct nilfs_direct_node *)direct->d_bmap.b_u.u_data + 1);
 }
 static inline __u64
 nilfs_direct_get_ptr(const struct nilfs_direct *direct, __u64 key)
 {
 	return nilfs_bmap_dptr_to_ptr(*(nilfs_direct_dptrs(direct) + key));
 }
 static inline void nilfs_direct_set_ptr(struct nilfs_direct *direct,
 					__u64 key, __u64 ptr)
 {
 	*(nilfs_direct_dptrs(direct) + key) = nilfs_bmap_ptr_to_dptr(ptr);
 }
 static int nilfs_direct_lookup(const struct nilfs_bmap *bmap,
 			       __u64 key, int level, __u64 *ptrp)
 {
 	struct nilfs_direct *direct;
 	__u64 ptr;
-	direct = (struct nilfs_direct *)bmap;
+	direct = (struct nilfs_direct *)bmap;  /* XXX: use macro for level 1 */
-	if ((key > NILFS_DIRECT_KEY_MAX) ||
+	if (key > NILFS_DIRECT_KEY_MAX || level != 1)
-	    (level != 1) ||	/* XXX: use macro for level 1 */
-	    ((ptr = nilfs_direct_get_ptr(direct, key)) ==
-	     NILFS_BMAP_INVALID_PTR))
 		return -ENOENT;
+	ptr = nilfs_direct_get_ptr(direct, key);
+	if (ptr == NILFS_BMAP_INVALID_PTR)
+		return -ENOENT;
 	if (ptrp != NULL)
 		*ptrp = ptr;
 	return 0;
 }
 static int nilfs_direct_lookup_contig(const struct nilfs_bmap *bmap,
 				      __u64 key, __u64 *ptrp,
 				      unsigned maxblocks)
 {
 	struct nilfs_direct *direct = (struct nilfs_direct *)bmap;
 	struct inode *dat = NULL;
 	__u64 ptr, ptr2;
 	sector_t blocknr;
 	int ret, cnt;
-	if (key > NILFS_DIRECT_KEY_MAX ||
+	if (key > NILFS_DIRECT_KEY_MAX)
-	    (ptr = nilfs_direct_get_ptr(direct, key)) ==
+		return -ENOENT;
-	    NILFS_BMAP_INVALID_PTR)
+	ptr = nilfs_direct_get_ptr(direct, key);
+	if (ptr == NILFS_BMAP_INVALID_PTR)
 		return -ENOENT;
 	if (NILFS_BMAP_USE_VBN(bmap)) {
 		dat = nilfs_bmap_get_dat(bmap);
 		ret = nilfs_dat_translate(dat, ptr, &blocknr);
 		if (ret < 0)
 			return ret;
 		ptr = blocknr;
 	}
 	maxblocks = min_t(unsigned, maxblocks, NILFS_DIRECT_KEY_MAX - key + 1);
 	for (cnt = 1; cnt < maxblocks &&
 		     (ptr2 = nilfs_direct_get_ptr(direct, key + cnt)) !=
 		     NILFS_BMAP_INVALID_PTR;
 	     cnt++) {
 		if (dat) {
 			ret = nilfs_dat_translate(dat, ptr2, &blocknr);
 			if (ret < 0)
 				return ret;
 			ptr2 = blocknr;
 		}
 		if (ptr2 != ptr + cnt)
 			break;
 	}
 	*ptrp = ptr;
 	return cnt;
 }
 static __u64
 nilfs_direct_find_target_v(const struct nilfs_direct *direct, __u64 key)
 {
 	__u64 ptr;
 	ptr = nilfs_bmap_find_target_seq(&direct->d_bmap, key);
 	if (ptr != NILFS_BMAP_INVALID_PTR)
 		/* sequential access */
 		return ptr;
 	else
 		/* block group */
 		return nilfs_bmap_find_target_in_group(&direct->d_bmap);
 }
 static void nilfs_direct_set_target_v(struct nilfs_direct *direct,
 				      __u64 key, __u64 ptr)
 {
 	direct->d_bmap.b_last_allocated_key = key;
 	direct->d_bmap.b_last_allocated_ptr = ptr;
 }
 static int nilfs_direct_insert(struct nilfs_bmap *bmap, __u64 key, __u64 ptr)
 {
 	struct nilfs_direct *direct = (struct nilfs_direct *)bmap;
 	union nilfs_bmap_ptr_req req;
 	struct inode *dat = NULL;
 	struct buffer_head *bh;
 	int ret;
 	if (key > NILFS_DIRECT_KEY_MAX)
 		return -ENOENT;
 	if (nilfs_direct_get_ptr(direct, key) != NILFS_BMAP_INVALID_PTR)
 		return -EEXIST;
 	if (NILFS_BMAP_USE_VBN(bmap)) {
 		req.bpr_ptr = nilfs_direct_find_target_v(direct, key);
 		dat = nilfs_bmap_get_dat(bmap);
 	}
 	ret = nilfs_bmap_prepare_alloc_ptr(bmap, &req, dat);
 	if (!ret) {
 		/* ptr must be a pointer to a buffer head. */
 		bh = (struct buffer_head *)((unsigned long)ptr);
 		set_buffer_nilfs_volatile(bh);
 		nilfs_bmap_commit_alloc_ptr(bmap, &req, dat);
 		nilfs_direct_set_ptr(direct, key, req.bpr_ptr);
 		if (!nilfs_bmap_dirty(bmap))
 			nilfs_bmap_set_dirty(bmap);
 		if (NILFS_BMAP_USE_VBN(bmap))
 			nilfs_direct_set_target_v(direct, key, req.bpr_ptr);
 		nilfs_bmap_add_blocks(bmap, 1);
 	}
 	return ret;
 }
 static int nilfs_direct_delete(struct nilfs_bmap *bmap, __u64 key)
 {
 	struct nilfs_direct *direct = (struct nilfs_direct *)bmap;
 	union nilfs_bmap_ptr_req req;
 	struct inode *dat;
 	int ret;
 	if (key > NILFS_DIRECT_KEY_MAX ||
 	    nilfs_direct_get_ptr(direct, key) == NILFS_BMAP_INVALID_PTR)
 		return -ENOENT;
 	dat = NILFS_BMAP_USE_VBN(bmap) ? nilfs_bmap_get_dat(bmap) : NULL;
 	req.bpr_ptr = nilfs_direct_get_ptr(direct, key);
 	ret = nilfs_bmap_prepare_end_ptr(bmap, &req, dat);
 	if (!ret) {
 		nilfs_bmap_commit_end_ptr(bmap, &req, dat);
 		nilfs_direct_set_ptr(direct, key, NILFS_BMAP_INVALID_PTR);
 		nilfs_bmap_sub_blocks(bmap, 1);
 	}
 	return ret;
 }
 static int nilfs_direct_last_key(const struct nilfs_bmap *bmap, __u64 *keyp)
 {
 	struct nilfs_direct *direct;
 	__u64 key, lastkey;
 	direct = (struct nilfs_direct *)bmap;
 	lastkey = NILFS_DIRECT_KEY_MAX + 1;
 	for (key = NILFS_DIRECT_KEY_MIN; key <= NILFS_DIRECT_KEY_MAX; key++)
 		if (nilfs_direct_get_ptr(direct, key) !=
 		    NILFS_BMAP_INVALID_PTR)
 			lastkey = key;
 	if (lastkey == NILFS_DIRECT_KEY_MAX + 1)
 		return -ENOENT;
 	*keyp = lastkey;
 	return 0;
 }
 static int nilfs_direct_check_insert(const struct nilfs_bmap *bmap, __u64 key)
 {
 	return key > NILFS_DIRECT_KEY_MAX;
 }
 static int nilfs_direct_gather_data(struct nilfs_bmap *bmap,
 				    __u64 *keys, __u64 *ptrs, int nitems)
 {
 	struct nilfs_direct *direct;
 	__u64 key;
 	__u64 ptr;
 	int n;
 	direct = (struct nilfs_direct *)bmap;
 	if (nitems > NILFS_DIRECT_NBLOCKS)
 		nitems = NILFS_DIRECT_NBLOCKS;
 	n = 0;
 	for (key = 0; key < nitems; key++) {
 		ptr = nilfs_direct_get_ptr(direct, key);
 		if (ptr != NILFS_BMAP_INVALID_PTR) {
 			keys[n] = key;
 			ptrs[n] = ptr;
 			n++;
 		}
 	}
 	return n;
 }
 int nilfs_direct_delete_and_convert(struct nilfs_bmap *bmap,
 				    __u64 key, __u64 *keys, __u64 *ptrs, int n)
 {
 	struct nilfs_direct *direct;
 	__le64 *dptrs;
 	int ret, i, j;
 	/* no need to allocate any resource for conversion */
 	/* delete */
 	ret = bmap->b_ops->bop_delete(bmap, key);
 	if (ret < 0)
 		return ret;
 	/* free resources */
 	if (bmap->b_ops->bop_clear != NULL)
 		bmap->b_ops->bop_clear(bmap);
 	/* convert */
 	direct = (struct nilfs_direct *)bmap;
 	dptrs = nilfs_direct_dptrs(direct);
 	for (i = 0, j = 0; i < NILFS_DIRECT_NBLOCKS; i++) {
 		if ((j < n) && (i == keys[j])) {
 			dptrs[i] = (i != key) ?
 				nilfs_bmap_ptr_to_dptr(ptrs[j]) :
 				NILFS_BMAP_INVALID_PTR;
 			j++;
 		} else
 			dptrs[i] = NILFS_BMAP_INVALID_PTR;
 	}
 	nilfs_direct_init(bmap);
 	return 0;
 }
 static int nilfs_direct_propagate(const struct nilfs_bmap *bmap,
 				  struct buffer_head *bh)
 {
 	struct nilfs_direct *direct = (struct nilfs_direct *)bmap;
 	struct nilfs_palloc_req oldreq, newreq;
 	struct inode *dat;
 	__u64 key;
 	__u64 ptr;
 	int ret;
 	if (!NILFS_BMAP_USE_VBN(bmap))
 		return 0;
 	dat = nilfs_bmap_get_dat(bmap);
 	key = nilfs_bmap_data_get_key(bmap, bh);
 	ptr = nilfs_direct_get_ptr(direct, key);
 	if (!buffer_nilfs_volatile(bh)) {
 		oldreq.pr_entry_nr = ptr;
 		newreq.pr_entry_nr = ptr;
 		ret = nilfs_dat_prepare_update(dat, &oldreq, &newreq);
 		if (ret < 0)
 			return ret;
 		nilfs_dat_commit_update(dat, &oldreq, &newreq,
 					bmap->b_ptr_type == NILFS_BMAP_PTR_VS);
 		set_buffer_nilfs_volatile(bh);
 		nilfs_direct_set_ptr(direct, key, newreq.pr_entry_nr);
 	} else
 		ret = nilfs_dat_mark_dirty(dat, ptr);
 	return ret;
 }
 static int nilfs_direct_assign_v(struct nilfs_direct *direct,
 				 __u64 key, __u64 ptr,
 				 struct buffer_head **bh,
 				 sector_t blocknr,
 				 union nilfs_binfo *binfo)
 {
 	struct inode *dat = nilfs_bmap_get_dat(&direct->d_bmap);
 	union nilfs_bmap_ptr_req req;
 	int ret;
 	req.bpr_ptr = ptr;
 	ret = nilfs_dat_prepare_start(dat, &req.bpr_req);
 	if (!ret) {
 		nilfs_dat_commit_start(dat, &req.bpr_req, blocknr);
 		binfo->bi_v.bi_vblocknr = nilfs_bmap_ptr_to_dptr(ptr);
 		binfo->bi_v.bi_blkoff = nilfs_bmap_key_to_dkey(key);
 	}
 	return ret;
 }
 static int nilfs_direct_assign_p(struct nilfs_direct *direct,
 				 __u64 key, __u64 ptr,
 				 struct buffer_head **bh,
 				 sector_t blocknr,
 				 union nilfs_binfo *binfo)
 {
 	nilfs_direct_set_ptr(direct, key, blocknr);
 	binfo->bi_dat.bi_blkoff = nilfs_bmap_key_to_dkey(key);
 	binfo->bi_dat.bi_level = 0;
 	return 0;
 }
 static int nilfs_direct_assign(struct nilfs_bmap *bmap,
 			       struct buffer_head **bh,
 			       sector_t blocknr,
 			       union nilfs_binfo *binfo)
 {
 	struct nilfs_direct *direct;
 	__u64 key;
 	__u64 ptr;
 	direct = (struct nilfs_direct *)bmap;
 	key = nilfs_bmap_data_get_key(bmap, *bh);
 	if (unlikely(key > NILFS_DIRECT_KEY_MAX)) {
 		printk(KERN_CRIT "%s: invalid key: %llu\n", __func__,
 		       (unsigned long long)key);
 		return -EINVAL;
 	}
 	ptr = nilfs_direct_get_ptr(direct, key);
 	if (unlikely(ptr == NILFS_BMAP_INVALID_PTR)) {
 		printk(KERN_CRIT "%s: invalid pointer: %llu\n", __func__,
 		       (unsigned long long)ptr);
 		return -EINVAL;
 	}
 	return NILFS_BMAP_USE_VBN(bmap) ?
 		nilfs_direct_assign_v(direct, key, ptr, bh, blocknr, binfo) :
 		nilfs_direct_assign_p(direct, key, ptr, bh, blocknr, binfo);
 }
 static const struct nilfs_bmap_operations nilfs_direct_ops = {
 	.bop_lookup		=	nilfs_direct_lookup,
 	.bop_lookup_contig	=	nilfs_direct_lookup_contig,
 	.bop_insert		=	nilfs_direct_insert,
 	.bop_delete		=	nilfs_direct_delete,
 	.bop_clear		=	NULL,
 	.bop_propagate		=	nilfs_direct_propagate,
 	.bop_lookup_dirty_buffers	=	NULL,
 	.bop_assign		=	nilfs_direct_assign,
 	.bop_mark		=	NULL,
 	.bop_last_key		=	nilfs_direct_last_key,
 	.bop_check_insert	=	nilfs_direct_check_insert,
 	.bop_check_delete	=	NULL,
 	.bop_gather_data	=	nilfs_direct_gather_data,
 };
 int nilfs_direct_init(struct nilfs_bmap *bmap)
 {
 	bmap->b_ops = &nilfs_direct_ops;