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 = NILFS_FIRST_INO(ifile->i_sb);
  60         req.pr_entry_bh = NULL;
  61
  62         ret = nilfs_palloc_prepare_alloc_entry(ifile, &req, false);
  63         if (!ret) {
  64                 ret = nilfs_palloc_get_entry_block(ifile, req.pr_entry_nr, 1,
  65                                                    &req.pr_entry_bh);
  66                 if (ret < 0)
  67                         nilfs_palloc_abort_alloc_entry(ifile, &req);
  68         }
  69         if (ret < 0) {
  70                 brelse(req.pr_entry_bh);
  71                 return ret;
  72         }
  73         nilfs_palloc_commit_alloc_entry(ifile, &req);
  74         mark_buffer_dirty(req.pr_entry_bh);
  75         nilfs_mdt_mark_dirty(ifile);
  76         *out_ino = (ino_t)req.pr_entry_nr;
  77         *out_bh = req.pr_entry_bh;
  78         return 0;
  79 }
  80
  81 /**
  82  * nilfs_ifile_delete_inode - delete a disk inode
  83  * @ifile: ifile inode
  84  * @ino: inode number
  85  *
  86  * Return Value: On success, 0 is returned. On error, one of the following
  87  * negative error codes is returned.
  88  *
  89  * %-EIO - I/O error.
  90  *
  91  * %-ENOMEM - Insufficient amount of memory available.
  92  *
  93  * %-ENOENT - The inode number @ino have not been allocated.
  94  */
  95 int nilfs_ifile_delete_inode(struct inode *ifile, ino_t ino)
  96 {
  97         struct nilfs_palloc_req req = {
  98                 .pr_entry_nr = ino, .pr_entry_bh = NULL
  99         };
 100         struct nilfs_inode *raw_inode;
 101         size_t offset;
 102         int ret;
 103
 104         ret = nilfs_palloc_prepare_free_entry(ifile, &req);
 105         if (!ret) {
 106                 ret = nilfs_palloc_get_entry_block(ifile, req.pr_entry_nr, 0,
 107                                                    &req.pr_entry_bh);
 108                 if (ret < 0)
 109                         nilfs_palloc_abort_free_entry(ifile, &req);
 110         }
 111         if (ret < 0) {
 112                 brelse(req.pr_entry_bh);
 113                 return ret;
 114         }
 115
 116         offset = nilfs_palloc_entry_offset(ifile, req.pr_entry_nr,
 117                                            req.pr_entry_bh);
 118         raw_inode = kmap_local_folio(req.pr_entry_bh->b_folio, offset);
 119         raw_inode->i_flags = 0;
 120         kunmap_local(raw_inode);
 121
 122         mark_buffer_dirty(req.pr_entry_bh);
 123         brelse(req.pr_entry_bh);
 124
 125         nilfs_palloc_commit_free_entry(ifile, &req);
 126
 127         return 0;
 128 }
 129
 130 int nilfs_ifile_get_inode_block(struct inode *ifile, ino_t ino,
 131                                 struct buffer_head **out_bh)
 132 {
 133         struct super_block *sb = ifile->i_sb;
 134         int err;
 135
 136         if (unlikely(!NILFS_VALID_INODE(sb, ino))) {
 137                 nilfs_error(sb, "bad inode number: %lu", (unsigned long)ino);
 138                 return -EINVAL;
 139         }
 140
 141         err = nilfs_palloc_get_entry_block(ifile, ino, 0, out_bh);
 142         if (unlikely(err))
 143                 nilfs_warn(sb, "error %d reading inode: ino=%lu",
 144                            err, (unsigned long)ino);
 145         return err;
 146 }
 147
 148 /**
 149  * nilfs_ifile_count_free_inodes - calculate free inodes count
 150  * @ifile: ifile inode
 151  * @nmaxinodes: current maximum of available inodes count [out]
 152  * @nfreeinodes: free inodes count [out]
 153  */
 154 int nilfs_ifile_count_free_inodes(struct inode *ifile,
 155                                     u64 *nmaxinodes, u64 *nfreeinodes)
 156 {
 157         u64 nused;
 158         int err;
 159
 160         *nmaxinodes = 0;
 161         *nfreeinodes = 0;
 162
 163         nused = atomic64_read(&NILFS_I(ifile)->i_root->inodes_count);
 164         err = nilfs_palloc_count_max_entries(ifile, nused, nmaxinodes);
 165         if (likely(!err))
 166                 *nfreeinodes = *nmaxinodes - nused;
 167         return err;
 168 }
 169
 170 /**
 171  * nilfs_ifile_read - read or get ifile inode
 172  * @sb: super block instance
 173  * @root: root object
 174  * @cno: number of checkpoint entry to read
 175  * @inode_size: size of an inode
 176  *
 177  * Return: 0 on success, or the following negative error code on failure.
 178  * * %-EINVAL   - Invalid checkpoint.
 179  * * %-ENOMEM   - Insufficient memory available.
 180  * * %-EIO      - I/O error (including metadata corruption).
 181  */
 182 int nilfs_ifile_read(struct super_block *sb, struct nilfs_root *root,
 183                      __u64 cno, size_t inode_size)
 184 {
 185         struct the_nilfs *nilfs;
 186         struct inode *ifile;
 187         int err;
 188
 189         ifile = nilfs_iget_locked(sb, root, NILFS_IFILE_INO);
 190         if (unlikely(!ifile))
 191                 return -ENOMEM;
 192         if (!(ifile->i_state & I_NEW))
 193                 goto out;
 194
 195         err = nilfs_mdt_init(ifile, NILFS_MDT_GFP,
 196                              sizeof(struct nilfs_ifile_info));
 197         if (err)
 198                 goto failed;
 199
 200         err = nilfs_palloc_init_blockgroup(ifile, inode_size);
 201         if (err)
 202                 goto failed;
 203
 204         nilfs_palloc_setup_cache(ifile, &NILFS_IFILE_I(ifile)->palloc_cache);
 205
 206         nilfs = sb->s_fs_info;
 207         err = nilfs_cpfile_read_checkpoint(nilfs->ns_cpfile, cno, root, ifile);
 208         if (err)
 209                 goto failed;
 210
 211         unlock_new_inode(ifile);
 212  out:
 213         return 0;
 214  failed:
 215         iget_failed(ifile);
 216         return err;
 217 }