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