nilfs2: fix bh leak in nilfs_cpfile_delete_checkpoints function
[sfrench/cifs-2.6.git] / fs / nilfs2 / cpfile.c
1 /*
2  * cpfile.c - NILFS checkpoint file.
3  *
4  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
5  *
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
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
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
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  * Written by Koji Sato <koji@osrg.net>.
21  */
22
23 #include <linux/kernel.h>
24 #include <linux/fs.h>
25 #include <linux/string.h>
26 #include <linux/buffer_head.h>
27 #include <linux/errno.h>
28 #include <linux/nilfs2_fs.h>
29 #include "mdt.h"
30 #include "cpfile.h"
31
32
33 static inline unsigned long
34 nilfs_cpfile_checkpoints_per_block(const struct inode *cpfile)
35 {
36         return NILFS_MDT(cpfile)->mi_entries_per_block;
37 }
38
39 /* block number from the beginning of the file */
40 static unsigned long
41 nilfs_cpfile_get_blkoff(const struct inode *cpfile, __u64 cno)
42 {
43         __u64 tcno = cno + NILFS_MDT(cpfile)->mi_first_entry_offset - 1;
44         do_div(tcno, nilfs_cpfile_checkpoints_per_block(cpfile));
45         return (unsigned long)tcno;
46 }
47
48 /* offset in block */
49 static unsigned long
50 nilfs_cpfile_get_offset(const struct inode *cpfile, __u64 cno)
51 {
52         __u64 tcno = cno + NILFS_MDT(cpfile)->mi_first_entry_offset - 1;
53         return do_div(tcno, nilfs_cpfile_checkpoints_per_block(cpfile));
54 }
55
56 static unsigned long
57 nilfs_cpfile_checkpoints_in_block(const struct inode *cpfile,
58                                   __u64 curr,
59                                   __u64 max)
60 {
61         return min_t(__u64,
62                      nilfs_cpfile_checkpoints_per_block(cpfile) -
63                      nilfs_cpfile_get_offset(cpfile, curr),
64                      max - curr);
65 }
66
67 static inline int nilfs_cpfile_is_in_first(const struct inode *cpfile,
68                                            __u64 cno)
69 {
70         return nilfs_cpfile_get_blkoff(cpfile, cno) == 0;
71 }
72
73 static unsigned int
74 nilfs_cpfile_block_add_valid_checkpoints(const struct inode *cpfile,
75                                          struct buffer_head *bh,
76                                          void *kaddr,
77                                          unsigned int n)
78 {
79         struct nilfs_checkpoint *cp = kaddr + bh_offset(bh);
80         unsigned int count;
81
82         count = le32_to_cpu(cp->cp_checkpoints_count) + n;
83         cp->cp_checkpoints_count = cpu_to_le32(count);
84         return count;
85 }
86
87 static unsigned int
88 nilfs_cpfile_block_sub_valid_checkpoints(const struct inode *cpfile,
89                                          struct buffer_head *bh,
90                                          void *kaddr,
91                                          unsigned int n)
92 {
93         struct nilfs_checkpoint *cp = kaddr + bh_offset(bh);
94         unsigned int count;
95
96         WARN_ON(le32_to_cpu(cp->cp_checkpoints_count) < n);
97         count = le32_to_cpu(cp->cp_checkpoints_count) - n;
98         cp->cp_checkpoints_count = cpu_to_le32(count);
99         return count;
100 }
101
102 static inline struct nilfs_cpfile_header *
103 nilfs_cpfile_block_get_header(const struct inode *cpfile,
104                               struct buffer_head *bh,
105                               void *kaddr)
106 {
107         return kaddr + bh_offset(bh);
108 }
109
110 static struct nilfs_checkpoint *
111 nilfs_cpfile_block_get_checkpoint(const struct inode *cpfile, __u64 cno,
112                                   struct buffer_head *bh,
113                                   void *kaddr)
114 {
115         return kaddr + bh_offset(bh) + nilfs_cpfile_get_offset(cpfile, cno) *
116                 NILFS_MDT(cpfile)->mi_entry_size;
117 }
118
119 static void nilfs_cpfile_block_init(struct inode *cpfile,
120                                     struct buffer_head *bh,
121                                     void *kaddr)
122 {
123         struct nilfs_checkpoint *cp = kaddr + bh_offset(bh);
124         size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;
125         int n = nilfs_cpfile_checkpoints_per_block(cpfile);
126
127         while (n-- > 0) {
128                 nilfs_checkpoint_set_invalid(cp);
129                 cp = (void *)cp + cpsz;
130         }
131 }
132
133 static inline int nilfs_cpfile_get_header_block(struct inode *cpfile,
134                                                 struct buffer_head **bhp)
135 {
136         return nilfs_mdt_get_block(cpfile, 0, 0, NULL, bhp);
137 }
138
139 static inline int nilfs_cpfile_get_checkpoint_block(struct inode *cpfile,
140                                                     __u64 cno,
141                                                     int create,
142                                                     struct buffer_head **bhp)
143 {
144         return nilfs_mdt_get_block(cpfile,
145                                    nilfs_cpfile_get_blkoff(cpfile, cno),
146                                    create, nilfs_cpfile_block_init, bhp);
147 }
148
149 static inline int nilfs_cpfile_delete_checkpoint_block(struct inode *cpfile,
150                                                        __u64 cno)
151 {
152         return nilfs_mdt_delete_block(cpfile,
153                                       nilfs_cpfile_get_blkoff(cpfile, cno));
154 }
155
156 /**
157  * nilfs_cpfile_get_checkpoint - get a checkpoint
158  * @cpfile: inode of checkpoint file
159  * @cno: checkpoint number
160  * @create: create flag
161  * @cpp: pointer to a checkpoint
162  * @bhp: pointer to a buffer head
163  *
164  * Description: nilfs_cpfile_get_checkpoint() acquires the checkpoint
165  * specified by @cno. A new checkpoint will be created if @cno is the current
166  * checkpoint number and @create is nonzero.
167  *
168  * Return Value: On success, 0 is returned, and the checkpoint and the
169  * buffer head of the buffer on which the checkpoint is located are stored in
170  * the place pointed by @cpp and @bhp, respectively. On error, one of the
171  * following negative error codes is returned.
172  *
173  * %-EIO - I/O error.
174  *
175  * %-ENOMEM - Insufficient amount of memory available.
176  *
177  * %-ENOENT - No such checkpoint.
178  *
179  * %-EINVAL - invalid checkpoint.
180  */
181 int nilfs_cpfile_get_checkpoint(struct inode *cpfile,
182                                 __u64 cno,
183                                 int create,
184                                 struct nilfs_checkpoint **cpp,
185                                 struct buffer_head **bhp)
186 {
187         struct buffer_head *header_bh, *cp_bh;
188         struct nilfs_cpfile_header *header;
189         struct nilfs_checkpoint *cp;
190         void *kaddr;
191         int ret;
192
193         if (unlikely(cno < 1 || cno > nilfs_mdt_cno(cpfile) ||
194                      (cno < nilfs_mdt_cno(cpfile) && create)))
195                 return -EINVAL;
196
197         down_write(&NILFS_MDT(cpfile)->mi_sem);
198
199         ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
200         if (ret < 0)
201                 goto out_sem;
202         ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, create, &cp_bh);
203         if (ret < 0)
204                 goto out_header;
205         kaddr = kmap(cp_bh->b_page);
206         cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
207         if (nilfs_checkpoint_invalid(cp)) {
208                 if (!create) {
209                         kunmap(cp_bh->b_page);
210                         brelse(cp_bh);
211                         ret = -ENOENT;
212                         goto out_header;
213                 }
214                 /* a newly-created checkpoint */
215                 nilfs_checkpoint_clear_invalid(cp);
216                 if (!nilfs_cpfile_is_in_first(cpfile, cno))
217                         nilfs_cpfile_block_add_valid_checkpoints(cpfile, cp_bh,
218                                                                  kaddr, 1);
219                 nilfs_mdt_mark_buffer_dirty(cp_bh);
220
221                 kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
222                 header = nilfs_cpfile_block_get_header(cpfile, header_bh,
223                                                        kaddr);
224                 le64_add_cpu(&header->ch_ncheckpoints, 1);
225                 kunmap_atomic(kaddr, KM_USER0);
226                 nilfs_mdt_mark_buffer_dirty(header_bh);
227                 nilfs_mdt_mark_dirty(cpfile);
228         }
229
230         if (cpp != NULL)
231                 *cpp = cp;
232         *bhp = cp_bh;
233
234  out_header:
235         brelse(header_bh);
236
237  out_sem:
238         up_write(&NILFS_MDT(cpfile)->mi_sem);
239         return ret;
240 }
241
242 /**
243  * nilfs_cpfile_put_checkpoint - put a checkpoint
244  * @cpfile: inode of checkpoint file
245  * @cno: checkpoint number
246  * @bh: buffer head
247  *
248  * Description: nilfs_cpfile_put_checkpoint() releases the checkpoint
249  * specified by @cno. @bh must be the buffer head which has been returned by
250  * a previous call to nilfs_cpfile_get_checkpoint() with @cno.
251  */
252 void nilfs_cpfile_put_checkpoint(struct inode *cpfile, __u64 cno,
253                                  struct buffer_head *bh)
254 {
255         kunmap(bh->b_page);
256         brelse(bh);
257 }
258
259 /**
260  * nilfs_cpfile_delete_checkpoints - delete checkpoints
261  * @cpfile: inode of checkpoint file
262  * @start: start checkpoint number
263  * @end: end checkpoint numer
264  *
265  * Description: nilfs_cpfile_delete_checkpoints() deletes the checkpoints in
266  * the period from @start to @end, excluding @end itself. The checkpoints
267  * which have been already deleted are ignored.
268  *
269  * Return Value: On success, 0 is returned. On error, one of the following
270  * negative error codes is returned.
271  *
272  * %-EIO - I/O error.
273  *
274  * %-ENOMEM - Insufficient amount of memory available.
275  *
276  * %-EINVAL - invalid checkpoints.
277  */
278 int nilfs_cpfile_delete_checkpoints(struct inode *cpfile,
279                                     __u64 start,
280                                     __u64 end)
281 {
282         struct buffer_head *header_bh, *cp_bh;
283         struct nilfs_cpfile_header *header;
284         struct nilfs_checkpoint *cp;
285         size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;
286         __u64 cno;
287         void *kaddr;
288         unsigned long tnicps;
289         int ret, ncps, nicps, count, i;
290
291         if (unlikely(start == 0 || start > end)) {
292                 printk(KERN_ERR "%s: invalid range of checkpoint numbers: "
293                        "[%llu, %llu)\n", __func__,
294                        (unsigned long long)start, (unsigned long long)end);
295                 return -EINVAL;
296         }
297
298         /* cannot delete the latest checkpoint */
299         if (start == nilfs_mdt_cno(cpfile) - 1)
300                 return -EPERM;
301
302         down_write(&NILFS_MDT(cpfile)->mi_sem);
303
304         ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
305         if (ret < 0)
306                 goto out_sem;
307         tnicps = 0;
308
309         for (cno = start; cno < end; cno += ncps) {
310                 ncps = nilfs_cpfile_checkpoints_in_block(cpfile, cno, end);
311                 ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);
312                 if (ret < 0) {
313                         if (ret != -ENOENT)
314                                 goto out_header;
315                         /* skip hole */
316                         ret = 0;
317                         continue;
318                 }
319
320                 kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
321                 cp = nilfs_cpfile_block_get_checkpoint(
322                         cpfile, cno, cp_bh, kaddr);
323                 nicps = 0;
324                 for (i = 0; i < ncps; i++, cp = (void *)cp + cpsz) {
325                         WARN_ON(nilfs_checkpoint_snapshot(cp));
326                         if (!nilfs_checkpoint_invalid(cp)) {
327                                 nilfs_checkpoint_set_invalid(cp);
328                                 nicps++;
329                         }
330                 }
331                 if (nicps > 0) {
332                         tnicps += nicps;
333                         nilfs_mdt_mark_buffer_dirty(cp_bh);
334                         nilfs_mdt_mark_dirty(cpfile);
335                         if (!nilfs_cpfile_is_in_first(cpfile, cno) &&
336                             (count = nilfs_cpfile_block_sub_valid_checkpoints(
337                                     cpfile, cp_bh, kaddr, nicps)) == 0) {
338                                 /* make hole */
339                                 kunmap_atomic(kaddr, KM_USER0);
340                                 brelse(cp_bh);
341                                 ret = nilfs_cpfile_delete_checkpoint_block(
342                                         cpfile, cno);
343                                 if (ret == 0)
344                                         continue;
345                                 printk(KERN_ERR "%s: cannot delete block\n",
346                                        __func__);
347                                 goto out_header;
348                         }
349                 }
350
351                 kunmap_atomic(kaddr, KM_USER0);
352                 brelse(cp_bh);
353         }
354
355         if (tnicps > 0) {
356                 kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
357                 header = nilfs_cpfile_block_get_header(cpfile, header_bh,
358                                                        kaddr);
359                 le64_add_cpu(&header->ch_ncheckpoints, -(u64)tnicps);
360                 nilfs_mdt_mark_buffer_dirty(header_bh);
361                 nilfs_mdt_mark_dirty(cpfile);
362                 kunmap_atomic(kaddr, KM_USER0);
363         }
364
365  out_header:
366         brelse(header_bh);
367
368  out_sem:
369         up_write(&NILFS_MDT(cpfile)->mi_sem);
370         return ret;
371 }
372
373 static void nilfs_cpfile_checkpoint_to_cpinfo(struct inode *cpfile,
374                                               struct nilfs_checkpoint *cp,
375                                               struct nilfs_cpinfo *ci)
376 {
377         ci->ci_flags = le32_to_cpu(cp->cp_flags);
378         ci->ci_cno = le64_to_cpu(cp->cp_cno);
379         ci->ci_create = le64_to_cpu(cp->cp_create);
380         ci->ci_nblk_inc = le64_to_cpu(cp->cp_nblk_inc);
381         ci->ci_inodes_count = le64_to_cpu(cp->cp_inodes_count);
382         ci->ci_blocks_count = le64_to_cpu(cp->cp_blocks_count);
383         ci->ci_next = le64_to_cpu(cp->cp_snapshot_list.ssl_next);
384 }
385
386 static ssize_t nilfs_cpfile_do_get_cpinfo(struct inode *cpfile, __u64 *cnop,
387                                           struct nilfs_cpinfo *ci, size_t nci)
388 {
389         struct nilfs_checkpoint *cp;
390         struct buffer_head *bh;
391         size_t cpsz = NILFS_MDT(cpfile)->mi_entry_size;
392         __u64 cur_cno = nilfs_mdt_cno(cpfile), cno = *cnop;
393         void *kaddr;
394         int n, ret;
395         int ncps, i;
396
397         if (cno == 0)
398                 return -ENOENT; /* checkpoint number 0 is invalid */
399         down_read(&NILFS_MDT(cpfile)->mi_sem);
400
401         for (n = 0; cno < cur_cno && n < nci; cno += ncps) {
402                 ncps = nilfs_cpfile_checkpoints_in_block(cpfile, cno, cur_cno);
403                 ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &bh);
404                 if (ret < 0) {
405                         if (ret != -ENOENT)
406                                 goto out;
407                         continue; /* skip hole */
408                 }
409
410                 kaddr = kmap_atomic(bh->b_page, KM_USER0);
411                 cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);
412                 for (i = 0; i < ncps && n < nci; i++, cp = (void *)cp + cpsz) {
413                         if (!nilfs_checkpoint_invalid(cp))
414                                 nilfs_cpfile_checkpoint_to_cpinfo(
415                                         cpfile, cp, &ci[n++]);
416                 }
417                 kunmap_atomic(kaddr, KM_USER0);
418                 brelse(bh);
419         }
420
421         ret = n;
422         if (n > 0)
423                 *cnop = ci[n - 1].ci_cno + 1;
424
425  out:
426         up_read(&NILFS_MDT(cpfile)->mi_sem);
427         return ret;
428 }
429
430 static ssize_t nilfs_cpfile_do_get_ssinfo(struct inode *cpfile, __u64 *cnop,
431                                           struct nilfs_cpinfo *ci, size_t nci)
432 {
433         struct buffer_head *bh;
434         struct nilfs_cpfile_header *header;
435         struct nilfs_checkpoint *cp;
436         __u64 curr = *cnop, next;
437         unsigned long curr_blkoff, next_blkoff;
438         void *kaddr;
439         int n = 0, ret;
440
441         down_read(&NILFS_MDT(cpfile)->mi_sem);
442
443         if (curr == 0) {
444                 ret = nilfs_cpfile_get_header_block(cpfile, &bh);
445                 if (ret < 0)
446                         goto out;
447                 kaddr = kmap_atomic(bh->b_page, KM_USER0);
448                 header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);
449                 curr = le64_to_cpu(header->ch_snapshot_list.ssl_next);
450                 kunmap_atomic(kaddr, KM_USER0);
451                 brelse(bh);
452                 if (curr == 0) {
453                         ret = 0;
454                         goto out;
455                 }
456         } else if (unlikely(curr == ~(__u64)0)) {
457                 ret = 0;
458                 goto out;
459         }
460
461         curr_blkoff = nilfs_cpfile_get_blkoff(cpfile, curr);
462         ret = nilfs_cpfile_get_checkpoint_block(cpfile, curr, 0, &bh);
463         if (unlikely(ret < 0)) {
464                 if (ret == -ENOENT)
465                         ret = 0; /* No snapshots (started from a hole block) */
466                 goto out;
467         }
468         kaddr = kmap_atomic(bh->b_page, KM_USER0);
469         while (n < nci) {
470                 cp = nilfs_cpfile_block_get_checkpoint(cpfile, curr, bh, kaddr);
471                 curr = ~(__u64)0; /* Terminator */
472                 if (unlikely(nilfs_checkpoint_invalid(cp) ||
473                              !nilfs_checkpoint_snapshot(cp)))
474                         break;
475                 nilfs_cpfile_checkpoint_to_cpinfo(cpfile, cp, &ci[n++]);
476                 next = le64_to_cpu(cp->cp_snapshot_list.ssl_next);
477                 if (next == 0)
478                         break; /* reach end of the snapshot list */
479
480                 next_blkoff = nilfs_cpfile_get_blkoff(cpfile, next);
481                 if (curr_blkoff != next_blkoff) {
482                         kunmap_atomic(kaddr, KM_USER0);
483                         brelse(bh);
484                         ret = nilfs_cpfile_get_checkpoint_block(cpfile, next,
485                                                                 0, &bh);
486                         if (unlikely(ret < 0)) {
487                                 WARN_ON(ret == -ENOENT);
488                                 goto out;
489                         }
490                         kaddr = kmap_atomic(bh->b_page, KM_USER0);
491                 }
492                 curr = next;
493                 curr_blkoff = next_blkoff;
494         }
495         kunmap_atomic(kaddr, KM_USER0);
496         brelse(bh);
497         *cnop = curr;
498         ret = n;
499
500  out:
501         up_read(&NILFS_MDT(cpfile)->mi_sem);
502         return ret;
503 }
504
505 /**
506  * nilfs_cpfile_get_cpinfo -
507  * @cpfile:
508  * @cno:
509  * @ci:
510  * @nci:
511  */
512
513 ssize_t nilfs_cpfile_get_cpinfo(struct inode *cpfile, __u64 *cnop, int mode,
514                                 struct nilfs_cpinfo *ci, size_t nci)
515 {
516         switch (mode) {
517         case NILFS_CHECKPOINT:
518                 return nilfs_cpfile_do_get_cpinfo(cpfile, cnop, ci, nci);
519         case NILFS_SNAPSHOT:
520                 return nilfs_cpfile_do_get_ssinfo(cpfile, cnop, ci, nci);
521         default:
522                 return -EINVAL;
523         }
524 }
525
526 /**
527  * nilfs_cpfile_delete_checkpoint -
528  * @cpfile:
529  * @cno:
530  */
531 int nilfs_cpfile_delete_checkpoint(struct inode *cpfile, __u64 cno)
532 {
533         struct nilfs_cpinfo ci;
534         __u64 tcno = cno;
535         ssize_t nci;
536         int ret;
537
538         nci = nilfs_cpfile_do_get_cpinfo(cpfile, &tcno, &ci, 1);
539         if (nci < 0)
540                 return nci;
541         else if (nci == 0 || ci.ci_cno != cno)
542                 return -ENOENT;
543
544         /* cannot delete the latest checkpoint nor snapshots */
545         ret = nilfs_cpinfo_snapshot(&ci);
546         if (ret < 0)
547                 return ret;
548         else if (ret > 0 || cno == nilfs_mdt_cno(cpfile) - 1)
549                 return -EPERM;
550
551         return nilfs_cpfile_delete_checkpoints(cpfile, cno, cno + 1);
552 }
553
554 static struct nilfs_snapshot_list *
555 nilfs_cpfile_block_get_snapshot_list(const struct inode *cpfile,
556                                      __u64 cno,
557                                      struct buffer_head *bh,
558                                      void *kaddr)
559 {
560         struct nilfs_cpfile_header *header;
561         struct nilfs_checkpoint *cp;
562         struct nilfs_snapshot_list *list;
563
564         if (cno != 0) {
565                 cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);
566                 list = &cp->cp_snapshot_list;
567         } else {
568                 header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);
569                 list = &header->ch_snapshot_list;
570         }
571         return list;
572 }
573
574 static int nilfs_cpfile_set_snapshot(struct inode *cpfile, __u64 cno)
575 {
576         struct buffer_head *header_bh, *curr_bh, *prev_bh, *cp_bh;
577         struct nilfs_cpfile_header *header;
578         struct nilfs_checkpoint *cp;
579         struct nilfs_snapshot_list *list;
580         __u64 curr, prev;
581         unsigned long curr_blkoff, prev_blkoff;
582         void *kaddr;
583         int ret;
584
585         if (cno == 0)
586                 return -ENOENT; /* checkpoint number 0 is invalid */
587         down_write(&NILFS_MDT(cpfile)->mi_sem);
588
589         ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);
590         if (ret < 0)
591                 goto out_sem;
592         kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
593         cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
594         if (nilfs_checkpoint_invalid(cp)) {
595                 ret = -ENOENT;
596                 kunmap_atomic(kaddr, KM_USER0);
597                 goto out_cp;
598         }
599         if (nilfs_checkpoint_snapshot(cp)) {
600                 ret = 0;
601                 kunmap_atomic(kaddr, KM_USER0);
602                 goto out_cp;
603         }
604         kunmap_atomic(kaddr, KM_USER0);
605
606         ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
607         if (ret < 0)
608                 goto out_cp;
609         kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
610         header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);
611         list = &header->ch_snapshot_list;
612         curr_bh = header_bh;
613         get_bh(curr_bh);
614         curr = 0;
615         curr_blkoff = 0;
616         prev = le64_to_cpu(list->ssl_prev);
617         while (prev > cno) {
618                 prev_blkoff = nilfs_cpfile_get_blkoff(cpfile, prev);
619                 curr = prev;
620                 if (curr_blkoff != prev_blkoff) {
621                         kunmap_atomic(kaddr, KM_USER0);
622                         brelse(curr_bh);
623                         ret = nilfs_cpfile_get_checkpoint_block(cpfile, curr,
624                                                                 0, &curr_bh);
625                         if (ret < 0)
626                                 goto out_header;
627                         kaddr = kmap_atomic(curr_bh->b_page, KM_USER0);
628                 }
629                 curr_blkoff = prev_blkoff;
630                 cp = nilfs_cpfile_block_get_checkpoint(
631                         cpfile, curr, curr_bh, kaddr);
632                 list = &cp->cp_snapshot_list;
633                 prev = le64_to_cpu(list->ssl_prev);
634         }
635         kunmap_atomic(kaddr, KM_USER0);
636
637         if (prev != 0) {
638                 ret = nilfs_cpfile_get_checkpoint_block(cpfile, prev, 0,
639                                                         &prev_bh);
640                 if (ret < 0)
641                         goto out_curr;
642         } else {
643                 prev_bh = header_bh;
644                 get_bh(prev_bh);
645         }
646
647         kaddr = kmap_atomic(curr_bh->b_page, KM_USER0);
648         list = nilfs_cpfile_block_get_snapshot_list(
649                 cpfile, curr, curr_bh, kaddr);
650         list->ssl_prev = cpu_to_le64(cno);
651         kunmap_atomic(kaddr, KM_USER0);
652
653         kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
654         cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
655         cp->cp_snapshot_list.ssl_next = cpu_to_le64(curr);
656         cp->cp_snapshot_list.ssl_prev = cpu_to_le64(prev);
657         nilfs_checkpoint_set_snapshot(cp);
658         kunmap_atomic(kaddr, KM_USER0);
659
660         kaddr = kmap_atomic(prev_bh->b_page, KM_USER0);
661         list = nilfs_cpfile_block_get_snapshot_list(
662                 cpfile, prev, prev_bh, kaddr);
663         list->ssl_next = cpu_to_le64(cno);
664         kunmap_atomic(kaddr, KM_USER0);
665
666         kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
667         header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);
668         le64_add_cpu(&header->ch_nsnapshots, 1);
669         kunmap_atomic(kaddr, KM_USER0);
670
671         nilfs_mdt_mark_buffer_dirty(prev_bh);
672         nilfs_mdt_mark_buffer_dirty(curr_bh);
673         nilfs_mdt_mark_buffer_dirty(cp_bh);
674         nilfs_mdt_mark_buffer_dirty(header_bh);
675         nilfs_mdt_mark_dirty(cpfile);
676
677         brelse(prev_bh);
678
679  out_curr:
680         brelse(curr_bh);
681
682  out_header:
683         brelse(header_bh);
684
685  out_cp:
686         brelse(cp_bh);
687
688  out_sem:
689         up_write(&NILFS_MDT(cpfile)->mi_sem);
690         return ret;
691 }
692
693 static int nilfs_cpfile_clear_snapshot(struct inode *cpfile, __u64 cno)
694 {
695         struct buffer_head *header_bh, *next_bh, *prev_bh, *cp_bh;
696         struct nilfs_cpfile_header *header;
697         struct nilfs_checkpoint *cp;
698         struct nilfs_snapshot_list *list;
699         __u64 next, prev;
700         void *kaddr;
701         int ret;
702
703         if (cno == 0)
704                 return -ENOENT; /* checkpoint number 0 is invalid */
705         down_write(&NILFS_MDT(cpfile)->mi_sem);
706
707         ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &cp_bh);
708         if (ret < 0)
709                 goto out_sem;
710         kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
711         cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
712         if (nilfs_checkpoint_invalid(cp)) {
713                 ret = -ENOENT;
714                 kunmap_atomic(kaddr, KM_USER0);
715                 goto out_cp;
716         }
717         if (!nilfs_checkpoint_snapshot(cp)) {
718                 ret = 0;
719                 kunmap_atomic(kaddr, KM_USER0);
720                 goto out_cp;
721         }
722
723         list = &cp->cp_snapshot_list;
724         next = le64_to_cpu(list->ssl_next);
725         prev = le64_to_cpu(list->ssl_prev);
726         kunmap_atomic(kaddr, KM_USER0);
727
728         ret = nilfs_cpfile_get_header_block(cpfile, &header_bh);
729         if (ret < 0)
730                 goto out_cp;
731         if (next != 0) {
732                 ret = nilfs_cpfile_get_checkpoint_block(cpfile, next, 0,
733                                                         &next_bh);
734                 if (ret < 0)
735                         goto out_header;
736         } else {
737                 next_bh = header_bh;
738                 get_bh(next_bh);
739         }
740         if (prev != 0) {
741                 ret = nilfs_cpfile_get_checkpoint_block(cpfile, prev, 0,
742                                                         &prev_bh);
743                 if (ret < 0)
744                         goto out_next;
745         } else {
746                 prev_bh = header_bh;
747                 get_bh(prev_bh);
748         }
749
750         kaddr = kmap_atomic(next_bh->b_page, KM_USER0);
751         list = nilfs_cpfile_block_get_snapshot_list(
752                 cpfile, next, next_bh, kaddr);
753         list->ssl_prev = cpu_to_le64(prev);
754         kunmap_atomic(kaddr, KM_USER0);
755
756         kaddr = kmap_atomic(prev_bh->b_page, KM_USER0);
757         list = nilfs_cpfile_block_get_snapshot_list(
758                 cpfile, prev, prev_bh, kaddr);
759         list->ssl_next = cpu_to_le64(next);
760         kunmap_atomic(kaddr, KM_USER0);
761
762         kaddr = kmap_atomic(cp_bh->b_page, KM_USER0);
763         cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, cp_bh, kaddr);
764         cp->cp_snapshot_list.ssl_next = cpu_to_le64(0);
765         cp->cp_snapshot_list.ssl_prev = cpu_to_le64(0);
766         nilfs_checkpoint_clear_snapshot(cp);
767         kunmap_atomic(kaddr, KM_USER0);
768
769         kaddr = kmap_atomic(header_bh->b_page, KM_USER0);
770         header = nilfs_cpfile_block_get_header(cpfile, header_bh, kaddr);
771         le64_add_cpu(&header->ch_nsnapshots, -1);
772         kunmap_atomic(kaddr, KM_USER0);
773
774         nilfs_mdt_mark_buffer_dirty(next_bh);
775         nilfs_mdt_mark_buffer_dirty(prev_bh);
776         nilfs_mdt_mark_buffer_dirty(cp_bh);
777         nilfs_mdt_mark_buffer_dirty(header_bh);
778         nilfs_mdt_mark_dirty(cpfile);
779
780         brelse(prev_bh);
781
782  out_next:
783         brelse(next_bh);
784
785  out_header:
786         brelse(header_bh);
787
788  out_cp:
789         brelse(cp_bh);
790
791  out_sem:
792         up_write(&NILFS_MDT(cpfile)->mi_sem);
793         return ret;
794 }
795
796 /**
797  * nilfs_cpfile_is_snapshot -
798  * @cpfile: inode of checkpoint file
799  * @cno: checkpoint number
800  *
801  * Description:
802  *
803  * Return Value: On success, 1 is returned if the checkpoint specified by
804  * @cno is a snapshot, or 0 if not. On error, one of the following negative
805  * error codes is returned.
806  *
807  * %-EIO - I/O error.
808  *
809  * %-ENOMEM - Insufficient amount of memory available.
810  *
811  * %-ENOENT - No such checkpoint.
812  */
813 int nilfs_cpfile_is_snapshot(struct inode *cpfile, __u64 cno)
814 {
815         struct buffer_head *bh;
816         struct nilfs_checkpoint *cp;
817         void *kaddr;
818         int ret;
819
820         if (cno == 0)
821                 return -ENOENT; /* checkpoint number 0 is invalid */
822         down_read(&NILFS_MDT(cpfile)->mi_sem);
823
824         ret = nilfs_cpfile_get_checkpoint_block(cpfile, cno, 0, &bh);
825         if (ret < 0)
826                 goto out;
827         kaddr = kmap_atomic(bh->b_page, KM_USER0);
828         cp = nilfs_cpfile_block_get_checkpoint(cpfile, cno, bh, kaddr);
829         ret = nilfs_checkpoint_snapshot(cp);
830         kunmap_atomic(kaddr, KM_USER0);
831         brelse(bh);
832
833  out:
834         up_read(&NILFS_MDT(cpfile)->mi_sem);
835         return ret;
836 }
837
838 /**
839  * nilfs_cpfile_change_cpmode - change checkpoint mode
840  * @cpfile: inode of checkpoint file
841  * @cno: checkpoint number
842  * @status: mode of checkpoint
843  *
844  * Description: nilfs_change_cpmode() changes the mode of the checkpoint
845  * specified by @cno. The mode @mode is NILFS_CHECKPOINT or NILFS_SNAPSHOT.
846  *
847  * Return Value: On success, 0 is returned. On error, one of the following
848  * negative error codes is returned.
849  *
850  * %-EIO - I/O error.
851  *
852  * %-ENOMEM - Insufficient amount of memory available.
853  *
854  * %-ENOENT - No such checkpoint.
855  */
856 int nilfs_cpfile_change_cpmode(struct inode *cpfile, __u64 cno, int mode)
857 {
858         struct the_nilfs *nilfs;
859         int ret;
860
861         nilfs = NILFS_MDT(cpfile)->mi_nilfs;
862
863         switch (mode) {
864         case NILFS_CHECKPOINT:
865                 /*
866                  * Check for protecting existing snapshot mounts:
867                  * bd_mount_sem is used to make this operation atomic and
868                  * exclusive with a new mount job.  Though it doesn't cover
869                  * umount, it's enough for the purpose.
870                  */
871                 down(&nilfs->ns_bdev->bd_mount_sem);
872                 if (nilfs_checkpoint_is_mounted(nilfs, cno, 1)) {
873                         /* Current implementation does not have to protect
874                            plain read-only mounts since they are exclusive
875                            with a read/write mount and are protected from the
876                            cleaner. */
877                         ret = -EBUSY;
878                 } else
879                         ret = nilfs_cpfile_clear_snapshot(cpfile, cno);
880                 up(&nilfs->ns_bdev->bd_mount_sem);
881                 return ret;
882         case NILFS_SNAPSHOT:
883                 return nilfs_cpfile_set_snapshot(cpfile, cno);
884         default:
885                 return -EINVAL;
886         }
887 }
888
889 /**
890  * nilfs_cpfile_get_stat - get checkpoint statistics
891  * @cpfile: inode of checkpoint file
892  * @stat: pointer to a structure of checkpoint statistics
893  *
894  * Description: nilfs_cpfile_get_stat() returns information about checkpoints.
895  *
896  * Return Value: On success, 0 is returned, and checkpoints information is
897  * stored in the place pointed by @stat. On error, one of the following
898  * negative error codes is returned.
899  *
900  * %-EIO - I/O error.
901  *
902  * %-ENOMEM - Insufficient amount of memory available.
903  */
904 int nilfs_cpfile_get_stat(struct inode *cpfile, struct nilfs_cpstat *cpstat)
905 {
906         struct buffer_head *bh;
907         struct nilfs_cpfile_header *header;
908         void *kaddr;
909         int ret;
910
911         down_read(&NILFS_MDT(cpfile)->mi_sem);
912
913         ret = nilfs_cpfile_get_header_block(cpfile, &bh);
914         if (ret < 0)
915                 goto out_sem;
916         kaddr = kmap_atomic(bh->b_page, KM_USER0);
917         header = nilfs_cpfile_block_get_header(cpfile, bh, kaddr);
918         cpstat->cs_cno = nilfs_mdt_cno(cpfile);
919         cpstat->cs_ncps = le64_to_cpu(header->ch_ncheckpoints);
920         cpstat->cs_nsss = le64_to_cpu(header->ch_nsnapshots);
921         kunmap_atomic(kaddr, KM_USER0);
922         brelse(bh);
923
924  out_sem:
925         up_read(&NILFS_MDT(cpfile)->mi_sem);
926         return ret;
927 }