root/fs/nilfs2/ifile.c

DEFINITIONS

1. NILFS_IFILE_I
2. nilfs_ifile_create_inode
3. nilfs_ifile_delete_inode
4. nilfs_ifile_get_inode_block
5. nilfs_ifile_count_free_inodes
6. nilfs_ifile_read

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