fs/nilfs2/ifile.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * NILFS inode file
   4  *
   5  * Copyright (C) 2006-2008 Nippon Telegraph and Telephone Corporation.
   6  *
   7  * Written by Amagai Yoshiji.
   8  * Revised by Ryusuke Konishi.
   9  *
  10  */
  11
  12 #include <linux/types.h>
  13 #include <linux/buffer_head.h>
  14 #include "nilfs.h"
  15 #include "mdt.h"
  16 #include "alloc.h"
  17 #include "ifile.h"
  18 #include "cpfile.h"
  19
  20 /**
  21  * struct nilfs_ifile_info - on-memory private data of ifile
  22  * @mi: on-memory private data of metadata file
  23  * @palloc_cache: persistent object allocator cache of ifile
  24  */
  25 struct nilfs_ifile_info {
  26         struct nilfs_mdt_info mi;
  27         struct nilfs_palloc_cache palloc_cache;
  28 };
  29
  30 static inline struct nilfs_ifile_info *NILFS_IFILE_I(struct inode *ifile)
  31 {
  32         return (struct nilfs_ifile_info *)NILFS_MDT(ifile);
  33 }
  34
  35 /**
  36  * nilfs_ifile_create_inode - create a new disk inode
  37  * @ifile: ifile inode
  38  * @out_ino: pointer to a variable to store inode number
  39  * @out_bh: buffer_head contains newly allocated disk inode
  40  *
  41  * Return Value: On success, 0 is returned and the newly allocated inode
  42  * number is stored in the place pointed by @ino, and buffer_head pointer
  43  * that contains newly allocated disk inode structure is stored in the
  44  * place pointed by @out_bh
  45  * On error, one of the following negative error codes is returned.
  46  *
  47  * %-EIO - I/O error.
  48  *
  49  * %-ENOMEM - Insufficient amount of memory available.
  50  *
  51  * %-ENOSPC - No inode left.
  52  */
  53 int nilfs_ifile_create_inode(struct inode *ifile, ino_t *out_ino,
  54                              struct buffer_head **out_bh)
  55 {
  56         struct nilfs_palloc_req req;
  57         int ret;
  58
  59         req.pr_entry_nr = 0;  /*
  60                                * 0 says find free inode from beginning
  61                                * of a group. dull code!!
  62                                */
  63         req.pr_entry_bh = NULL;
  64
  65         ret = nilfs_palloc_prepare_alloc_entry(ifile, &req);
  66         if (!ret) {
  67                 ret = nilfs_palloc_get_entry_block(ifile, req.pr_entry_nr, 1,
  68                                                    &req.pr_entry_bh);
  69                 if (ret < 0)
  70                         nilfs_palloc_abort_alloc_entry(ifile, &req);
  71         }
  72         if (ret < 0) {
  73                 brelse(req.pr_entry_bh);
  74                 return ret;
  75         }
  76         nilfs_palloc_commit_alloc_entry(ifile, &req);
  77         mark_buffer_dirty(req.pr_entry_bh);
  78         nilfs_mdt_mark_dirty(ifile);
  79         *out_ino = (ino_t)req.pr_entry_nr;
  80         *out_bh = req.pr_entry_bh;
  81         return 0;
  82 }
  83
  84 /**
  85  * nilfs_ifile_delete_inode - delete a disk inode
  86  * @ifile: ifile inode
  87  * @ino: inode number
  88  *
  89  * Return Value: On success, 0 is returned. On error, one of the following
  90  * negative error codes is returned.
  91  *
  92  * %-EIO - I/O error.
  93  *
  94  * %-ENOMEM - Insufficient amount of memory available.
  95  *
  96  * %-ENOENT - The inode number @ino have not been allocated.
  97  */
  98 int nilfs_ifile_delete_inode(struct inode *ifile, ino_t ino)
  99 {
 100         struct nilfs_palloc_req req = {
 101                 .pr_entry_nr = ino, .pr_entry_bh = NULL
 102         };
 103         struct nilfs_inode *raw_inode;
 104         void *kaddr;
 105         int ret;
 106
 107         ret = nilfs_palloc_prepare_free_entry(ifile, &req);
 108         if (!ret) {
 109                 ret = nilfs_palloc_get_entry_block(ifile, req.pr_entry_nr, 0,
 110                                                    &req.pr_entry_bh);
 111                 if (ret < 0)
 112                         nilfs_palloc_abort_free_entry(ifile, &req);
 113         }
 114         if (ret < 0) {
 115                 brelse(req.pr_entry_bh);
 116                 return ret;
 117         }
 118
 119         kaddr = kmap_local_page(req.pr_entry_bh->b_page);
 120         raw_inode = nilfs_palloc_block_get_entry(ifile, req.pr_entry_nr,
 121                                                  req.pr_entry_bh, kaddr);
 122         raw_inode->i_flags = 0;
 123         kunmap_local(kaddr);
 124
 125         mark_buffer_dirty(req.pr_entry_bh);
 126         brelse(req.pr_entry_bh);
 127
 128         nilfs_palloc_commit_free_entry(ifile, &req);
 129
 130         return 0;
 131 }
 132
 133 int nilfs_ifile_get_inode_block(struct inode *ifile, ino_t ino,
 134                                 struct buffer_head **out_bh)
 135 {
 136         struct super_block *sb = ifile->i_sb;
 137         int err;
 138
 139         if (unlikely(!NILFS_VALID_INODE(sb, ino))) {
 140                 nilfs_error(sb, "bad inode number: %lu", (unsigned long)ino);
 141                 return -EINVAL;
 142         }
 143
 144         err = nilfs_palloc_get_entry_block(ifile, ino, 0, out_bh);
 145         if (unlikely(err))
 146                 nilfs_warn(sb, "error %d reading inode: ino=%lu",
 147                            err, (unsigned long)ino);
 148         return err;
 149 }
 150
 151 /**
 152  * nilfs_ifile_count_free_inodes - calculate free inodes count
 153  * @ifile: ifile inode
 154  * @nmaxinodes: current maximum of available inodes count [out]
 155  * @nfreeinodes: free inodes count [out]
 156  */
 157 int nilfs_ifile_count_free_inodes(struct inode *ifile,
 158                                     u64 *nmaxinodes, u64 *nfreeinodes)
 159 {
 160         u64 nused;
 161         int err;
 162
 163         *nmaxinodes = 0;
 164         *nfreeinodes = 0;
 165
 166         nused = atomic64_read(&NILFS_I(ifile)->i_root->inodes_count);
 167         err = nilfs_palloc_count_max_entries(ifile, nused, nmaxinodes);
 168         if (likely(!err))
 169                 *nfreeinodes = *nmaxinodes - nused;
 170         return err;
 171 }
 172
 173 /**
 174  * nilfs_ifile_read - read or get ifile inode
 175  * @sb: super block instance
 176  * @root: root object
 177  * @cno: number of checkpoint entry to read
 178  * @inode_size: size of an inode
 179  *
 180  * Return: 0 on success, or the following negative error code on failure.
 181  * * %-EINVAL   - Invalid checkpoint.
 182  * * %-ENOMEM   - Insufficient memory available.
 183  * * %-EIO      - I/O error (including metadata corruption).
 184  */
 185 int nilfs_ifile_read(struct super_block *sb, struct nilfs_root *root,
 186                      __u64 cno, size_t inode_size)
 187 {
 188         struct the_nilfs *nilfs;
 189         struct inode *ifile;
 190         int err;
 191
 192         ifile = nilfs_iget_locked(sb, root, NILFS_IFILE_INO);
 193         if (unlikely(!ifile))
 194                 return -ENOMEM;
 195         if (!(ifile->i_state & I_NEW))
 196                 goto out;
 197
 198         err = nilfs_mdt_init(ifile, NILFS_MDT_GFP,
 199                              sizeof(struct nilfs_ifile_info));
 200         if (err)
 201                 goto failed;
 202
 203         err = nilfs_palloc_init_blockgroup(ifile, inode_size);
 204         if (err)
 205                 goto failed;
 206
 207         nilfs_palloc_setup_cache(ifile, &NILFS_IFILE_I(ifile)->palloc_cache);
 208
 209         nilfs = sb->s_fs_info;
 210         err = nilfs_cpfile_read_checkpoint(nilfs->ns_cpfile, cno, root, ifile);
 211         if (err)
 212                 goto failed;
 213
 214         unlock_new_inode(ifile);
 215  out:
 216         return 0;
 217  failed:
 218         iget_failed(ifile);
 219         return err;
 220 }