lib/libsffs/inode.c

   1 /* This file deals with inode management.
   2  *
   3  * The entry points into this file are:
   4  *   init_inode         initialize the inode table, return the root inode
   5  *   find_inode         find an inode based on its inode number
   6  *   get_inode          increase the reference count of an inode
   7  *   put_inode          decrease the reference count of an inode
   8  *   link_inode         link an inode as a directory entry to another inode
   9  *   unlink_inode       unlink an inode from its parent directory
  10  *   get_free_inode     return a free inode object
  11  *   have_free_inode    check whether there is a free inode available
  12  *   have_used_inode    check whether any inode is still in use
  13  *   do_putnode         perform the PUTNODE file system call
  14  *
  15  * Created:
  16  *   April 2009 (D.C. van Moolenbroek)
  17  */
  18
  19 #include "inc.h"
  20
  21 static struct inode inodes[NUM_INODES];
  22
  23 static TAILQ_HEAD(free_head, inode) free_list;
  24
  25 /*===========================================================================*
  26  *                              init_inode                                   *
  27  *===========================================================================*/
  28 struct inode *init_inode()
  29 {
  30 /* Initialize inode table. Return the root inode.
  31  */
  32   struct inode *ino;
  33   unsigned int index;
  34
  35   TAILQ_INIT(&free_list);
  36
  37   dprintf(("%s: %d inodes, %u bytes each, equals %u bytes\n",
  38         sffs_name, NUM_INODES, sizeof(struct inode), sizeof(inodes)));
  39
  40   /* Mark all inodes except the root inode as free. */
  41   for (index = 1; index < NUM_INODES; index++) {
  42         ino = &inodes[index];
  43         ino->i_parent = NULL;
  44         LIST_INIT(&ino->i_child);
  45         ino->i_num = index + 1;
  46         ino->i_gen = (unsigned short)-1; /* aesthetics */
  47         ino->i_ref = 0;
  48         ino->i_flags = 0;
  49         TAILQ_INSERT_TAIL(&free_list, ino, i_free);
  50   }
  51
  52   /* Initialize and return the root inode. */
  53   ino = &inodes[0];
  54   ino->i_parent = ino;          /* root inode is its own parent */
  55   LIST_INIT(&ino->i_child);
  56   ino->i_num = ROOT_INODE_NR;
  57   ino->i_gen = 0;               /* unused by root node */
  58   ino->i_ref = 1;               /* root inode is hereby in use */
  59   ino->i_flags = I_DIR;         /* root inode is a directory */
  60   ino->i_name[0] = 0;           /* root inode has empty name */
  61
  62   return ino;
  63 }
  64
  65 /*===========================================================================*
  66  *                              find_inode                                   *
  67  *===========================================================================*/
  68 struct inode *find_inode(ino_nr)
  69 ino_t ino_nr;
  70 {
  71 /* Get an inode based on its inode number. Do not increase its reference count.
  72  */
  73   struct inode *ino;
  74   int index;
  75
  76   /* Inode 0 (= index -1) is not a valid inode number. */
  77   index = INODE_INDEX(ino_nr);
  78   if (index < 0) {
  79         printf("%s: VFS passed invalid inode number!\n", sffs_name);
  80
  81         return NULL;
  82   }
  83
  84   assert(index < NUM_INODES);
  85
  86   ino = &inodes[index];
  87
  88   /* Make sure the generation number matches. */
  89   if (INODE_GEN(ino_nr) != ino->i_gen) {
  90         printf("%s: VFS passed outdated inode number!\n", sffs_name);
  91
  92         return NULL;
  93   }
  94
  95   /* The VFS/FS protocol only uses referenced inodes. */
  96   if (ino->i_ref == 0)
  97         printf("%s: VFS passed unused inode!\n", sffs_name);
  98
  99   return ino;
 100 }
 101
 102 /*===========================================================================*
 103  *                              get_inode                                    *
 104  *===========================================================================*/
 105 void get_inode(ino)
 106 struct inode *ino;
 107 {
 108 /* Increase the given inode's reference count. If both reference and link
 109  * count were zero before, remove the inode from the free list.
 110  */
 111
 112   dprintf(("%s: get_inode(%p) ['%s']\n", sffs_name, ino, ino->i_name));
 113
 114   /* (INUSE, CACHED) -> INUSE */
 115
 116   /* If this is the first reference, remove the node from the free list. */
 117   if (ino->i_ref == 0 && !HAS_CHILDREN(ino))
 118         TAILQ_REMOVE(&free_list, ino, i_free);
 119
 120   ino->i_ref++;
 121
 122   if (ino->i_ref == 0)
 123         panic("inode reference count wrapped");
 124 }
 125
 126 /*===========================================================================*
 127  *                              put_inode                                    *
 128  *===========================================================================*/
 129 void put_inode(ino)
 130 struct inode *ino;
 131 {
 132 /* Decrease an inode's reference count. If this count has reached zero, close
 133  * the inode's file handle, if any. If both reference and link count have
 134  * reached zero, mark the inode as cached or free.
 135  */
 136
 137   dprintf(("%s: put_inode(%p) ['%s']\n", sffs_name, ino, ino->i_name));
 138
 139   assert(ino != NULL);
 140   assert(ino->i_ref > 0);
 141
 142   ino->i_ref--;
 143
 144   /* If there are still references to this inode, we're done here. */
 145   if (ino->i_ref > 0)
 146         return;
 147
 148   /* Close any file handle associated with this inode. */
 149   put_handle(ino);
 150
 151   /* Only add the inode to the free list if there are also no links to it. */
 152   if (HAS_CHILDREN(ino))
 153         return;
 154
 155   /* INUSE -> CACHED, DELETED -> FREE */
 156
 157   /* Add the inode to the head or tail of the free list, depending on whether
 158    * it is also deleted (and therefore can never be reused as is).
 159    */
 160   if (ino->i_parent == NULL)
 161         TAILQ_INSERT_HEAD(&free_list, ino, i_free);
 162   else
 163         TAILQ_INSERT_TAIL(&free_list, ino, i_free);
 164 }
 165
 166 /*===========================================================================*
 167  *                              link_inode                                   *
 168  *===========================================================================*/
 169 void link_inode(parent, ino)
 170 struct inode *parent;
 171 struct inode *ino;
 172 {
 173 /* Link an inode to a parent. If both reference and link count were zero
 174  * before, remove the inode from the free list. This function should only be
 175  * called from add_dentry().
 176  */
 177
 178   /* This can never happen, right? */
 179   if (parent->i_ref == 0 && !HAS_CHILDREN(parent))
 180         TAILQ_REMOVE(&free_list, parent, i_free);
 181
 182   LIST_INSERT_HEAD(&parent->i_child, ino, i_next);
 183
 184   ino->i_parent = parent;
 185 }
 186
 187 /*===========================================================================*
 188  *                              unlink_inode                                 *
 189  *===========================================================================*/
 190 void unlink_inode(ino)
 191 struct inode *ino;
 192 {
 193 /* Unlink an inode from its parent. If both reference and link count have
 194  * reached zero, mark the inode as cached or free. This function should only
 195  * be used from del_dentry().
 196  */
 197   struct inode *parent;
 198
 199   parent = ino->i_parent;
 200
 201   LIST_REMOVE(ino, i_next);
 202
 203   if (parent->i_ref == 0 && !HAS_CHILDREN(parent)) {
 204         if (parent->i_parent == NULL)
 205                 TAILQ_INSERT_HEAD(&free_list, parent, i_free);
 206         else
 207                 TAILQ_INSERT_TAIL(&free_list, parent, i_free);
 208   }
 209
 210   ino->i_parent = NULL;
 211 }
 212
 213 /*===========================================================================*
 214  *                              get_free_inode                               *
 215  *===========================================================================*/
 216 struct inode *get_free_inode()
 217 {
 218 /* Return a free inode object (with reference count 1), if available.
 219  */
 220   struct inode *ino;
 221
 222   /* [CACHED -> FREE,] FREE -> DELETED */
 223
 224   /* If there are no inodes on the free list, we cannot satisfy the request. */
 225   if (TAILQ_EMPTY(&free_list)) {
 226         printf("%s: out of inodes!\n", sffs_name);
 227
 228         return NULL;
 229   }
 230
 231   ino = TAILQ_FIRST(&free_list);
 232   TAILQ_REMOVE(&free_list, ino, i_free);
 233
 234   assert(ino->i_ref == 0);
 235   assert(!HAS_CHILDREN(ino));
 236
 237   /* If this was a cached inode, free it first. */
 238   if (ino->i_parent != NULL)
 239         del_dentry(ino);
 240
 241   assert(ino->i_parent == NULL);
 242
 243   /* Initialize a subset of its fields */
 244   ino->i_gen++;
 245   ino->i_ref = 1;
 246
 247   return ino;
 248 }
 249
 250 /*===========================================================================*
 251  *                              have_free_inode                              *
 252  *===========================================================================*/
 253 int have_free_inode()
 254 {
 255 /* Check whether there are any free inodes at the moment. Kind of lame, but
 256  * this allows for easier error recovery in some places.
 257  */
 258
 259   return !TAILQ_EMPTY(&free_list);
 260 }
 261
 262 /*===========================================================================*
 263  *                              have_used_inode                              *
 264  *===========================================================================*/
 265 int have_used_inode()
 266 {
 267 /* Check whether any inodes are still in use, that is, any of the inodes have
 268  * a reference count larger than zero.
 269  */
 270   unsigned int index;
 271
 272   for (index = 0; index < NUM_INODES; index++)
 273         if (inodes[index].i_ref > 0)
 274                 return TRUE;
 275
 276   return FALSE;
 277 }
 278
 279 /*===========================================================================*
 280  *                              do_putnode                                   *
 281  *===========================================================================*/
 282 int do_putnode()
 283 {
 284 /* Decrease an inode's reference count.
 285  */
 286   struct inode *ino;
 287   int count;
 288
 289   if ((ino = find_inode(m_in.REQ_INODE_NR)) == NULL)
 290         return EINVAL;
 291
 292   count = m_in.REQ_COUNT;
 293
 294   if (count <= 0 || count > ino->i_ref) return EINVAL;
 295
 296   ino->i_ref -= count - 1;
 297
 298   put_inode(ino);
 299
 300   return OK;
 301 }