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